diff --git a/main/control.c b/main/control.c index 29a6295..7ddcab4 100644 --- a/main/control.c +++ b/main/control.c @@ -8,29 +8,35 @@ #include "safety.h" #include "sntp.h" -#define PERIODIC_INTERVAL 1U // run control loop every 1sec +#define PERIODIC_INTERVAL 1U // Run control loop every 1 second -#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY 30.0 -#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT 25.0 -#define CHAMPER_TEMPERATURE_TARGET 80.0 -#define BURNER_FAULT_DETECTION_THRESHOLD (60U * 3U) // Detect burner fault if after 3 minutes no burner start detected +// Temperature thresholds +#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY 30.0f +#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT 25.0f +#define CHAMBER_TEMPERATURE_TARGET 80.0f // Max cutoff temperature +#define CHAMBER_TEMPERATURE_THRESHOLD 45.0f // Min threshold for burner enable +#define SUMMER_MODE_TEMPERATURE_THRESHOLD_HIGH 20.0f // Summer mode will be activated +#define SUMMER_MODE_TEMPERATURE_THRESHOLD_LOW 15.0f // Summer mode will be deactivated --> Heating starts +#define CIRCULATION_PUMP_TEMPERATURE_THRESHOLD 30.0f // Min threshold of chamber for circulation pump enable +#define BURNER_FAULT_DETECTION_THRESHOLD (60U * 4U) // Burner fault detection after 4 minutes static const char *TAG = "smart-oil-heater-control-system-control"; static eControlState sControlState = CONTROL_STARTING; - -static sControlDay aControlTable[] = { - {MONDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMPER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_TEMPERATURE_TARGET}}}, - {TUESDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMPER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_TEMPERATURE_TARGET}}}, - {WEDNESDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMPER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_TEMPERATURE_TARGET}}}, - {THURSDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMPER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_TEMPERATURE_TARGET}}}, - {FRIDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMPER_TEMPERATURE_TARGET}, {{23, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_TEMPERATURE_TARGET}}}, - {SATURDAY, 2U, {{{6, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMPER_TEMPERATURE_TARGET}, {{23, 30}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_TEMPERATURE_TARGET}}}, - {SUNDAY, 2U, {{{6, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMPER_TEMPERATURE_TARGET}, {{22, 30}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_TEMPERATURE_TARGET}}}, +// Control table for daily schedules +static const sControlDay aControlTable[] = { + {MONDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMBER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMBER_TEMPERATURE_TARGET}}}, + {TUESDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMBER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMBER_TEMPERATURE_TARGET}}}, + {WEDNESDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMBER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMBER_TEMPERATURE_TARGET}}}, + {THURSDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMBER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMBER_TEMPERATURE_TARGET}}}, + {FRIDAY, 2U, {{{4, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMBER_TEMPERATURE_TARGET}, {{23, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMBER_TEMPERATURE_TARGET}}}, + {SATURDAY, 2U, {{{6, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMBER_TEMPERATURE_TARGET}, {{23, 30}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMBER_TEMPERATURE_TARGET}}}, + {SUNDAY, 2U, {{{6, 45}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY, CHAMBER_TEMPERATURE_TARGET}, {{22, 30}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMBER_TEMPERATURE_TARGET}}}, }; +static sControlTemperatureEntry currentControlEntry = aControlTable[0].aTemperatureEntries[0]; +// Function prototypes void taskControl(void *pvParameters); -eControlWeekday getCurrentWeekday(void); -sControlTemperatureEntry getCurrentTemperatureEntry(void); +void findControlCurrentTemperatureEntry(void); void initControl(void) { @@ -56,87 +62,71 @@ void initControl(void) void taskControl(void *pvParameters) { bool bHeatingInAction = false; - bool bBurnerFaultDetected = false; + bool bSummerMode = false; + eBurnerState eBurnerState = BURNER_UNKNOWN; int64_t i64BurnerEnableTimestamp = esp_timer_get_time(); while (1) { vTaskDelay(PERIODIC_INTERVAL * 1000U / portTICK_PERIOD_MS); + // Check for safety faults if (getSafetyState() != SAFETY_NO_ERROR) { ESP_LOGW(TAG, "Control not possible due to safety fault!"); sControlState = CONTROL_FAULT_SAFETY; - if (bHeatingInAction == true) + if (bHeatingInAction) { - ESP_LOGW(TAG, "Control not possible due to safety fault: Disable burner"); + ESP_LOGW(TAG, "Disabling burner due to safety fault"); bHeatingInAction = false; - setCirculationPumpState(ENABLED); setBurnerState(DISABLED); setSafetyControlState(ENABLED); } continue; } + // Check for SNTP faults if (getSntpState() != SYNC_SUCCESSFUL) { - ESP_LOGW(TAG, "Control not possible due to sntp fault!"); + ESP_LOGW(TAG, "Control not possible due to SNTP fault!"); sControlState = CONTROL_FAULT_SNTP; - if (bHeatingInAction == true) + if (bHeatingInAction) { - ESP_LOGW(TAG, "Control not possible due to sntp fault: Disable burner"); + ESP_LOGW(TAG, "Disabling burner due to SNTP fault"); bHeatingInAction = false; - setCirculationPumpState(ENABLED); setBurnerState(DISABLED); setSafetyControlState(ENABLED); } continue; } - sControlTemperatureEntry currentControlEntry = getCurrentTemperatureEntry(); - // ESP_LOGI(TAG, "Control Entry Hour: %i Minute: %i ChamberTemp: %lf ReturnFlowTemp: %lf", currentControlEntry.timestamp.hour, currentControlEntry.timestamp.minute, currentControlEntry.fChamberTemperature, currentControlEntry.fReturnFlowTemperature); + sControlTemperatureEntry currentControlEntry = getControlCurrentTemperatureEntry(); - if (bHeatingInAction == true) + if (getOutdoorTemperature().fDampedValue >= SUMMER_MODE_TEMPERATURE_THRESHOLD_HIGH) { - if ((getChamberTemperature().fCurrentValue >= currentControlEntry.fChamberTemperature) || (getChamberTemperature().predict60s.fValue >= currentControlEntry.fChamberTemperature)) - { - ESP_LOGI(TAG, "Chamber Target Temperature reached: Disable burner"); - bHeatingInAction = false; - setCirculationPumpState(ENABLED); - setBurnerState(DISABLED); - setSafetyControlState(ENABLED); - } - else - { - if (bHeatingInAction) - { - int64_t i64Delta = esp_timer_get_time() - i64BurnerEnableTimestamp; - - 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); - } - } - } - } + bSummerMode = true; + } + else if (getOutdoorTemperature().fDampedValue <= SUMMER_MODE_TEMPERATURE_THRESHOLD_LOW) + { + bSummerMode = false; } - if ((bHeatingInAction == false) && (bBurnerFaultDetected == false)) + // Enable burner if outdoor temperature is low and return flow temperature is cooled down + if (!bHeatingInAction && (eBurnerState != BURNER_FAULT)) { - if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= 45.0)) + if (bSummerMode) { - ESP_LOGI(TAG, "Return Flow Target Temperature reached: Enable Burner"); + // ESP_LOGI(TAG, "Outdoor temperature too warm: Disabling heating"); + setBurnerState(DISABLED); + setSafetyControlState(DISABLED); + sControlState = CONTROL_OUTDOOR_TOO_WARM; + } + else if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && + (getChamberTemperature().fCurrentValue <= CHAMBER_TEMPERATURE_THRESHOLD)) + { + ESP_LOGI(TAG, "Enabling burner: Return flow temperature target reached"); + eBurnerState = BURNER_UNKNOWN; bHeatingInAction = true; - setCirculationPumpState(ENABLED); setBurnerState(ENABLED); setSafetyControlState(ENABLED); i64BurnerEnableTimestamp = esp_timer_get_time(); @@ -144,10 +134,56 @@ void taskControl(void *pvParameters) } else { + // ESP_LOGI(TAG, "Return flow temperature too warm: Disabling heating"); sControlState = CONTROL_RETURN_FLOW_TOO_WARM; } } - } + + // Disable burner if target temperature is reached or a fault occurred + if (bHeatingInAction) + { + if ((getChamberTemperature().fCurrentValue >= currentControlEntry.fChamberTemperature) || + (getChamberTemperature().predict60s.fValue >= currentControlEntry.fChamberTemperature)) + { + ESP_LOGI(TAG, "Chamber target temperature reached: Disabling burner"); + bHeatingInAction = false; + setBurnerState(DISABLED); + setSafetyControlState(ENABLED); + } + else if (esp_timer_get_time() - i64BurnerEnableTimestamp >= BURNER_FAULT_DETECTION_THRESHOLD * 1000000U) + { + if (eBurnerState == BURNER_UNKNOWN) + { + if (getBurnerError() == FAULT) + { + // ESP_LOGW(TAG, "Burner fault detected: Disabling burner"); + bHeatingInAction = false; + eBurnerState = BURNER_FAULT; + sControlState = CONTROL_FAULT_BURNER; + setBurnerState(DISABLED); + setSafetyControlState(ENABLED); + } + else + { + // ESP_LOGI(TAG, "No burner fault detected: Marking burner as fired"); + eBurnerState = BURNER_FIRED; + } + } + } + } + + // Manage circulation pump + if (getChamberTemperature().fCurrentValue <= CIRCULATION_PUMP_TEMPERATURE_THRESHOLD) + { + // ESP_LOGI(TAG, "Burner cooled down: Disabling circulation pump"); + setCirculationPumpState(DISABLED); + } + else + { + // ESP_LOGI(TAG, "Burner heated: Enabling circulation pump"); + setCirculationPumpState(ENABLED); + } + } // End of while(1) } eControlState getControlState(void) @@ -155,78 +191,46 @@ eControlState getControlState(void) return sControlState; } -eControlWeekday getCurrentWeekday(void) +eControlWeekday getControlCurrentWeekday(void) { time_t now; struct tm *timeinfo; - // Get the current time time(&now); - timeinfo = localtime(&now); // Convert to local time + timeinfo = localtime(&now); - // Get the day of the week (0 = Sunday, 1 = Monday, ..., 6 = Saturday) int day = timeinfo->tm_wday; - - // Adjust so that Monday = 0, Sunday = 6 - if (day == 0) - { - day = 6; // Sunday becomes 6 - } - else - { - day -= 1; // Shift other days to make Monday = 0 - } - - return (eControlWeekday)day; + return (eControlWeekday)((day == 0) ? 6 : day - 1); } -sControlTemperatureEntry getCurrentTemperatureEntry(void) +void findControlCurrentTemperatureEntry(void) { - sControlTemperatureEntry result = aControlTable[0].aTemperatureEntries[0]; - eControlWeekday currentDay = getCurrentWeekday(); + eControlWeekday currentDay = getControlCurrentWeekday(); + time_t now; struct tm timeinfo; - - // Get the current time time(&now); - // Convert to local time structure localtime_r(&now, &timeinfo); - // Extract hour and minute - int hour = timeinfo.tm_hour; // Hour (0-23) - int minute = timeinfo.tm_min; // Minute (0-59)u - // ESP_LOGI(TAG, "Current Day: %i Hour: %i Minute: %i", currentDay, hour, minute); + int hour = timeinfo.tm_hour; + int minute = timeinfo.tm_min; for (int i = 0; i < sizeof(aControlTable) / sizeof(aControlTable[0]); i++) { - /// loops through days - // ESP_LOGI(TAG, "Day %d: %d", i + 1, aControlTable[i].day); - // int numberOfEntries = aControlTable[i].entryCount; - // ESP_LOGI(TAG, "Number of entries: %i", numberOfEntries); - for (int j = 0; j < aControlTable[i].entryCount; j++) { - if ((aControlTable[i].day) > currentDay) + if ((aControlTable[i].day > currentDay) || + (aControlTable[i].day == currentDay && aControlTable[i].aTemperatureEntries[j].timestamp.hour > hour) || + (aControlTable[i].day == currentDay && aControlTable[i].aTemperatureEntries[j].timestamp.hour == hour && aControlTable[i].aTemperatureEntries[j].timestamp.minute >= minute)) { - // ESP_LOGI(TAG, "DAY Return Control Entry Day: %i Hour: %i Minute: %i ChamberTemp: %lf ReturnFlowTemp: %lf", aControlTable[i].day, aControlTable[i].aTemperatureEntries[j].timestamp.hour, aControlTable[i].aTemperatureEntries[j].timestamp.minute, aControlTable[i].aTemperatureEntries[j].fChamberTemperature, aControlTable[i].aTemperatureEntries[j].fReturnFlowTemperature); - return result; + currentControlEntry = aControlTable[i].aTemperatureEntries[j]; } - - if ((aControlTable[i].day == currentDay) && (aControlTable[i].aTemperatureEntries[j].timestamp.hour > hour)) - { - // ESP_LOGI(TAG, "HOUR Return Control Entry Day: %i Hour: %i Minute: %i ChamberTemp: %lf ReturnFlowTemp: %lf", aControlTable[i].day, aControlTable[i].aTemperatureEntries[j].timestamp.hour, aControlTable[i].aTemperatureEntries[j].timestamp.minute, aControlTable[i].aTemperatureEntries[j].fChamberTemperature, aControlTable[i].aTemperatureEntries[j].fReturnFlowTemperature); - return result; - } - - if ((aControlTable[i].day == currentDay) && (aControlTable[i].aTemperatureEntries[j].timestamp.hour == hour) && (aControlTable[i].aTemperatureEntries[j].timestamp.minute == minute)) - { - // ESP_LOGI(TAG, "MINUTE Return Control Entry Day: %i Hour: %i Minute: %i ChamberTemp: %lf ReturnFlowTemp: %lf", aControlTable[i].day, aControlTable[i].aTemperatureEntries[j].timestamp.hour, aControlTable[i].aTemperatureEntries[j].timestamp.minute, aControlTable[i].aTemperatureEntries[j].fChamberTemperature, aControlTable[i].aTemperatureEntries[j].fReturnFlowTemperature); - return result; - } - - // ESP_LOGI(TAG, "SET Return Control Entry Day: %i Hour: %i Minute: %i ChamberTemp: %lf ReturnFlowTemp: %lf", aControlTable[i].day, aControlTable[i].aTemperatureEntries[j].timestamp.hour, aControlTable[i].aTemperatureEntries[j].timestamp.minute, aControlTable[i].aTemperatureEntries[j].fChamberTemperature, aControlTable[i].aTemperatureEntries[j].fReturnFlowTemperature); - result = aControlTable[i].aTemperatureEntries[j]; + currentControlEntry = aControlTable[i].aTemperatureEntries[j]; } } - return result; -} \ No newline at end of file +} + +sControlTemperatureEntry getControlCurrentTemperatureEntry(void) +{ + return currentControlEntry; +} diff --git a/main/control.h b/main/control.h index ba60d4c..7690bd1 100644 --- a/main/control.h +++ b/main/control.h @@ -14,6 +14,13 @@ typedef enum _ControlState CONTROL_FAULT_SNTP, } eControlState; +typedef enum _BurnerState +{ + BURNER_UNKNOWN, // Burner is disabled or state after enabling is still unkown + BURNER_FIRED, // Burner fired successfully + BURNER_FAULT // Burner was unable to fire successfully +} eBurnerState; + typedef enum _ControlWeekday { MONDAY, @@ -47,3 +54,5 @@ typedef struct _ControlDay void initControl(void); eControlState getControlState(void); +eControlWeekday getControlCurrentWeekday(void); +sControlTemperatureEntry getControlCurrentTemperatureEntry(void); diff --git a/main/inputs.c b/main/inputs.c index 62e7086..a9ef723 100644 --- a/main/inputs.c +++ b/main/inputs.c @@ -17,7 +17,7 @@ const uint8_t uBurnerFaultPin = 19U; const uint8_t uDS18B20Pin = 4U; const onewire_addr_t uChamperTempSensorAddr = 0xd00000108cd01d28; -const onewire_addr_t uOutdoorTempSensorAddr = 0x78000000c6c2f728; +const onewire_addr_t uOutdoorTempSensorAddr = 0xd70000108a9b9128; const onewire_addr_t uInletFlowTempSensorAddr = 0x410000108b8c0628; const onewire_addr_t uReturnFlowTempSensorAddr = 0x90000108cc77c28; @@ -88,22 +88,23 @@ void initMeasurement(sMeasurement *pMeasurement) return; pMeasurement->state = MEASUREMENT_FAULT; - pMeasurement->fCurrentValue = 0.0f; + pMeasurement->fCurrentValue = INITIALISATION_VALUE; + pMeasurement->fDampedValue = INITIALISATION_VALUE; - pMeasurement->average10s.fValue = 0.0f; + pMeasurement->average10s.fValue = INITIALISATION_VALUE; pMeasurement->average10s.bufferCount = 0U; pMeasurement->average10s.bufferIndex = 0U; - memset(pMeasurement->average10s.samples, 0U, AVG10_SAMPLE_SIZE); + memset(pMeasurement->average10s.samples, 0U, AVG10S_SAMPLE_SIZE); - pMeasurement->average60s.fValue = 0.0f; + pMeasurement->average60s.fValue = INITIALISATION_VALUE; pMeasurement->average60s.bufferCount = 0U; pMeasurement->average60s.bufferIndex = 0U; - memset(pMeasurement->average60s.samples, 0U, AVG60_SAMPLE_SIZE); + memset(pMeasurement->average60s.samples, 0U, AVG60S_SAMPLE_SIZE); - pMeasurement->predict60s.fValue = 0.0f; + pMeasurement->predict60s.fValue = INITIALISATION_VALUE; pMeasurement->predict60s.bufferCount = 0U; pMeasurement->predict60s.bufferIndex = 0U; - memset(pMeasurement->predict60s.samples, 0U, PRED60_SAMPLE_SIZE); + memset(pMeasurement->predict60s.samples, 0U, PRED60S_SAMPLE_SIZE); } void updateAverage(sMeasurement *pMeasurement) @@ -113,9 +114,9 @@ void updateAverage(sMeasurement *pMeasurement) // Average form the last 10sec 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) % AVG10S_SAMPLE_SIZE; - if (pMeasurement->average10s.bufferCount < AVG10_SAMPLE_SIZE) + if (pMeasurement->average10s.bufferCount < AVG10S_SAMPLE_SIZE) { pMeasurement->average10s.bufferCount++; } @@ -130,9 +131,9 @@ void updateAverage(sMeasurement *pMeasurement) // Average form the last 60sec 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) % AVG60S_SAMPLE_SIZE; - if (pMeasurement->average60s.bufferCount < AVG60_SAMPLE_SIZE) + if (pMeasurement->average60s.bufferCount < AVG60S_SAMPLE_SIZE) { pMeasurement->average60s.bufferCount++; } @@ -144,6 +145,24 @@ void updateAverage(sMeasurement *pMeasurement) } pMeasurement->average60s.fValue = sum / pMeasurement->average60s.bufferCount; + + // Damped current value + if (pMeasurement->fDampedValue == INITIALISATION_VALUE) + { + pMeasurement->fDampedValue = pMeasurement->fCurrentValue; + } + else + { + if (pMeasurement->fCurrentValue > pMeasurement->fDampedValue) + { + pMeasurement->fDampedValue = pMeasurement->fDampedValue + (DAMPING_FACTOR_WARMER * (pMeasurement->fCurrentValue - pMeasurement->fDampedValue)); + } + + if (pMeasurement->fCurrentValue < pMeasurement->fDampedValue) + { + pMeasurement->fDampedValue = pMeasurement->fDampedValue - (DAMPING_FACTOR_COLDER * (pMeasurement->fDampedValue - pMeasurement->fCurrentValue)); + } + } } void updatePrediction(sMeasurement *pMeasurement) @@ -154,8 +173,8 @@ void updatePrediction(sMeasurement *pMeasurement) // 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->bufferIndex = (predict60s->bufferIndex + 1) % PRED60S_SAMPLE_SIZE; + if (predict60s->bufferCount < PRED60S_SAMPLE_SIZE) predict60s->bufferCount++; // Predict 60s future value using linear regression @@ -271,9 +290,9 @@ 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 + return INITIALISATION_VALUE; // No prediction possible with no data - float sumX = 0.0f, sumY = 0.0f, sumXY = 0.0f, sumX2 = 0.0f; + float sumX = INITIALISATION_VALUE, sumY = INITIALISATION_VALUE, sumXY = INITIALISATION_VALUE, sumX2 = INITIALISATION_VALUE; for (size_t i = 0; i < count; i++) { diff --git a/main/inputs.h b/main/inputs.h index 9af37f5..17e095b 100644 --- a/main/inputs.h +++ b/main/inputs.h @@ -1,9 +1,13 @@ #pragma once #define MAX(a, b) ((a) > (b) ? (a) : (b)) -#define AVG10_SAMPLE_SIZE 10U -#define AVG60_SAMPLE_SIZE 60U -#define PRED60_SAMPLE_SIZE 60U +#define INITIALISATION_VALUE 0.0f +#define AVG10S_SAMPLE_SIZE 10U +#define AVG60S_SAMPLE_SIZE 60U +#define AVG24H_SAMPLE_SIZE 24U +#define PRED60S_SAMPLE_SIZE 60U +#define DAMPING_FACTOR_WARMER 0.00001f // 0.001% +#define DAMPING_FACTOR_COLDER 0.00005f // 0.005% typedef enum _BurnerErrorState { @@ -20,7 +24,7 @@ typedef enum _MeasurementErrorState typedef struct _Average { float fValue; - float samples[MAX(AVG10_SAMPLE_SIZE, AVG60_SAMPLE_SIZE)]; + float samples[MAX(AVG10S_SAMPLE_SIZE, MAX(AVG60S_SAMPLE_SIZE, AVG24H_SAMPLE_SIZE))]; size_t bufferIndex; size_t bufferCount; } sAverage; @@ -28,7 +32,7 @@ typedef struct _Average typedef struct _Predict { float fValue; - float samples[PRED60_SAMPLE_SIZE]; + float samples[PRED60S_SAMPLE_SIZE]; size_t bufferIndex; size_t bufferCount; } sPredict; @@ -36,6 +40,7 @@ typedef struct _Predict typedef struct _Measurement { float fCurrentValue; + float fDampedValue; sAverage average10s; sAverage average60s; sPredict predict60s; diff --git a/main/metrics.c b/main/metrics.c index c7aaf6f..6f1b2db 100644 --- a/main/metrics.c +++ b/main/metrics.c @@ -128,6 +128,12 @@ void taskMetrics(void *pvParameters) aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().average60s.fValue; u16MetricCounter++; + // Chamber Temperature Damped + strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_damped"); + aMetrics[u16MetricCounter].type = FLOAT; + aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().fDampedValue; + u16MetricCounter++; + // Chamber Temperature Predict 60s strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_pred60"); aMetrics[u16MetricCounter].type = FLOAT; @@ -152,6 +158,12 @@ void taskMetrics(void *pvParameters) aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().average60s.fValue; u16MetricCounter++; + // Inlet Flow Temperature Damped + strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_damped"); + aMetrics[u16MetricCounter].type = FLOAT; + aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().fDampedValue; + u16MetricCounter++; + // Inlet Flow Temperature Predict 60s strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_pred60"); aMetrics[u16MetricCounter].type = FLOAT; @@ -176,6 +188,12 @@ void taskMetrics(void *pvParameters) aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().average60s.fValue; u16MetricCounter++; + // Outdoor Temperature Average Damped + strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_damped"); + aMetrics[u16MetricCounter].type = FLOAT; + aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().fDampedValue; + u16MetricCounter++; + // Outdoor Temperature Predict 60s strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_pred60"); aMetrics[u16MetricCounter].type = FLOAT; @@ -200,6 +218,12 @@ void taskMetrics(void *pvParameters) aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().average60s.fValue; u16MetricCounter++; + // Return Flow Temperature Damped + strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_damped"); + aMetrics[u16MetricCounter].type = FLOAT; + aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().fDampedValue; + u16MetricCounter++; + // Return Flow Temperature Predict 60s strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_pred60"); aMetrics[u16MetricCounter].type = FLOAT; @@ -230,6 +254,31 @@ void taskMetrics(void *pvParameters) aMetrics[u16MetricCounter].u8MetricValue = getControlState(); u16MetricCounter++; + // Control Current Weekday + strcpy(aMetrics[u16MetricCounter].caMetricName, "control_current_weekday"); + aMetrics[u16MetricCounter].type = INTEGER_U8; + aMetrics[u16MetricCounter].u8MetricValue = getControlCurrentWeekday(); + u16MetricCounter++; + + // Control Current Entry Time + strcpy(aMetrics[u16MetricCounter].caMetricName, "control_current_entry_time"); + aMetrics[u16MetricCounter].type = INTEGER_64; + int64_t i64SecondsSinceMidnight = (getControlCurrentTemperatureEntry().timestamp.hour * 60U * 60U) + (getControlCurrentTemperatureEntry().timestamp.minute * 60U); + aMetrics[u16MetricCounter].i64MetricValue = i64SecondsSinceMidnight; + u16MetricCounter++; + + // Control Current Entry Chamber Temperature + strcpy(aMetrics[u16MetricCounter].caMetricName, "control_current_entry_chamber_temperature"); + aMetrics[u16MetricCounter].type = FLOAT; + aMetrics[u16MetricCounter].fMetricValue = getControlCurrentTemperatureEntry().fChamberTemperature; + u16MetricCounter++; + + // Control Current Entry Return Flow Temperature + strcpy(aMetrics[u16MetricCounter].caMetricName, "control_current_entry_return_flow_temperature"); + aMetrics[u16MetricCounter].type = FLOAT; + aMetrics[u16MetricCounter].fMetricValue = getControlCurrentTemperatureEntry().fReturnFlowTemperature; + u16MetricCounter++; + // SNTP State strcpy(aMetrics[u16MetricCounter].caMetricName, "sntp_state"); aMetrics[u16MetricCounter].type = INTEGER_U8; @@ -258,6 +307,7 @@ void taskMetrics(void *pvParameters) aMetrics[u16MetricCounter].i64MetricValue = ap.rssi; u16MetricCounter++; + ESP_ERROR_CHECK(u16MetricCounter > METRIC_MAX_COUNT); vSetMetrics(aMetrics, u16MetricCounter); } } diff --git a/main/metrics.h b/main/metrics.h index 7f48067..e8eafed 100644 --- a/main/metrics.h +++ b/main/metrics.h @@ -4,7 +4,7 @@ #define HTML_RESPONSE_SIZE 4096U #define METRIC_NAME_MAX_SIZE 64U -#define METRIC_MAX_COUNT 32U +#define METRIC_MAX_COUNT 38U typedef enum _MetricValueType {