Moved to Activities and Services

AppCore.cpp

@@ -1,477 +1,143 @@
 #include "AppCore.h"
 #include "Logs.h"
 
+#include "defines.h"
+#include "Boiler.h"
+#include "globals.h"
+#include "HomeActivity.h"
+#include "MenuItemActivity.h"
+#include "LoaderActivity.h"
+
 #define xstr(s) str(s)
 #define str(s) #s
 
-#define HIBERNATE_DELAY 5000
-#define SENSORS_CHECK_INTERVAL 2000
-#define SENSORS_REQUEST_DELAY 750
-#define TEMP_TRIGGER ((temp_t)(5 * 10.0f))
-#define TEMP_INTERVAL ((temp_t)(0.5 * 10.0f))
-#define LCD_CHAR_SENSOR 1
-
-#define PIN_ONEWIRE A0
-#define PIN_RELAY2 A1
-#define PIN_RELAY1 A2
-#define PIN_BTN_CANCEL 9
-#define PIN_BTN_OK 10
-#define PIN_BTN_MINUS 11
-#define PIN_BTN_PLUS 12
-#define PIN_LCD_LED 2
-#define PIN_LCD_RS 8
-#define PIN_LCD_ENABLE 7
-#define PIN_LCD_D4 6
-#define PIN_LCD_D5 5
-#define PIN_LCD_D6 4
-#define PIN_LCD_D7 3
-
-UiStateEnum AppCore::s_menuSequence[4]{MenuWaterSetting, MenuHeaterSetting, MenuTempTrigger, MenuVersion};
-
-AppCore::AppCore()
-        : m_appCoreState(new AppCoreState{
-        .appState = {
-                .lastSensorRequestMs = 0,
-                .hasReadSensors = true,
-                .water = {
-                        .current = TEMP_T_INVALID,
+Button g_btnCancel(PIN_BTN_CANCEL);
+Button g_btnOk(PIN_BTN_OK);
+Button g_btnMinus(PIN_BTN_MINUS);
+Button g_btnPlus(PIN_BTN_PLUS);
+HibernateService g_hibernateService;
+LiquidCrystal g_lcd{PIN_LCD_RS, PIN_LCD_ENABLE, PIN_LCD_D4, PIN_LCD_D5, PIN_LCD_D6, PIN_LCD_D7};
+DigitalOutput g_lcdLed{PIN_LCD_LED};
+DigitalOutput g_relay1{PIN_RELAY1};
+DigitalOutput g_relay2{PIN_RELAY2};
+OneWire g_oneWire{PIN_ONEWIRE};
+DallasTemperature g_dallasTemperature{&g_oneWire};
+TempInput g_tempInput1{0};
+TempInput g_tempInput2{1};
+BoilerTankService g_tankService1{&g_appState.tanks[0]};
+BoilerTankService g_tankService2{&g_appState.tanks[1]};
+
+AppCoreState g_appState{
+        .tanks = {
+                {
+                        .mode = BoilerTankState::Auto,
                         .setting = 0,
-                        .isActive = false,
-                        .pinNo = PIN_RELAY1
+                        .tempTrigger = TEMP_TRIGGER,
+                        .input = &g_tempInput1,
+                        .relay = &g_relay1
                 },
-                .heater = {
-                        .current = TEMP_T_INVALID,
+                {
+                        .mode = BoilerTankState::Auto,
                         .setting = 0,
-                        .isActive = false,
-                        .pinNo = PIN_RELAY2
-                },
-                .tempTrigger = TEMP_TRIGGER,
-                .pCurrentSettingEdit = nullptr,
-                .currentSettingEditTmp = 0
-        },
-        .uiState = {
-                .state = HomeLighting,
-                .lastOpMs = 0,
-                .isUpdateNeeded = true
+                        .tempTrigger = TEMP_TRIGGER,
+                        .input = &g_tempInput2,
+                        .relay = &g_relay2
+                }
         }
-})
-          , m_pBtnCancel(new Button{PIN_BTN_CANCEL})
-          , m_pBtnOk(new Button{PIN_BTN_OK})
-          , m_pBtnMinus(new Button{PIN_BTN_MINUS})
-          , m_pBtnPlus(new Button{PIN_BTN_PLUS})
-          , m_pButtons{m_pBtnCancel, m_pBtnOk, m_pBtnMinus, m_pBtnPlus}
-          , m_pLcd(new LiquidCrystal{PIN_LCD_RS, PIN_LCD_ENABLE, PIN_LCD_D4, PIN_LCD_D5, PIN_LCD_D6, PIN_LCD_D7})
-          , m_pOneWire(new OneWire{PIN_ONEWIRE})
-          , m_pSensors(new DallasTemperature{m_pOneWire})
-          , m_sensor1{0}
-          , m_sensor2{0}
+};
+Storage g_storage;
+
+LoaderActivity g_loaderActivity;
+HomeActivity g_homeActivity;
+BoilerTankMenuActivity g_menuWaterActivity(&g_homeActivity, &g_menuVersionActivity, &g_menuHeaterActivity, "Sanitaire",
+                                           "", &g_appState.tanks[0]);
+BoilerTankMenuActivity g_menuHeaterActivity(&g_homeActivity, &g_menuWaterActivity, &g_menuVersionActivity, "Chauffage",
+                                            "", &g_appState.tanks[1]);
+MenuItemActivity g_menuVersionActivity(&g_homeActivity, nullptr, &g_menuHeaterActivity, &g_menuWaterActivity, "Version",
+                                       xstr(APP_CORE_VERSION) " - " xstr(APP_CORE_COMMIT));
+IActivity* g_currentActivity = nullptr;
+
+
+int freeRam()
 {
+    extern int __heap_start, * __brkval;
+    int v;
+    return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
 }
 
-void AppCore::setup()
+void AppCore::begin()
 {
     Serial.begin(9600);
     LOG_FN_BEGIN(1);
 
-    m_pSensors->begin();
-    LOG(5, "Found %i sensors", m_pSensors->getDeviceCount());
-    m_pSensors->getAddress(m_sensor1, 0);
-    m_pSensors->getAddress(m_sensor2, 1);
-    m_pSensors->setWaitForConversion(false);
-
-    for (auto& g_button : m_pButtons)
-    {
-        g_button->begin();
-    }
+    LOG(1, "Free RAM: %i bytes", freeRam());
 
-    pinMode(PIN_RELAY1, OUTPUT);
-    digitalWrite(PIN_RELAY1, LOW);
+    g_btnCancel.begin();
+    g_btnOk.begin();
+    g_btnMinus.begin();
+    g_btnPlus.begin();
 
-    pinMode(PIN_RELAY2, OUTPUT);
-    digitalWrite(PIN_RELAY2, LOW);
+    g_hibernateService.begin();
 
-    pinMode(PIN_LCD_LED, OUTPUT);
-    digitalWrite(PIN_LCD_LED, 1);
-
-    m_pLcd->begin(16, 2);
+    g_lcd.begin(16, 2);
     byte sensorChar[8] = {
             B00100,
-            B01110,
-            B01110,
-            B01110,
-            B01110,
-            B11111,
+            B01010,
+            B01010,
+            B01010,
+            B01010,
+            B10001,
             B11111,
             B01110,
     };
-    m_pLcd->createChar(LCD_CHAR_SENSOR, sensorChar);
+    g_lcd.createChar(LCD_CHAR_SENSOR, sensorChar);
 
+    g_lcdLed.begin();
+    g_relay1.begin();
+    g_relay2.begin();
 
-    bool allButtonsPressed = true;
-    for (auto& g_button : m_pButtons)
-    {
-        g_button->read();
-        allButtonsPressed = allButtonsPressed && g_button->isPressed();
-    }
-    if (!allButtonsPressed)
-    {
-        LOG(5, "%s: Loading settings", __FUNCTION__);
-        m_storage.load(*m_appCoreState);
-    }
-    else
-    {
-        LOG(5, "%s: Resetting settings", __FUNCTION__);
-        m_storage.save(*m_appCoreState);
-        m_pLcd->clear();
-        m_pLcd->setCursor(6, 0);
-        m_pLcd->print("Reset");
-        bool allButtonsPressed = true;
-        while (allButtonsPressed)
-        {
-            for (auto& g_button : m_pButtons)
-            {
-                g_button->read();
-                allButtonsPressed = allButtonsPressed && g_button->isPressed();
-            }
-        }
-    }
+    g_dallasTemperature.begin();
+    g_dallasTemperature.setWaitForConversion(false);
+    LOG(1, "Found %i sensors", g_dallasTemperature.getDeviceCount());
 
-    LOG_FN_END(1);
-}
+    g_tempInput1.begin();
+    g_tempInput2.begin();
 
-void AppCore::loop()
-{
-    LOG_FN_BEGIN(50);
+    g_tankService1.begin();
+    g_tankService2.begin();
 
-    const auto& currentMs = millis();
-
-    if (currentMs - m_appCoreState->appState.lastSensorRequestMs >= SENSORS_CHECK_INTERVAL)
-    {
-        m_appCoreState->appState.lastSensorRequestMs = currentMs;
-        m_appCoreState->appState.hasReadSensors = false;
-        m_pSensors->requestTemperaturesByAddress(m_sensor1);
-        m_pSensors->requestTemperaturesByAddress(m_sensor2);
-    }
-    if (currentMs - m_appCoreState->appState.lastSensorRequestMs >= SENSORS_REQUEST_DELAY &&
-        !m_appCoreState->appState.hasReadSensors)
-    {
-        m_appCoreState->appState.hasReadSensors = true;
-        readAndUpdateSensors(&m_appCoreState->appState.water, m_sensor1);
-        readAndUpdateSensors(&m_appCoreState->appState.heater, m_sensor2);
-        checkBoilerItem(&m_appCoreState->appState.water);
-        checkBoilerItem(&m_appCoreState->appState.heater);
-    }
-
-
-    for (auto& pButton : m_pButtons)
-    {
-        pButton->read();
-        if (pButton->isPressed())
-        {
-            m_appCoreState->uiState.lastOpMs = currentMs;
-            break;
-        }
-    }
-
-
-    if (m_appCoreState->uiState.state == HomeHibernate)
-    {
-        for (auto& pButton : m_pButtons)
-        {
-            if (pButton->wasReleased())
-            {
-                setState(HomeLighting);
-                break;
-            }
-        }
-    }
-    else
-    {
-        if (currentMs - m_appCoreState->uiState.lastOpMs >= HIBERNATE_DELAY)
-        {
-            setState(HomeHibernate);
-        }
-        else
-        {
-            if (m_appCoreState->uiState.state == HomeLighting)
-            {
-                if (m_pBtnCancel->wasReleased())
-                {
-                    setState(HomeHibernate);
-                }
-                else if (m_pBtnOk->wasReleased())
-                {
-                    setState(s_menuSequence[0]);
-                }
-            }
-            else if (m_appCoreState->uiState.state == MenuWaterSetting || m_appCoreState->uiState.state == MenuHeaterSetting || m_appCoreState->uiState.state == MenuTempTrigger || m_appCoreState->uiState.state == MenuVersion)
-            {
-                if (m_pBtnCancel->wasReleased())
-                {
-                    setState(HomeLighting);
-                }
-                else if (m_pBtnOk->wasReleased())
-                {
-                    UiStateEnum nextState = m_appCoreState->uiState.state;
-                    if (m_appCoreState->uiState.state == MenuWaterSetting)
-                    {
-                        nextState = MenuWaterSettingEdit;
-                    }
-                    else if (m_appCoreState->uiState.state == MenuHeaterSetting)
-                    {
-                        nextState = MenuHeaterSettingEdit;
-                    }
-                    else if (m_appCoreState->uiState.state == MenuTempTrigger)
-                    {
-                        nextState = MenuTempTriggerEdit;
-                    }
-                    setState(nextState);
-                }
-                else if (m_pBtnMinus->wasReleased() || m_pBtnPlus->wasReleased())
-                {
-                    int idx = 0;
-                    while (m_appCoreState->uiState.state != s_menuSequence[idx])
-                    {
-                        ++idx;
-                    }
-                    auto shift = m_pBtnMinus->wasReleased() ? (-1) : 1;
-                    setState(s_menuSequence[(idx + shift) % ((sizeof(s_menuSequence) / sizeof(*s_menuSequence)))]);
-                }
-            }
-            else if (m_appCoreState->uiState.state == MenuWaterSettingEdit || m_appCoreState->uiState.state == MenuHeaterSettingEdit || m_appCoreState->uiState.state == MenuTempTriggerEdit)
-            {
-                if (m_pBtnCancel->wasReleased() || m_pBtnOk->wasReleased())
-                {
-                    UiStateEnum nextState = m_appCoreState->uiState.state;
-                    if (m_appCoreState->uiState.state == MenuWaterSettingEdit)
-                    {
-                        nextState = MenuWaterSetting;
-                    }
-                    else if (m_appCoreState->uiState.state == MenuHeaterSettingEdit)
-                    {
-                        nextState = MenuHeaterSetting;
-                    }
-                    else if (m_appCoreState->uiState.state == MenuTempTriggerEdit)
-                    {
-                        nextState = MenuTempTrigger;
-                    }
-
-                    if (m_pBtnOk->wasReleased())
-                    {
-                        *m_appCoreState->appState.pCurrentSettingEdit = m_appCoreState->appState.currentSettingEditTmp;
-                    }
-
-                    m_appCoreState->appState.currentSettingEditTmp = 0;
-                    m_appCoreState->appState.pCurrentSettingEdit = nullptr;
-                    setState(nextState);
-                }
-                else if (m_pBtnMinus->wasReleased() || m_pBtnPlus->wasReleased())
-                {
-                    m_appCoreState->appState.currentSettingEditTmp += (m_pBtnMinus->wasReleased() ? -1 : 1) * TEMP_INTERVAL;
-                    m_appCoreState->uiState.isUpdateNeeded = true;
-                }
-            }
-        }
-    }
-
-    if (m_appCoreState->uiState.isUpdateNeeded)
-    {
-        printState();
-    }
-
-    LOG_FN_END(50);
-}
-
-void AppCore::setState(
-        UiStateEnum state
-)
-{
-    LOG_FN_BEGIN(1);
-    LOG(5, "Changing state %i => %i", m_appCoreState->uiState.state, state);
-
-    if (state == HomeLighting)
-    {
-        digitalWrite(PIN_LCD_LED, 1);
-    }
-    else if (state == HomeHibernate)
-    {
-        digitalWrite(PIN_LCD_LED, 0);
-        m_storage.save(*m_appCoreState);
-    }
-    else if (state == MenuWaterSettingEdit)
-    {
-        m_appCoreState->appState.currentSettingEditTmp = m_appCoreState->appState.water.setting;
-        m_appCoreState->appState.pCurrentSettingEdit = &m_appCoreState->appState.water.setting;
-    }
-    else if (state == MenuHeaterSettingEdit)
-    {
-        m_appCoreState->appState.currentSettingEditTmp = m_appCoreState->appState.heater.setting;
-        m_appCoreState->appState.pCurrentSettingEdit = &m_appCoreState->appState.heater.setting;
-    }
-    else if (state == MenuTempTriggerEdit)
-    {
-        m_appCoreState->appState.currentSettingEditTmp = m_appCoreState->appState.tempTrigger;
-        m_appCoreState->appState.pCurrentSettingEdit = &m_appCoreState->appState.tempTrigger;
-    }
-    m_appCoreState->uiState.state = state;
-    m_appCoreState->uiState.isUpdateNeeded = true;
+    setActivity(&g_loaderActivity);
 
     LOG_FN_END(1);
 }
 
-void AppCore::checkBoilerItem(
-        BoilerItemState* boilerItemState
-)
-{
-    LOG_FN_BEGIN(2);
-
-    if (!boilerItemState->isActive && boilerItemState->current != TEMP_T_INVALID &&
-        boilerItemState->current <= boilerItemState->setting - m_appCoreState->appState.tempTrigger)
-    {
-        boilerItemState->isActive = true;
-        digitalWrite(boilerItemState->pinNo, HIGH);
-        m_appCoreState->uiState.isUpdateNeeded = true;
-    }
-    else if (boilerItemState->isActive &&
-             (boilerItemState->current == TEMP_T_INVALID || boilerItemState->current >= boilerItemState->setting))
-    {
-        boilerItemState->isActive = false;
-        digitalWrite(boilerItemState->pinNo, LOW);
-        m_appCoreState->uiState.isUpdateNeeded = true;
-    }
-
-    LOG_FN_END(2);
-}
-
-void AppCore::readAndUpdateSensors(
-        BoilerItemState* boilerItemState
-        , const uint8_t* sensor
-)
+void AppCore::loop()
 {
-    LOG_FN_BEGIN(2);
+    LOG_FN_BEGIN(50);
 
-    auto raw = m_pSensors->getTempC(sensor);
-    temp_t temp = TEMP_T_INVALID;
-    if (raw != DEVICE_DISCONNECTED_C)
-    {
-        temp = (temp_t) (raw * 10);
-    }
+    g_btnCancel.read();
+    g_btnOk.read();
+    g_btnMinus.read();
+    g_btnPlus.read();
 
-    if (temp != boilerItemState->current)
-    {
-        boilerItemState->current = temp;
-        m_appCoreState->uiState.isUpdateNeeded = true;
-    }
+    g_tempInput1.loop();
+    g_tempInput2.loop();
 
-    LOG_FN_END(2);
-}
+    g_tankService1.loop();
+    g_tankService2.loop();
 
-void AppCore::printState()
-{
-    LOG_FN_BEGIN(2);
+    g_hibernateService.loop();
 
-    if (m_appCoreState->uiState.state == HomeLighting || m_appCoreState->uiState.state == HomeHibernate)
-    {
-        m_pLcd->setCursor(0, 0);
-        printStateLine('S', &m_appCoreState->appState.water);
-        m_pLcd->setCursor(0, 1);
-        printStateLine('C', &m_appCoreState->appState.heater);
-    }
-    else if (m_appCoreState->uiState.state == MenuWaterSetting || m_appCoreState->uiState.state == MenuHeaterSetting || m_appCoreState->uiState.state == MenuTempTrigger ||
-            m_appCoreState->uiState.state == MenuWaterSettingEdit || m_appCoreState->uiState.state == MenuHeaterSettingEdit || m_appCoreState->uiState.state == MenuTempTriggerEdit)
-    {
-        const auto isEdit = m_appCoreState->uiState.state == MenuWaterSettingEdit || m_appCoreState->uiState.state == MenuHeaterSettingEdit || m_appCoreState->uiState.state == MenuTempTriggerEdit;
-        const char* pTitle = nullptr;
-        temp_t* pTemp = nullptr;
-        if (isEdit)
-        {
-            pTemp = &m_appCoreState->appState.currentSettingEditTmp;
-        }
-        else
-        {
-            if (m_appCoreState->uiState.state == MenuWaterSetting ||
-                m_appCoreState->uiState.state == MenuWaterSettingEdit)
-            {
-                pTitle = "Sanitaire";
-                pTemp = &m_appCoreState->appState.water.setting;
-            }
-            else if (m_appCoreState->uiState.state == MenuHeaterSetting ||
-                     m_appCoreState->uiState.state == MenuHeaterSettingEdit)
-            {
-                pTitle = "Chauffage";
-                pTemp = &m_appCoreState->appState.heater.setting;
-            }
-            else if (m_appCoreState->uiState.state == MenuTempTrigger ||
-                     m_appCoreState->uiState.state == MenuTempTriggerEdit)
-            {
-                pTitle = "Delta";
-                pTemp = &m_appCoreState->appState.tempTrigger;
-            }
-        }
-        char tmpStr[17], tmpTemp[7];
-        m_pLcd->setCursor(0, 0);
-        snprintf(tmpStr, sizeof(tmpStr), "%s :                ", pTitle);
-        m_pLcd->print(tmpStr);
-        m_pLcd->setCursor(0, 1);
-        tempToStr(tmpTemp, *pTemp, 4);
-        snprintf(tmpStr, sizeof(tmpStr), "%s%s C                ", isEdit ? "> " : "  ", tmpTemp);
-        m_pLcd->print(tmpStr);
-    }
-    else if (m_appCoreState->uiState.state == MenuVersion)
+    if (g_currentActivity)
     {
-        char tmpStr[17];
-        m_pLcd->setCursor(0, 0);
-        snprintf(tmpStr, sizeof(tmpStr), "%s :                ", "Version");
-        m_pLcd->print(tmpStr);
-        m_pLcd->setCursor(0, 1);
-        snprintf(tmpStr, sizeof(tmpStr), "%s - %s                ", xstr(APP_CORE_VERSION), xstr(APP_CORE_COMMIT));
-        m_pLcd->print(tmpStr);
+        g_currentActivity->loop();
     }
-    m_appCoreState->uiState.isUpdateNeeded = false;
 
-    LOG_FN_END(2);
-}
-
-void
-AppCore::printStateLine(
-        char prefix
-        , const BoilerItemState* boilerItemState
-)
-{
-    LOG_FN_BEGIN(2);
-
-    char curTmp[7], setTmp[7], tmp[17];
-    tempToStr(curTmp, boilerItemState->current, 5);
-    tempToStr(setTmp, boilerItemState->setting, 4);
-    int count = snprintf(tmp, sizeof(tmp), "%c:%s [%s] %c", prefix, curTmp, setTmp, boilerItemState->isActive ? LCD_CHAR_SENSOR : ' ');
-    for (; count < 17; ++count)
-    {
-        tmp[count] = ' ';
-    }
-    tmp[count] = 0;
-    m_pLcd->print(tmp);
-
-    LOG_FN_END(2);
+    LOG_FN_END(50);
 }
 
-void AppCore::tempToStr(
-        char* out
-        , temp_t temp
-        , signed char width
-)
+void AppCore::setActivity(IActivity* activity)
 {
-    LOG_FN_BEGIN(2);
-
-    LOG(5, "%s: temp=%i", __FUNCTION__, (int)temp);
-
-    if (temp == TEMP_T_INVALID)
-    {
-        strcpy(out, " --.-");
-    }
-    else
-    {
-        dtostrf(temp / 10.0f, width, 1, out);
-    }
-
-    LOG_FN_END(2);
+    g_currentActivity = activity;
+    g_currentActivity->begin();
 }

AppCore.h

@@ -6,52 +6,17 @@
 #include <DallasTemperature.h>
 #include "Boiler.h"
 #include "Storage.h"
+#include "IInput.h"
+#include "ILifeCycle.h"
+#include "IActivity.h"
 
 class AppCore
+        : public ILifeCycle
 {
 public:
-    static UiStateEnum s_menuSequence[4];
+    void begin() override;
 
-    AppCore();
+    void loop() override;
 
-    void setup();
-
-    void loop();
-
-protected:
-    void setState(UiStateEnum state);
-
-    void checkBoilerItem(BoilerItemState* boilerItemState);
-
-    void readAndUpdateSensors(BoilerItemState* boilerItemState, const uint8_t* sensor);
-
-    void printState();
-
-    void printStateLine(
-            char prefix
-            , const BoilerItemState* boilerItemState
-    );
-
-    void tempToStr(
-            char* out
-            , temp_t temp
-            , signed char width
-    );
-
-private:
-    AppCoreState* m_appCoreState;
-    Storage m_storage;
-
-    Button* m_pBtnCancel;
-    Button* m_pBtnOk;
-    Button* m_pBtnMinus;
-    Button* m_pBtnPlus;
-    Button* m_pButtons[4];
-
-    LiquidCrystal* m_pLcd;
-
-    OneWire* m_pOneWire;
-    DallasTemperature* m_pSensors;
-    DeviceAddress m_sensor1;
-    DeviceAddress m_sensor2;
+    void setActivity(IActivity* activity);
 };

BaseActivity.cpp

@@ -0,0 +1,98 @@
+#include "BaseActivity.h"
+#include "globals.h"
+#include "Helpers.h"
+
+BaseActivity::BaseActivity(
+        IActivity* mParentActivity
+        , IActivity* mChildActivity
+        , IActivity* mPreviousActivity
+        , IActivity* mNextActivity
+)
+        : m_lcdUpdateNeeded(true)
+          , m_parentActivity(mParentActivity), m_childActivity(mChildActivity), m_previousActivity(mPreviousActivity)
+          , m_nextActivity(mNextActivity)
+{
+}
+
+void BaseActivity::begin()
+{
+    m_lcdUpdateNeeded = true;
+}
+
+void BaseActivity::loop()
+{
+    if (!g_hibernateService.getValue() && !g_hibernateService.hasChanged())
+    {
+        if (g_btnCancel.wasReleased())
+        {
+            onButtonReleased(Cancel);
+        }
+        else if (g_btnOk.wasReleased())
+        {
+            onButtonReleased(Ok);
+        }
+        else if (g_btnMinus.wasReleased())
+        {
+            onButtonReleased(Minus);
+        }
+        else if (g_btnPlus.wasReleased())
+        {
+            onButtonReleased(Plus);
+        }
+    }
+
+    if (m_lcdUpdateNeeded)
+    {
+        updateLcd();
+    }
+}
+
+void BaseActivity::updateLcd()
+{
+    char lines[2][17];
+    lines[0][0] = 0;
+    lines[1][0] = 0;
+    char* lines_[2] = {lines[0], lines[1]};
+    getLcdText(lines_);
+    for (int i = 0; i < 2; ++i)
+    {
+        g_lcd.setCursor(0, i);
+        Helpers::fillLine(lines[i], 16, ' ');
+        g_lcd.print(lines[i]);
+    }
+    m_lcdUpdateNeeded = false;
+}
+
+void BaseActivity::onButtonReleased(BaseActivity::Button button)
+{
+    if (button == Cancel)
+    {
+        if (m_parentActivity)
+        {
+            g_appCore.setActivity(m_parentActivity);
+        }
+    }
+    else if (button == Ok)
+    {
+        if (m_childActivity)
+        {
+            g_appCore.setActivity(m_childActivity);
+        }
+    }
+    else if (button == Minus)
+    {
+        if (m_previousActivity)
+        {
+            g_appCore.setActivity(m_previousActivity);
+        }
+    }
+    else if (button == Plus)
+    {
+        if (m_nextActivity)
+        {
+            g_appCore.setActivity(m_nextActivity);
+        }
+    }
+}
+
+

BaseActivity.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "IActivity.h"
+
+class BaseActivity
+        : public IActivity
+{
+public:
+    enum Button
+    {
+        Cancel = 1,
+        Ok = 2,
+        Minus = 4,
+        Plus = 8
+    };
+
+    explicit BaseActivity(
+            IActivity* mParentActivity = nullptr
+            , IActivity* mChildActivity = nullptr
+            , IActivity* mPreviousActivity = nullptr
+            , IActivity* mNextActivity = nullptr
+    );
+
+    void begin() override;
+
+    void loop() override;
+
+protected:
+    void updateLcd();
+
+    virtual void getLcdText(char** lines) = 0;
+
+    virtual void onButtonReleased(Button button);
+
+    bool m_lcdUpdateNeeded;
+
+    IActivity* m_parentActivity;
+    IActivity* m_childActivity;
+    IActivity* m_previousActivity;
+    IActivity* m_nextActivity;
+};

Boiler.h

@@ -1,50 +1,33 @@
 #pragma once
 
-typedef short temp_t;
+#include "stdint.h"
+
+using temp_t = short;
 #define TEMP_T_INVALID -127
-typedef unsigned long timestamp_t;
+using timestamp_t = unsigned long;
 
-enum UiStateEnum
-{
-    HomeHibernate,
-    HomeLighting,
-    MenuWaterSetting,
-    MenuWaterSettingEdit,
-    MenuHeaterSetting,
-    MenuHeaterSettingEdit,
-    MenuTempTrigger,
-    MenuTempTriggerEdit,
-    MenuVersion
-};
+class TempInput;
 
-struct BoilerItemState
-{
-    temp_t current;
-    temp_t setting;
-    bool isActive;
-    int pinNo;
-};
+class DigitalOutput;
 
-struct AppState
+struct BoilerTankState
 {
-    timestamp_t lastSensorRequestMs;
-    bool hasReadSensors;
-    BoilerItemState water;
-    BoilerItemState heater;
-    temp_t tempTrigger;
-    temp_t* pCurrentSettingEdit;
-    temp_t currentSettingEditTmp;
-};
+    enum Mode
+    {
+        Auto,
+        On,
+        Off
+    };
 
-struct UiState
-{
-    UiStateEnum state;
-    timestamp_t lastOpMs;
-    bool isUpdateNeeded;
+    Mode mode;
+    temp_t setting;
+    temp_t tempTrigger;
+//    uint8_t sensorAddress[8];
+    TempInput* input;
+    DigitalOutput* relay;
 };
 
 struct AppCoreState
 {
-    AppState appState;
-    UiState uiState;
+    BoilerTankState tanks[2];
 };

BoilerTankMenuActivity.cpp

@@ -0,0 +1,18 @@
+#include "BoilerTankMenuActivity.h"
+
+BoilerTankMenuActivity::BoilerTankMenuActivity(
+        IActivity* mParentActivity
+        , IActivity* mPreviousActivity
+        , IActivity* mNextActivity
+        , const char* line1
+        , const char* line2
+        , BoilerTankState* state
+)
+        : MenuItemActivity(mParentActivity, &m_tempSettingActivity, mPreviousActivity, mNextActivity, line1, line2)
+          , m_tempSettingActivity(this, &m_modeSettingActivity, &m_triggerSettingActivity, "Temperature",
+                                  &state->setting)
+          , m_triggerSettingActivity(this, &m_tempSettingActivity, &m_modeSettingActivity, "Delta", &state->tempTrigger)
+          , m_modeSettingActivity(this, &m_triggerSettingActivity, &m_tempSettingActivity, "Mode", &state->mode)
+          , m_state(state)
+{
+}

BoilerTankMenuActivity.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "MenuItemActivity.h"
+#include "Boiler.h"
+#include "TempEditorActivity.h"
+#include "BoilerTankModeEditorActivity.h"
+
+class BoilerTankMenuActivity
+        : public MenuItemActivity
+{
+public:
+    BoilerTankMenuActivity(
+            IActivity* mParentActivity
+            , IActivity* mPreviousActivity
+            , IActivity* mNextActivity
+            , const char* line1
+            , const char* line2
+            , BoilerTankState* state
+    );
+
+protected:
+    TempEditorActivity m_tempSettingActivity;
+    TempEditorActivity m_triggerSettingActivity;
+    BoilerTankModeEditorActivity m_modeSettingActivity;
+    BoilerTankState* m_state;
+};

BoilerTankModeEditorActivity.cpp

@@ -0,0 +1,108 @@
+#include <stdio.h>
+#include "BoilerTankModeEditorActivity.h"
+#include "Helpers.h"
+#include "globals.h"
+
+BoilerTankModeEditorActivity::BoilerTankModeEditorActivity(
+        IActivity* mParentActivity
+        , IActivity* mPreviousActivity
+        , IActivity* mNextActivity
+        , const char* line1
+        , BoilerTankState::Mode* value
+)
+        : BaseActivity(mParentActivity, nullptr, mPreviousActivity, mNextActivity)
+          , m_line1(line1)
+          , m_value(value)
+          , m_tmpValue(*value)
+          , m_isEditMode(false)
+{
+}
+
+void BoilerTankModeEditorActivity::begin()
+{
+    m_tmpValue = *m_value;
+    BaseActivity::begin();
+}
+
+void BoilerTankModeEditorActivity::getLcdText(char** lines)
+{
+    Helpers::center(lines[0], m_line1, 16, ' ');
+
+    const char* str = "??";
+    if (m_tmpValue == BoilerTankState::Auto)
+    {
+        str = "Auto";
+    }
+    else if (m_tmpValue == BoilerTankState::On)
+    {
+        str = "On  ";
+    }
+    else if (m_tmpValue == BoilerTankState::Off)
+    {
+        str = "Off ";
+    }
+    snprintf(lines[1], 17, "%c %s %c", m_isEditMode ? '>' : ' ', str, *m_value != m_tmpValue ? '*' : ' ');
+}
+
+void BoilerTankModeEditorActivity::onButtonReleased(BaseActivity::Button button)
+{
+    if (m_isEditMode)
+    {
+        if (button == Cancel)
+        {
+            m_tmpValue = *m_value;
+            m_isEditMode = false;
+        }
+        else if (button == Ok)
+        {
+            *m_value = m_tmpValue;
+            g_storage.save();
+            m_isEditMode = false;
+        }
+        else if (button == Minus)
+        {
+            switch (m_tmpValue)
+            {
+                case BoilerTankState::Auto:
+                    m_tmpValue = BoilerTankState::Off;
+                    break;
+                case BoilerTankState::On:
+                    m_tmpValue = BoilerTankState::Auto;
+                    break;
+                case BoilerTankState::Off:
+                default:
+                    m_tmpValue = BoilerTankState::On;
+                    break;
+            }
+        }
+        else if (button == Plus)
+        {
+            switch (m_tmpValue)
+            {
+                case BoilerTankState::Auto:
+                    m_tmpValue = BoilerTankState::On;
+                    break;
+                case BoilerTankState::On:
+                    m_tmpValue = BoilerTankState::Off;
+                    break;
+                case BoilerTankState::Off:
+                default:
+                    m_tmpValue = BoilerTankState::Auto;
+                    break;
+            }
+        }
+        m_lcdUpdateNeeded = true;
+    }
+    else
+    {
+        if (button == Ok)
+        {
+            m_isEditMode = true;
+            m_lcdUpdateNeeded = true;
+        }
+        else
+        {
+            BaseActivity::onButtonReleased(button);
+        }
+    }
+}

BoilerTankModeEditorActivity.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <stdint.h>
+#include "BaseActivity.h"
+#include "Boiler.h"
+
+class BoilerTankModeEditorActivity
+        : public BaseActivity
+{
+public:
+    explicit BoilerTankModeEditorActivity(
+            IActivity* mParentActivity
+            , IActivity* mPreviousActivity
+            , IActivity* mNextActivity
+            , const char* line1
+            , BoilerTankState::Mode* value
+    );
+
+    void begin() override;
+
+protected:
+    void getLcdText(char** lines) override;
+
+    void onButtonReleased(Button button) override;
+
+    const char* m_line1;
+    BoilerTankState::Mode* m_value;
+    BoilerTankState::Mode m_tmpValue;
+    bool m_isEditMode;
+};

BoilerTankService.cpp

@@ -0,0 +1,44 @@
+#include "BoilerTankService.h"
+#include "DigitalOutput.h"
+#include "TempInput.h"
+
+BoilerTankService::BoilerTankService(BoilerTankState* mBoilerTank)
+        : m_boilerTank(mBoilerTank)
+{
+}
+
+void BoilerTankService::loop()
+{
+    if (m_boilerTank->mode == BoilerTankState::Auto)
+    {
+        if (!m_boilerTank->relay->isEnabled() &&
+            m_boilerTank->input->getValue() != TEMP_T_INVALID &&
+            m_boilerTank->setting != TEMP_T_INVALID &&
+            m_boilerTank->input->getValue() <= m_boilerTank->setting - m_boilerTank->tempTrigger)
+        {
+            m_boilerTank->relay->setEnabled(true);
+        }
+        else if (m_boilerTank->relay->isEnabled() && (
+                m_boilerTank->input->getValue() == TEMP_T_INVALID ||
+                m_boilerTank->setting == TEMP_T_INVALID ||
+                m_boilerTank->input->getValue() >= m_boilerTank->setting)
+                )
+        {
+            m_boilerTank->relay->setEnabled(false);
+        }
+    }
+    else if (m_boilerTank->mode == BoilerTankState::On)
+    {
+        if (!m_boilerTank->relay->isEnabled())
+        {
+            m_boilerTank->relay->setEnabled(true);
+        }
+    }
+    else if (m_boilerTank->mode == BoilerTankState::Off)
+    {
+        if (m_boilerTank->relay->isEnabled())
+        {
+            m_boilerTank->relay->setEnabled(false);
+        }
+    }
+}

BoilerTankService.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "ILifeCycle.h"
+#include "Boiler.h"
+
+class BoilerTankService
+        : public ILifeCycle
+{
+public:
+    BoilerTankService(BoilerTankState* mBoilerTank);
+
+    void loop() override;
+
+protected:
+    BoilerTankState* m_boilerTank;
+};
+
+

CMakeLists.txt

@@ -19,7 +19,7 @@ set(${CMAKE_PROJECT_NAME}_PORT /dev/ttyUSB3)
 
 
 enable_language(ASM)
-set(${CMAKE_PROJECT_NAME}_ALL_SRCS main.ino Storage.cpp AppCore.cpp)
+set(${CMAKE_PROJECT_NAME}_ALL_SRCS main.ino TempInput.cpp BoilerTankService.cpp HibernateService.cpp DigitalOutput.cpp BaseActivity.cpp LoaderActivity.cpp HomeActivity.cpp MenuItemActivity.cpp BoilerTankMenuActivity.cpp TempEditorActivity.cpp BoilerTankModeEditorActivity.cpp Storage.cpp AppCore.cpp Helpers.cpp)
 set(${CMAKE_PROJECT_NAME}_SKETCH main.ino)
 generate_arduino_firmware(${CMAKE_PROJECT_NAME})
 
@@ -28,10 +28,8 @@ add_definitions(-DAPP_CORE_VERSION=1.0.0)
 execute_process(
         COMMAND
         git rev-parse --short HEAD
-        RESULT_VARIABLE
-        SHORT_HASH_RESULT
-        OUTPUT_VARIABLE
-        SHORT_HASH
+        RESULT_VARIABLE SHORT_HASH_RESULT
+        OUTPUT_VARIABLE SHORT_HASH
 )
 string(REGEX REPLACE "\n$" "" SHORT_HASH "${SHORT_HASH}")
 message(STATUS "SHORT_HASH=${SHORT_HASH}")
@@ -40,4 +38,4 @@ add_definitions(-DAPP_CORE_COMMIT=${SHORT_HASH})
 if (CMAKE_BUILD_TYPE MATCHES "Debug")
     message(STATUS "Debug build detected. Enabling logs.")
     add_definitions(-DAPP_CORE_LOGS=1)
-endif()
+endif ()

DigitalOutput.cpp

@@ -0,0 +1,22 @@
+#include "DigitalOutput.h"
+#include <Arduino.h>
+
+DigitalOutput::DigitalOutput(uint8_t mPin)
+        : m_pin(mPin)
+{
+}
+
+void DigitalOutput::begin()
+{
+    pinMode(m_pin, OUTPUT);
+}
+
+void DigitalOutput::setEnabled(bool enabled)
+{
+    digitalWrite(m_pin, enabled ? HIGH : LOW);
+}
+
+bool DigitalOutput::isEnabled() const
+{
+    return digitalRead(m_pin);
+}

DigitalOutput.h

@@ -0,0 +1,23 @@
+#pragma once
+
+
+#include <stdint.h>
+#include "ILifeCycle.h"
+
+class DigitalOutput
+        : public ILifeCycle
+{
+public:
+    explicit DigitalOutput(uint8_t mPin);
+
+    void begin() override;
+
+    void setEnabled(bool enabled);
+
+    bool isEnabled() const;
+
+protected:
+    const uint8_t m_pin;
+};
+
+

Helpers.cpp

@@ -0,0 +1,65 @@
+#include <string.h>
+#include <stdlib.h>
+#include "Helpers.h"
+#include "Logs.h"
+
+void Helpers::tempToStr(
+        char* out
+        , temp_t temp
+        , signed char width
+)
+{
+    LOG_FN_BEGIN(2);
+
+    LOG(5, "%s: temp=%i", __FUNCTION__, (int) temp);
+
+    if (temp == TEMP_T_INVALID)
+    {
+        for (int i = 0; i < width - 4; ++i)
+        {
+            out[i] = ' ';
+        }
+        strcpy(&out[width - 4], "--.-");
+    }
+    else
+    {
+        dtostrf((float) temp / 10.0f, width, 1, out);
+    }
+
+    LOG_FN_END(2);
+}
+
+void Helpers::fillLine(
+        char* line
+        , int length
+        , char c
+)
+{
+    int i = 0;
+    while (line[i] && i < length)
+    {
+        ++i;
+    }
+    while (i < length)
+    {
+        line[i] = c;
+        ++i;
+    }
+    line[length] = 0;
+}
+
+void Helpers::center(
+        char* line
+        , const char* text
+        , int length
+        , char c
+)
+{
+    auto cCount = (length - strlen(text)) / 2;
+    for (int i = 0; i < cCount; ++i)
+    {
+        line[i] = c;
+    }
+    strcpy(&line[cCount], text);
+    fillLine(line, length, c);
+}

Helpers.h

@@ -0,0 +1,29 @@
+#pragma once
+
+
+#include "Boiler.h"
+
+class Helpers
+{
+public:
+    static void tempToStr(
+            char* out
+            , temp_t temp
+            , signed char width
+    );
+
+    static void fillLine(
+            char* line
+            , int length
+            , char c
+    );
+
+    static void center(
+            char* line
+            , const char* text
+            , int length
+            , char c
+    );
+};
+
+

HibernateService.cpp

@@ -0,0 +1,52 @@
+#include "HibernateService.h"
+#include "defines.h"
+#include "Logs.h"
+#include "globals.h"
+#include <Arduino.h>
+
+HibernateService::HibernateService()
+        : m_buttons{
+        &g_btnCancel,
+        &g_btnOk,
+        &g_btnMinus,
+        &g_btnPlus,
+        nullptr
+}
+          , m_lastEventMs(0)
+{
+}
+
+void HibernateService::begin()
+{
+    m_lastEventMs = millis();
+    setValue(false);
+    g_lcdLed.setEnabled(!m_lastValue);
+}
+
+void HibernateService::loop()
+{
+    auto currentMs = millis();
+    bool shouldHibernate = m_lastValue;
+
+    for (auto i = 0; m_buttons[i]; ++i)
+    {
+        if (m_buttons[i]->wasReleased())
+        {
+            m_lastEventMs = currentMs;
+            shouldHibernate = false;
+            break;
+        }
+    }
+    if (!m_lastValue && currentMs - m_lastEventMs > HIBERNATE_DELAY)
+    {
+        shouldHibernate = true;
+    }
+
+    setValue(shouldHibernate);
+
+    if (hasChanged())
+    {
+        LOG(1, "Hibernate event");
+        g_lcdLed.setEnabled(!m_lastValue);
+    }
+}

HibernateService.h

@@ -0,0 +1,22 @@
+#pragma once
+
+
+#include "IInput.h"
+#include "Boiler.h"
+#include "JC_Button.h"
+
+class HibernateService
+        : public IInput<bool>
+{
+public:
+    HibernateService();
+
+    void begin() override;
+
+    void loop() override;
+
+protected:
+    Button* m_buttons[5];
+
+    timestamp_t m_lastEventMs;
+};

HomeActivity.cpp

@@ -0,0 +1,41 @@
+#include "HomeActivity.h"
+#include "Boiler.h"
+#include "defines.h"
+#include "Helpers.h"
+#include "Logs.h"
+#include "globals.h"
+#include "BaseActivity.h"
+
+HomeActivity::HomeActivity()
+        : BaseActivity(nullptr, &g_menuWaterActivity)
+{
+}
+
+void HomeActivity::getLcdText(char** lines)
+{
+    getLineText(lines[0], 'S', &g_appState.tanks[0]);
+    getLineText(lines[1], 'C', &g_appState.tanks[1]);
+}
+
+void HomeActivity::getLineText(
+        char* line
+        , char prefix
+        , const BoilerTankState* boilerItemState
+)
+{
+    char curTmp[7], setTmp[7];
+    Helpers::tempToStr(curTmp, boilerItemState->input->getValue(), 5);
+    Helpers::tempToStr(setTmp,
+                       boilerItemState->mode == BoilerTankState::Auto ? boilerItemState->setting : TEMP_T_INVALID, 4);
+    snprintf(line, 17, "%c:%s [%s] %c", prefix, curTmp, setTmp,
+             boilerItemState->relay->isEnabled() ? LCD_CHAR_SENSOR : ' ');
+}
+
+void HomeActivity::loop()
+{
+    if (g_appState.tanks[0].input->hasChanged() || g_appState.tanks[1].input->hasChanged())
+    {
+        m_lcdUpdateNeeded = true;
+    }
+    BaseActivity::loop();
+}

HomeActivity.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <LiquidCrystal.h>
+#include <JC_Button.h>
+#include "Boiler.h"
+#include "BaseActivity.h"
+
+class HomeActivity
+        : public BaseActivity
+{
+public:
+    explicit HomeActivity();
+
+    void loop() override;
+
+protected:
+    void getLcdText(char** lines) override;
+
+    void getLineText(
+            char* line
+            , char prefix
+            , const BoilerTankState* boilerItemState
+    );
+};
+

IActivity.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "ILifeCycle.h"
+
+class IActivity
+        : public ILifeCycle
+{
+public:
+    IActivity() = default;
+};

IInput.h

@@ -0,0 +1,37 @@
+#pragma once
+
+
+#include "ILifeCycle.h"
+
+template<class T>
+class IInput
+        : public ILifeCycle
+{
+public:
+    const T& getValue() const
+    {
+        return m_lastValue;
+    }
+
+    bool hasChanged() const
+    {
+        return m_hasChanged;
+    }
+
+protected:
+    void setValue(const T& value)
+    {
+        if (value != m_lastValue)
+        {
+            m_hasChanged = true;
+            m_lastValue = value;
+        }
+        else if (m_hasChanged)
+        {
+            m_hasChanged = false;
+        }
+    }
+
+    T m_lastValue;
+    bool m_hasChanged;
+};

ILifeCycle.h

@@ -0,0 +1,12 @@
+#pragma once
+
+
+class ILifeCycle
+{
+public:
+    virtual void begin()
+    {}
+
+    virtual void loop()
+    {}
+};

LoaderActivity.cpp

@@ -0,0 +1,47 @@
+#include "LoaderActivity.h"
+#include "globals.h"
+#include "Helpers.h"
+#include "Logs.h"
+
+void LoaderActivity::begin()
+{
+    if (!g_btnMinus.read() || !g_btnPlus.read())
+    {
+        load();
+    }
+    else
+    {
+        BaseActivity::begin();
+    }
+}
+
+void LoaderActivity::load()
+{
+    LOG(1, "%s: Loading settings", __FUNCTION__);
+    g_storage.load();
+    g_appCore.setActivity(&g_homeActivity);
+}
+
+void LoaderActivity::reset()
+{
+    LOG(1, "%s: Resetting settings", __FUNCTION__);
+    g_storage.save();
+    g_appCore.setActivity(&g_homeActivity);
+}
+
+void LoaderActivity::getLcdText(char** lines)
+{
+    Helpers::center(lines[0], "Reset?", 16, ' ');
+}
+
+void LoaderActivity::onButtonReleased(BaseActivity::Button button)
+{
+    if (button == Cancel)
+    {
+        load();
+    }
+    else if (button == Ok)
+    {
+        reset();
+    }
+}

LoaderActivity.h

@@ -0,0 +1,22 @@
+#pragma once
+
+
+#include "BaseActivity.h"
+
+class LoaderActivity
+        : public BaseActivity
+{
+public:
+    void begin() override;
+
+    void load();
+
+    void reset();
+
+protected:
+    void getLcdText(char** lines) override;
+
+    void onButtonReleased(Button button) override;
+};
+
+

Logs.h

@@ -2,6 +2,9 @@
 
 #if APP_CORE_LOGS
 
+#include <stdio.h>
+#include <Arduino.h>
+
 #define APP_CORE_LOGS_LEVEL 1
 
 #define LOG(level_, ...) do {                           \

MenuItemActivity.cpp

@@ -0,0 +1,23 @@
+#include "MenuItemActivity.h"
+#include "globals.h"
+#include "Helpers.h"
+
+MenuItemActivity::MenuItemActivity(
+        IActivity* mParentActivity
+        , IActivity* mChildActivity
+        , IActivity* mPreviousActivity
+        , IActivity* mNextActivity
+        , const char* line1
+        , const char* line2
+)
+        : BaseActivity(mParentActivity, mChildActivity, mPreviousActivity, mNextActivity)
+          , m_line1(line1)
+          , m_line2(line2)
+{
+}
+
+void MenuItemActivity::getLcdText(char** lines)
+{
+    Helpers::center(lines[0], m_line1, 16, ' ');
+    strncpy(lines[1], m_line2, 16);
+}

MenuItemActivity.h

@@ -0,0 +1,26 @@
+#pragma once
+
+
+#include "BaseActivity.h"
+
+class MenuItemActivity
+        : public BaseActivity
+{
+public:
+    MenuItemActivity(
+            IActivity* mParentActivity
+            , IActivity* mChildActivity
+            , IActivity* mPreviousActivity
+            , IActivity* mNextActivity
+            , const char* line1
+            , const char* line2
+    );
+
+protected:
+    void getLcdText(char** lines) override;
+
+    const char* m_line1;
+    const char* m_line2;
+};
+
+

Storage.cpp

@@ -1,43 +1,78 @@
 #include "Storage.h"
+#include "globals.h"
 #include <EEPROM.h>
 #include <Arduino.h>
 
-template <class T> int EEPROM_writeAnything(int ee, const T& value)
+template<class T>
+int EEPROM_writeAnything(
+        int ee
+        , const T& value
+)
 {
-    const byte* p = (const byte*)(const void*)&value;
+    const byte* p = (const byte*) (const void*) &value;
     unsigned int i;
     for (i = 0; i < sizeof(value); i++)
         EEPROM.write(ee++, *p++);
     return i;
 }
 
-template <class T> int EEPROM_readAnything(int ee, T& value)
+template<class T>
+int EEPROM_readAnything(
+        int ee
+        , T& value
+)
 {
-    byte* p = (byte*)(void*)&value;
+    byte* p = (byte*) (void*) &value;
     unsigned int i;
     for (i = 0; i < sizeof(value); i++)
         *p++ = EEPROM.read(ee++);
     return i;
 }
 
-void Storage::load(AppCoreState& data)
+void Storage::load()
 {
     uint8_t version;
     uint32_t index = 0;
     index += EEPROM_readAnything(index, version);
     if (version == 1)
     {
-        index += EEPROM_readAnything(index, data.appState.water.setting);
-        index += EEPROM_readAnything(index, data.appState.heater.setting);
-        index += EEPROM_readAnything(index, data.appState.tempTrigger);
+        index += load(index, g_appState.tanks[0]);
+        index += load(index, g_appState.tanks[1]);
     }
 }
 
-void Storage::save(const AppCoreState& data)
+uint32_t Storage::load(
+        uint32_t index
+        , BoilerTankState& tankState
+)
+{
+    uint32_t delta = 0;
+
+    delta += EEPROM_readAnything(index + delta, tankState.setting);
+    delta += EEPROM_readAnything(index + delta, tankState.tempTrigger);
+    delta += EEPROM_readAnything(index + delta, tankState.mode);
+
+    return delta;
+}
+
+void Storage::save()
 {
     uint32_t index = 0;
-    index += EEPROM_writeAnything(index, (uint8_t)1);
-    index += EEPROM_writeAnything(index, data.appState.water.setting);
-    index += EEPROM_writeAnything(index, data.appState.heater.setting);
-    index += EEPROM_writeAnything(index, data.appState.tempTrigger);
+    index += EEPROM_writeAnything(index, (uint8_t) 1);
+    index += save(index, g_appState.tanks[0]);
+    index += save(index, g_appState.tanks[1]);
+}
+
+uint32_t Storage::save(
+        uint32_t index
+        , const BoilerTankState& tankState
+)
+{
+    uint32_t delta = 0;
+
+    delta += EEPROM_writeAnything(index + delta, tankState.setting);
+    delta += EEPROM_writeAnything(index + delta, tankState.tempTrigger);
+    delta += EEPROM_writeAnything(index + delta, tankState.mode);
+
+    return delta;
 }

Storage.h

@@ -5,7 +5,18 @@
 class Storage
 {
 public:
-    void load(AppCoreState& data);
+    void load();
 
-    void save(const AppCoreState& data);
+    void save();
+
+protected:
+    uint32_t load(
+            uint32_t index
+            , BoilerTankState& tankState
+    );
+
+    uint32_t save(
+            uint32_t index
+            , const BoilerTankState& tankState
+    );
 };

TempEditorActivity.cpp

@@ -0,0 +1,74 @@
+#include <stdio.h>
+#include "TempEditorActivity.h"
+#include "Helpers.h"
+#include "defines.h"
+#include "globals.h"
+
+TempEditorActivity::TempEditorActivity(
+        IActivity* mParentActivity
+        , IActivity* mPreviousActivity
+        , IActivity* mNextActivity
+        , const char* line1
+        , temp_t* value
+)
+        : BaseActivity(mParentActivity, nullptr, mPreviousActivity, mNextActivity)
+          , m_line1(line1)
+          , m_value(value)
+          , m_tmpValue(*value)
+          , m_isEditMode(false)
+{
+}
+
+void TempEditorActivity::begin()
+{
+    m_tmpValue = *m_value;
+    BaseActivity::begin();
+}
+
+void TempEditorActivity::getLcdText(char** lines)
+{
+    Helpers::center(lines[0], m_line1, 16, ' ');
+
+    char temp[7];
+    Helpers::tempToStr(temp, m_tmpValue, 5);
+    snprintf(lines[1], 17, "%c %s C %c", m_isEditMode ? '>' : ' ', temp, *m_value != m_tmpValue ? '*' : ' ');
+}
+
+void TempEditorActivity::onButtonReleased(BaseActivity::Button button)
+{
+    if (m_isEditMode)
+    {
+        if (button == Cancel)
+        {
+            m_tmpValue = *m_value;
+            m_isEditMode = false;
+        }
+        else if (button == Ok)
+        {
+            *m_value = m_tmpValue;
+            g_storage.save();
+            m_isEditMode = false;
+        }
+        else if (button == Minus)
+        {
+            m_tmpValue -= TEMP_INTERVAL;
+        }
+        else if (button == Plus)
+        {
+            m_tmpValue += TEMP_INTERVAL;
+        }
+        m_lcdUpdateNeeded = true;
+    }
+    else
+    {
+        if (button == Ok)
+        {
+            m_isEditMode = true;
+            m_lcdUpdateNeeded = true;
+        }
+        else
+        {
+            BaseActivity::onButtonReleased(button);
+        }
+    }
+}

TempEditorActivity.h

@@ -0,0 +1,32 @@
+#pragma once
+
+
+#include "BaseActivity.h"
+#include "Boiler.h"
+
+class TempEditorActivity
+        : public BaseActivity
+{
+public:
+    TempEditorActivity(
+            IActivity* mParentActivity
+            , IActivity* mPreviousActivity
+            , IActivity* mNextActivity
+            , const char* line1
+            , temp_t* value
+    );
+
+    void begin() override;
+
+protected:
+    void getLcdText(char** lines) override;
+
+    void onButtonReleased(Button button) override;
+
+    const char* m_line1;
+    temp_t* m_value;
+    temp_t m_tmpValue;
+    bool m_isEditMode;
+};
+
+

TempInput.cpp

@@ -0,0 +1,41 @@
+#include "TempInput.h"
+#include "globals.h"
+#include "defines.h"
+
+TempInput::TempInput(uint8_t index)
+        : m_address{0}
+          , m_index(index)
+          , m_lastSensorRequestMs(0)
+          , m_hasReadSensor(false)
+{
+}
+
+void TempInput::begin()
+{
+    setValue(TEMP_T_INVALID);
+    g_dallasTemperature.getAddress(m_address, m_index);
+}
+
+void TempInput::loop()
+{
+    const auto& currentMs = millis();
+
+    if (currentMs - m_lastSensorRequestMs >= SENSORS_CHECK_INTERVAL)
+    {
+        m_lastSensorRequestMs = currentMs;
+        m_hasReadSensor = false;
+        g_dallasTemperature.requestTemperaturesByAddress(m_address);
+    }
+    if (currentMs - m_lastSensorRequestMs >= SENSORS_REQUEST_DELAY &&
+        !m_hasReadSensor)
+    {
+        m_hasReadSensor = true;
+        auto raw = g_dallasTemperature.getTempC(m_address);
+        temp_t temp = TEMP_T_INVALID;
+        if (raw != DEVICE_DISCONNECTED_C)
+        {
+            temp = (temp_t) (raw * 10);
+        }
+        setValue(temp);
+    }
+}

TempInput.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "Boiler.h"
+#include "IInput.h"
+
+class TempInput
+        : public IInput<temp_t>
+{
+public:
+    explicit TempInput(uint8_t index);
+
+    void begin() override;
+
+    void loop() override;
+
+protected:
+    uint8_t m_address[8];
+    uint8_t m_index;
+    timestamp_t m_lastSensorRequestMs;
+    bool m_hasReadSensor;
+};
+
+

defines.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#define HIBERNATE_DELAY 5000
+#define SENSORS_CHECK_INTERVAL 2000
+#define SENSORS_REQUEST_DELAY 750
+#define TEMP_TRIGGER ((temp_t)(5 * 10.0f))
+#define TEMP_INTERVAL ((temp_t)(0.5 * 10.0f))
+#define LCD_CHAR_SENSOR 1
+
+#define PIN_ONEWIRE 14 //A0
+#define PIN_RELAY2 15 //A1
+#define PIN_RELAY1 16 //A2
+#define PIN_BTN_CANCEL 9
+#define PIN_BTN_OK 10
+#define PIN_BTN_MINUS 11
+#define PIN_BTN_PLUS 12
+#define PIN_LCD_LED 2
+#define PIN_LCD_RS 8
+#define PIN_LCD_ENABLE 7
+#define PIN_LCD_D4 6
+#define PIN_LCD_D5 5
+#define PIN_LCD_D6 4
+#define PIN_LCD_D7 3

globals.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <JC_Button.h>
+#include <LiquidCrystal.h>
+#include <OneWire.h>
+#include <DallasTemperature.h>
+#include "AppCore.h"
+#include "HibernateService.h"
+#include "DigitalOutput.h"
+#include "Storage.h"
+#include "HomeActivity.h"
+#include "MenuItemActivity.h"
+#include "BoilerTankMenuActivity.h"
+#include "TempInput.h"
+#include "BoilerTankService.h"
+
+extern AppCore g_appCore;
+extern AppCoreState g_appState;
+extern Storage g_storage;
+extern Button g_btnCancel;
+extern Button g_btnOk;
+extern Button g_btnMinus;
+extern Button g_btnPlus;
+extern HibernateService g_hibernateService;
+extern LiquidCrystal g_lcd;
+extern DigitalOutput g_lcdLed;
+extern OneWire g_oneWire;
+extern DallasTemperature g_dallasTemperature;
+extern BoilerTankService g_tankService1;
+extern BoilerTankService g_tankService2;
+
+extern HomeActivity g_homeActivity;
+extern BoilerTankMenuActivity g_menuWaterActivity;
+extern BoilerTankMenuActivity g_menuHeaterActivity;
+extern MenuItemActivity g_menuVersionActivity;

main.ino

@@ -1,14 +1,14 @@
 #include "AppCore.h"
 #include <OneWire.h>
 
-auto g_pAppCore = new AppCore();
+AppCore g_appCore;
 
 void setup()
 {
-    g_pAppCore->setup();
+    g_appCore.begin();
 }
 
 void loop()
 {
-    g_pAppCore->loop();
+    g_appCore.loop();
 }