localhorst/smart-oil-heating-control-system
SHA256
1
0
Fork 0
Code Issues 3 Pull Requests 2 Actions Packages Projects Releases 1 Wiki Activity

bugfix/static-code-analysis (#28)

Browse Source 
The claude.ai LLM performed a static code analysis.

Reviewed-on: #28
Co-authored-by: localhorst <localhorst@mosad.xyz>
Co-committed-by: localhorst <localhorst@mosad.xyz>
This commit is contained in:
Hendrik Schutter
2026-02-14 16:21:32 +01:00
committed by Hendrik Schutter
parent 0c3779bf72
commit 260b26023c
7 changed files with 212 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
main/control.c
View File

@ -25,9 +25,9 @@
(60U * 4U) // Burner fault detection after 4 minutes
static const char *TAG = "smart-oil-heater-control-system-control";
static eControlState sControlState = CONTROL_STARTING;
static eControlState gControlState = CONTROL_STARTING;
// Control table for daily schedules
static const sControlDay aControlTable[] = {
static const sControlDay gControlTable[] = {
{MONDAY,
2U,
{{{4, 45},
@ -85,15 +85,25 @@ static const sControlDay aControlTable[] = {
RETURN_FLOW_TEMPERATURE_LOWER_LIMIT_NIGHT,
CHAMBER_TEMPERATURE_TARGET}}},
};
static sControlTemperatureEntry currentControlEntry =
aControlTable[0].aTemperatureEntries[0];
static sControlTemperatureEntry gCurrentControlEntry =
gControlTable[0].aTemperatureEntries[0];
static SemaphoreHandle_t xMutexAccessControl = NULL;
// Function prototypes
void taskControl(void *pvParameters);
void findControlCurrentTemperatureEntry(void);
void setControlState(eControlState state);
void initControl(void)
{
xMutexAccessControl = xSemaphoreCreateRecursiveMutex();
if (xMutexAccessControl == NULL)
{
ESP_LOGE(TAG, "Unable to create mutex");
}
xSemaphoreGiveRecursive(xMutexAccessControl);
BaseType_t taskCreated =
xTaskCreate(taskControl, // Function to implement the task
"taskControl", // Task name
@ -117,7 +127,7 @@ void taskControl(void *pvParameters)
{
bool bHeatingInAction = false;
bool bSummerMode = false;
eBurnerState eBurnerState = BURNER_UNKNOWN;
eBurnerState burnerState = BURNER_UNKNOWN;
int64_t i64BurnerEnableTimestamp = esp_timer_get_time();
while (1)
@ -128,7 +138,7 @@ void taskControl(void *pvParameters)
if (getSafetyState() != SAFETY_NO_ERROR)
{
ESP_LOGW(TAG, "Control not possible due to safety fault!");
sControlState = CONTROL_FAULT_SAFETY;
setControlState(CONTROL_FAULT_SAFETY);
if (bHeatingInAction)
{
ESP_LOGW(TAG, "Disabling burner due to safety fault");
@ -143,7 +153,7 @@ void taskControl(void *pvParameters)
if (getSntpState() != SYNC_SUCCESSFUL)
{
ESP_LOGW(TAG, "Control not possible due to SNTP fault!");
sControlState = CONTROL_FAULT_SNTP;
setControlState(CONTROL_FAULT_SNTP);
if (bHeatingInAction)
{
ESP_LOGW(TAG, "Disabling burner due to SNTP fault");
@ -155,8 +165,6 @@ void taskControl(void *pvParameters)
}
findControlCurrentTemperatureEntry();
sControlTemperatureEntry currentControlEntry =
getControlCurrentTemperatureEntry();
if (getOutdoorTemperature().fDampedValue >=
SUMMER_MODE_TEMPERATURE_THRESHOLD_HIGH)
@ -171,33 +179,33 @@ void taskControl(void *pvParameters)
// Enable burner if outdoor temperature is low and return flow temperature
// is cooled down
if (!bHeatingInAction && (eBurnerState != BURNER_FAULT))
if (!bHeatingInAction && (burnerState != BURNER_FAULT))
{
if (bSummerMode)
{
// ESP_LOGI(TAG, "Outdoor temperature too warm: Disabling heating");
setBurnerState(DISABLED);
setSafetyControlState(DISABLED);
sControlState = CONTROL_OUTDOOR_TOO_WARM;
setControlState(CONTROL_OUTDOOR_TOO_WARM);
}
else if ((getReturnFlowTemperature().average60s.fValue <=
currentControlEntry.fReturnFlowTemperature) &&
getControlCurrentTemperatureEntry().fReturnFlowTemperature) &&
(getChamberTemperature().fCurrentValue <=
CHAMBER_TEMPERATURE_THRESHOLD))
{
ESP_LOGI(TAG,
"Enabling burner: Return flow temperature target reached");
eBurnerState = BURNER_UNKNOWN;
burnerState = BURNER_UNKNOWN;
bHeatingInAction = true;
setBurnerState(ENABLED);
setSafetyControlState(ENABLED);
i64BurnerEnableTimestamp = esp_timer_get_time();
sControlState = CONTROL_HEATING;
setControlState(CONTROL_HEATING);
}
else
{
// ESP_LOGI(TAG, "Return flow temperature too warm: Disabling heating");
sControlState = CONTROL_RETURN_FLOW_TOO_WARM;
setControlState(CONTROL_RETURN_FLOW_TOO_WARM);
}
}
@ -205,9 +213,9 @@ void taskControl(void *pvParameters)
if (bHeatingInAction)
{
if ((getChamberTemperature().fCurrentValue >=
currentControlEntry.fChamberTemperature) ||
getControlCurrentTemperatureEntry().fChamberTemperature) ||
(getChamberTemperature().predict60s.fValue >=
currentControlEntry.fChamberTemperature))
getControlCurrentTemperatureEntry().fChamberTemperature))
{
ESP_LOGI(TAG, "Chamber target temperature reached: Disabling burner");
bHeatingInAction = false;
@ -217,14 +225,14 @@ void taskControl(void *pvParameters)
else if (esp_timer_get_time() - i64BurnerEnableTimestamp >=
BURNER_FAULT_DETECTION_THRESHOLD * 1000000U)
{
if (eBurnerState == BURNER_UNKNOWN)
if (burnerState == BURNER_UNKNOWN)
{
if (getBurnerError() == FAULT)
{
// ESP_LOGW(TAG, "Burner fault detected: Disabling burner");
bHeatingInAction = false;
eBurnerState = BURNER_FAULT;
sControlState = CONTROL_FAULT_BURNER;
burnerState = BURNER_FAULT;
setControlState(CONTROL_FAULT_BURNER);
setBurnerState(DISABLED);
setSafetyControlState(ENABLED);
}
@ -232,7 +240,7 @@ void taskControl(void *pvParameters)
{
// ESP_LOGI(TAG, "No burner fault detected: Marking burner as
// fired");
eBurnerState = BURNER_FIRED;
burnerState = BURNER_FIRED;
}
}
}
@ -253,17 +261,47 @@ void taskControl(void *pvParameters)
} // End of while(1)
}
eControlState getControlState(void) { return sControlState; }
void setControlState(eControlState state)
{
if (xSemaphoreTakeRecursive(xMutexAccessControl, pdMS_TO_TICKS(5000)) == pdTRUE)
{
gControlState = state;
xSemaphoreGiveRecursive(xMutexAccessControl);
}
else
{
ESP_LOGE(TAG, "Unable to take mutex: setControlState()");
}
}
eControlState getControlState(void)
{
eControlState ret = CONTROL_FAULT_SAFETY;
if (xSemaphoreTakeRecursive(xMutexAccessControl, pdMS_TO_TICKS(5000)) == pdTRUE)
{
ret = gControlState;
xSemaphoreGiveRecursive(xMutexAccessControl);
}
else
{
ESP_LOGE(TAG, "Unable to take mutex: getControlState()");
}
return ret;
}
eControlWeekday getControlCurrentWeekday(void)
{
// Get current time
time_t now;
struct tm *timeinfo;
struct tm timeinfo;
time(&now);
timeinfo = localtime(&now);
localtime_r(&now, &timeinfo);
int day = timeinfo->tm_wday;
int day = timeinfo.tm_wday;
return (eControlWeekday)((day == 0) ? 6 : day - 1);
}
@ -294,66 +332,88 @@ void findControlCurrentTemperatureEntry(void)
int currentHour = timeinfo.tm_hour;
int currentMinute = timeinfo.tm_min;
// ESP_LOGI(TAG, "Searching for control entry - Day: %d, Time: %02d:%02d", currentDay, currentHour, currentMinute);
// Search through all days and entries
for (int dayIndex = 0; dayIndex < 7; dayIndex++)
if (xSemaphoreTakeRecursive(xMutexAccessControl, pdMS_TO_TICKS(5000)) == pdTRUE)
{
const sControlDay *day = &aControlTable[dayIndex];
for (int entryIndex = 0; entryIndex < day->entryCount; entryIndex++)
// ESP_LOGI(TAG, "Searching for control entry - Day: %d, Time: %02d:%02d", currentDay, currentHour, currentMinute);
// Search through all days and entries
for (int dayIndex = 0; dayIndex < 7; dayIndex++)
{
const sControlTemperatureEntry *entry = &day->aTemperatureEntries[entryIndex];
const sControlDay *day = &gControlTable[dayIndex];
// Check if this entry is in the future (next active entry)
bool isFutureDay = (day->day > currentDay);
bool isTodayFutureTime = (day->day == currentDay) &&
((entry->timestamp.hour > currentHour) ||
(entry->timestamp.hour == currentHour &&
entry->timestamp.minute > currentMinute));
if (isFutureDay || isTodayFutureTime)
for (int entryIndex = 0; entryIndex < day->entryCount; entryIndex++)
{
// Found next scheduled entry, so determine the previous (active) one
if (entryIndex > 0)
const sControlTemperatureEntry *entry = &day->aTemperatureEntries[entryIndex];
// Check if this entry is in the future (next active entry)
bool isFutureDay = (day->day > currentDay);
bool isTodayFutureTime = (day->day == currentDay) &&
((entry->timestamp.hour > currentHour) ||
(entry->timestamp.hour == currentHour &&
entry->timestamp.minute > currentMinute));
if (isFutureDay || isTodayFutureTime)
{
// Use previous entry from same day
currentControlEntry = day->aTemperatureEntries[entryIndex - 1];
// Found next scheduled entry, so determine the previous (active) one
if (entryIndex > 0)
{
// Use previous entry from same day
gCurrentControlEntry = day->aTemperatureEntries[entryIndex - 1];
}
else if (dayIndex > 0)
{
// Use last entry from previous day
const sControlDay *previousDay = &gControlTable[dayIndex - 1];
gCurrentControlEntry = previousDay->aTemperatureEntries[previousDay->entryCount - 1];
}
else
{
// First entry of the week - wrap to last entry of Sunday
const sControlDay *sunday = &gControlTable[6];
gCurrentControlEntry = sunday->aTemperatureEntries[sunday->entryCount - 1];
}
/*
ESP_LOGI(TAG, "Active entry found - Time: %02d:%02d, "
"Return Temp: %lf, Chamber Temp: %lf",
gCurrentControlEntry.timestamp.hour,
gCurrentControlEntry.timestamp.minute,
gCurrentControlEntry.fReturnFlowTemperature,
gCurrentControlEntry.fChamberTemperature);
*/
xSemaphoreGiveRecursive(xMutexAccessControl);
return;
}
else if (dayIndex > 0)
{
// Use last entry from previous day
const sControlDay *previousDay = &aControlTable[dayIndex - 1];
currentControlEntry = previousDay->aTemperatureEntries[previousDay->entryCount - 1];
}
else
{
// First entry of the week - wrap to last entry of Sunday
const sControlDay *sunday = &aControlTable[6];
currentControlEntry = sunday->aTemperatureEntries[sunday->entryCount - 1];
}
/*
ESP_LOGI(TAG, "Active entry found - Time: %02d:%02d, "
"Return Temp: %lf, Chamber Temp: %lf",
currentControlEntry.timestamp.hour,
currentControlEntry.timestamp.minute,
currentControlEntry.fReturnFlowTemperature,
currentControlEntry.fChamberTemperature);
*/
return;
}
}
// If we reached here, current time is after all entries this week
// Use the last entry (Sunday evening)
const sControlDay *sunday = &gControlTable[6];
gCurrentControlEntry = sunday->aTemperatureEntries[sunday->entryCount - 1];
// ESP_LOGI(TAG, "Using last entry of week - Time: %02d:%02d", gCurrentControlEntry.timestamp.hour, gCurrentControlEntry.timestamp.minute);
xSemaphoreGiveRecursive(xMutexAccessControl);
}
else
{
ESP_LOGE(TAG, "Unable to take mutex: findControlCurrentTemperatureEntry()");
}
// If we reached here, current time is after all entries this week
// Use the last entry (Sunday evening)
const sControlDay *sunday = &aControlTable[6];
currentControlEntry = sunday->aTemperatureEntries[sunday->entryCount - 1];
// ESP_LOGI(TAG, "Using last entry of week - Time: %02d:%02d", currentControlEntry.timestamp.hour, currentControlEntry.timestamp.minute);
}
sControlTemperatureEntry getControlCurrentTemperatureEntry(void)
{
return currentControlEntry;
sControlTemperatureEntry ret = gControlTable[0].aTemperatureEntries[0];
if (xSemaphoreTakeRecursive(xMutexAccessControl, pdMS_TO_TICKS(5000)) == pdTRUE)
{
ret = gCurrentControlEntry;
xSemaphoreGiveRecursive(xMutexAccessControl);
}
else
{
ESP_LOGE(TAG, "Unable to take mutex: getControlCurrentTemperatureEntry()");
}
return ret;
}