From 3771a83fcc26a6e376b8130c2b946e6aa656c7745146b7fda58ef6982f75e094 Mon Sep 17 00:00:00 2001 From: localhorst Date: Sat, 1 Mar 2025 14:27:12 +0100 Subject: [PATCH 01/10] change onewire addr to new outdoor sensor --- main/inputs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main/inputs.c b/main/inputs.c index 62e7086..0c118e7 100644 --- a/main/inputs.c +++ b/main/inputs.c @@ -17,7 +17,7 @@ const uint8_t uBurnerFaultPin = 19U; const uint8_t uDS18B20Pin = 4U; const onewire_addr_t uChamperTempSensorAddr = 0xd00000108cd01d28; -const onewire_addr_t uOutdoorTempSensorAddr = 0x78000000c6c2f728; +const onewire_addr_t uOutdoorTempSensorAddr = 0xd70000108a9b9128; const onewire_addr_t uInletFlowTempSensorAddr = 0x410000108b8c0628; const onewire_addr_t uReturnFlowTempSensorAddr = 0x90000108cc77c28; -- 2.47.1 From fa958dd53b8834d7c2c2c43fa44f884664a02b8af3c484c9c9b64444a0f03db3 Mon Sep 17 00:00:00 2001 From: localhorst Date: Sat, 1 Mar 2025 15:17:22 +0100 Subject: [PATCH 02/10] add outdoor threshold --- main/control.c | 35 ++++++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 11 deletions(-) diff --git a/main/control.c b/main/control.c index 29a6295..387c953 100644 --- a/main/control.c +++ b/main/control.c @@ -10,9 +10,11 @@ #define PERIODIC_INTERVAL 1U // run control loop every 1sec -#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 RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY 30.0f +#define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT 25.0f +#define CHAMPER_TEMPERATURE_TARGET 80.0f // Max cut off temperature, burner will stop if chamber is even or higher +#define CHAMPER_TEMPERATURE_THRESHOLD 45.0f // Min threshold temperature for enabling burner, burner will only start if chamber is even or lower +#define OUTDOOR_TEMPERATURE_THRESHOLD 15.0f // Min threshold temperature for enabling burner, burner will only start if outdoor is even or lower #define BURNER_FAULT_DETECTION_THRESHOLD (60U * 3U) // Detect burner fault if after 3 minutes no burner start detected static const char *TAG = "smart-oil-heater-control-system-control"; @@ -132,15 +134,26 @@ void taskControl(void *pvParameters) if ((bHeatingInAction == false) && (bBurnerFaultDetected == false)) { - if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= 45.0)) + if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= CHAMPER_TEMPERATURE_THRESHOLD)) { - 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; + if (getOutdoorTemperature().average60s.fValue >= OUTDOOR_TEMPERATURE_THRESHOLD) + { + ESP_LOGI(TAG, "Outdoor temperature too warm: Waiting for winter."); + setCirculationPumpState(DISABLED); + setBurnerState(DISABLED); + setSafetyControlState(DISABLED); + sControlState = CONTROL_OUTDOOR_TOO_WARM; + } + else + { + 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 { -- 2.47.1 From c9b7313608fc34dee64d77df9771b011299087387966bf1df9de17a20a1d801e Mon Sep 17 00:00:00 2001 From: localhorst Date: Sat, 1 Mar 2025 15:24:48 +0100 Subject: [PATCH 03/10] refactor --- main/control.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/main/control.c b/main/control.c index 387c953..1bb1726 100644 --- a/main/control.c +++ b/main/control.c @@ -134,17 +134,17 @@ void taskControl(void *pvParameters) if ((bHeatingInAction == false) && (bBurnerFaultDetected == false)) { - if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= CHAMPER_TEMPERATURE_THRESHOLD)) + if (getOutdoorTemperature().average60s.fValue >= OUTDOOR_TEMPERATURE_THRESHOLD) { - if (getOutdoorTemperature().average60s.fValue >= OUTDOOR_TEMPERATURE_THRESHOLD) - { - ESP_LOGI(TAG, "Outdoor temperature too warm: Waiting for winter."); - setCirculationPumpState(DISABLED); - setBurnerState(DISABLED); - setSafetyControlState(DISABLED); - sControlState = CONTROL_OUTDOOR_TOO_WARM; - } - else + ESP_LOGI(TAG, "Outdoor temperature too warm: Waiting for winter."); + setCirculationPumpState(DISABLED); + setBurnerState(DISABLED); + setSafetyControlState(DISABLED); + sControlState = CONTROL_OUTDOOR_TOO_WARM; + } + else + { + if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= CHAMPER_TEMPERATURE_THRESHOLD)) { ESP_LOGI(TAG, "Return Flow Target Temperature reached: Enable Burner"); bHeatingInAction = true; @@ -154,10 +154,10 @@ void taskControl(void *pvParameters) i64BurnerEnableTimestamp = esp_timer_get_time(); sControlState = CONTROL_HEATING; } - } - else - { - sControlState = CONTROL_RETURN_FLOW_TOO_WARM; + else + { + sControlState = CONTROL_RETURN_FLOW_TOO_WARM; + } } } } -- 2.47.1 From 8ca3d9716599b1504bec9b1e854b55e5fc19bb24ed56b715450420b94d5a1042 Mon Sep 17 00:00:00 2001 From: localhorst Date: Sat, 1 Mar 2025 15:36:05 +0100 Subject: [PATCH 04/10] refactoring --- main/control.c | 160 +++++++++++++++++++------------------------------ 1 file changed, 60 insertions(+), 100 deletions(-) diff --git a/main/control.c b/main/control.c index 1bb1726..04ccd8b 100644 --- a/main/control.c +++ b/main/control.c @@ -8,28 +8,31 @@ #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 +// Temperature thresholds #define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_DAY 30.0f #define RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT 25.0f -#define CHAMPER_TEMPERATURE_TARGET 80.0f // Max cut off temperature, burner will stop if chamber is even or higher -#define CHAMPER_TEMPERATURE_THRESHOLD 45.0f // Min threshold temperature for enabling burner, burner will only start if chamber is even or lower -#define OUTDOOR_TEMPERATURE_THRESHOLD 15.0f // Min threshold temperature for enabling burner, burner will only start if outdoor is even or lower -#define BURNER_FAULT_DETECTION_THRESHOLD (60U * 3U) // Detect burner fault if after 3 minutes no burner start detected +#define CHAMBER_TEMPERATURE_TARGET 80.0f // Max cutoff temperature +#define CHAMBER_TEMPERATURE_THRESHOLD 45.0f // Min threshold for burner enable +#define OUTDOOR_TEMPERATURE_THRESHOLD 15.0f // Min threshold for burner enable +#define BURNER_FAULT_DETECTION_THRESHOLD (60U * 3U) // Burner fault detection after 3 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); @@ -65,13 +68,14 @@ void taskControl(void *pvParameters) { vTaskDelay(PERIODIC_INTERVAL * 1000U / portTICK_PERIOD_MS); + // Handle 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); @@ -80,13 +84,14 @@ void taskControl(void *pvParameters) continue; } + // Handle 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); @@ -95,69 +100,59 @@ void taskControl(void *pvParameters) continue; } + // Get current temperature entry 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) + if (bHeatingInAction) { - if ((getChamberTemperature().fCurrentValue >= currentControlEntry.fChamberTemperature) || (getChamberTemperature().predict60s.fValue >= currentControlEntry.fChamberTemperature)) + if ((getChamberTemperature().fCurrentValue >= currentControlEntry.fChamberTemperature) || + (getChamberTemperature().predict60s.fValue >= currentControlEntry.fChamberTemperature)) { - ESP_LOGI(TAG, "Chamber Target Temperature reached: Disable burner"); + ESP_LOGI(TAG, "Chamber target temperature reached: Disabling burner"); bHeatingInAction = false; setCirculationPumpState(ENABLED); setBurnerState(DISABLED); setSafetyControlState(ENABLED); } - else + else if (esp_timer_get_time() - i64BurnerEnableTimestamp >= BURNER_FAULT_DETECTION_THRESHOLD * 1000000U) { - if (bHeatingInAction) + if (getBurnerError() == FAULT) { - 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); - } - } + ESP_LOGW(TAG, "Burner fault detected after timeout!"); + bHeatingInAction = false; + bBurnerFaultDetected = true; + sControlState = CONTROL_FAULT_BURNER; + setCirculationPumpState(ENABLED); + setBurnerState(DISABLED); + setSafetyControlState(ENABLED); } } } - if ((bHeatingInAction == false) && (bBurnerFaultDetected == false)) + if (!bHeatingInAction && !bBurnerFaultDetected) { if (getOutdoorTemperature().average60s.fValue >= OUTDOOR_TEMPERATURE_THRESHOLD) { - ESP_LOGI(TAG, "Outdoor temperature too warm: Waiting for winter."); + ESP_LOGI(TAG, "Outdoor temperature too warm: Disabling heating"); setCirculationPumpState(DISABLED); 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"); + bHeatingInAction = true; + setCirculationPumpState(ENABLED); + setBurnerState(ENABLED); + setSafetyControlState(ENABLED); + i64BurnerEnableTimestamp = esp_timer_get_time(); + sControlState = CONTROL_HEATING; + } else { - if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= CHAMPER_TEMPERATURE_THRESHOLD)) - { - 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 - { - sControlState = CONTROL_RETURN_FLOW_TOO_WARM; - } + sControlState = CONTROL_RETURN_FLOW_TOO_WARM; } } } @@ -173,73 +168,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; -} \ No newline at end of file +} -- 2.47.1 From 416cda0f50272e7602ccb136e102894383c61f7c92d7d6bedd2e38dd15138c73 Mon Sep 17 00:00:00 2001 From: localhorst Date: Sat, 1 Mar 2025 15:43:29 +0100 Subject: [PATCH 05/10] disable log of event --- main/control.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main/control.c b/main/control.c index 04ccd8b..91e35fb 100644 --- a/main/control.c +++ b/main/control.c @@ -133,7 +133,7 @@ void taskControl(void *pvParameters) { if (getOutdoorTemperature().average60s.fValue >= OUTDOOR_TEMPERATURE_THRESHOLD) { - ESP_LOGI(TAG, "Outdoor temperature too warm: Disabling heating"); + // ESP_LOGI(TAG, "Outdoor temperature too warm: Disabling heating"); setCirculationPumpState(DISABLED); setBurnerState(DISABLED); setSafetyControlState(DISABLED); -- 2.47.1 From 66b7f8320ef075afeae2c93722735d796443b8ba0c3c913f26628d6e1c71b101 Mon Sep 17 00:00:00 2001 From: localhorst Date: Fri, 18 Apr 2025 17:50:20 +0200 Subject: [PATCH 06/10] increase burner fault threshold --- main/control.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main/control.c b/main/control.c index 91e35fb..938a1a3 100644 --- a/main/control.c +++ b/main/control.c @@ -16,7 +16,7 @@ #define CHAMBER_TEMPERATURE_TARGET 80.0f // Max cutoff temperature #define CHAMBER_TEMPERATURE_THRESHOLD 45.0f // Min threshold for burner enable #define OUTDOOR_TEMPERATURE_THRESHOLD 15.0f // Min threshold for burner enable -#define BURNER_FAULT_DETECTION_THRESHOLD (60U * 3U) // Burner fault detection after 3 minutes +#define BURNER_FAULT_DETECTION_THRESHOLD (60U * 15U) // Burner fault detection after 15 minutes static const char *TAG = "smart-oil-heater-control-system-control"; static eControlState sControlState = CONTROL_STARTING; -- 2.47.1 From f66b8316669f52e22ec3f5f98c333cac7d53a02e2fed9e4f263f8442466e13e4 Mon Sep 17 00:00:00 2001 From: localhorst Date: Sat, 19 Apr 2025 08:36:19 +0200 Subject: [PATCH 07/10] rework burner fault detection --- main/control.c | 40 +++++++++++++++++++++++++++------------- 1 file changed, 27 insertions(+), 13 deletions(-) diff --git a/main/control.c b/main/control.c index 938a1a3..f8c9eb0 100644 --- a/main/control.c +++ b/main/control.c @@ -13,9 +13,9 @@ // 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 15.0f // Min threshold for burner enable +#define CHAMBER_TEMPERATURE_TARGET 80.0f // Max cutoff temperature +#define CHAMBER_TEMPERATURE_THRESHOLD 45.0f // Min threshold for burner enable +#define OUTDOOR_TEMPERATURE_THRESHOLD 15.0f // Min threshold for burner enable #define BURNER_FAULT_DETECTION_THRESHOLD (60U * 15U) // Burner fault detection after 15 minutes static const char *TAG = "smart-oil-heater-control-system-control"; @@ -58,10 +58,17 @@ void initControl(void) } } +typedef enum _BurnerState +{ + BURNER_UNKNOWN, + BURNER_FIRED, + BURNER_FAULT +} eBurnerState; + void taskControl(void *pvParameters) { bool bHeatingInAction = false; - bool bBurnerFaultDetected = false; + eBurnerState eBurnerState = BURNER_UNKNOWN; int64_t i64BurnerEnableTimestamp = esp_timer_get_time(); while (1) @@ -116,20 +123,27 @@ void taskControl(void *pvParameters) } else if (esp_timer_get_time() - i64BurnerEnableTimestamp >= BURNER_FAULT_DETECTION_THRESHOLD * 1000000U) { - if (getBurnerError() == FAULT) + if (eBurnerState == BURNER_UNKNOWN) { - ESP_LOGW(TAG, "Burner fault detected after timeout!"); - bHeatingInAction = false; - bBurnerFaultDetected = true; - sControlState = CONTROL_FAULT_BURNER; - setCirculationPumpState(ENABLED); - setBurnerState(DISABLED); - setSafetyControlState(ENABLED); + if (getBurnerError() == FAULT) + { + ESP_LOGW(TAG, "Burner fault detected after timeout!"); + bHeatingInAction = false; + eBurnerState = BURNER_FAULT; + sControlState = CONTROL_FAULT_BURNER; + setCirculationPumpState(ENABLED); + setBurnerState(DISABLED); + setSafetyControlState(ENABLED); + } + else + { + eBurnerState = BURNER_FIRED; + } } } } - if (!bHeatingInAction && !bBurnerFaultDetected) + if (!bHeatingInAction && (eBurnerState != BURNER_FAULT)) { if (getOutdoorTemperature().average60s.fValue >= OUTDOOR_TEMPERATURE_THRESHOLD) { -- 2.47.1 From 2477ccb42a70f1c65dd3897e7c79797a92d682453f0edd91b1c37c701162d30d Mon Sep 17 00:00:00 2001 From: localhorst Date: Sat, 19 Apr 2025 08:48:57 +0200 Subject: [PATCH 08/10] increase threshold --- main/control.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/main/control.c b/main/control.c index f8c9eb0..f540b80 100644 --- a/main/control.c +++ b/main/control.c @@ -13,10 +13,10 @@ // 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 15.0f // Min threshold for burner enable -#define BURNER_FAULT_DETECTION_THRESHOLD (60U * 15U) // Burner fault detection after 15 minutes +#define CHAMBER_TEMPERATURE_TARGET 80.0f // Max cutoff temperature +#define CHAMBER_TEMPERATURE_THRESHOLD 45.0f // Min threshold for burner enable +#define OUTDOOR_TEMPERATURE_THRESHOLD 15.0f // Min threshold for burner 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; @@ -127,7 +127,7 @@ void taskControl(void *pvParameters) { if (getBurnerError() == FAULT) { - ESP_LOGW(TAG, "Burner fault detected after timeout!"); + ESP_LOGW(TAG, "Burner fault detected after threshold!"); bHeatingInAction = false; eBurnerState = BURNER_FAULT; sControlState = CONTROL_FAULT_BURNER; @@ -137,6 +137,7 @@ void taskControl(void *pvParameters) } else { + ESP_LOGW(TAG, "No Burner fault detected after threshold!"); eBurnerState = BURNER_FIRED; } } @@ -157,6 +158,7 @@ void taskControl(void *pvParameters) (getChamberTemperature().fCurrentValue <= CHAMBER_TEMPERATURE_THRESHOLD)) { ESP_LOGI(TAG, "Enabling burner: Return flow temperature target reached"); + eBurnerState = BURNER_UNKNOWN; bHeatingInAction = true; setCirculationPumpState(ENABLED); setBurnerState(ENABLED); -- 2.47.1 From dcace073d9c0d61a0e380f7658937b133bc093ccbe0e0309fa79c31977a68a92 Mon Sep 17 00:00:00 2001 From: localhorst Date: Fri, 25 Apr 2025 21:45:59 +0200 Subject: [PATCH 09/10] rework circulation pump --- main/control.c | 95 ++++++++++++++++++++++++++------------------------ main/control.h | 7 ++++ 2 files changed, 56 insertions(+), 46 deletions(-) diff --git a/main/control.c b/main/control.c index f540b80..f140917 100644 --- a/main/control.c +++ b/main/control.c @@ -58,13 +58,6 @@ void initControl(void) } } -typedef enum _BurnerState -{ - BURNER_UNKNOWN, - BURNER_FIRED, - BURNER_FAULT -} eBurnerState; - void taskControl(void *pvParameters) { bool bHeatingInAction = false; @@ -84,7 +77,6 @@ void taskControl(void *pvParameters) { ESP_LOGW(TAG, "Disabling burner due to safety fault"); bHeatingInAction = false; - setCirculationPumpState(ENABLED); setBurnerState(DISABLED); setSafetyControlState(ENABLED); } @@ -100,7 +92,6 @@ void taskControl(void *pvParameters) { ESP_LOGW(TAG, "Disabling burner due to SNTP fault"); bHeatingInAction = false; - setCirculationPumpState(ENABLED); setBurnerState(DISABLED); setSafetyControlState(ENABLED); } @@ -110,46 +101,12 @@ void taskControl(void *pvParameters) // Get current temperature entry sControlTemperatureEntry currentControlEntry = getCurrentTemperatureEntry(); - if (bHeatingInAction) - { - if ((getChamberTemperature().fCurrentValue >= currentControlEntry.fChamberTemperature) || - (getChamberTemperature().predict60s.fValue >= currentControlEntry.fChamberTemperature)) - { - ESP_LOGI(TAG, "Chamber target temperature reached: Disabling burner"); - bHeatingInAction = false; - setCirculationPumpState(ENABLED); - 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 after threshold!"); - bHeatingInAction = false; - eBurnerState = BURNER_FAULT; - sControlState = CONTROL_FAULT_BURNER; - setCirculationPumpState(ENABLED); - setBurnerState(DISABLED); - setSafetyControlState(ENABLED); - } - else - { - ESP_LOGW(TAG, "No Burner fault detected after threshold!"); - eBurnerState = BURNER_FIRED; - } - } - } - } - + // Enable burner if outdoor temperature is low and return flow temperature is cooled down if (!bHeatingInAction && (eBurnerState != BURNER_FAULT)) { if (getOutdoorTemperature().average60s.fValue >= OUTDOOR_TEMPERATURE_THRESHOLD) { // ESP_LOGI(TAG, "Outdoor temperature too warm: Disabling heating"); - setCirculationPumpState(DISABLED); setBurnerState(DISABLED); setSafetyControlState(DISABLED); sControlState = CONTROL_OUTDOOR_TOO_WARM; @@ -160,7 +117,6 @@ void taskControl(void *pvParameters) 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(); @@ -168,10 +124,57 @@ void taskControl(void *pvParameters) } else { + // ESP_LOGI(TAG, "Return flow temperature is still to 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_LOGI(TAG, "Burner fault detected after threshold!"); + bHeatingInAction = false; + eBurnerState = BURNER_FAULT; + sControlState = CONTROL_FAULT_BURNER; + setBurnerState(DISABLED); + setSafetyControlState(ENABLED); + } + else + { + // ESP_LOGI(TAG, "No Burner fault detected after threshold!"); + eBurnerState = BURNER_FIRED; + } + } + } + } + + // Handle circulation pump state + if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && + (getChamberTemperature().fCurrentValue <= CHAMBER_TEMPERATURE_THRESHOLD)) + { + // ESP_LOGI(TAG, "Burner is cooled down: Disable circulation pump"); + setCirculationPumpState(DISABLED); + } + else + { + // ESP_LOGI(TAG, "Burner is heated: Enable circulation pump"); + setCirculationPumpState(ENABLED); + } + } // End of while(1) } eControlState getControlState(void) diff --git a/main/control.h b/main/control.h index ba60d4c..fe7f3ad 100644 --- a/main/control.h +++ b/main/control.h @@ -14,6 +14,13 @@ typedef enum _ControlState CONTROL_FAULT_SNTP, } eControlState; +typedef enum _BurnerState +{ + BURNER_UNKNOWN, // Burner is disabled or state after enabling is still unkown + BURNER_FIRED, // Burner fired successfully + BURNER_FAULT // Burner was unable to fire successfully +} eBurnerState; + typedef enum _ControlWeekday { MONDAY, -- 2.47.1 From ac15376f6b8d47c72c9014f05a01225deb07c4102fb79045e401b604442ef57e Mon Sep 17 00:00:00 2001 From: localhorst Date: Fri, 25 Apr 2025 21:52:31 +0200 Subject: [PATCH 10/10] spelling fixes --- main/control.c | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/main/control.c b/main/control.c index f140917..02d0ebc 100644 --- a/main/control.c +++ b/main/control.c @@ -68,7 +68,7 @@ void taskControl(void *pvParameters) { vTaskDelay(PERIODIC_INTERVAL * 1000U / portTICK_PERIOD_MS); - // Handle safety faults + // Check for safety faults if (getSafetyState() != SAFETY_NO_ERROR) { ESP_LOGW(TAG, "Control not possible due to safety fault!"); @@ -83,7 +83,7 @@ void taskControl(void *pvParameters) continue; } - // Handle SNTP faults + // Check for SNTP faults if (getSntpState() != SYNC_SUCCESSFUL) { ESP_LOGW(TAG, "Control not possible due to SNTP fault!"); @@ -98,7 +98,6 @@ void taskControl(void *pvParameters) continue; } - // Get current temperature entry sControlTemperatureEntry currentControlEntry = getCurrentTemperatureEntry(); // Enable burner if outdoor temperature is low and return flow temperature is cooled down @@ -124,7 +123,7 @@ void taskControl(void *pvParameters) } else { - // ESP_LOGI(TAG, "Return flow temperature is still to warm: Disabling heating"); + // ESP_LOGI(TAG, "Return flow temperature too warm: Disabling heating"); sControlState = CONTROL_RETURN_FLOW_TOO_WARM; } } @@ -146,7 +145,7 @@ void taskControl(void *pvParameters) { if (getBurnerError() == FAULT) { - // ESP_LOGI(TAG, "Burner fault detected after threshold!"); + // ESP_LOGW(TAG, "Burner fault detected: Disabling burner"); bHeatingInAction = false; eBurnerState = BURNER_FAULT; sControlState = CONTROL_FAULT_BURNER; @@ -155,23 +154,23 @@ void taskControl(void *pvParameters) } else { - // ESP_LOGI(TAG, "No Burner fault detected after threshold!"); + // ESP_LOGI(TAG, "No burner fault detected: Marking burner as fired"); eBurnerState = BURNER_FIRED; } } } } - // Handle circulation pump state + // Manage circulation pump if ((getReturnFlowTemperature().average60s.fValue <= currentControlEntry.fReturnFlowTemperature) && (getChamberTemperature().fCurrentValue <= CHAMBER_TEMPERATURE_THRESHOLD)) { - // ESP_LOGI(TAG, "Burner is cooled down: Disable circulation pump"); + // ESP_LOGI(TAG, "Burner cooled down: Disabling circulation pump"); setCirculationPumpState(DISABLED); } else { - // ESP_LOGI(TAG, "Burner is heated: Enable circulation pump"); + // ESP_LOGI(TAG, "Burner heated: Enabling circulation pump"); setCirculationPumpState(ENABLED); } } // End of while(1) -- 2.47.1