- refactored Formatter -> DeFormatter, Formatter

- refactored Symbolizer -> DeSymbolizer, Symbolizer
- Formatter is a Processor::Block
- changed retrieval for Processor::Buffer
- added Exception.hpp

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

radio/DeFormatter.cpp

@@ -0,0 +1,97 @@
+// --------------------------------------------------------------
+#include <string.h>
+#include <math.h>
+#include <stdint.h>
+#include <algorithm>
+#include <stdio.h>
+
+#include <crc/crc.h>
+#include "DeFormatter.hpp"
+
+// --------------------------------------------------------------
+// Deformatter
+// --------------------------------------------------------------
+DeFormatter::DeFormatter(IDeFormatter *pDataHandler)
+	: m_pDataHandler(pDataHandler)
+	, m_scrambler(FRAME_SCRAMBLER_SEED, FRAME_SCRAMBLER_POLY)
+	, m_dataCount(0)
+	, 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()
+{
+	m_dataCount = 0;
+	m_state = Header;
+};
+
+void DeFormatter::onData(data_t data)
+{
+	process((uint8_t)data);
+}
+
+// --------------------------------------------------------------

radio/DeFormatter.hpp

@@ -0,0 +1,56 @@
+// --------------------------------------------------------------
+#ifndef _RADIO_DEFORMATTER_HPP_
+#define	_RADIO_DEFORMATTER_HPP_
+
+#include <radio/radio_types.h>
+#include <radio/cpx.h>
+#include "FrameDefs.hpp"
+#include "Scrambler.hpp"
+
+
+class IData
+{
+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
+	{
+		Idle,
+		Header,
+		Data
+	};
+public:
+	DeFormatter(IDeFormatter *pDataHandler);
+	~DeFormatter();
+	void process(uint8_t data);
+	frame_statistics_t getStats();
+	void resetStats();
+
+private:
+	IDeFormatter *m_pDataHandler;
+	Scrambler m_scrambler;
+	uint32_t m_dataCount;
+	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; 
+	void onReset() override;
+};
+
+// --------------------------------------------------------------
+#endif // _RADIO_DEFORMATTER_HPP_

radio/DeSymbolizer.cpp

@@ -0,0 +1,91 @@
+// --------------------------------------------------------------
+#include <string.h>
+#include <math.h>
+#include <stdint.h>
+#include "DeSymbolizer.hpp"
+
+
+DeSymbolizer::DeSymbolizer(IData *pDataHandler)
+	: m_pDataHandler(pDataHandler)
+	, m_dataBitCount(0)
+	, m_lastSymbol(0)
+	, m_symbolMask(0)
+	, m_nBitsPerSym(0)
+{
+	setNumBitsPerSymbol(8);
+}
+
+DeSymbolizer::~DeSymbolizer()
+{
+}
+
+void DeSymbolizer::setNumBitsPerSymbol(uint32_t nBitsPerSym)
+{
+	m_nBitsPerSym = nBitsPerSym;
+	m_symbolMask = 0;
+	for(uint32_t k=0; k < nBitsPerSym; k++)
+	{
+		m_symbolMask <<= 1;
+		m_symbolMask |= 1;
+	}
+	m_dataBitCount = 0;
+	m_lastSymbol = 0;
+}
+
+void DeSymbolizer::process(uint32_t src)
+{
+	uint32_t i, j;
+	static uint8_t dst;
+	static uint16_t preamble;
+	uint16_t preamble_soll;
+	uint32_t symSync;
+	src = differentialDecode(src);
+	symSync = src;
+
+	preamble_soll = ((uint16_t)FRAME_PREAMBLE_IV << 8) | (~(uint16_t)FRAME_PREAMBLE_IV & 0xFF);
+
+	j = 0;
+	for (i=0; i < m_nBitsPerSym; i++)
+	{
+		preamble <<= 1;
+		preamble |= (uint32_t)((symSync >> (m_nBitsPerSym-1) & 1) != 0);
+		symSync <<= 1;
+		if (preamble == preamble_soll)
+		{
+			preamble = 0;
+			// We have data sync
+			m_dataBitCount = 0;
+			m_pDataHandler->onReset();
+			j = i + 1;
+			src = symSync;
+		}
+	}
+
+	// Transmission order MSB first
+	for (i=j; i < m_nBitsPerSym; i++)
+	{
+		dst <<= 1;
+		dst |= (uint32_t)((src >> (m_nBitsPerSym-1) & 1) != 0);
+		src <<= 1;
+		m_dataBitCount++;
+		if (m_dataBitCount == SIZEOF_DATA_BITS)
+		{
+			m_pDataHandler->onData(dst);
+			m_dataBitCount = 0;
+			dst = 0;
+		}
+	}
+}
+
+uint32_t DeSymbolizer::differentialDecode(uint32_t symbol)
+{
+	uint32_t res;
+
+	// Differential decode
+	res = (uint32_t)(m_symbolMask & (symbol - m_lastSymbol));
+	m_lastSymbol = symbol;
+
+	return res;
+}
+
+// --------------------------------------------------------------

radio/DeSymbolizer.hpp

@@ -0,0 +1,28 @@
+// --------------------------------------------------------------
+#ifndef _RADIO_DESYMBOLIZER_HPP_
+#define	_RADIO_DESYMBOLIZER_HPP_
+
+#include <radio/radio_types.h>
+#include <radio/cpx.h>
+#include "DeFormatter.hpp"
+
+
+class DeSymbolizer
+{
+public:
+	DeSymbolizer(IData *pDataHandler);
+	~DeSymbolizer();
+	void process(symbol_t src);
+	void setNumBitsPerSymbol(uint32_t nBitsPerSym);
+
+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);
+};
+
+// --------------------------------------------------------------
+#endif // _RADIO_DESYMBOLIZER_HPP_

radio/Formatter.cpp

@@ -12,10 +12,11 @@
 // Formatter
 // --------------------------------------------------------------
 Formatter::Formatter(IFormatter *pFrameHandler)
-	: m_scrambler(FRAME_SCRAMBLER_SEED, FRAME_SCRAMBLER_POLY)
+: Processor::Block(1, 1)
-	, m_pFrameHandler(pFrameHandler)
+, m_scrambler(FRAME_SCRAMBLER_SEED, FRAME_SCRAMBLER_POLY)
-	, m_dataCount(0)
+, m_pFrameHandler(pFrameHandler)
-	, m_idleCount(0)
+, m_dataCount(0)
+, m_idleCount(0)
 {
 	resetStats();
 	memset(&m_frame, 0, sizeof(frame_t));
@@ -25,10 +26,6 @@ Formatter::Formatter(IFormatter *pFrameHandler)
 	m_frame.preamble.data[1] = ~(m_frame.preamble.data[0]);
 }
 
-Formatter::~Formatter()
-{
-}
-
 void Formatter::process_data(uint8_t *pData, uint32_t len)
 {
 	if (m_idleCount)
@@ -82,8 +79,8 @@ void Formatter::process_idle(uint32_t len)
 			m_idleCount = 0;
 		}
 	}
-
 }
+
 void Formatter::process(void *pData, uint32_t len)
 {
 	if (pData)
@@ -98,6 +95,29 @@ void Formatter::process(void *pData, uint32_t len)
 	}
 }
 
+void Formatter::process()
+{
+	// Get buffers
+	auto buf_in = buffer_in<uint8_t>();
+//	auto buf_out = buffer_out<uint8_t>();
+	
+	// Process input
+	while(buf_in->len())
+	{
+		size_t frame_remain = FRAME_NUM_BYTES_PER_FRAME - m_dataCount;
+		size_t to_write = std::min(buf_in->len(), frame_remain);
+		buf_in->read(&m_frame.data[m_dataCount], to_write);
+		m_dataCount += to_write;
+
+		if (m_dataCount == FRAME_NUM_BYTES_PER_FRAME)
+		{
+			// Commit full DATA frame of size FRAME_NUM_BYTES_PER_FRAME
+			commit(FRAME_TYPE_DATA, m_dataCount);
+			m_dataCount = 0;
+		}
+	};
+}
+
 frame_statistics_t Formatter::getStats()
 {
 	return m_frameStats;
@@ -125,89 +145,3 @@ void Formatter::commit(frame_type frameType, uint32_t dataCount)
 }
 
 // --------------------------------------------------------------
-// Deformatter
-// --------------------------------------------------------------
-DeFormatter::DeFormatter(IDeFormatter *pDataHandler)
-	: m_pDataHandler(pDataHandler)
-	, m_scrambler(FRAME_SCRAMBLER_SEED, FRAME_SCRAMBLER_POLY)
-	, m_dataCount(0)
-	, 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()
-{
-	m_dataCount = 0;
-	m_state = Header;
-};
-
-void DeFormatter::onData(data_t data)
-{
-	process((uint8_t)data);
-}
-
-// --------------------------------------------------------------

radio/Formatter.hpp

@@ -4,6 +4,7 @@
 
 #include <radio/radio_types.h>
 #include <radio/cpx.h>
+#include <cpp/radio/processor/src/Block.hpp>
 #include "FrameDefs.hpp"
 #include "Scrambler.hpp"
 
@@ -15,14 +16,15 @@ public:
 	virtual void onFrame(void *pFrame, uint32_t size) = 0;
 };
 
-class Formatter
+class Formatter : public Processor::Block
 {
 public:
 	Formatter(IFormatter *pFrameHandler);
-	~Formatter();
+	virtual ~Formatter() = default;
 	void process(void *pData, uint32_t len);
 	frame_statistics_t getStats();
 	void resetStats();
+	void process();
 
 private:
 	Scrambler m_scrambler;
@@ -33,51 +35,9 @@ private:
 	frame_statistics_t m_frameStats;
 	void process_idle(uint32_t len);
 	void process_data(uint8_t *pData, uint32_t len);
+
 	void commit(frame_type frameType, uint32_t m_dataCount);
-};
+	
-
-class IData
-{
-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
-	{
-		Idle,
-		Header,
-		Data
-	};
-public:
-	DeFormatter(IDeFormatter *pDataHandler);
-	~DeFormatter();
-	void process(uint8_t data);
-	frame_statistics_t getStats();
-	void resetStats();
-
-private:
-	IDeFormatter *m_pDataHandler;
-	Scrambler m_scrambler;
-	uint32_t m_dataCount;
-	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; 
-	void onReset() override;
 };
 
 // --------------------------------------------------------------

radio/Frame.hpp

@@ -8,6 +8,8 @@
 #include "FrameDefs.hpp"
 #include "Symbolizer.hpp"
 #include "Formatter.hpp"
+#include "DeSymbolizer.hpp"
+#include "DeFormatter.hpp"
 
 class FrameReceiver
 {

radio/Makefile

@@ -5,6 +5,8 @@ NAME := Radio
 
 CXX_SRCS := $(LIBSRC_PATH)/cpp/radio/Formatter.cpp
 CXX_SRCS += $(LIBSRC_PATH)/cpp/radio/Symbolizer.cpp
+CXX_SRCS += $(LIBSRC_PATH)/cpp/radio/DeFormatter.cpp
+CXX_SRCS += $(LIBSRC_PATH)/cpp/radio/DeSymbolizer.cpp
 CXX_SRCS += $(LIBSRC_PATH)/cpp/radio/Scrambler.cpp
 CXX_SRCS += $(LIBSRC_PATH)/cpp/radio/Frame.cpp
 CXX_SRCS += $(LIBSRC_PATH)/cpp/radio/metrics/Tracker.cpp

radio/Symbolizer.cpp

@@ -14,10 +14,6 @@ Symbolizer::Symbolizer(ISymbolizer *pSymbolHandler)
 	setNumBitsPerSymbol(8);
 }
 
-Symbolizer::~Symbolizer()
-{
-}
-
 void Symbolizer::setNumBitsPerSymbol(uint32_t nBitsPerSym)
 {
 	m_symbolBitCount = 0;
@@ -90,87 +86,4 @@ void Symbolizer::onFrame(void *pFrame, uint32_t size)
 	}
 }
 
-DeSymbolizer::DeSymbolizer(IData *pDataHandler)
-	: m_pDataHandler(pDataHandler)
-	, m_dataBitCount(0)
-	, m_lastSymbol(0)
-	, m_symbolMask(0)
-	, m_nBitsPerSym(0)
-{
-	setNumBitsPerSymbol(8);
-}
-
-DeSymbolizer::~DeSymbolizer()
-{
-}
-
-void DeSymbolizer::setNumBitsPerSymbol(uint32_t nBitsPerSym)
-{
-	m_nBitsPerSym = nBitsPerSym;
-	m_symbolMask = 0;
-	for(uint32_t k=0; k < nBitsPerSym; k++)
-	{
-		m_symbolMask <<= 1;
-		m_symbolMask |= 1;
-	}
-	m_dataBitCount = 0;
-	m_lastSymbol = 0;
-}
-
-void DeSymbolizer::process(uint32_t src)
-{
-	uint32_t i, j;
-	static uint8_t dst;
-	static uint16_t preamble;
-	uint16_t preamble_soll;
-	uint32_t symSync;
-	src = differentialDecode(src);
-	symSync = src;
-
-	preamble_soll = ((uint16_t)FRAME_PREAMBLE_IV << 8) | (~(uint16_t)FRAME_PREAMBLE_IV & 0xFF);
-
-	j = 0;
-	for (i=0; i < m_nBitsPerSym; i++)
-	{
-		preamble <<= 1;
-		preamble |= (uint32_t)((symSync >> (m_nBitsPerSym-1) & 1) != 0);
-		symSync <<= 1;
-		if (preamble == preamble_soll)
-		{
-			preamble = 0;
-			// We have data sync
-			m_dataBitCount = 0;
-			m_pDataHandler->onReset();
-			j = i + 1;
-			src = symSync;
-		}
-	}
-
-	// Transmission order MSB first
-	for (i=j; i < m_nBitsPerSym; i++)
-	{
-		dst <<= 1;
-		dst |= (uint32_t)((src >> (m_nBitsPerSym-1) & 1) != 0);
-		src <<= 1;
-		m_dataBitCount++;
-		if (m_dataBitCount == SIZEOF_DATA_BITS)
-		{
-			m_pDataHandler->onData(dst);
-			m_dataBitCount = 0;
-			dst = 0;
-		}
-	}
-}
-
-uint32_t DeSymbolizer::differentialDecode(uint32_t symbol)
-{
-	uint32_t res;
-
-	// Differential decode
-	res = (uint32_t)(m_symbolMask & (symbol - m_lastSymbol));
-	m_lastSymbol = symbol;
-
-	return res;
-}
-
 // --------------------------------------------------------------

radio/Symbolizer.hpp

@@ -11,7 +11,7 @@ class ISymbolizer
 {
 public:
 	ISymbolizer() {}
-	virtual ~ISymbolizer() {}
+	virtual ~ISymbolizer() = default;
 	virtual void onSymbol(symbol_t symbol) = 0;
 };
 
@@ -19,7 +19,7 @@ class Symbolizer : public IFormatter
 {
 public:
 	Symbolizer(ISymbolizer *pSymbolHandler);
-	~Symbolizer();
+	virtual ~Symbolizer() = default;
 	void process(data_t src);
 	void process(void *pSrc, uint32_t len);
 	void setNumBitsPerSymbol(uint32_t nBitsPerSym);
@@ -34,22 +34,5 @@ private:
 	void onFrame(void *pFrame, uint32_t size) override;
 };
 
-class DeSymbolizer
-{
-public:
-	DeSymbolizer(IData *pDataHandler);
-	~DeSymbolizer();
-	void process(symbol_t src);
-	void setNumBitsPerSymbol(uint32_t nBitsPerSym);
-
-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);
-};
-
 // --------------------------------------------------------------
 #endif // _RADIO_SYMBOLIZER_HPP_

radio/interpolation/Farrow.hpp

@@ -64,8 +64,8 @@ public:
 	void process()
 	{
 		// Get buffers
-		auto buf_in = dynamic_cast<Processor::Buffer<ComplexScalar>*>(buffer_in());
+		auto buf_in = buffer_in<ComplexScalar>();
-		auto buf_out = dynamic_cast<Processor::Buffer<ComplexScalar>*>(buffer_out());
+		auto buf_out = buffer_out<ComplexScalar>();
 
 		// Process input
 		while(buf_out->free())

radio/interpolation/PolyPhase.hpp

@@ -64,8 +64,8 @@ public:
 	void process()
 	{
 		// Get buffers
-		auto buf_in = dynamic_cast<Processor::Buffer<ComplexScalar>*>(buffer_in());
+		auto buf_in = buffer_in<ComplexScalar>();
-		auto buf_out = dynamic_cast<Processor::Buffer<ComplexScalar>*>(buffer_out());
+		auto buf_out = buffer_out<ComplexScalar>();
 
 		// Process input
 		while(buf_out->free())