Refactored AppCore

AppCore.cpp

@@ -1,9 +1,3 @@
-#include <LiquidCrystal.h>
-#include <JC_Button.h>
-#include <OneWire.h>
-#include <DallasTemperature.h>
-#include "Boiler.h"
-#include "Storage.h"
 #include "AppCore.h"
 
 #define HIBERNATE_DELAY 5000
@@ -24,35 +18,11 @@
 #define PIN_LCD_D2 3
 #define PIN_LCD_D3 2
 
-byte g_sensorChar[8] = {
-        B00100,
-        B01110,
-        B01110,
-        B01110,
-        B01110,
-        B11111,
-        B11111,
-        B01110,
-};
-
-Storage g_storage;
-
-OneWire g_oneWire(PIN_ONEWIRE);
-DallasTemperature g_sensors(&g_oneWire);
-DeviceAddress g_sensor1;
-
-Button g_btnMode(PIN_BTN_MODE);
-Button g_btnMinus(PIN_BTN_MINUS);
-Button g_btnPlus(PIN_BTN_PLUS);
-Button* g_buttons[3] = {&g_btnMode, &g_btnMinus, &g_btnPlus};
 #define BUTTONS_COUNT (sizeof(g_buttons) / sizeof(*g_buttons))
+#define MODE_SEQUENCE_COUNT (sizeof(m_modeSequence) / sizeof(*m_modeSequence))
 
-LiquidCrystal g_lcd(PIN_LCD_RS, PIN_LCD_ENABLE, PIN_LCD_D0, PIN_LCD_D1, PIN_LCD_D2, PIN_LCD_D3);
-
-UiStateEnum g_modeSequence[3] = {WaterSetting, HeaterSetting, Lighting};
-#define MODE_SEQUENCE_COUNT (sizeof(g_modeSequence) / sizeof(*g_modeSequence))
-
-AppCoreState g_appCoreState = {
+AppCore::AppCore()
+        : m_appCoreState{
         .appState = {
                 .lastSensorRequestMs = 0,
                 .hasReadSensors = true,
@@ -73,115 +43,60 @@ AppCoreState g_appCoreState = {
                 .modeSequenceIndex = MODE_SEQUENCE_COUNT - 1,
                 .isUpdateNeeded = true
         }
-};
-
-void tmpToStr(char* out, temp_t temp)
-{
-    if (temp == TEMP_T_INVALID)
-    {
-        strcpy(out, " -- ");
-    }
-    else
-    {
-        char tmp[7];
-        dtostrf(temp / 2.0f, 2, 1, tmp);
-        auto len = 4 - strlen(tmp);
-        for (auto i = 0; i < len; ++i)
-        {
-            out[i] = ' ';
-        }
-        strcpy(&out[len], tmp);
-    }
 }
-
-void printStateLine(char prefix, const BoilerItemState& boilerItemState, bool isModifying, bool isActive, LiquidCrystal lcd)
+          , m_modeSequence{WaterSetting, HeaterSetting, Lighting}
+          , m_btnMode{PIN_BTN_MODE}
+          , m_btnMinus{PIN_BTN_MINUS}
+          , m_btnPlus{PIN_BTN_PLUS}
+          , m_buttons{&m_btnMode, &m_btnMinus, &m_btnPlus}
+          , m_lcd{PIN_LCD_RS, PIN_LCD_ENABLE, PIN_LCD_D0, PIN_LCD_D1, PIN_LCD_D2, PIN_LCD_D3}
+          , m_oneWire{PIN_ONEWIRE}
+          , m_sensors{&m_oneWire}
+          , m_sensor1{0}
 {
-    char curTmp[7], setTmp[7], tmp[17];
-    tmpToStr(curTmp, boilerItemState.current);
-    tmpToStr(setTmp, boilerItemState.setting);
-    int count = snprintf(tmp, sizeof(tmp), "%c: %s [%s]%c%c", prefix, curTmp, setTmp, isModifying ? '<' : ' ', isActive ? LCD_CHAR_SENSOR : ' ');
-    for (; count < 17; ++count)
-    {
-        tmp[count] = ' ';
-    }
-    tmp[count] = 0;
-    lcd.print(tmp);
-}
-
-void printState(const AppCoreState& appCoreState, LiquidCrystal lcd)
-{
-    Serial.println("Updating display");
-
-    lcd.setCursor(0, 0);
-    printStateLine('S', appCoreState.appState.water, appCoreState.uiState.state == WaterSetting, appCoreState.appState.water.isActive, lcd);
-    lcd.setCursor(0, 1);
-    printStateLine('C', appCoreState.appState.heater, appCoreState.uiState.state == HeaterSetting, appCoreState.appState.heater.isActive, lcd);
-}
-
-void setState(AppCoreState& boilerState, UiStateEnum state)
-{
-    char tmp[50];
-    snprintf(tmp, sizeof(tmp), "Changing state %i => %i", g_appCoreState.uiState.state, state);
-    Serial.println(tmp);
-
-    if (state == Lighting)
-    {
-        digitalWrite(PIN_LCD_LED, 1);
-    }
-    else if (state == Hibernate)
-    {
-        digitalWrite(PIN_LCD_LED, 0);
-        g_appCoreState.uiState.modeSequenceIndex = MODE_SEQUENCE_COUNT - 1;
-    }
-    g_appCoreState.uiState.state = state;
-    g_appCoreState.uiState.isUpdateNeeded = true;
-}
-
-void checkBoilerItem(BoilerItemState& boilerItemState, UiState uiState)
-{
-    if (!boilerItemState.isActive && boilerItemState.current != TEMP_T_INVALID && boilerItemState.current <= boilerItemState.setting - TEMP_TRIGGER)
-    {
-        boilerItemState.isActive = true;
-        uiState.isUpdateNeeded = true;
-    }
-    else if (boilerItemState.isActive && (boilerItemState.current == TEMP_T_INVALID || boilerItemState.current >= boilerItemState.setting))
-    {
-        boilerItemState.isActive = false;
-        uiState.isUpdateNeeded = true;
-    }
 }
 
 void AppCore::setup()
 {
-    g_sensors.begin();
-    g_sensors.getAddress(g_sensor1, 0);
-    g_sensors.setWaitForConversion(false);
+    m_sensors.begin();
+    m_sensors.getAddress(m_sensor1, 0);
+    m_sensors.setWaitForConversion(false);
 
-    for (unsigned i = 0; i < BUTTONS_COUNT; ++i)
+    for (auto& g_button : m_buttons)
     {
-        g_buttons[i]->begin();
+        g_button->begin();
     }
 
     pinMode(PIN_LCD_LED, OUTPUT);
     digitalWrite(PIN_LCD_LED, 1);
 
-    g_lcd.begin(16, 2);
-    g_lcd.createChar(LCD_CHAR_SENSOR, g_sensorChar);
+    m_lcd.begin(16, 2);
+    byte sensorChar[8] = {
+            B00100,
+            B01110,
+            B01110,
+            B01110,
+            B01110,
+            B11111,
+            B11111,
+            B01110,
+    };
+    m_lcd.createChar(LCD_CHAR_SENSOR, sensorChar);
 
     Serial.begin(9600);
 
     bool allButtonsPressed = true;
-    for (unsigned i = 0; i < BUTTONS_COUNT; ++i)
+    for (auto& g_button : m_buttons)
     {
-        allButtonsPressed = allButtonsPressed && g_buttons[i]->isPressed();
+        allButtonsPressed = allButtonsPressed && g_button->isPressed();
     }
     if (!allButtonsPressed)
     {
-        g_storage.load(g_appCoreState);
+        m_storage.load(m_appCoreState);
     }
     else
     {
-        g_storage.save(g_appCoreState);
+        m_storage.save(m_appCoreState);
     }
 }
 
@@ -189,99 +104,197 @@ void AppCore::loop()
 {
     const auto& currentMs = millis();
 
-    if (currentMs - g_appCoreState.appState.lastSensorRequestMs >= SENSORS_CHECK_INTERVAL)
+    if (currentMs - m_appCoreState.appState.lastSensorRequestMs >= SENSORS_CHECK_INTERVAL)
     {
-        g_appCoreState.appState.lastSensorRequestMs = currentMs;
-        g_appCoreState.appState.hasReadSensors = false;
-        g_sensors.requestTemperaturesByAddress(g_sensor1);
+        m_appCoreState.appState.lastSensorRequestMs = currentMs;
+        m_appCoreState.appState.hasReadSensors = false;
+        m_sensors.requestTemperaturesByAddress(m_sensor1);
     }
-    if (currentMs - g_appCoreState.appState.lastSensorRequestMs >= SENSORS_REQUEST_DELAY && !g_appCoreState.appState.hasReadSensors)
+    if (currentMs - m_appCoreState.appState.lastSensorRequestMs >= SENSORS_REQUEST_DELAY &&
+        !m_appCoreState.appState.hasReadSensors)
     {
-        g_appCoreState.appState.hasReadSensors = true;
-        auto raw = g_sensors.getTempC(g_sensor1);
+        m_appCoreState.appState.hasReadSensors = true;
+        auto raw = m_sensors.getTempC(m_sensor1);
         temp_t temp = TEMP_T_INVALID;
         if (raw != DEVICE_DISCONNECTED_C)
         {
             temp = (temp_t) (raw * 2);
         }
 
-        if (temp != g_appCoreState.appState.water.current)
+        if (temp != m_appCoreState.appState.water.current)
         {
-            g_appCoreState.appState.water.current = temp;
-            g_appCoreState.uiState.isUpdateNeeded = true;
+            m_appCoreState.appState.water.current = temp;
+            m_appCoreState.uiState.isUpdateNeeded = true;
         }
     }
 
 
-    for (unsigned i = 0; i < BUTTONS_COUNT; ++i)
+    for (auto& pButton : m_buttons)
     {
-        g_buttons[i]->read();
-        if (g_buttons[i]->isPressed())
+        pButton->read();
+        if (pButton->isPressed())
         {
-            g_appCoreState.uiState.lastOpMs = currentMs;
+            m_appCoreState.uiState.lastOpMs = currentMs;
             break;
         }
     }
 
 
-    if (g_appCoreState.uiState.state == Hibernate)
+    if (m_appCoreState.uiState.state == Hibernate)
     {
-        for (unsigned i = 0; i < BUTTONS_COUNT; ++i)
+        for (auto& pButton : m_buttons)
         {
-            if (g_buttons[i]->wasReleased())
+            if (pButton->wasReleased())
             {
-                setState(g_appCoreState, Lighting);
+                setState(Lighting);
                 break;
             }
         }
     }
     else
     {
-        if (currentMs - g_appCoreState.uiState.lastOpMs >= HIBERNATE_DELAY)
+        if (currentMs - m_appCoreState.uiState.lastOpMs >= HIBERNATE_DELAY)
         {
-            setState(g_appCoreState, Hibernate);
+            setState(Hibernate);
         }
         else
         {
-            if (g_btnMode.wasReleased())
+            if (m_btnMode.wasReleased())
             {
-                g_appCoreState.uiState.modeSequenceIndex = (g_appCoreState.uiState.modeSequenceIndex + 1) % MODE_SEQUENCE_COUNT;
-                setState(g_appCoreState, g_modeSequence[g_appCoreState.uiState.modeSequenceIndex]);
+                m_appCoreState.uiState.modeSequenceIndex =
+                        (m_appCoreState.uiState.modeSequenceIndex + 1) % MODE_SEQUENCE_COUNT;
+                setState(m_modeSequence[m_appCoreState.uiState.modeSequenceIndex]);
             }
-            else if (g_btnMinus.wasReleased() || g_btnPlus.wasReleased())
+            else if (m_btnMinus.wasReleased() || m_btnPlus.wasReleased())
             {
-                BoilerItemState* itemState = NULL;
-                if (g_appCoreState.uiState.state == WaterSetting)
+                BoilerItemState* itemState = nullptr;
+                if (m_appCoreState.uiState.state == WaterSetting)
                 {
-                    itemState = &g_appCoreState.appState.water;
+                    itemState = &m_appCoreState.appState.water;
                 }
-                else if (g_appCoreState.uiState.state == HeaterSetting)
+                else if (m_appCoreState.uiState.state == HeaterSetting)
                 {
-                    itemState = &g_appCoreState.appState.heater;
+                    itemState = &m_appCoreState.appState.heater;
                 }
 
                 if (itemState)
                 {
-                    if (g_btnMinus.wasReleased())
+                    if (m_btnMinus.wasReleased())
                     {
                         --itemState->setting;
                     }
-                    else if (g_btnPlus.wasReleased())
+                    else if (m_btnPlus.wasReleased())
                     {
                         ++itemState->setting;
                     }
-                    g_appCoreState.uiState.isUpdateNeeded = true;
+                    m_appCoreState.uiState.isUpdateNeeded = true;
                 }
             }
         }
     }
 
-    checkBoilerItem(g_appCoreState.appState.water, g_appCoreState.uiState);
-    checkBoilerItem(g_appCoreState.appState.heater, g_appCoreState.uiState);
+    checkBoilerItem(m_appCoreState.appState.water);
+    checkBoilerItem(m_appCoreState.appState.heater);
 
-    if (g_appCoreState.uiState.isUpdateNeeded)
+    if (m_appCoreState.uiState.isUpdateNeeded)
     {
-        printState(g_appCoreState, g_lcd);
-        g_appCoreState.uiState.isUpdateNeeded = false;
+        printState();
+        m_appCoreState.uiState.isUpdateNeeded = false;
+    }
+}
+
+
+void AppCore::setState(
+        UiStateEnum state
+)
+{
+    char tmp[50];
+    snprintf(tmp, sizeof(tmp), "Changing state %i => %i", m_appCoreState.uiState.state, state);
+    Serial.println(tmp);
+
+    if (state == Lighting)
+    {
+        digitalWrite(PIN_LCD_LED, 1);
+    }
+    else if (state == Hibernate)
+    {
+        digitalWrite(PIN_LCD_LED, 0);
+        m_appCoreState.uiState.modeSequenceIndex = MODE_SEQUENCE_COUNT - 1;
+        m_storage.save(m_appCoreState);
+    }
+    m_appCoreState.uiState.state = state;
+    m_appCoreState.uiState.isUpdateNeeded = true;
+}
+
+void AppCore::checkBoilerItem(
+        BoilerItemState& boilerItemState
+)
+{
+    if (!boilerItemState.isActive && boilerItemState.current != TEMP_T_INVALID &&
+        boilerItemState.current <= boilerItemState.setting - TEMP_TRIGGER)
+    {
+        boilerItemState.isActive = true;
+        m_appCoreState.uiState.isUpdateNeeded = true;
+    }
+    else if (boilerItemState.isActive &&
+             (boilerItemState.current == TEMP_T_INVALID || boilerItemState.current >= boilerItemState.setting))
+    {
+        boilerItemState.isActive = false;
+        m_appCoreState.uiState.isUpdateNeeded = true;
+    }
+}
+
+void AppCore::printState()
+{
+    Serial.println("Updating display");
+
+    m_lcd.setCursor(0, 0);
+    printStateLine('S', m_appCoreState.appState.water, m_appCoreState.uiState.state == WaterSetting,
+                   m_appCoreState.appState.water.isActive);
+    m_lcd.setCursor(0, 1);
+    printStateLine('C', m_appCoreState.appState.heater, m_appCoreState.uiState.state == HeaterSetting,
+                   m_appCoreState.appState.heater.isActive);
+}
+
+void
+AppCore::printStateLine(
+        char prefix
+        , const BoilerItemState& boilerItemState
+        , bool isModifying
+        , bool isActive
+)
+{
+    char curTmp[7], setTmp[7], tmp[17];
+    tempToStr(curTmp, boilerItemState.current);
+    tempToStr(setTmp, boilerItemState.setting);
+    int count = snprintf(tmp, sizeof(tmp), "%c: %s [%s]%c%c", prefix, curTmp, setTmp, isModifying ? '<' : ' ',
+                         isActive ? LCD_CHAR_SENSOR : ' ');
+    for (; count < 17; ++count)
+    {
+        tmp[count] = ' ';
+    }
+    tmp[count] = 0;
+    m_lcd.print(tmp);
+}
+
+void AppCore::tempToStr(
+        char* out
+        , temp_t temp
+)
+{
+    if (temp == TEMP_T_INVALID)
+    {
+        strcpy(out, " -- ");
+    }
+    else
+    {
+        char tmp[7];
+        dtostrf(temp / 2.0f, 2, 1, tmp);
+        auto len = 4 - strlen(tmp);
+        for (auto i = 0; i < len; ++i)
+        {
+            out[i] = ' ';
+        }
+        strcpy(&out[len], tmp);
     }
 }

AppCore.h

@@ -1,15 +1,56 @@
 #pragma once
 
+#include <LiquidCrystal.h>
+#include <JC_Button.h>
+#include <OneWire.h>
+#include <DallasTemperature.h>
+#include "Boiler.h"
+#include "Storage.h"
 
 class AppCore
 {
 public:
+    AppCore();
+
     void setup();
 
     void loop();
 
+protected:
+    void setState(UiStateEnum state);
+
+    void checkBoilerItem(BoilerItemState& boilerItemState);
+
+    void printState();
+
+    void printStateLine(
+            char prefix
+            , const BoilerItemState& boilerItemState
+            , bool isModifying
+            , bool isActive
+    );
+
+    void tempToStr(
+            char* out
+            , temp_t temp
+    );
+
 private:
+    AppCoreState m_appCoreState;
+    Storage m_storage;
+
+    UiStateEnum m_modeSequence[3];
+
+    Button m_btnMode;
+    Button m_btnMinus;
+    Button m_btnPlus;
+    Button* m_buttons[3];
+
+    LiquidCrystal m_lcd;
 
+    OneWire m_oneWire;
+    DallasTemperature m_sensors;
+    DeviceAddress m_sensor1;
 };
 
 

main.ino

@@ -1,4 +1,5 @@
 #include "AppCore.h"
+#include <OneWire.h>
 
 AppCore g_appCore;