Reworked buffering structure

software/app/ads_converter.cpp

@@ -29,12 +29,12 @@ void cAdsConverter::ReceiveCallback(void* i_data, cDataReceiver* i_provider) {
 		int64_t average = 0;
 		int size = i_adcBuffer->GetSize();
 		arr.size = size;
-		arr.array = new uint32_t[size];
+		arr.u_array = new uint32_t[size];
 		for (int i = 0; i < size; i++) {
-			arr.array[i] = m_adc.ConvertSample(buf[i]);
+			arr.u_array[i] = m_adc.ConvertSample(buf[i]);
 		}
 		m_convertedSamples[pos].Push(static_cast<void *>(&arr));
-		delete arr.array;
+		delete arr.u_array;
 	}
 }
 

software/app/application.cpp

@@ -22,6 +22,13 @@ cAdsConverter * adsConverter;
 
 //We want different signal processing for the channels
 cSignalProcess signalProcess[2];
+
+cProviderAverager<uint16_t, uint32_t> averagers[4];
+cProviderBuffer<uint32_t> bufferChannels[2] { { 1024 }, { 1024 } };
+
+cProviderAverager<uint16_t, uint32_t> processedAveragers[2] { { 10 }, { 10 } };
+cProviderAverager<uint16_t, uint32_t> processedAveragersBuffer[2] { { 10 }, { 10 } };
+
 Timer procTimer;
 Timer rectangleTimer;
 Timer _stopTimer;
@@ -112,14 +119,20 @@ void init() {
 	hub.SetAdcSettings(adcSettings);
 
 	// Channel one and two are getting processed
-	adsConverter->m_convertedSamples[0].Connect(&signalProcess[0].m_incommingData);
-	adsConverter->m_convertedSamples[1].Connect(&signalProcess[1].m_incommingData);
-	signalProcess[0].m_processedData.Connect(&cWebInterface::GetInstance()->m_adc_0);
-	signalProcess[1].m_processedData.Connect(&cWebInterface::GetInstance()->m_adc_1);
-	// Channel three and four are not
-	adsConverter->m_convertedSamples[2].Connect(&cWebInterface::GetInstance()->m_adc_2);
-	adsConverter->m_convertedSamples[3].Connect(&cWebInterface::GetInstance()->m_adc_3);
+	// adc:uint16 -- buffer:sSizedArray[] -- signal:sSizedArray[] -- average:uint16 -- web
+	for (int i = 0; i < 2; i++) {
+		hub.m_adc_output[i].Connect(&bufferChannels[i].m_input);
+		bufferChannels[i].m_output.Connect(&signalProcess[i].m_incommingData);
+		signalProcess[i].m_processedData.Connect(&processedAveragers[i].m_input);
+		processedAveragers[i].m_output.Connect(&processedAveragersBuffer[i].m_input);
+		processedAveragersBuffer[i].m_output.Connect(&cWebInterface::GetInstance()->m_sensorValRaw);
 
+	}
+
+	for (int i = 0; i < 4; i++) {
+		hub.m_adc_output[i].Connect(&averagers[i].m_input);
+		averagers[i].m_output.Connect(&cWebInterface::GetInstance()->m_adcAverage[i]);
+	}
 	cWebInterface::GetInstance()->StartServer();
 
 	mylight.SetCurrent(500);

software/app/port_utilities.cpp

@@ -0,0 +1,21 @@
+/*
+ * port_utilities.cpp
+ *
+ *  Created on: Aug 29, 2017
+ *      Author: Elmar
+ */
+
+#include "port_utilities.h"
+
+namespace rijnfel {
+
+cPortUtilities::cPortUtilities() {
+	// TODO Auto-generated constructor stub
+
+}
+
+cPortUtilities::~cPortUtilities() {
+	// TODO Auto-generated destructor stub
+}
+
+} /* namespace rijnfel */

software/app/port_utilities.h

@@ -0,0 +1,23 @@
+/*
+ * port_utilities.h
+ *
+ *  Created on: Aug 29, 2017
+ *      Author: Elmar
+ */
+
+#ifndef APP_PORT_UTILITIES_H_
+#define APP_PORT_UTILITIES_H_
+
+#include <rijnfel_core/rijnfel_core.h>
+
+namespace rijnfel {
+
+class cPortUtilities {
+public:
+	cPortUtilities();
+	virtual ~cPortUtilities();
+};
+
+} /* namespace rijnfel */
+
+#endif /* APP_PORT_UTILITIES_H_ */

software/app/sensor_hub.cpp

@@ -23,9 +23,9 @@ void cSensorHub::Update() {
 		return;
 	if (m_adcSettings) {
 		if (m_adcSettings->ShouldSample(m_updatePeriod)) {
-			if (m_adcSettings->m_buffer.AddValue(m_adc->RawSample())) {
-				m_adcSettings->m_samplesProvider.Push(static_cast<void*>(&m_adcSettings->m_buffer));
-			}
+			ads::ads_sample_t sample = m_adc->RawSample();
+			ads::ads_voltage_t voltage = m_adc->ConvertSample(sample);
+			m_adc_output[sample.mux - ads::eInputMux::AIN_0].Push(&voltage);
 		}
 	}
 }
@@ -50,7 +50,7 @@ void cSensorHub::Stop() {
 		m_running = false;
 		//if (m_adcSettings) {
 		//	m_adcSettings->m_samplesProvider.Push(static_cast<void*>(&m_adcSettings->m_buffer));
-			m_adcSettings->Reset();
+		m_adcSettings->Reset();
 		//}
 	}
 }

software/app/sensor_hub.h

@@ -8,7 +8,7 @@
 #ifndef APP_SENSOR_HUB_H_
 #define APP_SENSOR_HUB_H_
 
-#include <rijnfel_core/sensor_settings.h>
+#include <rijnfel_core/rijnfel_core.h>
 #include "ads101x.h"
 
 
@@ -25,7 +25,7 @@ public:
 	void SetTempSettings(cSensorSettings<uint32_t> * i_tempSettings);
 	void Update();
 	virtual ~cSensorHub();
-
+	cDataProvider m_adc_output[4];
 private:
 	uint32_t m_updatePeriod;
 	cSensorSettings<ads::ads_sample_t> * m_adcSettings;

software/app/signal_process.cpp

@@ -9,8 +9,6 @@
 #include <stddef.h>
 #include <SmingCore/SmingCore.h>
 #include <rijnfel_core/rijnfel_core.h>
-#include <arduinoFFT.h>
-#include <signal_processing.h>
 
 //TODO remove this
 
@@ -31,35 +29,17 @@ cSignalProcess::~cSignalProcess() {
 
 void cSignalProcess::ReceiveCallback(void* i_data, cDataReceiver* i_provider) {
 	sSizedArray * arr = static_cast<sSizedArray*>(i_data);
-	process(arr->array, arr->size);
+	process(arr->u_array, arr->size);
+	Serial.printf("Size: %d\n", arr->size);
 	m_processedData.Push(i_data);
 }
 
 void cSignalProcess::process(uint32_t* io_array, size_t size) {
-	//Vars
-	arduinoFFT FFT;
-	double vReal[SAMPLES];
-	double vImag[SAMPLES];
-
-	//Action
-	Serial.printf("Size:%d\n", size);
-	for(int i = 0; i < SAMPLES; i++)
-	{
-		vReal[i] = (double)(io_array[i]);	
-	}
-	Serial.printf("Casted.\n");
-	FFT.Windowing(vReal, SAMPLES, FFT_WIN_TYP_HAMMING, FFT_FORWARD);	
-	Serial.printf("Windowed.\n");
-	FFT.Compute(vReal, vImag, SAMPLES, FFT_FORWARD);
-	Serial.printf("Computed.\n");
-	print(vReal);
 }
 
-void cSignalProcess::print(double* vData)
-{
-	for(int i = 0; i < SAMPLES; i++)
-	{
-		if(i == SAMPLES-1)
+void cSignalProcess::print(double* vData) {
+	for (int i = 0; i < SAMPLES; i++) {
+		if (i == SAMPLES - 1)
 			Serial.printf("%f\n", vData[i]);
 		else
 			Serial.printf("%f, ", vData[i]);

software/app/web_interface.cpp

@@ -62,17 +62,11 @@ void wsDisconnected(WebSocketConnection& socket) {
 }
 
 cWebInterface::cWebInterface() :
-		m_serverStarted(false), m_adc_0(this), m_adc_1(this), m_adc_2(this), m_adc_3(this), m_connectedUser(NULL), m_sendWebsocket(
-				false) {
+		m_serverStarted(false), m_adcAverage { { this }, { this }, { this }, { this } }, m_sensorValRaw(this), m_connectedUser(
+		NULL), m_sendWebsocket(false) {
 	for (int i = 0; i < 4; i++) {
-		m_adc_value_average[i] = 0;
+		m_adcAverageVal[i] = 0;
 	}
-	// Integer requires 8 digits, and one for the comma
-	// m_jsonBuffer = new char[1];
-	// if (m_jsonBuffer == NULL) {
-	//	Serial.print("Not enough ram");
-	//}
-	// TODO Auto-generated constructor stub
 
 }
 
@@ -126,11 +120,11 @@ void cWebInterface::OnRefresh(HttpRequest & i_request, HttpResponse & i_response
 	JsonObjectStream* stream = new JsonObjectStream();
 	JsonObject& json = stream->getRoot();
 
-	json["adc_1"] = m_adc_value_average[0];
-	json["adc_2"] = m_adc_value_average[1];
+	json["adc_1"] = m_adcAverageVal[0];
+	json["adc_2"] = m_adcAverageVal[1];
 #ifdef REV_1
-	json["adc_3"] = m_adc_value_average[3];
-	json["adc_4"] = m_adc_value_average[2];
+	json["adc_3"] = m_adcAverageVal[3];
+	json["adc_4"] = m_adcAverageVal[2];
 #else
 	json["adc_3"] = m_adc_value_average[2];
 	json["adc_4"] = m_adc_value_average[3];
@@ -142,32 +136,33 @@ void cWebInterface::OnRawUpdate(HttpRequest& i_request, HttpResponse& i_response
 }
 
 void cWebInterface::ReceiveCallback(void* i_data, cDataReceiver* i_receiver) {
-	int64_t average = 0;
-	sSizedArray * arr = static_cast<sSizedArray *>(i_data);
-	char buf[12];
-	for (int i = 0; i < arr->size; i++) {
-		average += arr->array[i];
+	if (i_receiver == &m_sensorValRaw) {
 		if (m_connectedUser != NULL && m_sendWebsocket) {
-			sprintf(buf, "%d,", arr->array[i]);
-			const String send(buf);
-			m_connectedUser->sendString(send);
+			sSizedArray * arr = static_cast<sSizedArray *>(i_data);
+			Serial.printf("Web Size: %d\n", arr->size);
+			char buf[12];
+			for (size_t i = 0; i < arr->size; i++) {
+				sprintf(buf, "%d,", arr->u_array[i]);
+				const String sendString(buf);
+				m_connectedUser->sendString(sendString);
+				if (i % 10 == 0)
+					WDT.alive();
+			}
+		}
+	} else {
+		for (int i = 0; i < 4; i++) {
+			if (i_receiver == &m_adcAverage[i]) {
+				m_adcAverageVal[i] = *static_cast<int32_t *>(i_data);
+				PrintValues();
+				break;
+			}
 		}
-	}
-	average /= arr->size;
-	if (i_receiver == &m_adc_0) {
-		m_adc_value_average[0] = static_cast<int32_t>(average);
-	} else if (i_receiver == &m_adc_1) {
-		m_adc_value_average[1] = static_cast<int32_t>(average);
-	} else if (i_receiver == &m_adc_2) {
-		m_adc_value_average[2] = static_cast<int32_t>(average);
-	} else if (i_receiver == &m_adc_3) {
-		m_adc_value_average[3] = static_cast<int32_t>(average);
 	}
 }
 
 void cWebInterface::PrintValues() {
-	Serial.printf("c[0]: %d c[1]: %d c[2]: %d c[3]: %d\n\r", m_adc_value_average[0], m_adc_value_average[1],
-			m_adc_value_average[2], m_adc_value_average[3]);
+	Serial.printf("c[0]: %d c[1]: %d c[2]: %d c[3]: %d\n\r", m_adcAverageVal[0], m_adcAverageVal[1], m_adcAverageVal[2],
+			m_adcAverageVal[3]);
 }
 
 cWebInterface::~cWebInterface() {

software/app/web_interface.h

@@ -15,8 +15,7 @@
 #include <rijnfel_core/rijnfel_core.h>
 
 namespace rijnfel {
-#define RAW_CHANNEL 1
-#define RAW_SAMPLES 1000
+
 class cWebInterface: public cDataSink {
 public:
 	/**
@@ -74,10 +73,8 @@ public:
 	// cDataReceiver m_ledLife;
 	// cDataReceiver m_temp;
 	// But for now...
-	cDataReceiver m_adc_0;
-	cDataReceiver m_adc_1;
-	cDataReceiver m_adc_2;
-	cDataReceiver m_adc_3;
+	cDataReceiver m_sensorValRaw;
+	cDataReceiver m_adcAverage[4];
 
 	virtual void ReceiveCallback(void * i_data, cDataReceiver * i_receiver);
 public:
@@ -117,7 +114,7 @@ private:
 	/// Whether the server has started or not
 	bool m_serverStarted;
 	/// Holds the average for all the channels
-	int32_t m_adc_value_average[4];
+	int32_t m_adcAverageVal[4];
 	/// Server instance
 	HttpServer m_server;
 };

software/include/rijnfel_core/helper_structs.h

@@ -8,15 +8,17 @@
 #ifndef APP_HELPER_STRUCTS_H_
 #define APP_HELPER_STRUCTS_H_
 
-namespace rijnfel{
+namespace rijnfel {
 
-struct sSizedArray{
+struct sSizedArray {
 	size_t size;
-	uint32_t * array;
+	union {
+		uint32_t * u_array;
+		int32_t * i_array;
+		void * p_array;
+	};
 };
 
 }
 
-
-
 #endif /* APP_HELPER_STRUCTS_H_ */

software/include/rijnfel_core/provider_averager.h

@@ -0,0 +1,53 @@
+/*
+ * provider_averager.h
+ *
+ *  Created on: Aug 29, 2017
+ *      Author: Elmar
+ */
+
+#ifndef APP_PROVIDER_AVERAGER_H_
+#define APP_PROVIDER_AVERAGER_H_
+
+#include "data_provider.h"
+
+namespace rijnfel {
+template<typename DataType, typename MaxType>
+class cProviderAverager: public cDataSink {
+public:
+	cProviderAverager(uint32_t i_averageSize = 250) :
+			m_input(this) {
+		m_averageSize = i_averageSize;
+		m_counter = 0;
+	}
+
+	virtual void ReceiveCallback(void * i_data, cDataReceiver * i_receiver) {
+		m_outcome += *static_cast<DataType*>(i_data);
+		m_counter++;
+		if (m_counter >= m_averageSize ) {
+			if (m_averageSize == 0) {
+				//TODO log message
+				return;
+			}
+			m_outcome = m_outcome / m_counter;
+			m_output.Push(&m_outcome);
+			Reset();
+		}
+	}
+	void Reset() {
+		m_outcome = 0;
+		m_counter = 0;
+	}
+	virtual ~cProviderAverager() {
+	}
+	cDataReceiver m_input;
+	cDataProvider m_output;
+private:
+	uint32_t m_averageSize;
+	uint32_t m_counter;
+
+	MaxType m_outcome;
+};
+
+} /* namespace rijnfel */
+
+#endif /* APP_PROVIDER_AVERAGER_H_ */

software/include/rijnfel_core/provider_buffer.h

@@ -0,0 +1,52 @@
+/*
+ * provider_buffer.h
+ *
+ *  Created on: Aug 29, 2017
+ *      Author: Elmar
+ */
+
+#ifndef APP_PROVIDER_BUFFER_H_
+#define APP_PROVIDER_BUFFER_H_
+
+#include "data_provider.h"
+#include "helper_structs.h"
+
+namespace rijnfel {
+template<typename Data>
+class cProviderBuffer: public cDataSink {
+public:
+	cProviderBuffer(size_t i_bufferSize) :
+			m_input(this) {
+		m_bufferSize = i_bufferSize;
+		m_counter = 0;
+		m_array = new Data[i_bufferSize];
+		m_sizedArray.p_array = static_cast<void*>(m_array);
+		m_sizedArray.size = m_bufferSize;
+	}
+
+	virtual void ReceiveCallback(void * i_data, cDataReceiver * i_receiver) {
+		m_array[m_counter] = *static_cast<Data*>(i_data);
+		m_counter++;
+		if (m_counter == m_bufferSize) {
+			m_output.Push(static_cast<void*>(&m_sizedArray));
+			Reset();
+		}
+	}
+	void Reset(){
+		m_counter = 0;
+	}
+	virtual ~cProviderBuffer() {
+		delete[] m_array;
+	}
+	cDataReceiver m_input;
+	cDataProvider m_output;
+private:
+	sSizedArray m_sizedArray;
+	size_t m_bufferSize;
+	size_t m_counter;
+	Data * m_array;
+};
+
+} /* namespace rijnfel */
+
+#endif /* APP_PROVIDER_BUFFER_H_ */

software/include/rijnfel_core/rijnfel_core.h

@@ -13,6 +13,8 @@
 #include "data_receiver.h"
 #include "data_sink.h"
 #include "double_buffer.h"
+#include "provider_averager.h"
+#include "provider_buffer.h"
 #include "helper_structs.h"
 #include "sensor_settings.h"