suppress heating in summer

Reviewed-on: #23

README.md

@@ -77,31 +77,35 @@ Sntp <|-- Metrics
 #### Example
 ```
 burner_fault_pending 1
-circulation_pump_enabled 0
+circulation_pump_enabled 1
-burner_enabled 1
+burner_enabled 0
-safety_contact_enabled 1
+safety_contact_enabled 0
-chamber_temperature 21.812500
+chamber_temperature 58.750000
-chamber_temperature_avg10 21.837500
+chamber_temperature_avg10 58.931252
-chamber_temperature_avg60 21.825521
+chamber_temperature_avg60 59.190475
-inlet_flow_temperature 22.437500
+chamber_temperature_pred60 55.870998
-inlet_flow_temperature_avg10 22.437500
+inlet_flow_temperature 53.875000
-inlet_flow_temperature_avg60 22.434896
+inlet_flow_temperature_avg10 53.900002
-outdoor_temperature 21.937500
+inlet_flow_temperature_avg60 53.994320
-outdoor_temperature_avg10 21.937500
+inlet_flow_temperature_pred60 52.848743
-outdoor_temperature_avg60 21.933594
+outdoor_temperature 18.000000
-return_flow_temperature 22.375000
+outdoor_temperature_avg10 18.006250
-return_flow_temperature_avg10 22.375000
+outdoor_temperature_avg60 18.002840
-return_flow_temperature_avg60 22.375000
+outdoor_temperature_pred60 18.050785
+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
 outdoor_temperature_state 0
 inlet_flow_temperature_state 0
 return_flow_temperature_state 0
 safety_state 0
-control_state 5
+control_state 3
 sntp_state 0
-system_unixtime 1734814285
+system_unixtime 1735242392
-uptime_seconds 90
+uptime_seconds 40
-wifi_rssi -63
+wifi_rssi -74
 ```
 
 #### Status Encoding
@@ -131,15 +135,15 @@ wifi_rssi -63
 ##### Control Loop
  - 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_BURNER_FAULT                              | 4     | Burner reported fault              |
+| CONTROL_FAULT_BURNER                              | 4     | Burner reported fault after threshold is reached |
-| 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_state

main/control.c

@@ -1,5 +1,6 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#include "esp_timer.h"
 #include "esp_log.h"
 #include "control.h"
 #include "outputs.h"
@@ -7,25 +8,32 @@
 #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
+// Temperature thresholds
-#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT 25.0
+#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY 30.0f
-#define CHAMPER_TEMPERATURE_TARGET 70.0
+#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 OUTDOOR_TEMPERATURE_THRESHOLD 13.0f          // Min threshold for burner enable
+#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;
 
+// Control table for daily schedules
 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}}},
+    {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, CHAMPER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_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, CHAMPER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_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, CHAMPER_TEMPERATURE_TARGET}, {{22, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_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, CHAMPER_TEMPERATURE_TARGET}, {{23, 0}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_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, CHAMPER_TEMPERATURE_TARGET}, {{23, 30}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_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, CHAMPER_TEMPERATURE_TARGET}, {{22, 30}, RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT, CHAMPER_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}}},
 };
 
+// Function prototypes
 void taskControl(void *pvParameters);
 eControlWeekday getCurrentWeekday(void);
 sControlTemperatureEntry getCurrentTemperatureEntry(void);
@@ -54,34 +62,37 @@ void initControl(void)
 void taskControl(void *pvParameters)
 {
     bool bHeatingInAction = 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_LOGI(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_LOGI(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);
             }
@@ -89,44 +100,80 @@ void taskControl(void *pvParameters)
         }
 
         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);
 
-        if (bHeatingInAction == true)
+        // Enable burner if outdoor temperature is low and return flow temperature is cooled down
+        if (!bHeatingInAction && (eBurnerState != BURNER_FAULT))
         {
-            if (getChamberTemperature().fCurrentValue >= currentControlEntry.fChamberTemperature)
+            if (getOutdoorTemperature().average60s.fValue >= OUTDOOR_TEMPERATURE_THRESHOLD)
             {
-                ESP_LOGI(TAG, "Chamber Target Temperature reached: Disable burner");
+                // ESP_LOGI(TAG, "Outdoor temperature too warm: Disabling heating");
-                bHeatingInAction = false;
-                setCirculationPumpState(ENABLED);
                 setBurnerState(DISABLED);
-                setSafetyControlState(ENABLED);
+                setSafetyControlState(DISABLED);
+                sControlState = CONTROL_OUTDOOR_TOO_WARM;
             }
-            else
+            else if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) &&
+                     (getChamberTemperature().fCurrentValue <= CHAMBER_TEMPERATURE_THRESHOLD))
             {
-                if (bHeatingInAction)
+                ESP_LOGI(TAG, "Enabling burner: Return flow temperature target reached");
-                {
+                eBurnerState = BURNER_UNKNOWN;
-                    // TODO: Check burner fault signal here
-                }
-            }
-        }
-
-        if (bHeatingInAction == false)
-        {
-            if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= 45.0))
-            {
-                ESP_LOGI(TAG, "Return Flow Target Temperature reached: Enable Burner");
                 bHeatingInAction = true;
-                setCirculationPumpState(ENABLED);
                 setBurnerState(ENABLED);
                 setSafetyControlState(ENABLED);
+                i64BurnerEnableTimestamp = esp_timer_get_time();
                 sControlState = CONTROL_HEATING;
             }
             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)
@@ -139,71 +186,36 @@ eControlWeekday getCurrentWeekday(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;
-
+    return (eControlWeekday)((day == 0) ? 6 : day - 1);
-    // 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;
 }
 
 sControlTemperatureEntry getCurrentTemperatureEntry(void)
 {
     sControlTemperatureEntry result = aControlTable[0].aTemperatureEntries[0];
     eControlWeekday currentDay = getCurrentWeekday();
+
     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 aControlTable[i].aTemperatureEntries[j];
-                return result;
             }
-
-            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];
         }
     }

main/control.h

@@ -9,11 +9,18 @@ typedef enum _ControlState
     CONTROL_HEATING,
     CONTROL_OUTDOOR_TOO_WARM,
     CONTROL_RETURN_FLOW_TOO_WARM,
-    CONTROL_BURNER_FAULT,
+    CONTROL_FAULT_BURNER,
     CONTROL_FAULT_SAFETY,
     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,

main/inputs.c

@@ -16,10 +16,10 @@ static const char *TAG = "smart-oil-heater-control-system-inputs";
 const uint8_t uBurnerFaultPin = 19U;
 const uint8_t uDS18B20Pin = 4U;
 
-const onewire_addr_t uChamperTempSensorAddr = 0x78000000c6c2f728;
+const onewire_addr_t uChamperTempSensorAddr = 0xd00000108cd01d28;
-const onewire_addr_t uOutdoorTempSensorAddr = 0x78000000c6c2f728;
+const onewire_addr_t uOutdoorTempSensorAddr = 0xd70000108a9b9128;
-const onewire_addr_t uInletFlowTempSensorAddr = 0x78000000c6c2f728;
+const onewire_addr_t uInletFlowTempSensorAddr = 0x410000108b8c0628;
-const onewire_addr_t uReturnFlowTempSensorAddr = 0x78000000c6c2f728;
+const onewire_addr_t uReturnFlowTempSensorAddr = 0x90000108cc77c28;
 
 onewire_addr_t uOneWireAddresses[MAX_DN18B20_SENSORS];
 float fDS18B20Temps[MAX_DN18B20_SENSORS];
@@ -36,7 +36,7 @@ void taskInput(void *pvParameters);
 void initMeasurement(sMeasurement *pMeasurement);
 void updateAverage(sMeasurement *pMeasurement);
 void updatePrediction(sMeasurement *pMeasurement);
-float linearRegressionPredict(const float *samples, size_t count, float futureIndex);
+float linearRegressionPredict(const float *samples, size_t count, size_t bufferIndex, float futureIndex);
 
 void initInputs(void)
 {
@@ -162,6 +162,7 @@ void updatePrediction(sMeasurement *pMeasurement)
     predict60s->fValue = linearRegressionPredict(
         predict60s->samples,
         predict60s->bufferCount,
+        predict60s->bufferIndex,
         predict60s->bufferCount + 60.0f);
 }
 
@@ -217,7 +218,7 @@ void taskInput(void *pvParameters)
                         for (int j = 0; j < sSensorCount; j++)
                         {
                             float temp_c = fDS18B20Temps[j];
-                            ESP_LOGI(TAG, "Sensor: %08" PRIx64 " reports %lf°C", (uint64_t)uOneWireAddresses[j], temp_c);
+                            // ESP_LOGI(TAG, "Sensor: %08" PRIx64 " reports %lf°C", (uint64_t)uOneWireAddresses[j], temp_c);
 
                             switch ((uint64_t)uOneWireAddresses[j])
                             {
@@ -226,17 +227,20 @@ void taskInput(void *pvParameters)
                                 sChamperTemperature.state = MEASUREMENT_NO_ERROR;
                                 updateAverage(&sChamperTemperature);
                                 updatePrediction(&sChamperTemperature);
-
+                                break;
+                            case ((uint64_t)uOutdoorTempSensorAddr):
                                 sOutdoorTemperature.fCurrentValue = temp_c;
                                 sOutdoorTemperature.state = MEASUREMENT_NO_ERROR;
                                 updateAverage(&sOutdoorTemperature);
                                 updatePrediction(&sOutdoorTemperature);
-
+                                break;
+                            case ((uint64_t)uInletFlowTempSensorAddr):
                                 sInletFlowTemperature.fCurrentValue = temp_c;
                                 sInletFlowTemperature.state = MEASUREMENT_NO_ERROR;
                                 updateAverage(&sInletFlowTemperature);
                                 updatePrediction(&sInletFlowTemperature);
-
+                                break;
+                            case ((uint64_t)uReturnFlowTempSensorAddr):
                                 sReturnFlowTemperature.fCurrentValue = temp_c;
                                 sReturnFlowTemperature.state = MEASUREMENT_NO_ERROR;
                                 updateAverage(&sReturnFlowTemperature);
@@ -264,7 +268,7 @@ void taskInput(void *pvParameters)
     }
 }
 
-float linearRegressionPredict(const float *samples, size_t count, float futureIndex)
+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
@@ -273,8 +277,11 @@ float linearRegressionPredict(const float *samples, size_t count, float futureIn
 
     for (size_t i = 0; i < count; i++)
     {
-        float x = (float)i;   // Time index
+        // Calculate the circular buffer index for the current sample
-        float y = samples[i]; // Sample value
+        size_t circularIndex = (bufferIndex + i + 1) % count;
+
+        float x = (float)i;               // Time index
+        float y = samples[circularIndex]; // Sample value
 
         sumX += x;
         sumY += y;
@@ -284,8 +291,8 @@ float linearRegressionPredict(const float *samples, size_t count, float futureIn
 
     // 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
+    if (fabs(denominator) < 1e-6)    // Avoid division by zero
-        return samples[count - 1]; // Return last value as prediction
+        return samples[bufferIndex]; // Return the latest value as prediction
 
     float m = (count * sumXY - sumX * sumY) / denominator;
     float b = (sumY - m * sumX) / count;