- improved sync

git-svn-id: http://moon:8086/svn/software/trunk/libsrc/cpp@1081 b431acfa-c32f-4a4a-93f1-934dc6c82436

radio/DeSymbolizer.cpp

@@ -4,6 +4,7 @@
 #include <stdint.h>
 #include "DeSymbolizer.hpp"
 
+#define DESYMBOLIZER_DEBUG printf
 
 DeSymbolizer::DeSymbolizer()
 : Processor::Block(1, 1)
@@ -11,15 +12,19 @@ DeSymbolizer::DeSymbolizer()
 , m_lastSymbol(0)
 , m_symbolMask(0)
 , m_nBitsPerSym(0)
+, m_state(State::Idle)
+, m_sync_dist(0)
+, m_sync_dist_last(0)
+, m_sync_counter(0)
 {
 	setNumBitsPerSymbol(8);
 }
 
-void DeSymbolizer::setNumBitsPerSymbol(uint32_t nBitsPerSym)
+void DeSymbolizer::setNumBitsPerSymbol(size_t nBitsPerSym)
 {
 	m_nBitsPerSym = nBitsPerSym;
 	m_symbolMask = 0;
-	for(uint32_t k=0; k < nBitsPerSym; k++)
+	for(size_t k=0; k < nBitsPerSym; k++)
 	{
 		m_symbolMask <<= 1;
 		m_symbolMask |= 1;
@@ -28,49 +33,104 @@ void DeSymbolizer::setNumBitsPerSymbol(uint32_t nBitsPerSym)
 	m_lastSymbol = 0;
 }
 
-void DeSymbolizer::process(uint32_t src)
+bool DeSymbolizer::is_preamble(uint16_t data)
 {
-	uint32_t i, j;
-	static uint8_t dst;
-	static uint16_t preamble;
-	uint16_t preamble_soll;
-	uint32_t symSync;
-	src = differentialDecode(src);
-	symSync = src;
-	const uint8_t preamble_bytes[2] = {(uint8_t)FRAME_PREAMBLE_IV, (uint8_t)(~FRAME_PREAMBLE_IV)};
+	return 0x55AA == data;
+}
 
-	preamble_soll = ((uint16_t)preamble_bytes[0] << 8) | ((uint16_t)preamble_bytes[1] & 0xFF);
+void DeSymbolizer::sync(symbol_t symbol)
+{
+	static uint16_t word;
+	word <<= m_nBitsPerSym;
+	word |= symbol & m_symbolMask;
 
-	j = 0;
-	for (i=0; i < m_nBitsPerSym; i++)
+	if (m_state == State::Idle)
 	{
-		preamble <<= 1;
-		preamble |= (uint32_t)((symSync >> (m_nBitsPerSym-1) & 1) != 0);
-		symSync <<= 1;
-		if (preamble == preamble_soll)
+		m_sync_counter = 0;
+		m_sync_dist_last = 0;
+		DESYMBOLIZER_DEBUG("Idle -> ACQ\n");
+		m_state = State::Acq;
+	}
+	else if (m_state == State::Acq)
+	{
+		if (is_preamble(word))
 		{
-			// We have bit sync
-			m_dataBitCount = 0;
-			j = i + 1;
-			src = symSync;
-			preamble = 0;
-			m_buf_out->write(preamble_bytes, sizeof(preamble_bytes));
+			DESYMBOLIZER_DEBUG("Acquired bit sync. Last bit sync was %zu symbols ago\n", m_sync_dist);
+			if (m_sync_dist_last == m_sync_dist)
+			{
+				m_sync_counter++;
+				DESYMBOLIZER_DEBUG("Received sync at %zu %zu times -> OK\n", m_sync_dist, m_sync_counter);
+				if (m_sync_counter == SYNC_COUNTER_RELOAD)
+				{
+					m_sync_counter = 0;
+					m_dataBitCount = 0;
+					DESYMBOLIZER_DEBUG("ACQ -> TRK\n");
+					m_state = State::Trk;
+				}
+			}
+			else
+			{
+				m_sync_counter = 0;
+			}
+			m_sync_dist_last = m_sync_dist;
+			word = 0;
+			m_sync_dist = 0;
 		}
 	}
-
-	// Transmission order MSB first
-	for (i=j; i < m_nBitsPerSym; i++)
+	else if (m_state == State::Trk)
 	{
-		dst <<= 1;
-		dst |= (uint32_t)((src >> (m_nBitsPerSym-1) & 1) != 0);
-		src <<= 1;
-		m_dataBitCount++;
-		if (m_dataBitCount == SIZEOF_DATA_BITS)
+		if (m_sync_dist == m_sync_dist_last)
 		{
-			m_buf_out->write(&dst, 1);
-			m_dataBitCount = 0;
-			dst = 0;
+			if (not is_preamble(word))
+			{			
+				DESYMBOLIZER_DEBUG("Missed sync at %zu. Found %04X instead -> NOK\n", m_sync_dist, word);
+				DESYMBOLIZER_DEBUG("TRK -> Idle\n");
+				m_state = State::Idle;
+			}
+			else
+			{
+//				printf("We tracked sync at %zu -> OK\n", m_sync_dist);
+			}
+			m_sync_dist = 0;
 		}
+		else
+		{
+			if (is_preamble(word))
+			{			
+				DESYMBOLIZER_DEBUG("Found sync at %zu -> IGN\n", m_sync_dist);
+			}
+		}
+	}
+	m_sync_dist++;
+}
+
+uint8_t DeSymbolizer::sym2byte(symbol_t symbol)
+{
+	static uint8_t byte;
+	byte <<= m_nBitsPerSym;
+	byte |= symbol & m_symbolMask;
+
+	return byte;
+}
+
+void DeSymbolizer::process(symbol_t symbol_enc)
+{
+
+	symbol_t symbol = differentialDecode(symbol_enc);
+	sync(symbol);
+
+	// Create bytes from symbol
+	uint8_t byte = sym2byte(symbol);
+
+	// Commit bytes if in sync
+	if (m_state == State::Trk)
+	{
+		if (m_dataBitCount == 0)
+		{
+//			printf("Write %02X\n", byte);
+			m_buf_out->write(&byte, 1);
+		}
+		m_dataBitCount = (m_dataBitCount + m_nBitsPerSym) & 7;
 	}
 }
 
@@ -97,7 +157,7 @@ uint32_t DeSymbolizer::differentialDecode(uint32_t symbol)
 	uint32_t res;
 
 	// Differential decode
-	res = (uint32_t)(m_symbolMask & (symbol - m_lastSymbol));
+	res = (symbol_t)(m_symbolMask & (symbol - m_lastSymbol));
 	m_lastSymbol = symbol;
 
 	return res;

radio/DeSymbolizer.hpp

@@ -9,12 +9,20 @@
 
 class DeSymbolizer : public Processor::Block
 {
+	enum State
+	{
+		Idle,
+		Acq,
+		Trk
+	};
+
+	static const size_t SYNC_COUNTER_RELOAD = 3;
+
 public:
 	DeSymbolizer();
 	virtual ~DeSymbolizer() = default;
 
-	void setNumBitsPerSymbol(uint32_t nBitsPerSym);
-	void process(symbol_t src);
+	void setNumBitsPerSymbol(size_t nBitsPerSym);
 
 	// Processor::Block
 	void prepare() override;
@@ -27,9 +35,18 @@ private:
 	symbol_t m_lastSymbol;
 	symbol_t m_symbolMask;
 	symbol_t differentialDecode(symbol_t symbol);
+	State m_state;
+	size_t m_sync_dist;
+	size_t m_sync_dist_last;
+	size_t m_sync_counter;
+	uint8_t m_delay[2];
+
 	Processor::Buffer<symbol_t> *m_buf_in;
 	Processor::Buffer<uint8_t> *m_buf_out;
-
+	void process(symbol_t symbol);
+	void sync(symbol_t symbol);
+	uint8_t sym2byte(symbol_t symbol);
+	bool is_preamble(uint16_t data);
 };
 
 // --------------------------------------------------------------