suppress heating in summer

spelling fixes
rework circulation pump
2025-07-12 12:04:08 +02:00 · 2025-04-25 21:52:31 +02:00 · 2025-04-25 21:45:59 +02:00 · 2025-04-25 20:45:51 +02:00 · 2025-04-19 08:48:57 +02:00 · 2025-04-19 08:36:19 +02:00
8 changed files with 317 additions and 163 deletions
--- a/README.md
+++ b/README.md
@ -77,31 +77,35 @@ Sntp <|-- Metrics
 #### Example
 ```
 burner_fault_pending 1
-circulation_pump_enabled 0
-burner_enabled 1
-safety_contact_enabled 1
-chamber_temperature 21.812500
-chamber_temperature_avg10 21.837500
-chamber_temperature_avg60 21.825521
-inlet_flow_temperature 22.437500
-inlet_flow_temperature_avg10 22.437500
-inlet_flow_temperature_avg60 22.434896
-outdoor_temperature 21.937500
-outdoor_temperature_avg10 21.937500
-outdoor_temperature_avg60 21.933594
-return_flow_temperature 22.375000
-return_flow_temperature_avg10 22.375000
-return_flow_temperature_avg60 22.375000
+circulation_pump_enabled 1
+burner_enabled 0
+safety_contact_enabled 0
+chamber_temperature 58.750000
+chamber_temperature_avg10 58.931252
+chamber_temperature_avg60 59.190475
+chamber_temperature_pred60 55.870998
+inlet_flow_temperature 53.875000
+inlet_flow_temperature_avg10 53.900002
+inlet_flow_temperature_avg60 53.994320
+inlet_flow_temperature_pred60 52.848743
+outdoor_temperature 18.000000
+outdoor_temperature_avg10 18.006250
+outdoor_temperature_avg60 18.002840
+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
-uptime_seconds 90
-wifi_rssi -63
+system_unixtime 1735242392
+uptime_seconds 40
+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                        |
-|---------------------------------------------------|-------|------------------------------------|
-| CONTROL_STARTING                                  | 0     |                                    |
-| CONTROL_HEATING                                   | 1     | Burner running                     |
-| CONTROL_OUTDOOR_TOO_WARM                          | 2     | Heating not needed                 |
-| CONTROL_RETURN_FLOW_TOO_WARM                      | 3     | Heating not needed                 |
-| CONTROL_BURNER_FAULT                              | 4     | Burner reported fault              |
-| CONTROL_FAULT_SAFETY                              | 5     | Unable to control due safety fault |
-| CONTROL_FAULT_SNTP                                | 6     | Unable to control due SNTP fault   |
+| Enum eControlState in [control.h](main/control.h) | Value | Description                                      |
+|---------------------------------------------------|-------|--------------------------------------------------|
+| CONTROL_STARTING                                  | 0     |                                                  |
+| CONTROL_HEATING                                   | 1     | Burner running                                   |
+| CONTROL_OUTDOOR_TOO_WARM                          | 2     | Heating not needed                               |
+| CONTROL_RETURN_FLOW_TOO_WARM                      | 3     | Heating not needed                               |
+| CONTROL_FAULT_BURNER                              | 4     | Burner reported fault after threshold is reached |
+| CONTROL_FAULT_SAFETY                              | 5     | Unable to control due safety fault               |
+| CONTROL_FAULT_SNTP                                | 6     | Unable to control due SNTP fault                 |

 ##### SNTP Client
 - sntp_state
--- a/main/control.c
+++ b/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
-#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT 25.0
-#define CHAMPER_TEMPERATURE_TARGET 70.0
+// 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 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}}},
-    {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}}},
+    {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}}},
 };

+// Function prototypes
 void taskControl(void *pvParameters);
 eControlWeekday getCurrentWeekday(void);
 sControlTemperatureEntry getCurrentTemperatureEntry(void);
@ -35,7 +43,7 @@ void initControl(void)
    BaseType_t taskCreated = xTaskCreate(
        taskControl,   // Function to implement the task
        "taskControl", // Task name
-        4096,          // Stack size (in words, not bytes)
+        8192,          // Stack size (in words, not bytes)
        NULL,          // Parameters to the task function (none in this case)
        5,             // Task priority (higher number = higher priority)
        NULL           // Task handle (optional)
@ -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");
-                bHeatingInAction = false;
-                setCirculationPumpState(ENABLED);
+                // ESP_LOGI(TAG, "Outdoor temperature too warm: Disabling heating");
                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)
-                {
-                    // 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");
+                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();
                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,73 +186,38 @@ 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;
-
-    // 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)
 {
    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 result;
+                return 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];
        }
    }
    return result;
-}
+}
--- a/main/control.h
+++ b/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,
--- a/main/inputs.c
+++ b/main/inputs.c
@ -1,6 +1,8 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "driver/gpio.h"
+#include <string.h>
+#include <math.h>
 #include "esp_log.h"
 #include <ds18x20.h>

@ -14,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 = 0x3e0000001754be28;
-const onewire_addr_t uOutdoorTempSensorAddr = 0x880000001648e328;
-const onewire_addr_t uInletFlowTempSensorAddr = 0xe59cdef51e64ff28;
-const onewire_addr_t uReturnFlowTempSensorAddr = 0xa7a8e1531f64ff28;
+const onewire_addr_t uChamperTempSensorAddr = 0xd00000108cd01d28;
+const onewire_addr_t uOutdoorTempSensorAddr = 0xd70000108a9b9128;
+const onewire_addr_t uInletFlowTempSensorAddr = 0x410000108b8c0628;
+const onewire_addr_t uReturnFlowTempSensorAddr = 0x90000108cc77c28;

 onewire_addr_t uOneWireAddresses[MAX_DN18B20_SENSORS];
 float fDS18B20Temps[MAX_DN18B20_SENSORS];
@ -31,7 +33,10 @@ static sMeasurement sInletFlowTemperature;
 static sMeasurement sReturnFlowTemperature;

 void taskInput(void *pvParameters);
+void initMeasurement(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)
 {
@ -53,6 +58,11 @@ void initInputs(void)
    }
    xSemaphoreGiveRecursive(xMutexAccessInputs);

+    initMeasurement(&sChamperTemperature);
+    initMeasurement(&sOutdoorTemperature);
+    initMeasurement(&sInletFlowTemperature);
+    initMeasurement(&sReturnFlowTemperature);
+
    BaseType_t taskCreated = xTaskCreate(
        taskInput,   // Function to implement the task
        "taskInput", // Task name
@ -72,8 +82,36 @@ 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)
-{ /* Average form the last 10sec */
+{
+    if (!pMeasurement)
+        return;
+
+    // Average form the last 10sec
    pMeasurement->average10s.samples[pMeasurement->average10s.bufferIndex] = pMeasurement->fCurrentValue;
    pMeasurement->average10s.bufferIndex = (pMeasurement->average10s.bufferIndex + 1) % AVG10_SAMPLE_SIZE;

@ -82,20 +120,15 @@ void updateAverage(sMeasurement *pMeasurement)
        pMeasurement->average10s.bufferCount++;
    }

-    if (pMeasurement->average10s.bufferCount == 0U)
-    {
-        pMeasurement->average10s.fValue = pMeasurement->fCurrentValue;
-    }
-
    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];
    }

    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.bufferIndex = (pMeasurement->average60s.bufferIndex + 1) % AVG60_SAMPLE_SIZE;

@ -104,13 +137,8 @@ void updateAverage(sMeasurement *pMeasurement)
        pMeasurement->average60s.bufferCount++;
    }

-    if (pMeasurement->average60s.bufferCount == 0U)
-    {
-        pMeasurement->average60s.fValue = pMeasurement->fCurrentValue;
-    }
-
    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];
    }
@ -118,6 +146,26 @@ void updateAverage(sMeasurement *pMeasurement)
    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)
 {
    while (1)
@ -163,7 +211,7 @@ void taskInput(void *pvParameters)
                    if (ds18x20_measure_and_read_multi(uDS18B20Pin, uOneWireAddresses, sSensorCount, fDS18B20Temps) != ESP_OK)
                    {
                        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
                    {
@ -178,21 +226,25 @@ void taskInput(void *pvParameters)
                                sChamperTemperature.fCurrentValue = temp_c;
                                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);
+                                updatePrediction(&sReturnFlowTemperature);
                                break;
                            default:
                                break;
@ -216,6 +268,39 @@ 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 ret;
--- a/main/inputs.h
+++ b/main/inputs.h
@ -3,6 +3,7 @@
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 #define AVG10_SAMPLE_SIZE 10U
 #define AVG60_SAMPLE_SIZE 60U
+#define PRED60_SAMPLE_SIZE 60U

 typedef enum _BurnerErrorState
 {
@ -24,11 +25,20 @@ typedef struct _Average
    size_t bufferCount;
 } sAverage;

+typedef struct _Predict
+{
+    float fValue;
+    float samples[PRED60_SAMPLE_SIZE];
+    size_t bufferIndex;
+    size_t bufferCount;
+} sPredict;
+
 typedef struct _Measurement
 {
    float fCurrentValue;
    sAverage average10s;
    sAverage average60s;
+    sPredict predict60s;
    eMeasurementErrorState state;
 } sMeasurement;

--- a/main/metrics.c
+++ b/main/metrics.c
@ -32,7 +32,7 @@ void initMetrics(void)
    BaseType_t taskCreated = xTaskCreate(
        taskMetrics,   // Function to implement the task
        "taskMetrics", // Task name
-        16384,         // Stack size (in words, not bytes)
+        32768,         // Stack size (in words, not bytes)
        NULL,          // Parameters to the task function (none in this case)
        5,             // Task priority (higher number = higher priority)
        NULL           // Task handle (optional)
@ -56,13 +56,13 @@ void taskMetrics(void *pvParameters)

        u16MetricCounter = 0U;

-        /*Burner Error State*/
+        // Burner Error State
        strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_fault_pending");
        aMetrics[u16MetricCounter].type = INTEGER_U8;
        aMetrics[u16MetricCounter].u8MetricValue = getBurnerError();
        u16MetricCounter++;

-        /*Circulation Pump State*/
+        // Circulation Pump State
        if (getCirculationPumpState() == ENABLED)
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, "circulation_pump_enabled");
@ -78,7 +78,7 @@ void taskMetrics(void *pvParameters)
            u16MetricCounter++;
        }

-        /*Burner State*/
+        // Burner State
        if (getBurnerState() == ENABLED)
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_enabled");
@ -94,7 +94,7 @@ void taskMetrics(void *pvParameters)
            u16MetricCounter++;
        }

-        /*Safety Contact State*/
+        // Safety Contact State
        if (getSafetyControlState() == ENABLED)
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, "safety_contact_enabled");
@ -110,79 +110,103 @@ void taskMetrics(void *pvParameters)
            u16MetricCounter++;
        }

-        /*Chamber Temperature*/
+        // Chamber Temperature
        strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().fCurrentValue;
        u16MetricCounter++;

-        /*Chamber Temperature Average 10s*/
+        // Chamber Temperature Average 10s
        strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg10");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().average10s.fValue;
        u16MetricCounter++;

-        /*Chamber Temperature Average 60s*/
+        // Chamber Temperature Average 60s
        strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg60");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().average60s.fValue;
        u16MetricCounter++;

-        /*Inlet Flow Temperature*/
+        // Chamber Temperature Predict 60s
+        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");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().fCurrentValue;
        u16MetricCounter++;

-        /*Inlet Flow Temperature Average 10s*/
+        // Inlet Flow Temperature Average 10s
        strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg10");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().average10s.fValue;
        u16MetricCounter++;

-        /*Inlet Flow Temperature Average 60s*/
+        // Inlet Flow Temperature Average 60s
        strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg60");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().average60s.fValue;
        u16MetricCounter++;

-        /*Outdoor Temperature*/
+        // Inlet Flow Temperature Predict 60s
+        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");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().fCurrentValue;
        u16MetricCounter++;

-        /*Outdoor Temperature Average 10s*/
+        // Outdoor Temperature Average 10s
        strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg10");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().average10s.fValue;
        u16MetricCounter++;

-        /*Outdoor Temperature Average 60s*/
+        // Outdoor Temperature Average 60s
        strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg60");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().average60s.fValue;
        u16MetricCounter++;

-        /*Return Flow Temperature*/
+        // Outdoor Temperature Predict 60s
+        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");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().fCurrentValue;
        u16MetricCounter++;

-        /*Return Flow Temperature Average 10s*/
+        // Return Flow Temperature Average 10s
        strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg10");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().average10s.fValue;
        u16MetricCounter++;

-        /*Return Flow Temperature Average 60s*/
+        // Return Flow Temperature Average 60s
        strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg60");
        aMetrics[u16MetricCounter].type = FLOAT;
        aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().average60s.fValue;
        u16MetricCounter++;

-        /*Sensor State*/
+        // Return Flow Temperature Predict 60s
+        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];
        getSensorSanityStates(aChecks);
        for (size_t i = 0; i < NUMBER_OF_SENSOR_SANITY_CHECKS; i++)
@ -194,25 +218,25 @@ void taskMetrics(void *pvParameters)
            u16MetricCounter++;
        }

-        /*Safety State*/
+        // Safety State
        strcpy(aMetrics[u16MetricCounter].caMetricName, "safety_state");
        aMetrics[u16MetricCounter].type = INTEGER_U8;
        aMetrics[u16MetricCounter].u8MetricValue = getSafetyState();
        u16MetricCounter++;

-        /*Control State*/
+        // Control State
        strcpy(aMetrics[u16MetricCounter].caMetricName, "control_state");
        aMetrics[u16MetricCounter].type = INTEGER_U8;
        aMetrics[u16MetricCounter].u8MetricValue = getControlState();
        u16MetricCounter++;

-        /*SNTP State*/
+        // SNTP State
        strcpy(aMetrics[u16MetricCounter].caMetricName, "sntp_state");
        aMetrics[u16MetricCounter].type = INTEGER_U8;
        aMetrics[u16MetricCounter].u8MetricValue = getSntpState();
        u16MetricCounter++;

-        /*System Time*/
+        // System Time
        time_t now;
        time(&now);
        strcpy(aMetrics[u16MetricCounter].caMetricName, "system_unixtime");
@ -220,13 +244,13 @@ void taskMetrics(void *pvParameters)
        aMetrics[u16MetricCounter].i64MetricValue = now;
        u16MetricCounter++;

-        /*Uptime*/
+        // Uptime
        strcpy(aMetrics[u16MetricCounter].caMetricName, "uptime_seconds");
        aMetrics[u16MetricCounter].type = INTEGER_64;
        aMetrics[u16MetricCounter].i64MetricValue = (esp_timer_get_time() / 1000000U);
        u16MetricCounter++;

-        /*Wifi RSSI*/
+        // Wifi RSSI
        wifi_ap_record_t ap;
        esp_wifi_sta_get_ap_info(&ap);
        strcpy(aMetrics[u16MetricCounter].caMetricName, "wifi_rssi");
@ -243,7 +267,7 @@ void vSetMetrics(sMetric *paMetrics, uint16_t u16Size)

    if (xSemaphoreTakeRecursive(xMutexAccessMetricResponse, pdMS_TO_TICKS(5000)) == pdTRUE)
    {
-        memset(caHtmlResponse, 0, strlen(caHtmlResponse));
+        memset(caHtmlResponse, 0U, strlen(caHtmlResponse));
        for (uint16_t u16Index = 0U; u16Index < u16Size; u16Index++)
        {
            char caValueBuffer[64];
@ -263,6 +287,7 @@ void vSetMetrics(sMetric *paMetrics, uint16_t u16Size)
                break;
            }

+            // printf("%s\n", paMetrics[u16Index].caMetricName);
            // printf("%s\n", caValueBuffer);
            strcat(caHtmlResponse, paMetrics[u16Index].caMetricName);
            strcat(caHtmlResponse, caValueBuffer);
--- a/main/metrics.h
+++ b/main/metrics.h
@ -2,9 +2,9 @@

 #include <esp_http_server.h>

-#define HTML_RESPONSE_SIZE 1024U
-#define METRIC_NAME_MAX_SIZE 256U
-#define METRIC_MAX_COUNT 64U
+#define HTML_RESPONSE_SIZE 4096U
+#define METRIC_NAME_MAX_SIZE 64U
+#define METRIC_MAX_COUNT 32U

 typedef enum _MetricValueType
 {
--- a/main/safety.c
+++ b/main/safety.c
@ -155,5 +155,16 @@ void getSensorSanityStates(sSensorSanityCheck *pSensorSanityChecks)

 eSafetyState getSafetyState(void)
 {
-    return sSafetyState;
+    eSafetyState state = SAFETY_NO_ERROR;
+    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;
 }
Author	SHA256	Message	Date
localhorst	6eca00200e	suppress heating in summer	2025-07-12 12:04:08 +02:00
localhorst	ac15376f6b	spelling fixes	2025-04-25 21:52:31 +02:00
localhorst	dcace073d9	rework circulation pump	2025-04-25 21:45:59 +02:00
Hendrik Schutter	da7a1be183	Merge pull request 'fix/burner-fault-detection' (#23 ) from fix/burner-fault-detection into feature/summer-mode Reviewed-on: #23	2025-04-25 20:45:51 +02:00
localhorst	2477ccb42a	increase threshold	2025-04-19 08:48:57 +02:00
localhorst	f66b831666	rework burner fault detection	2025-04-19 08:36:19 +02:00
localhorst	66b7f8320e	increase burner fault threshold	2025-04-18 17:50:20 +02:00
localhorst	416cda0f50	disable log of event	2025-03-01 15:43:29 +01:00
localhorst	8ca3d97165	refactoring	2025-03-01 15:36:05 +01:00
localhorst	c9b7313608	refactor	2025-03-01 15:24:48 +01:00
localhorst	fa958dd53b	add outdoor threshold	2025-03-01 15:17:22 +01:00
localhorst	3771a83fcc	change onewire addr to new outdoor sensor	2025-03-01 14:27:12 +01:00
localhorst	a72c0673b1	Improve efficiency (#21 ) - Change to new One Wire Sensors that are no fakes - Increase chamber temperature Reviewed-on: #21 Co-authored-by: localhorst <localhorst@mosad.xyz> Co-committed-by: localhorst <localhorst@mosad.xyz>	2025-02-08 20:05:14 +01:00
Hendrik Schutter	999af9d888	Merge pull request 'bugfix/linear-regression-prediction' (#19 ) from bugfix/linear-regression-prediction into main Reviewed-on: #19	2024-12-26 22:47:35 +01:00
localhorst	8a8bcd078b	disable log	2024-12-26 22:47:12 +01:00
localhorst	59b8c3e2b2	revert lab setup	2024-12-26 22:46:30 +01:00
localhorst	06c6612ef6	fix algo	2024-12-26 22:40:20 +01:00
localhorst	e790660c36	Merge branch 'main' into testing/lab-temperature-sensor	2024-12-26 22:19:41 +01:00
Hendrik Schutter	3c972296ce	update example metric	2024-12-26 20:47:21 +01:00
Hendrik Schutter	8672241151	Merge pull request 'detect burner fault' (#17 ) from feature/burner-fault-detection into main Reviewed-on: #17	2024-12-26 20:37:50 +01:00
localhorst	25b0a11694	fix detection state	2024-12-26 20:37:19 +01:00
localhorst	effd5c19e9	detect burner fault	2024-12-26 20:27:42 +01:00
localhorst	b21dc720ed	use lab single sensor	2024-12-26 20:00:37 +01:00
Hendrik Schutter	4ffa416f6f	Merge pull request 'feature/temperature-predict' (#16 ) from feature/temperature-predict into main Reviewed-on: #16	2024-12-26 19:12:20 +01:00
localhorst	5fde319b63	formatting	2024-12-26 19:09:16 +01:00
localhorst	6b38a73d77	Revert "switch to single sensor config" This reverts commit `307278e679`.	2024-12-26 19:08:50 +01:00
localhorst	b5229a4082	cleanup average function	2024-12-26 19:00:09 +01:00
localhorst	856f009e7f	add prediction to all temps	2024-12-26 18:54:50 +01:00
localhorst	1564860213	use linear regression for preduction	2024-12-26 18:49:04 +01:00
localhorst	29223c0070	increase metrics task stack to support more metrics	2024-12-26 18:12:39 +01:00
localhorst	655d890a0f	chamber temp prediction metrics	2024-12-26 13:07:03 +01:00
localhorst	59eb361431	get pred10s working	2024-12-26 11:25:50 +01:00
localhorst	56f1831d8c	pred10s	2024-12-26 11:20:07 +01:00
localhorst	80e48f632f	fix mem fault	2024-12-26 11:01:25 +01:00
localhorst	26d0761aed	Merge branch 'testing/lab-temperature-sensor' into feature/temperature-predict	2024-12-26 10:40:47 +01:00
localhorst	e267e2be58	disable changes	2024-12-26 10:36:42 +01:00
localhorst	795223ff66	Merge branch 'main' into feature/temperature-predict	2024-12-26 10:14:41 +01:00
localhorst	5380cc9cca	Merge branch 'main' into testing/lab-temperature-sensor	2024-12-25 22:57:09 +01:00
Hendrik Schutter	8effd730b9	Merge pull request 'Fix: Mutex in getter of safety state' (#9 ) from bugfix/get-safety-state-critial-section into main Reviewed-on: #9	2024-12-25 22:56:04 +01:00
localhorst	4deed03190	add mutex in getter of safety state	2024-12-25 22:54:57 +01:00
localhorst	ff16e601fb	add prediction for 10s	2024-12-25 22:10:38 +01:00
localhorst	307278e679	switch to single sensor config	2024-12-25 20:39:49 +01:00