Improved internals

Boiler.h

 #define HEATER_BOILER_H
 
 typedef char temp_t;
+typedef unsigned long timestamp_t;
 
 enum UiStateEnum
 {
     HeaterSetting
 };
 
-struct UiState
-{
-    UiStateEnum state;
-    unsigned long lastOpMs;
-    unsigned modeSequenceIndex;
-};
-
-struct BoilerLineState
+struct BoilerItemState
 {
     temp_t current;
     temp_t setting;
     bool isActive;
 };
 
-struct BoilerState
+struct AppState
+{
+    BoilerItemState water;
+    BoilerItemState heater;
+};
+
+struct UiState
+{
+    UiStateEnum state;
+    timestamp_t lastOpMs;
+    unsigned modeSequenceIndex;
+    bool isUpdateNeeded;
+};
+
+struct GlobalState
 {
-    BoilerLineState water;
-    BoilerLineState heater;
+    AppState appState;
     UiState uiState;
 };
 

main.ino

 UiStateEnum g_modeSequence[3] = {WaterSetting, HeaterSetting, Lighting};
 #define MODE_SEQUENCE_COUNT (sizeof(g_modeSequence) / sizeof(*g_modeSequence))
 
-BoilerState g_boilerState = {
-        .water = {
-              .current = 44,
-              .setting = 44,
-              .isActive = false
-        },
-        .heater = {
-              .current = 44,
-              .setting = 44,
-              .isActive = false
+GlobalState g_globalState = {
+        .appState = {
+                .water = {
+                        .current = 44,
+                        .setting = 44,
+                        .isActive = false
+                },
+                .heater = {
+                        .current = 44,
+                        .setting = 44,
+                        .isActive = false
+                }
         },
         .uiState = {
                 .state = Lighting,
                 .lastOpMs = 0,
-                .modeSequenceIndex = MODE_SEQUENCE_COUNT - 1
+                .modeSequenceIndex = MODE_SEQUENCE_COUNT - 1,
+                .isUpdateNeeded = true
         }
 };
 
-void printStateLine(char prefix, const BoilerLineState& boilerLineState, bool isModifying, bool isActive, LiquidCrystal lcd)
+void printStateLine(char prefix, const BoilerItemState& boilerItemState, bool isModifying, bool isActive, LiquidCrystal lcd)
 {
     char curTmp[5], setTmp[5], tmp[17];
-    dtostrf(boilerLineState.current / 2.0f, 2, 1, curTmp);
-    dtostrf(boilerLineState.setting / 2.0f, 2, 1, setTmp);
+    dtostrf(boilerItemState.current / 2.0f, 2, 1, curTmp);
+    dtostrf(boilerItemState.setting / 2.0f, 2, 1, setTmp);
     int count = snprintf(tmp, sizeof(tmp), "%c: %s [%s]%c%c", prefix, curTmp, setTmp, isModifying ? '<' : ' ', isActive ? LCD_CHAR_SENSOR : ' ');
     for (; count < 17; ++count)
     {
     lcd.print(tmp);
 }
 
-void printState(const BoilerState& boilerState, LiquidCrystal lcd)
+void printState(const GlobalState& globalState, LiquidCrystal lcd)
 {
+    Serial.println("Updating display");
+
     lcd.setCursor(0, 0);
-    printStateLine('S', boilerState.water, boilerState.uiState.state == WaterSetting, boilerState.water.isActive, lcd);
+    printStateLine('S', globalState.appState.water, globalState.uiState.state == WaterSetting, globalState.appState.water.isActive, lcd);
     lcd.setCursor(0, 1);
-    printStateLine('C', boilerState.heater, boilerState.uiState.state == HeaterSetting, boilerState.heater.isActive, lcd);
+    printStateLine('C', globalState.appState.heater, globalState.uiState.state == HeaterSetting, globalState.appState.heater.isActive, lcd);
+}
+
+void setState(GlobalState& boilerState, UiStateEnum state)
+{
+    char tmp[50];
+    snprintf(tmp, sizeof(tmp), "Changing state %i => %i", g_globalState.uiState.state, state);
+    Serial.println(tmp);
+    
+    if (state == Lighting)
+    {
+        digitalWrite(PIN_LCD_LED, 1);
+    }
+    else if (state == Hibernate)
+    {
+        digitalWrite(PIN_LCD_LED, 0);
+        g_globalState.uiState.modeSequenceIndex = MODE_SEQUENCE_COUNT - 1;
+    }
+    g_globalState.uiState.state = state;
+    g_globalState.uiState.isUpdateNeeded = true;
+}
+
+void checkBoilerItem(BoilerItemState& boilerItemState, UiState uiState)
+{
+    if (!boilerItemState.isActive && (boilerItemState.current <= boilerItemState.setting - TEMP_TRIGGER))
+    {
+        boilerItemState.isActive = true;
+        uiState.isUpdateNeeded = true;
+    }
+    else if (boilerItemState.isActive && (boilerItemState.current >= boilerItemState.setting))
+    {
+        boilerItemState.isActive = false;
+        uiState.isUpdateNeeded = true;
+    }
 }
 
 void setup()
 
     g_lcd.begin(16, 2);
     g_lcd.createChar(LCD_CHAR_SENSOR, g_sensorChar);
-    printState(g_boilerState, g_lcd);
 
     Serial.begin(9600);
 }
 
 void loop()
 {
-    bool needLcdUpdate = false;
-    unsigned long currentMs = millis();
+    const auto& currentMs = millis();
 
     for (unsigned i = 0; i < BUTTONS_COUNT; ++i)
     {
         g_buttons[i]->read();
         if (g_buttons[i]->isPressed())
         {
-            g_boilerState.uiState.lastOpMs = currentMs;
+            g_globalState.uiState.lastOpMs = currentMs;
+            break;
         }
     }
 
 
-    if (g_boilerState.uiState.state == Hibernate)
+    if (g_globalState.uiState.state == Hibernate)
     {
         for (unsigned i = 0; i < BUTTONS_COUNT; ++i)
         {
             if (g_buttons[i]->wasReleased())
             {
-                g_boilerState.uiState.state = Lighting;
-                digitalWrite(PIN_LCD_LED, 1);
+                setState(g_globalState, Lighting);
                 break;
             }
         }
-        needLcdUpdate = true;
     }
     else
     {
-        if (currentMs - g_boilerState.uiState.lastOpMs >= HIBERNATE_DELAY)
+        if (currentMs - g_globalState.uiState.lastOpMs >= HIBERNATE_DELAY)
         {
-            g_boilerState.uiState.state = Hibernate;
-            digitalWrite(PIN_LCD_LED, 0);
-            g_boilerState.uiState.modeSequenceIndex = MODE_SEQUENCE_COUNT - 1;
-            needLcdUpdate = true;
+            setState(g_globalState, Hibernate);
         }
         else
         {
-            if (g_btnMode.wasPressed())
+            if (g_btnMode.wasReleased())
             {
-                g_boilerState.uiState.modeSequenceIndex =
-                        (g_boilerState.uiState.modeSequenceIndex + 1) % MODE_SEQUENCE_COUNT;
-                g_boilerState.uiState.state = g_modeSequence[g_boilerState.uiState.modeSequenceIndex];
-                needLcdUpdate = true;
+                g_globalState.uiState.modeSequenceIndex = (g_globalState.uiState.modeSequenceIndex + 1) % MODE_SEQUENCE_COUNT;
+                setState(g_globalState, g_modeSequence[g_globalState.uiState.modeSequenceIndex]);
             }
-            else
+            else if (g_btnMinus.wasReleased() || g_btnPlus.wasReleased())
             {
-                temp_t* setting = NULL;
-                if (g_boilerState.uiState.state == WaterSetting)
+                BoilerItemState* itemState = NULL;
+                if (g_globalState.uiState.state == WaterSetting)
                 {
-                    setting = &g_boilerState.water.setting;
+                    itemState = &g_globalState.appState.water;
                 }
-                else if (g_boilerState.uiState.state == HeaterSetting)
+                else if (g_globalState.uiState.state == HeaterSetting)
                 {
-                    setting = &g_boilerState.heater.setting;
+                    itemState = &g_globalState.appState.heater;
                 }
 
-                if (setting)
+                if (itemState)
                 {
                     if (g_btnMinus.wasReleased())
                     {
-                        --(*setting);
+                        --itemState->setting;
                     }
                     else if (g_btnPlus.wasReleased())
                     {
-                        ++(*setting);
+                        ++itemState->setting;
                     }
-                    needLcdUpdate = true;
+                    g_globalState.uiState.isUpdateNeeded = true;
                 }
             }
         }
     }
 
-    if (!g_boilerState.water.isActive && (g_boilerState.water.current <= g_boilerState.water.setting - TEMP_TRIGGER))
-    {
-        g_boilerState.water.isActive = true;
-        needLcdUpdate = true;
-    }
-    else if (g_boilerState.water.isActive && (g_boilerState.water.current >= g_boilerState.water.setting))
-    {
-        g_boilerState.water.isActive = false;
-        needLcdUpdate = true;
-    }
+    checkBoilerItem(g_globalState.appState.water, g_globalState.uiState);
+    checkBoilerItem(g_globalState.appState.heater, g_globalState.uiState);
 
-    if (needLcdUpdate)
+    if (g_globalState.uiState.isUpdateNeeded)
     {
-        printState(g_boilerState, g_lcd);
+        printState(g_globalState, g_lcd);
+        g_globalState.uiState.isUpdateNeeded = false;
     }
 }