- refactore Formatter

- prpeared for unscrambled sync data
- State-based deformatter


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

radio/Formatter.cpp

@@ -3,6 +3,7 @@
 #include <math.h>
 #include <stdint.h>
 #include <algorithm>
+#include <stdio.h>
 
 #include <crc/crc.h>
 #include "Formatter.hpp"
@@ -20,8 +21,8 @@ Formatter::Formatter(IFormatter *pFrameHandler)
 	memset(&m_frame, 0, sizeof(frame_t));
 
 	// Set preamble
-	m_frame.hdr.preamble[0] = FRAME_PREAMBLE_IV;
+	m_frame.preamble.data[0] = FRAME_PREAMBLE_IV;
-	m_frame.hdr.preamble[1] = ~(m_frame.hdr.preamble[0]);
+	m_frame.preamble.data[1] = ~(m_frame.preamble.data[0]);
 }
 
 Formatter::~Formatter()
@@ -115,10 +116,10 @@ void Formatter::commit(frame_type frameType, uint32_t dataCount)
 	m_frame.hdr.crc16 = Crc16(FRAME_CRC16_POLY, FRAME_CRC16_IV, m_frame.data, FRAME_NUM_BYTES_PER_FRAME);
 	m_frame.hdr.prn_state = m_scrambler.stateGet();
 
-	m_scrambler.process(m_frame.data, FRAME_NUM_BYTES_PER_FRAME);
 	m_scrambler.process((uint8_t*)&m_frame.hdr.crc16, sizeof(m_frame.hdr.crc16));
 	m_scrambler.process((uint8_t*)&m_frame.hdr.type, sizeof(m_frame.hdr.type));
 	m_scrambler.process((uint8_t*)&m_frame.hdr.length, sizeof(m_frame.hdr.length));
+	m_scrambler.process(m_frame.data, FRAME_NUM_BYTES_PER_FRAME);
 
 	m_pFrameHandler->onFrame((void*)&m_frame, sizeof(frame_t));
 }
@@ -130,7 +131,7 @@ DeFormatter::DeFormatter(IDeFormatter *pDataHandler)
 	: m_pDataHandler(pDataHandler)
 	, m_scrambler(FRAME_SCRAMBLER_SEED, FRAME_SCRAMBLER_POLY)
 	, m_dataCount(0)
-	, m_enable(0)
+	, m_state(Idle)
 {
 	resetStats();
 }
@@ -141,39 +142,50 @@ DeFormatter::~DeFormatter()
 
 void DeFormatter::process(uint8_t data)
 {
-	uint8_t *pData;
+	if (m_state == Idle)
-
-	pData = (uint8_t*)&m_frame;
-	pData += 2;
-	
-	if (!m_enable)
-		return;
-
-	pData[m_dataCount++] = data;
-
-	if (m_dataCount == (sizeof(frame_t)-2))
 	{
-		m_scrambler.stateSet(m_frame.hdr.prn_state);
+		return;
-		m_scrambler.process(m_frame.data, FRAME_NUM_BYTES_PER_FRAME);
+	}
-		m_scrambler.process((uint8_t*)&m_frame.hdr.crc16, sizeof(m_frame.hdr.crc16));
+
-		m_scrambler.process((uint8_t*)&m_frame.hdr.type, sizeof(m_frame.hdr.type));
+	uint8_t *pData;
-		m_scrambler.process((uint8_t*)&m_frame.hdr.length, sizeof(m_frame.hdr.length));
+	if (m_state == Header)
-		uint16_t crc16_ist = Crc16(FRAME_CRC16_POLY, FRAME_CRC16_IV, m_frame.data, FRAME_NUM_BYTES_PER_FRAME);
+	{
-		if (crc16_ist == m_frame.hdr.crc16)
+		pData = (uint8_t*)&m_Hdr;
+		pData[m_dataCount++] = data;
+		if (m_dataCount == (sizeof(frame_hdr_t)))
+		{
+			m_scrambler.stateSet(m_Hdr.prn_state);
+			m_scrambler.process((uint8_t*)&m_Hdr.crc16, sizeof(m_Hdr.crc16));
+			m_scrambler.process((uint8_t*)&m_Hdr.type, sizeof(m_Hdr.type));
+			m_scrambler.process((uint8_t*)&m_Hdr.length, sizeof(m_Hdr.length));
+			m_dataCount = 0; 
+			m_state = Data;
+		}
+	}
+	else if (m_state == Data)
+	{
+		pData = (uint8_t*)&m_data;
+		pData[m_dataCount++] = data;
+		if (m_dataCount == m_Hdr.length)
+		{
+			m_scrambler.process(m_data, FRAME_NUM_BYTES_PER_FRAME);
+			uint16_t crc16_ist = Crc16(FRAME_CRC16_POLY, FRAME_CRC16_IV, m_data, FRAME_NUM_BYTES_PER_FRAME);
+			if (crc16_ist == m_Hdr.crc16)
 			{
 				// Frame is valid
-			if (m_frame.hdr.type == FRAME_TYPE_DATA)
+				if (m_Hdr.type == FRAME_TYPE_DATA)
 				{
-				m_frameStats.numDataBytes += m_frame.hdr.length;
+					m_frameStats.numDataBytes += m_Hdr.length;
-				m_pDataHandler->onData(m_frame.data, m_frame.hdr.length);
+					m_pDataHandler->onData(m_data, m_Hdr.length);
 				}
 			}
-		m_frameStats.numDataFrame += (uint32_t)(m_frame.hdr.type == FRAME_TYPE_DATA);
+			m_frameStats.numDataFrame += (uint32_t)(m_Hdr.type == FRAME_TYPE_DATA);
-		m_frameStats.numIdleFrame += (uint32_t)(m_frame.hdr.type == FRAME_TYPE_IDLE);
+			m_frameStats.numIdleFrame += (uint32_t)(m_Hdr.type == FRAME_TYPE_IDLE);
-		m_frameStats.numInvalidFrame += (uint32_t)(crc16_ist != m_frame.hdr.crc16);
+			m_frameStats.numInvalidFrame += (uint32_t)(crc16_ist != m_Hdr.crc16);
 			m_frameStats.numTotalFrame++;
 			m_dataCount = 0;
-		m_enable = 0;
+			m_state = Idle;
+		}
 	}
 }
 
@@ -190,7 +202,7 @@ void DeFormatter::resetStats()
 void DeFormatter::onReset()
 {
 	m_dataCount = 0;
-	m_enable = 1;
+	m_state = Header;
 };
 
 void DeFormatter::onData(data_t data)

radio/Formatter.hpp

@@ -55,6 +55,12 @@ public:
 
 class DeFormatter : public IData
 {
+	enum State
+	{
+		Idle,
+		Header,
+		Data
+	};
 public:
 	DeFormatter(IDeFormatter *pDataHandler);
 	~DeFormatter();
@@ -66,9 +72,10 @@ private:
 	IDeFormatter *m_pDataHandler;
 	Scrambler m_scrambler;
 	uint32_t m_dataCount;
-	frame_t m_frame;
+	frame_hdr_t m_Hdr;
+	uint8_t m_data[FRAME_NUM_BYTES_PER_FRAME];
 	frame_statistics_t m_frameStats;
-	bool m_enable;
+	State m_state;
 	void onData(data_t data) override; 
 	void onReset() override;
 };

radio/FrameDefs.hpp

@@ -29,9 +29,17 @@ enum frame_type
 
 #pragma pack(push)
 #pragma pack(1)
+typedef struct _sync_t
+{
+} sync_t;
+
+typedef struct _preamble_t
+{
+	uint8_t data[2];
+} preamble_t;
+
 typedef struct _frame_hdr_t
 {
-	uint8_t preamble[2];
 	uint32_t prn_state;
 	uint16_t crc16;
 	uint16_t type;
@@ -41,6 +49,8 @@ typedef struct _frame_hdr_t
 
 typedef struct _frame_t
 {
+	sync_t sync;
+	preamble_t preamble;
 	frame_hdr_t hdr;
 	uint8_t data[FRAME_NUM_BYTES_PER_FRAME];
 

radio/Symbolizer.cpp

@@ -113,7 +113,6 @@ void DeSymbolizer::setNumBitsPerSymbol(uint32_t nBitsPerSym)
 		m_symbolMask <<= 1;
 		m_symbolMask |= 1;
 	}
-	m_bitCount = 0;
 	m_dataBitCount = 0;
 	m_lastSymbol = 0;
 }
@@ -125,7 +124,6 @@ void DeSymbolizer::process(uint32_t src)
 	static uint16_t preamble;
 	uint16_t preamble_soll;
 	uint32_t symSync;
-	const uint32_t frameLengthInBits = 8*sizeof(frame_t);
 	src = differentialDecode(src);
 	symSync = src;
 
@@ -137,23 +135,15 @@ void DeSymbolizer::process(uint32_t src)
 		preamble <<= 1;
 		preamble |= (uint32_t)((symSync >> (m_nBitsPerSym-1) & 1) != 0);
 		symSync <<= 1;
-		m_bitCount++;
 		if (preamble == preamble_soll)
 		{
 			preamble = 0;
 			// We have data sync
-			if (m_bitCount == frameLengthInBits)
-			{
 			m_dataBitCount = 0;
 			m_pDataHandler->onReset();
 			j = i + 1;
 			src = symSync;
 		}
-			if (m_bitCount >= frameLengthInBits)
-			{
-				m_bitCount = 0;
-			}
-		}
 	}
 
 	// Transmission order MSB first

radio/Symbolizer.hpp

@@ -45,7 +45,6 @@ public:
 private:
 	uint32_t m_nBitsPerSym;
 	IData *m_pDataHandler;
-	uint32_t m_bitCount;
 	uint32_t m_dataBitCount;
 	symbol_t m_lastSymbol;
 	symbol_t m_symbolMask;