- blockifized DeSymbolizer, DeFormatter, FrameReceiver

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

radio/DeFormatter.cpp

@@ -3,7 +3,7 @@
 #include <math.h>
 #include <stdint.h>
 #include <algorithm>
-#include <stdio.h>
+#include <cstdio>
 
 #include <crc/crc.h>
 #include "DeFormatter.hpp"
@@ -11,87 +11,113 @@
 // --------------------------------------------------------------
 // Deformatter
 // --------------------------------------------------------------
-DeFormatter::DeFormatter(IDeFormatter *pDataHandler)
+DeFormatter::DeFormatter()
-	: m_pDataHandler(pDataHandler)
+: Processor::Block(1, 1)
-	, m_scrambler(FRAME_SCRAMBLER_SEED, FRAME_SCRAMBLER_POLY)
+, m_scrambler(FRAME_SCRAMBLER_SEED, FRAME_SCRAMBLER_POLY)
-	, m_dataCount(0)
+, m_dataCount(0)
-	, m_state(Idle)
+, m_state(Idle)
 {
 	resetStats();
 }
 
-DeFormatter::~DeFormatter()
-{
-}
-
-void DeFormatter::process(uint8_t data)
-{
-	if (m_state == Idle)
-	{
-		return;
-	}
-
-	uint8_t *pData;
-	if (m_state == Header)
-	{
-		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_Hdr.type == FRAME_TYPE_DATA)
-				{
-					m_frameStats.numDataBytes += m_Hdr.length;
-					m_pDataHandler->onData(m_data, m_Hdr.length);
-				}
-			}
-			m_frameStats.numDataFrame += (uint32_t)(m_Hdr.type == FRAME_TYPE_DATA);
-			m_frameStats.numIdleFrame += (uint32_t)(m_Hdr.type == FRAME_TYPE_IDLE);
-			m_frameStats.numInvalidFrame += (uint32_t)(crc16_ist != m_Hdr.crc16);
-			m_frameStats.numTotalFrame++;
-			m_dataCount = 0;
-			m_state = Idle;
-		}
-	}
-}
-
-frame_statistics_t DeFormatter::getStats()
-{
-	return m_frameStats;
-}
-
 void DeFormatter::resetStats()
 {
 	memset(&m_frameStats, 0, sizeof(frame_statistics_t));
 }
 
-void DeFormatter::onReset()
+frame_statistics_t DeFormatter::getStats()
 {
-	m_dataCount = 0;
+	return m_frameStats;
-	m_state = Header;
+}
-};
 
-void DeFormatter::onData(data_t data)
+void DeFormatter::prepare()
 {
-	process((uint8_t)data);
+	// Get buffers
+	m_buf_in = buffer_in<uint8_t>();
+//	m_buf_out = buffer_out<uint8_t>();
+}
+
+void DeFormatter::process()
+{
+	// Process input
+	if (m_state == Idle)
+	{
+		process_sync();
+	}
+	else if (m_state == Header)
+	{
+		process_header();
+	}
+	else if (m_state == Data)
+	{
+		process_data();
+	}
+}
+
+void DeFormatter::process_sync()
+{
+	while(m_buf_in->len())
+	{
+		uint8_t data;
+		m_buf_in->read(&data, 1);
+		m_sync_preamble <<= 8;
+		m_sync_preamble = m_sync_preamble | (uint16_t)data & 0xFF;
+
+		if (m_sync_preamble == 0x55AA)
+		{
+			m_state = Header;
+			break;
+		}
+	}
+}
+
+void DeFormatter::process_header()
+{
+	if (m_buf_in->len() < sizeof(frame_hdr_t))
+	{
+		return;
+	}
+
+	m_buf_in->read((uint8_t*)&m_Hdr, 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;
+}
+
+void DeFormatter::process_data()
+{
+	if (m_Hdr.length != sizeof(m_data))
+	{
+		m_state = Idle;
+	}
+
+	if(m_buf_in->len() < m_Hdr.length)
+	{
+		return;
+	}
+
+	m_buf_in->read(m_data, m_Hdr.length);
+	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_Hdr.type == FRAME_TYPE_DATA)
+		{
+			m_frameStats.numDataBytes += m_Hdr.length;
+		}
+	}
+	m_frameStats.numDataFrame += (uint32_t)(m_Hdr.type == FRAME_TYPE_DATA);
+	m_frameStats.numIdleFrame += (uint32_t)(m_Hdr.type == FRAME_TYPE_IDLE);
+	m_frameStats.numInvalidFrame += (uint32_t)(crc16_ist != m_Hdr.crc16);
+	m_frameStats.numTotalFrame++;
+	m_dataCount = 0;
+	m_state = Idle;
 }
 
 // --------------------------------------------------------------

radio/DeFormatter.hpp

@@ -4,28 +4,12 @@
 
 #include <radio/radio_types.h>
 #include <radio/cpx.h>
+#include <cpp/radio/processor/src/Block.hpp>
 #include "FrameDefs.hpp"
 #include "Scrambler.hpp"
 
 
-class IData
+class DeFormatter : public Processor::Block
-{
-public:
-	IData() {}
-	virtual ~IData() {}
-	virtual void onData(data_t data) = 0;
-	virtual void onReset() = 0;
-};
-
-class IDeFormatter
-{
-public:
-	IDeFormatter() {}
-	virtual ~IDeFormatter() {}
-	virtual void onData(void *pData, uint32_t size) = 0;
-};
-
-class DeFormatter : public IData
 {
 	enum State
 	{
@@ -33,23 +17,32 @@ class DeFormatter : public IData
 		Header,
 		Data
 	};
+
 public:
-	DeFormatter(IDeFormatter *pDataHandler);
+	DeFormatter();
-	~DeFormatter();
+	virtual ~DeFormatter() = default;
 	void process(uint8_t data);
 	frame_statistics_t getStats();
 	void resetStats();
 
+	// Processor::Block
+	void prepare() override;
+	void process() override;
+
 private:
-	IDeFormatter *m_pDataHandler;
 	Scrambler m_scrambler;
 	uint32_t m_dataCount;
+	uint16_t m_sync_preamble;
 	frame_hdr_t m_Hdr;
 	uint8_t m_data[FRAME_NUM_BYTES_PER_FRAME];
 	frame_statistics_t m_frameStats;
 	State m_state;
-	void onData(data_t data) override; 
+	Processor::Buffer<uint8_t> *m_buf_in;
-	void onReset() override;
+	Processor::Buffer<uint8_t> *m_buf_out;
+
+	void process_sync();
+	void process_header();
+	void process_data();
 };
 
 // --------------------------------------------------------------

radio/DeSymbolizer.cpp

@@ -5,20 +5,16 @@
 #include "DeSymbolizer.hpp"
 
 
-DeSymbolizer::DeSymbolizer(IData *pDataHandler)
+DeSymbolizer::DeSymbolizer()
-	: m_pDataHandler(pDataHandler)
+: Processor::Block(1, 1)
-	, m_dataBitCount(0)
+, m_dataBitCount(0)
-	, m_lastSymbol(0)
+, m_lastSymbol(0)
-	, m_symbolMask(0)
+, m_symbolMask(0)
-	, m_nBitsPerSym(0)
+, m_nBitsPerSym(0)
 {
 	setNumBitsPerSymbol(8);
 }
 
-DeSymbolizer::~DeSymbolizer()
-{
-}
-
 void DeSymbolizer::setNumBitsPerSymbol(uint32_t nBitsPerSym)
 {
 	m_nBitsPerSym = nBitsPerSym;
@@ -41,8 +37,9 @@ void DeSymbolizer::process(uint32_t src)
 	uint32_t symSync;
 	src = differentialDecode(src);
 	symSync = src;
+	const uint8_t preamble_bytes[2] = {(uint8_t)FRAME_PREAMBLE_IV, (uint8_t)(~FRAME_PREAMBLE_IV)};
 
-	preamble_soll = ((uint16_t)FRAME_PREAMBLE_IV << 8) | (~(uint16_t)FRAME_PREAMBLE_IV & 0xFF);
+	preamble_soll = ((uint16_t)preamble_bytes[0] << 8) | ((uint16_t)preamble_bytes[1] & 0xFF);
 
 	j = 0;
 	for (i=0; i < m_nBitsPerSym; i++)
@@ -52,12 +49,12 @@ void DeSymbolizer::process(uint32_t src)
 		symSync <<= 1;
 		if (preamble == preamble_soll)
 		{
-			preamble = 0;
+			// We have bit sync
-			// We have data sync
 			m_dataBitCount = 0;
-			m_pDataHandler->onReset();
 			j = i + 1;
 			src = symSync;
+			preamble = 0;
+			m_buf_out->write(preamble_bytes, sizeof(preamble_bytes));
 		}
 	}
 
@@ -70,13 +67,31 @@ void DeSymbolizer::process(uint32_t src)
 		m_dataBitCount++;
 		if (m_dataBitCount == SIZEOF_DATA_BITS)
 		{
-			m_pDataHandler->onData(dst);
+			m_buf_out->write(&dst, 1);
 			m_dataBitCount = 0;
 			dst = 0;
 		}
 	}
 }
 
+void DeSymbolizer::prepare()
+{
+	// Get buffers
+	m_buf_in = buffer_in<symbol_t>();
+	m_buf_out = buffer_out<uint8_t>();
+}
+
+void DeSymbolizer::process()
+{
+	// Process input
+	while(m_buf_in->len())
+	{
+		symbol_t sym;
+		m_buf_in->read(&sym, 1);
+		process(sym);
+	}
+}
+
 uint32_t DeSymbolizer::differentialDecode(uint32_t symbol)
 {
 	uint32_t res;

radio/DeSymbolizer.hpp

@@ -7,21 +7,29 @@
 #include "DeFormatter.hpp"
 
 
-class DeSymbolizer
+class DeSymbolizer : public Processor::Block
 {
 public:
-	DeSymbolizer(IData *pDataHandler);
+	DeSymbolizer();
-	~DeSymbolizer();
+	virtual ~DeSymbolizer() = default;
-	void process(symbol_t src);
+
 	void setNumBitsPerSymbol(uint32_t nBitsPerSym);
+	void process(symbol_t src);
+
+	// Processor::Block
+	void prepare() override;
+	void process() override;
+
 
 private:
 	uint32_t m_nBitsPerSym;
-	IData *m_pDataHandler;
 	uint32_t m_dataBitCount;
 	symbol_t m_lastSymbol;
 	symbol_t m_symbolMask;
 	symbol_t differentialDecode(symbol_t symbol);
+	Processor::Buffer<symbol_t> *m_buf_in;
+	Processor::Buffer<uint8_t> *m_buf_out;
+
 };
 
 // --------------------------------------------------------------

radio/Frame.hpp

@@ -5,53 +5,78 @@
 #include <cstdint>
 #include <radio/radio_types.h>
 #include <radio/cpx.h>
+#include <cpp/radio/processor/src/Block.hpp>
+
 #include "FrameDefs.hpp"
 #include "Symbolizer.hpp"
 #include "Formatter.hpp"
 #include "DeSymbolizer.hpp"
 #include "DeFormatter.hpp"
 
-class FrameReceiver
+class FrameReceiver : public Processor::Block
 {
 public:
-	FrameReceiver(IDeFormatter *pRawFrameHandler)
+FrameReceiver()
-		: m_deformatter(pRawFrameHandler)
+: Processor::Block(1, 1)
-		, m_desymbolizer( &m_deformatter)
+, m_desymbolizer()
-		, m_framesCount(0)
+, m_deformatter()
-		, m_byteCount(0)
+, m_framesCount(0)
-	{
+, m_byteCount(0)
-	}
+, m_buf_symbol_in(nullptr)
+, m_buf_byte_out(nullptr)
+{
 
-	~FrameReceiver()
+}
-	{
-	}
 
-	frame_statistics_t getStats()
+~FrameReceiver()
-	{
+{
-		return m_deformatter.getStats();
+}
-	}
 
-	void resetStats()
+frame_statistics_t getStats()
-	{
+{
-		m_deformatter.resetStats();
+	return m_deformatter.getStats();
-	}
+}
 
-	void setNumBitsPerSymbol(uint32_t nBitsPerSym)
+void resetStats()
-	{
+{
-		m_desymbolizer.setNumBitsPerSymbol(nBitsPerSym);
+	m_deformatter.resetStats();
-		m_deformatter.resetStats();
+}
-	}
 
-	void process(symbol_t symbol)
+void setNumBitsPerSymbol(uint32_t nBitsPerSym)
-	{
+{
-		m_desymbolizer.process(symbol);
+	m_desymbolizer.setNumBitsPerSymbol(nBitsPerSym);
-	}
+	m_deformatter.resetStats();
+}
+
+void prepare()
+{
+	m_buf_symbol_in = buffer_in<symbol_t>();
+//	m_buf_byte_out = buffer_out<uint8_t>();
+	m_buf_byte_in.resize(2048);
+
+	m_desymbolizer.buffer_in_add(m_buf_symbol_in);
+	m_desymbolizer.buffer_out_add(&m_buf_byte_in);
+	m_desymbolizer.prepare();
+
+	m_deformatter.buffer_in_add(&m_buf_byte_in);
+	m_deformatter.buffer_out_add(m_buf_byte_out);
+	m_deformatter.prepare();
+}
+
+void process()
+{
+	m_desymbolizer.process();
+	m_deformatter.process();
+}
 
 private:
-	DeFormatter m_deformatter;
 	DeSymbolizer m_desymbolizer;
+	DeFormatter m_deformatter;
 	uint32_t m_framesCount;
 	uint32_t m_byteCount;
+	Processor::Buffer<symbol_t> *m_buf_symbol_in;
+	Processor::Buffer<uint8_t> *m_buf_byte_out;
+	Processor::Buffer<uint8_t> m_buf_byte_in;
 };
 
 // --------------------------------------------------------------