localhorst/smart-oil-heating-control-system
SHA256
1
0
Fork 0
Code Issues 6 Pull Requests 1 Actions Packages Projects Releases 1 Wiki Activity

rework average calc and export avg

Browse Source
This commit is contained in:
Hendrik Schutter 2024-12-10 22:11:59 +01:00
parent cec891f0df
commit dfddeab566
3 changed files with 99 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
main/inputs.c
View File

@ -6,22 +6,26 @@
#include "inputs.h" #include "inputs.h"
#define MIN(x, y) (((x) < (y)) ? (x) : (y)) #define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MAX_DN18B20_SENSORS 4U #define MAX_DN18B20_SENSORS 4U
#define PERIODIC_INTERVAL 1U // read and compute the inputs every 1sec #define PERIODIC_INTERVAL 1U // read and compute the inputs every 1sec
#define AVG10_SAMPLE_SIZE 10U #define AVG10_SAMPLE_SIZE 10U
#define AVG60_SAMPLE_SIZE 60U #define AVG60_SAMPLE_SIZE 60U
typedef struct _Measurement typedef struct _Average
{ {
float lastValue; float value;
float average10s;
float average60s;
float samples[MAX(AVG10_SAMPLE_SIZE, AVG60_SAMPLE_SIZE)]; float samples[MAX(AVG10_SAMPLE_SIZE, AVG60_SAMPLE_SIZE)];
size_t bufferIndex; size_t bufferIndex;
size_t bufferCount; size_t bufferCount;
} sAverage;
typedef struct _Measurement
{
float value;
sAverage average10s;
sAverage average60s;
} sMeasurement; } sMeasurement;
static const char *TAG = "smart-oil-heater-control-system-inputs"; static const char *TAG = "smart-oil-heater-control-system-inputs";
@ -45,6 +49,7 @@ static sMeasurement fInletFlowTemperature;
static sMeasurement fReturnFlowTemperature; static sMeasurement fReturnFlowTemperature;
void taskInput(void *pvParameters); void taskInput(void *pvParameters);
void updateAverage(sMeasurement *pMeasurement);
void initInputs(void) void initInputs(void)
{ {
@ -85,37 +90,50 @@ void initInputs(void)
} }
} }
// Function to add a new temperature value to the buffer void updateAverage(sMeasurement *pMeasurement)
void updateAverage(sMeasurement* pMeasurement) { /* Average form the last 10sec */
{ pMeasurement->average10s.samples[pMeasurement->average10s.bufferIndex] = pMeasurement->value;
pMeasurement->samples[pMeasurement->bufferIndex] = pMeasurement->lastValue; pMeasurement->average10s.bufferIndex = (pMeasurement->average10s.bufferIndex + 1) % AVG10_SAMPLE_SIZE;
pMeasurement->bufferIndex = (pMeasurement->bufferIndex + 1) % MAX(AVG10_SAMPLE_SIZE, AVG60_SAMPLE_SIZE);
if (pMeasurement->bufferCount < MAX(AVG10_SAMPLE_SIZE, AVG60_SAMPLE_SIZE)) if (pMeasurement->average10s.bufferCount < AVG10_SAMPLE_SIZE)
{ {
pMeasurement->bufferCount++; pMeasurement->average10s.bufferCount++;
} }
if (pMeasurement->bufferCount == 0U) if (pMeasurement->average10s.bufferCount == 0U)
{ {
pMeasurement->average10s = pMeasurement->lastValue; pMeasurement->average10s.value = pMeasurement->value;
pMeasurement->average60s = pMeasurement->lastValue;
} }
float sum = 0.0; float sum = 0.0;
for (int i = 0; i < MIN(pMeasurement->bufferCount, AVG10_SAMPLE_SIZE); i++) for (int i = 0; i < pMeasurement->average10s.bufferCount; i++)
{ {
sum += pMeasurement->samples[i]; sum += pMeasurement->average10s.samples[i];
} }
pMeasurement->average10s = sum / MIN(pMeasurement->bufferCount, AVG10_SAMPLE_SIZE); pMeasurement->average10s.value = sum / pMeasurement->average10s.bufferCount;
/* Average form the last 60sec */
pMeasurement->average60s.samples[pMeasurement->average60s.bufferIndex] = pMeasurement->value;
pMeasurement->average60s.bufferIndex = (pMeasurement->average60s.bufferIndex + 1) % AVG60_SAMPLE_SIZE;
if (pMeasurement->average60s.bufferCount < AVG60_SAMPLE_SIZE)
{
pMeasurement->average60s.bufferCount++;
}
if (pMeasurement->average60s.bufferCount == 0U)
{
pMeasurement->average60s.value = pMeasurement->value;
}
sum = 0.0; sum = 0.0;
for (int i = 0; i < MIN(pMeasurement->bufferCount, AVG60_SAMPLE_SIZE); i++) for (int i = 0; i < pMeasurement->average60s.bufferCount; i++)
{ {
sum += pMeasurement->samples[i]; sum += pMeasurement->average60s.samples[i];
} }
pMeasurement->average60s = sum / MIN(pMeasurement->bufferCount, AVG60_SAMPLE_SIZE);
pMeasurement->average60s.value = sum / pMeasurement->average60s.bufferCount;
} }
void taskInput(void *pvParameters) void taskInput(void *pvParameters)
@ -167,19 +185,19 @@ void taskInput(void *pvParameters)
switch ((uint64_t)uOneWireAddresses[j]) switch ((uint64_t)uOneWireAddresses[j])
{ {
case ((uint64_t)uChamperTempSensorAddr): case ((uint64_t)uChamperTempSensorAddr):
fChamperTemperature.lastValue = temp_c; fChamperTemperature.value = temp_c;
updateAverage(&fChamperTemperature); updateAverage(&fChamperTemperature);
break; break;
case ((uint64_t)uOutdoorTempSensorAddr): case ((uint64_t)uOutdoorTempSensorAddr):
fOutdoorTemperature.lastValue = temp_c; fOutdoorTemperature.value = temp_c;
updateAverage(&fOutdoorTemperature); updateAverage(&fOutdoorTemperature);
break; break;
case ((uint64_t)uInletFlowTempSensorAddr): case ((uint64_t)uInletFlowTempSensorAddr):
fInletFlowTemperature.lastValue = temp_c; fInletFlowTemperature.value = temp_c;
updateAverage(&fInletFlowTemperature); updateAverage(&fInletFlowTemperature);
break; break;
case ((uint64_t)uReturnFlowTempSensorAddr): case ((uint64_t)uReturnFlowTempSensorAddr):
fReturnFlowTemperature.lastValue = temp_c; fReturnFlowTemperature.value = temp_c;
updateAverage(&fReturnFlowTemperature); updateAverage(&fReturnFlowTemperature);
break; break;
default: default:
@ -201,13 +219,13 @@ float getChamberTemperature(eMeasurementMode mode)
switch (mode) switch (mode)
{ {
case CURRENT: case CURRENT:
ret = fChamperTemperature.lastValue; ret = fChamperTemperature.value;
break; break;
case AVERAGE_10S: case AVERAGE_10S:
ret = fChamperTemperature.average10s; ret = fChamperTemperature.average10s.value;
break; break;
case AVERAGE_60S: case AVERAGE_60S:
ret = fChamperTemperature.average60s; ret = fChamperTemperature.average60s.value;
break; break;
default: default:
break; break;
@ -224,13 +242,13 @@ float getOutdoorTemperature(eMeasurementMode mode)
switch (mode) switch (mode)
{ {
case CURRENT: case CURRENT:
ret = fOutdoorTemperature.lastValue; ret = fOutdoorTemperature.value;
break; break;
case AVERAGE_10S: case AVERAGE_10S:
ret = fOutdoorTemperature.average10s; ret = fOutdoorTemperature.average10s.value;
break; break;
case AVERAGE_60S: case AVERAGE_60S:
ret = fOutdoorTemperature.average60s; ret = fOutdoorTemperature.average60s.value;
break; break;
default: default:
break; break;
@ -247,13 +265,13 @@ float getInletFlowTemperature(eMeasurementMode mode)
switch (mode) switch (mode)
{ {
case CURRENT: case CURRENT:
ret = fInletFlowTemperature.lastValue; ret = fInletFlowTemperature.value;
break; break;
case AVERAGE_10S: case AVERAGE_10S:
ret = fInletFlowTemperature.average10s; ret = fInletFlowTemperature.average10s.value;
break; break;
case AVERAGE_60S: case AVERAGE_60S:
ret = fInletFlowTemperature.average60s; ret = fInletFlowTemperature.average60s.value;
break; break;
default: default:
break; break;
@ -270,13 +288,13 @@ float getReturnFlowTemperature(eMeasurementMode mode)
switch (mode) switch (mode)
{ {
case CURRENT: case CURRENT:
ret = fReturnFlowTemperature.lastValue; ret = fReturnFlowTemperature.value;
break; break;
case AVERAGE_10S: case AVERAGE_10S:
ret = fReturnFlowTemperature.average10s; ret = fReturnFlowTemperature.average10s.value;
break; break;
case AVERAGE_60S: case AVERAGE_60S:
ret = fReturnFlowTemperature.average60s; ret = fReturnFlowTemperature.average60s.value;
break; break;
default: default:
break; break;

40
main/metrics.c
View File

@ -142,6 +142,46 @@ void taskMetrics(void *pvParameters)
aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature(CURRENT); aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature(CURRENT);
u16MetricCounter++; u16MetricCounter++;
/*Chamber Temperature Average 10s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg10");
aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature(AVERAGE_10S);
u16MetricCounter++;
/*Outdoor Temperature Average 10s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg10");
aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature(AVERAGE_10S);
u16MetricCounter++;
/*Chamber Temperature Average 10s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg10");
aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature(AVERAGE_10S);
u16MetricCounter++;
/*Chamber Temperature Average 10s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg10");
aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature(AVERAGE_10S);
u16MetricCounter++;
/*Chamber Temperature Average 60s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg60");
aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature(AVERAGE_60S);
u16MetricCounter++;
/*Outdoor Temperature Average 60s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg60");
aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature(AVERAGE_60S);
u16MetricCounter++;
/*Chamber Temperature Average 60s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg60");
aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature(AVERAGE_60S);
u16MetricCounter++;
/*Chamber Temperature Average 60s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg60");
aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature(AVERAGE_60S);
u16MetricCounter++;
vSetMetrics(aMetrics, u16MetricCounter); vSetMetrics(aMetrics, u16MetricCounter);
} }
} }

6
main/metrics.h
View File

@ -4,9 +4,9 @@
#define WIFI_CONNECTED_BIT BIT0 #define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT BIT1 #define WIFI_FAIL_BIT BIT1
#define HTML_RESPONSE_SIZE 512U #define HTML_RESPONSE_SIZE 1024U
#define METRIC_NAME_MAX_SIZE 64U #define METRIC_NAME_MAX_SIZE 256U
#define METRIC_MAX_COUNT 32U #define METRIC_MAX_COUNT 64U
typedef struct _metric typedef struct _metric
{ {