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

Compare commits

base: localhorst:main
Branches Tags
localhorst:main
localhorst:feature/summer-mode
localhorst:feature/wifi-stability
localhorst:testing/lab-temperature-sensor
localhorst:a0.0.1
..
compare: localhorst:a0.0.1
Branches Tags
localhorst:feature/summer-mode
localhorst:feature/wifi-stability
localhorst:main
localhorst:testing/lab-temperature-sensor
localhorst:a0.0.1

No commits in common. "main" and "a0.0.1" have entirely different histories.
main ... a0.0.1

8 changed files with 84 additions and 240 deletions
Show Stats Expand all files Collapse all files

60
README.md
View File

@ -77,35 +77,31 @@ Sntp <|-- Metrics
#### Example #### Example
``` ```
burner_fault_pending 1 burner_fault_pending 1
circulation_pump_enabled 1 circulation_pump_enabled 0
burner_enabled 0 burner_enabled 1
safety_contact_enabled 0 safety_contact_enabled 1
chamber_temperature 58.750000 chamber_temperature 21.812500
chamber_temperature_avg10 58.931252 chamber_temperature_avg10 21.837500
chamber_temperature_avg60 59.190475 chamber_temperature_avg60 21.825521
chamber_temperature_pred60 55.870998 inlet_flow_temperature 22.437500
inlet_flow_temperature 53.875000 inlet_flow_temperature_avg10 22.437500
inlet_flow_temperature_avg10 53.900002 inlet_flow_temperature_avg60 22.434896
inlet_flow_temperature_avg60 53.994320 outdoor_temperature 21.937500
inlet_flow_temperature_pred60 52.848743 outdoor_temperature_avg10 21.937500
outdoor_temperature 18.000000 outdoor_temperature_avg60 21.933594
outdoor_temperature_avg10 18.006250 return_flow_temperature 22.375000
outdoor_temperature_avg60 18.002840 return_flow_temperature_avg10 22.375000
outdoor_temperature_pred60 18.050785 return_flow_temperature_avg60 22.375000
return_flow_temperature 48.625000
return_flow_temperature_avg10 48.718750
return_flow_temperature_avg60 48.846592
return_flow_temperature_pred60 47.383083
chamber_temperature_state 0 chamber_temperature_state 0
outdoor_temperature_state 0 outdoor_temperature_state 0
inlet_flow_temperature_state 0 inlet_flow_temperature_state 0
return_flow_temperature_state 0 return_flow_temperature_state 0
safety_state 0 safety_state 0
control_state 3 control_state 5
sntp_state 0 sntp_state 0
system_unixtime 1735242392 system_unixtime 1734814285
uptime_seconds 40 uptime_seconds 90
wifi_rssi -74 wifi_rssi -63
``` ```
#### Status Encoding #### Status Encoding
@ -135,15 +131,15 @@ wifi_rssi -74
##### Control Loop ##### Control Loop
- control_state - control_state
| Enum eControlState in [control.h](main/control.h) | Value | Description | | Enum eControlState in [control.h](main/control.h) | Value | Description |
|---------------------------------------------------|-------|--------------------------------------------------| |---------------------------------------------------|-------|------------------------------------|
| CONTROL_STARTING | 0 | | | CONTROL_STARTING | 0 | |
| CONTROL_HEATING | 1 | Burner running | | CONTROL_HEATING | 1 | Burner running |
| CONTROL_OUTDOOR_TOO_WARM | 2 | Heating not needed | | CONTROL_OUTDOOR_TOO_WARM | 2 | Heating not needed |
| CONTROL_RETURN_FLOW_TOO_WARM | 3 | Heating not needed | | CONTROL_RETURN_FLOW_TOO_WARM | 3 | Heating not needed |
| CONTROL_FAULT_BURNER | 4 | Burner reported fault after threshold is reached | | CONTROL_BURNER_FAULT | 4 | Burner reported fault |
| CONTROL_FAULT_SAFETY | 5 | Unable to control due safety fault | | CONTROL_FAULT_SAFETY | 5 | Unable to control due safety fault |
| CONTROL_FAULT_SNTP | 6 | Unable to control due SNTP fault | | CONTROL_FAULT_SNTP | 6 | Unable to control due SNTP fault |
##### SNTP Client ##### SNTP Client
- sntp_state - sntp_state

35
main/control.c
View File

@ -1,6 +1,5 @@
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h" #include "freertos/task.h"
#include "esp_timer.h"
#include "esp_log.h" #include "esp_log.h"
#include "control.h" #include "control.h"
#include "outputs.h" #include "outputs.h"
@ -12,8 +11,7 @@
#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY 30.0 #define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY 30.0
#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT 25.0 #define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT 25.0
#define CHAMPER_TEMPERATURE_TARGET 80.0 #define CHAMPER_TEMPERATURE_TARGET 70.0
#define BURNER_FAULT_DETECTION_THRESHOLD (60U * 3U) // Detect burner fault if after 3 minutes no burner start detected
static const char *TAG = "smart-oil-heater-control-system-control"; static const char *TAG = "smart-oil-heater-control-system-control";
static eControlState sControlState = CONTROL_STARTING; static eControlState sControlState = CONTROL_STARTING;
@ -37,7 +35,7 @@ void initControl(void)
BaseType_t taskCreated = xTaskCreate( BaseType_t taskCreated = xTaskCreate(
taskControl, // Function to implement the task taskControl, // Function to implement the task
"taskControl", // Task name "taskControl", // Task name
8192, // Stack size (in words, not bytes) 4096, // Stack size (in words, not bytes)
NULL, // Parameters to the task function (none in this case) NULL, // Parameters to the task function (none in this case)
5, // Task priority (higher number = higher priority) 5, // Task priority (higher number = higher priority)
NULL // Task handle (optional) NULL // Task handle (optional)
@ -56,9 +54,6 @@ void initControl(void)
void taskControl(void *pvParameters) void taskControl(void *pvParameters)
{ {
bool bHeatingInAction = false; bool bHeatingInAction = false;
bool bBurnerFaultDetected = false;
int64_t i64BurnerEnableTimestamp = esp_timer_get_time();
while (1) while (1)
{ {
vTaskDelay(PERIODIC_INTERVAL * 1000U / portTICK_PERIOD_MS); vTaskDelay(PERIODIC_INTERVAL * 1000U / portTICK_PERIOD_MS);
@ -69,7 +64,7 @@ void taskControl(void *pvParameters)
sControlState = CONTROL_FAULT_SAFETY; sControlState = CONTROL_FAULT_SAFETY;
if (bHeatingInAction == true) if (bHeatingInAction == true)
{ {
ESP_LOGW(TAG, "Control not possible due to safety fault: Disable burner"); ESP_LOGI(TAG, "Control not possible due to safety fault: Disable burner");
bHeatingInAction = false; bHeatingInAction = false;
setCirculationPumpState(ENABLED); setCirculationPumpState(ENABLED);
setBurnerState(DISABLED); setBurnerState(DISABLED);
@ -84,7 +79,7 @@ void taskControl(void *pvParameters)
sControlState = CONTROL_FAULT_SNTP; sControlState = CONTROL_FAULT_SNTP;
if (bHeatingInAction == true) if (bHeatingInAction == true)
{ {
ESP_LOGW(TAG, "Control not possible due to sntp fault: Disable burner"); ESP_LOGI(TAG, "Control not possible due to sntp fault: Disable burner");
bHeatingInAction = false; bHeatingInAction = false;
setCirculationPumpState(ENABLED); setCirculationPumpState(ENABLED);
setBurnerState(DISABLED); setBurnerState(DISABLED);
@ -98,7 +93,7 @@ void taskControl(void *pvParameters)
if (bHeatingInAction == true) if (bHeatingInAction == true)
{ {
if ((getChamberTemperature().fCurrentValue >= currentControlEntry.fChamberTemperature) || (getChamberTemperature().predict60s.fValue >= currentControlEntry.fChamberTemperature)) if (getChamberTemperature().fCurrentValue >= currentControlEntry.fChamberTemperature)
{ {
ESP_LOGI(TAG, "Chamber Target Temperature reached: Disable burner"); ESP_LOGI(TAG, "Chamber Target Temperature reached: Disable burner");
bHeatingInAction = false; bHeatingInAction = false;
@ -110,27 +105,12 @@ void taskControl(void *pvParameters)
{ {
if (bHeatingInAction) if (bHeatingInAction)
{ {
int64_t i64Delta = esp_timer_get_time() - i64BurnerEnableTimestamp; // TODO: Check burner fault signal here
if ((i64Delta / 1000000U) >= BURNER_FAULT_DETECTION_THRESHOLD)
{
if (getBurnerError() == FAULT)
{
ESP_LOGW(TAG, "Detected burner fault after %lli seconds!", (i64Delta / 1000000U));
ESP_LOGW(TAG, "Control not possible due to burner fault: Disable burner");
sControlState = CONTROL_FAULT_BURNER;
bHeatingInAction = false;
bBurnerFaultDetected = true;
setCirculationPumpState(ENABLED);
setBurnerState(DISABLED);
setSafetyControlState(ENABLED);
}
}
} }
} }
} }
if ((bHeatingInAction == false) && (bBurnerFaultDetected == false)) if (bHeatingInAction == false)
{ {
if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= 45.0)) if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= 45.0))
{ {
@ -139,7 +119,6 @@ void taskControl(void *pvParameters)
setCirculationPumpState(ENABLED); setCirculationPumpState(ENABLED);
setBurnerState(ENABLED); setBurnerState(ENABLED);
setSafetyControlState(ENABLED); setSafetyControlState(ENABLED);
i64BurnerEnableTimestamp = esp_timer_get_time();
sControlState = CONTROL_HEATING; sControlState = CONTROL_HEATING;
} }
else else

2
main/control.h
View File

@ -9,7 +9,7 @@ typedef enum _ControlState
CONTROL_HEATING, CONTROL_HEATING,
CONTROL_OUTDOOR_TOO_WARM, CONTROL_OUTDOOR_TOO_WARM,
CONTROL_RETURN_FLOW_TOO_WARM, CONTROL_RETURN_FLOW_TOO_WARM,
CONTROL_FAULT_BURNER, CONTROL_BURNER_FAULT,
CONTROL_FAULT_SAFETY, CONTROL_FAULT_SAFETY,
CONTROL_FAULT_SNTP, CONTROL_FAULT_SNTP,
} eControlState; } eControlState;

123
main/inputs.c
View File

@ -1,8 +1,6 @@
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h" #include "freertos/task.h"
#include "driver/gpio.h" #include "driver/gpio.h"
#include <string.h>
#include <math.h>
#include "esp_log.h" #include "esp_log.h"
#include <ds18x20.h> #include <ds18x20.h>
@ -16,10 +14,10 @@ static const char *TAG = "smart-oil-heater-control-system-inputs";
const uint8_t uBurnerFaultPin = 19U; const uint8_t uBurnerFaultPin = 19U;
const uint8_t uDS18B20Pin = 4U; const uint8_t uDS18B20Pin = 4U;
const onewire_addr_t uChamperTempSensorAddr = 0xd00000108cd01d28; const onewire_addr_t uChamperTempSensorAddr = 0x3e0000001754be28;
const onewire_addr_t uOutdoorTempSensorAddr = 0x78000000c6c2f728; const onewire_addr_t uOutdoorTempSensorAddr = 0x880000001648e328;
const onewire_addr_t uInletFlowTempSensorAddr = 0x410000108b8c0628; const onewire_addr_t uInletFlowTempSensorAddr = 0xe59cdef51e64ff28;
const onewire_addr_t uReturnFlowTempSensorAddr = 0x90000108cc77c28; const onewire_addr_t uReturnFlowTempSensorAddr = 0xa7a8e1531f64ff28;
onewire_addr_t uOneWireAddresses[MAX_DN18B20_SENSORS]; onewire_addr_t uOneWireAddresses[MAX_DN18B20_SENSORS];
float fDS18B20Temps[MAX_DN18B20_SENSORS]; float fDS18B20Temps[MAX_DN18B20_SENSORS];
@ -33,10 +31,7 @@ static sMeasurement sInletFlowTemperature;
static sMeasurement sReturnFlowTemperature; static sMeasurement sReturnFlowTemperature;
void taskInput(void *pvParameters); void taskInput(void *pvParameters);
void initMeasurement(sMeasurement *pMeasurement);
void updateAverage(sMeasurement *pMeasurement); void updateAverage(sMeasurement *pMeasurement);
void updatePrediction(sMeasurement *pMeasurement);
float linearRegressionPredict(const float *samples, size_t count, size_t bufferIndex, float futureIndex);
void initInputs(void) void initInputs(void)
{ {
@ -58,11 +53,6 @@ void initInputs(void)
} }
xSemaphoreGiveRecursive(xMutexAccessInputs); xSemaphoreGiveRecursive(xMutexAccessInputs);
initMeasurement(&sChamperTemperature);
initMeasurement(&sOutdoorTemperature);
initMeasurement(&sInletFlowTemperature);
initMeasurement(&sReturnFlowTemperature);
BaseType_t taskCreated = xTaskCreate( BaseType_t taskCreated = xTaskCreate(
taskInput, // Function to implement the task taskInput, // Function to implement the task
"taskInput", // Task name "taskInput", // Task name
@ -82,36 +72,8 @@ void initInputs(void)
} }
} }
void initMeasurement(sMeasurement *pMeasurement)
{
if (!pMeasurement)
return;
pMeasurement->state = MEASUREMENT_FAULT;
pMeasurement->fCurrentValue = 0.0f;
pMeasurement->average10s.fValue = 0.0f;
pMeasurement->average10s.bufferCount = 0U;
pMeasurement->average10s.bufferIndex = 0U;
memset(pMeasurement->average10s.samples, 0U, AVG10_SAMPLE_SIZE);
pMeasurement->average60s.fValue = 0.0f;
pMeasurement->average60s.bufferCount = 0U;
pMeasurement->average60s.bufferIndex = 0U;
memset(pMeasurement->average60s.samples, 0U, AVG60_SAMPLE_SIZE);
pMeasurement->predict60s.fValue = 0.0f;
pMeasurement->predict60s.bufferCount = 0U;
pMeasurement->predict60s.bufferIndex = 0U;
memset(pMeasurement->predict60s.samples, 0U, PRED60_SAMPLE_SIZE);
}
void updateAverage(sMeasurement *pMeasurement) void updateAverage(sMeasurement *pMeasurement)
{ { /* Average form the last 10sec */
if (!pMeasurement)
return;
// Average form the last 10sec
pMeasurement->average10s.samples[pMeasurement->average10s.bufferIndex] = pMeasurement->fCurrentValue; pMeasurement->average10s.samples[pMeasurement->average10s.bufferIndex] = pMeasurement->fCurrentValue;
pMeasurement->average10s.bufferIndex = (pMeasurement->average10s.bufferIndex + 1) % AVG10_SAMPLE_SIZE; pMeasurement->average10s.bufferIndex = (pMeasurement->average10s.bufferIndex + 1) % AVG10_SAMPLE_SIZE;
@ -120,15 +82,20 @@ void updateAverage(sMeasurement *pMeasurement)
pMeasurement->average10s.bufferCount++; pMeasurement->average10s.bufferCount++;
} }
if (pMeasurement->average10s.bufferCount == 0U)
{
pMeasurement->average10s.fValue = pMeasurement->fCurrentValue;
}
float sum = 0.0; float sum = 0.0;
for (int i = 0; i <= pMeasurement->average10s.bufferCount; i++) for (int i = 0; i < pMeasurement->average10s.bufferCount; i++)
{ {
sum += pMeasurement->average10s.samples[i]; sum += pMeasurement->average10s.samples[i];
} }
pMeasurement->average10s.fValue = sum / pMeasurement->average10s.bufferCount; pMeasurement->average10s.fValue = sum / pMeasurement->average10s.bufferCount;
// Average form the last 60sec /* Average form the last 60sec */
pMeasurement->average60s.samples[pMeasurement->average60s.bufferIndex] = pMeasurement->fCurrentValue; pMeasurement->average60s.samples[pMeasurement->average60s.bufferIndex] = pMeasurement->fCurrentValue;
pMeasurement->average60s.bufferIndex = (pMeasurement->average60s.bufferIndex + 1) % AVG60_SAMPLE_SIZE; pMeasurement->average60s.bufferIndex = (pMeasurement->average60s.bufferIndex + 1) % AVG60_SAMPLE_SIZE;
@ -137,8 +104,13 @@ void updateAverage(sMeasurement *pMeasurement)
pMeasurement->average60s.bufferCount++; pMeasurement->average60s.bufferCount++;
} }
if (pMeasurement->average60s.bufferCount == 0U)
{
pMeasurement->average60s.fValue = pMeasurement->fCurrentValue;
}
sum = 0.0; sum = 0.0;
for (int i = 0; i <= pMeasurement->average60s.bufferCount; i++) for (int i = 0; i < pMeasurement->average60s.bufferCount; i++)
{ {
sum += pMeasurement->average60s.samples[i]; sum += pMeasurement->average60s.samples[i];
} }
@ -146,26 +118,6 @@ void updateAverage(sMeasurement *pMeasurement)
pMeasurement->average60s.fValue = sum / pMeasurement->average60s.bufferCount; pMeasurement->average60s.fValue = sum / pMeasurement->average60s.bufferCount;
} }
void updatePrediction(sMeasurement *pMeasurement)
{
if (!pMeasurement)
return;
// Update predict60s buffer
sPredict *predict60s = &pMeasurement->predict60s;
predict60s->samples[predict60s->bufferIndex] = pMeasurement->fCurrentValue;
predict60s->bufferIndex = (predict60s->bufferIndex + 1) % PRED60_SAMPLE_SIZE;
if (predict60s->bufferCount < PRED60_SAMPLE_SIZE)
predict60s->bufferCount++;
// Predict 60s future value using linear regression
predict60s->fValue = linearRegressionPredict(
predict60s->samples,
predict60s->bufferCount,
predict60s->bufferIndex,
predict60s->bufferCount + 60.0f);
}
void taskInput(void *pvParameters) void taskInput(void *pvParameters)
{ {
while (1) while (1)
@ -211,7 +163,7 @@ void taskInput(void *pvParameters)
if (ds18x20_measure_and_read_multi(uDS18B20Pin, uOneWireAddresses, sSensorCount, fDS18B20Temps) != ESP_OK) if (ds18x20_measure_and_read_multi(uDS18B20Pin, uOneWireAddresses, sSensorCount, fDS18B20Temps) != ESP_OK)
{ {
ESP_LOGE(TAG, "1-Wire devices read error"); ESP_LOGE(TAG, "1-Wire devices read error");
vTaskDelay(PERIODIC_INTERVAL * 100U / portTICK_PERIOD_MS); // Wait 100ms if bus error occurred vTaskDelay(PERIODIC_INTERVAL * 100U / portTICK_PERIOD_MS); //Wait 100ms if bus error occurred
} }
else else
{ {
@ -226,25 +178,21 @@ void taskInput(void *pvParameters)
sChamperTemperature.fCurrentValue = temp_c; sChamperTemperature.fCurrentValue = temp_c;
sChamperTemperature.state = MEASUREMENT_NO_ERROR; sChamperTemperature.state = MEASUREMENT_NO_ERROR;
updateAverage(&sChamperTemperature); updateAverage(&sChamperTemperature);
updatePrediction(&sChamperTemperature);
break; break;
case ((uint64_t)uOutdoorTempSensorAddr): case ((uint64_t)uOutdoorTempSensorAddr):
sOutdoorTemperature.fCurrentValue = temp_c; sOutdoorTemperature.fCurrentValue = temp_c;
sOutdoorTemperature.state = MEASUREMENT_NO_ERROR; sOutdoorTemperature.state = MEASUREMENT_NO_ERROR;
updateAverage(&sOutdoorTemperature); updateAverage(&sOutdoorTemperature);
updatePrediction(&sOutdoorTemperature);
break; break;
case ((uint64_t)uInletFlowTempSensorAddr): case ((uint64_t)uInletFlowTempSensorAddr):
sInletFlowTemperature.fCurrentValue = temp_c; sInletFlowTemperature.fCurrentValue = temp_c;
sInletFlowTemperature.state = MEASUREMENT_NO_ERROR; sInletFlowTemperature.state = MEASUREMENT_NO_ERROR;
updateAverage(&sInletFlowTemperature); updateAverage(&sInletFlowTemperature);
updatePrediction(&sInletFlowTemperature);
break; break;
case ((uint64_t)uReturnFlowTempSensorAddr): case ((uint64_t)uReturnFlowTempSensorAddr):
sReturnFlowTemperature.fCurrentValue = temp_c; sReturnFlowTemperature.fCurrentValue = temp_c;
sReturnFlowTemperature.state = MEASUREMENT_NO_ERROR; sReturnFlowTemperature.state = MEASUREMENT_NO_ERROR;
updateAverage(&sReturnFlowTemperature); updateAverage(&sReturnFlowTemperature);
updatePrediction(&sReturnFlowTemperature);
break; break;
default: default:
break; break;
@ -268,39 +216,6 @@ void taskInput(void *pvParameters)
} }
} }
float linearRegressionPredict(const float *samples, size_t count, size_t bufferIndex, float futureIndex)
{
if (count == 0)
return 0.0f; // No prediction possible with no data
float sumX = 0.0f, sumY = 0.0f, sumXY = 0.0f, sumX2 = 0.0f;
for (size_t i = 0; i < count; i++)
{
// Calculate the circular buffer index for the current sample
size_t circularIndex = (bufferIndex + i + 1) % count;
float x = (float)i; // Time index
float y = samples[circularIndex]; // Sample value
sumX += x;
sumY += y;
sumXY += x * y;
sumX2 += x * x;
}
// Calculate slope (m) and intercept (b) of the line: y = mx + b
float denominator = (count * sumX2 - sumX * sumX);
if (fabs(denominator) < 1e-6) // Avoid division by zero
return samples[bufferIndex]; // Return the latest value as prediction
float m = (count * sumXY - sumX * sumY) / denominator;
float b = (sumY - m * sumX) / count;
// Predict value at futureIndex
return m * futureIndex + b;
}
sMeasurement getChamberTemperature(void) sMeasurement getChamberTemperature(void)
{ {
sMeasurement ret; sMeasurement ret;

10
main/inputs.h
View File

@ -3,7 +3,6 @@
#define MAX(a, b) ((a) > (b) ? (a) : (b)) #define MAX(a, b) ((a) > (b) ? (a) : (b))
#define AVG10_SAMPLE_SIZE 10U #define AVG10_SAMPLE_SIZE 10U
#define AVG60_SAMPLE_SIZE 60U #define AVG60_SAMPLE_SIZE 60U
#define PRED60_SAMPLE_SIZE 60U
typedef enum _BurnerErrorState typedef enum _BurnerErrorState
{ {
@ -25,20 +24,11 @@ typedef struct _Average
size_t bufferCount; size_t bufferCount;
} sAverage; } sAverage;
typedef struct _Predict
{
float fValue;
float samples[PRED60_SAMPLE_SIZE];
size_t bufferIndex;
size_t bufferCount;
} sPredict;
typedef struct _Measurement typedef struct _Measurement
{ {
float fCurrentValue; float fCurrentValue;
sAverage average10s; sAverage average10s;
sAverage average60s; sAverage average60s;
sPredict predict60s;
eMeasurementErrorState state; eMeasurementErrorState state;
} sMeasurement; } sMeasurement;

75
main/metrics.c
View File

@ -32,7 +32,7 @@ void initMetrics(void)
BaseType_t taskCreated = xTaskCreate( BaseType_t taskCreated = xTaskCreate(
taskMetrics, // Function to implement the task taskMetrics, // Function to implement the task
"taskMetrics", // Task name "taskMetrics", // Task name
32768, // Stack size (in words, not bytes) 16384, // Stack size (in words, not bytes)
NULL, // Parameters to the task function (none in this case) NULL, // Parameters to the task function (none in this case)
5, // Task priority (higher number = higher priority) 5, // Task priority (higher number = higher priority)
NULL // Task handle (optional) NULL // Task handle (optional)
@ -56,13 +56,13 @@ void taskMetrics(void *pvParameters)
u16MetricCounter = 0U; u16MetricCounter = 0U;
// Burner Error State /*Burner Error State*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_fault_pending"); strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_fault_pending");
aMetrics[u16MetricCounter].type = INTEGER_U8; aMetrics[u16MetricCounter].type = INTEGER_U8;
aMetrics[u16MetricCounter].u8MetricValue = getBurnerError(); aMetrics[u16MetricCounter].u8MetricValue = getBurnerError();
u16MetricCounter++; u16MetricCounter++;
// Circulation Pump State /*Circulation Pump State*/
if (getCirculationPumpState() == ENABLED) if (getCirculationPumpState() == ENABLED)
{ {
strcpy(aMetrics[u16MetricCounter].caMetricName, "circulation_pump_enabled"); strcpy(aMetrics[u16MetricCounter].caMetricName, "circulation_pump_enabled");
@ -78,7 +78,7 @@ void taskMetrics(void *pvParameters)
u16MetricCounter++; u16MetricCounter++;
} }
// Burner State /*Burner State*/
if (getBurnerState() == ENABLED) if (getBurnerState() == ENABLED)
{ {
strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_enabled"); strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_enabled");
@ -94,7 +94,7 @@ void taskMetrics(void *pvParameters)
u16MetricCounter++; u16MetricCounter++;
} }
// Safety Contact State /*Safety Contact State*/
if (getSafetyControlState() == ENABLED) if (getSafetyControlState() == ENABLED)
{ {
strcpy(aMetrics[u16MetricCounter].caMetricName, "safety_contact_enabled"); strcpy(aMetrics[u16MetricCounter].caMetricName, "safety_contact_enabled");
@ -110,103 +110,79 @@ void taskMetrics(void *pvParameters)
u16MetricCounter++; u16MetricCounter++;
} }
// Chamber Temperature /*Chamber Temperature*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature"); strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().fCurrentValue; aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().fCurrentValue;
u16MetricCounter++; u16MetricCounter++;
// Chamber Temperature Average 10s /*Chamber Temperature Average 10s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg10"); strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg10");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().average10s.fValue; aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().average10s.fValue;
u16MetricCounter++; u16MetricCounter++;
// Chamber Temperature Average 60s /*Chamber Temperature Average 60s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg60"); strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg60");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().average60s.fValue; aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().average60s.fValue;
u16MetricCounter++; u16MetricCounter++;
// Chamber Temperature Predict 60s /*Inlet Flow Temperature*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_pred60");
aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().predict60s.fValue;
u16MetricCounter++;
// Inlet Flow Temperature
strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature"); strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().fCurrentValue; aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().fCurrentValue;
u16MetricCounter++; u16MetricCounter++;
// Inlet Flow Temperature Average 10s /*Inlet Flow Temperature Average 10s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg10"); strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg10");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().average10s.fValue; aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().average10s.fValue;
u16MetricCounter++; u16MetricCounter++;
// Inlet Flow Temperature Average 60s /*Inlet Flow Temperature Average 60s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg60"); strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg60");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().average60s.fValue; aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().average60s.fValue;
u16MetricCounter++; u16MetricCounter++;
// Inlet Flow Temperature Predict 60s /*Outdoor Temperature*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_pred60");
aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().predict60s.fValue;
u16MetricCounter++;
// Outdoor Temperature
strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature"); strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().fCurrentValue; aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().fCurrentValue;
u16MetricCounter++; u16MetricCounter++;
// Outdoor Temperature Average 10s /*Outdoor Temperature Average 10s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg10"); strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg10");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().average10s.fValue; aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().average10s.fValue;
u16MetricCounter++; u16MetricCounter++;
// Outdoor Temperature Average 60s /*Outdoor Temperature Average 60s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg60"); strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg60");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().average60s.fValue; aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().average60s.fValue;
u16MetricCounter++; u16MetricCounter++;
// Outdoor Temperature Predict 60s /*Return Flow Temperature*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_pred60");
aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().predict60s.fValue;
u16MetricCounter++;
// Return Flow Temperature
strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature"); strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().fCurrentValue; aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().fCurrentValue;
u16MetricCounter++; u16MetricCounter++;
// Return Flow Temperature Average 10s /*Return Flow Temperature Average 10s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg10"); strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg10");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().average10s.fValue; aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().average10s.fValue;
u16MetricCounter++; u16MetricCounter++;
// Return Flow Temperature Average 60s /*Return Flow Temperature Average 60s*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg60"); strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg60");
aMetrics[u16MetricCounter].type = FLOAT; aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().average60s.fValue; aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().average60s.fValue;
u16MetricCounter++; u16MetricCounter++;
// Return Flow Temperature Predict 60s /*Sensor State*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_pred60");
aMetrics[u16MetricCounter].type = FLOAT;
aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().predict60s.fValue;
u16MetricCounter++;
// Sensor State
sSensorSanityCheck aChecks[NUMBER_OF_SENSOR_SANITY_CHECKS]; sSensorSanityCheck aChecks[NUMBER_OF_SENSOR_SANITY_CHECKS];
getSensorSanityStates(aChecks); getSensorSanityStates(aChecks);
for (size_t i = 0; i < NUMBER_OF_SENSOR_SANITY_CHECKS; i++) for (size_t i = 0; i < NUMBER_OF_SENSOR_SANITY_CHECKS; i++)
@ -218,25 +194,25 @@ void taskMetrics(void *pvParameters)
u16MetricCounter++; u16MetricCounter++;
} }
// Safety State /*Safety State*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "safety_state"); strcpy(aMetrics[u16MetricCounter].caMetricName, "safety_state");
aMetrics[u16MetricCounter].type = INTEGER_U8; aMetrics[u16MetricCounter].type = INTEGER_U8;
aMetrics[u16MetricCounter].u8MetricValue = getSafetyState(); aMetrics[u16MetricCounter].u8MetricValue = getSafetyState();
u16MetricCounter++; u16MetricCounter++;
// Control State /*Control State*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "control_state"); strcpy(aMetrics[u16MetricCounter].caMetricName, "control_state");
aMetrics[u16MetricCounter].type = INTEGER_U8; aMetrics[u16MetricCounter].type = INTEGER_U8;
aMetrics[u16MetricCounter].u8MetricValue = getControlState(); aMetrics[u16MetricCounter].u8MetricValue = getControlState();
u16MetricCounter++; u16MetricCounter++;
// SNTP State /*SNTP State*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "sntp_state"); strcpy(aMetrics[u16MetricCounter].caMetricName, "sntp_state");
aMetrics[u16MetricCounter].type = INTEGER_U8; aMetrics[u16MetricCounter].type = INTEGER_U8;
aMetrics[u16MetricCounter].u8MetricValue = getSntpState(); aMetrics[u16MetricCounter].u8MetricValue = getSntpState();
u16MetricCounter++; u16MetricCounter++;
// System Time /*System Time*/
time_t now; time_t now;
time(&now); time(&now);
strcpy(aMetrics[u16MetricCounter].caMetricName, "system_unixtime"); strcpy(aMetrics[u16MetricCounter].caMetricName, "system_unixtime");
@ -244,13 +220,13 @@ void taskMetrics(void *pvParameters)
aMetrics[u16MetricCounter].i64MetricValue = now; aMetrics[u16MetricCounter].i64MetricValue = now;
u16MetricCounter++; u16MetricCounter++;
// Uptime /*Uptime*/
strcpy(aMetrics[u16MetricCounter].caMetricName, "uptime_seconds"); strcpy(aMetrics[u16MetricCounter].caMetricName, "uptime_seconds");
aMetrics[u16MetricCounter].type = INTEGER_64; aMetrics[u16MetricCounter].type = INTEGER_64;
aMetrics[u16MetricCounter].i64MetricValue = (esp_timer_get_time() / 1000000U); aMetrics[u16MetricCounter].i64MetricValue = (esp_timer_get_time() / 1000000U);
u16MetricCounter++; u16MetricCounter++;
// Wifi RSSI /*Wifi RSSI*/
wifi_ap_record_t ap; wifi_ap_record_t ap;
esp_wifi_sta_get_ap_info(&ap); esp_wifi_sta_get_ap_info(&ap);
strcpy(aMetrics[u16MetricCounter].caMetricName, "wifi_rssi"); strcpy(aMetrics[u16MetricCounter].caMetricName, "wifi_rssi");
@ -267,7 +243,7 @@ void vSetMetrics(sMetric *paMetrics, uint16_t u16Size)
if (xSemaphoreTakeRecursive(xMutexAccessMetricResponse, pdMS_TO_TICKS(5000)) == pdTRUE) if (xSemaphoreTakeRecursive(xMutexAccessMetricResponse, pdMS_TO_TICKS(5000)) == pdTRUE)
{ {
memset(caHtmlResponse, 0U, strlen(caHtmlResponse)); memset(caHtmlResponse, 0, strlen(caHtmlResponse));
for (uint16_t u16Index = 0U; u16Index < u16Size; u16Index++) for (uint16_t u16Index = 0U; u16Index < u16Size; u16Index++)
{ {
char caValueBuffer[64]; char caValueBuffer[64];
@ -287,7 +263,6 @@ void vSetMetrics(sMetric *paMetrics, uint16_t u16Size)
break; break;
} }
// printf("%s\n", paMetrics[u16Index].caMetricName);
// printf("%s\n", caValueBuffer); // printf("%s\n", caValueBuffer);
strcat(caHtmlResponse, paMetrics[u16Index].caMetricName); strcat(caHtmlResponse, paMetrics[u16Index].caMetricName);
strcat(caHtmlResponse, caValueBuffer); strcat(caHtmlResponse, caValueBuffer);

6
main/metrics.h
View File

@ -2,9 +2,9 @@
#include <esp_http_server.h> #include <esp_http_server.h>
#define HTML_RESPONSE_SIZE 4096U #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 enum _MetricValueType typedef enum _MetricValueType
{ {

13
main/safety.c
View File

@ -155,16 +155,5 @@ void getSensorSanityStates(sSensorSanityCheck *pSensorSanityChecks)
eSafetyState getSafetyState(void) eSafetyState getSafetyState(void)
{ {
eSafetyState state = SAFETY_NO_ERROR; return sSafetyState;
if (xSemaphoreTakeRecursive(xMutexAccessSafety, pdMS_TO_TICKS(5000)) == pdTRUE)
{
state = sSafetyState;
xSemaphoreGiveRecursive(xMutexAccessSafety);
}
else
{
state = SAFETY_INTERNAL_ERROR;
ESP_LOGE(TAG, "Unable to take mutex: getSafetyState()");
}
return state;
} }