Merge pull request 'Disable heating in summer' (#22) from feature/summer-mode into main

Reviewed-on: #22

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;
-}
+}
+
+sControlTemperatureEntry getControlCurrentTemperatureEntry(void)
+{
+    return currentControlEntry;
+}

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);

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++)
     {

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;

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);
     }
 }

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
 {