Pause hibernate when editing and resetting; Logs

AppCore.cpp

                                             "", &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()
     return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
 }
 
+AppCore::AppCore()
+        : m_currentActivity(nullptr)
+{
+}
+
 void AppCore::begin()
 {
     Serial.begin(9600);
 
     g_hibernateService.loop();
 
-    if (g_currentActivity)
+    if (m_currentActivity)
     {
-        g_currentActivity->loop();
+        m_currentActivity->loop();
     }
 
     LOG_FN_END(50);
 
 void AppCore::setActivity(IActivity* activity)
 {
-    g_currentActivity = activity;
-    g_currentActivity->begin();
+    m_currentActivity = activity;
+    m_currentActivity->begin();
+}
+
+IActivity* AppCore::getCurrentActivity() const
+{
+    return m_currentActivity;
 }

AppCore.h

 #pragma once
 
-#include <LiquidCrystal.h>
-#include <JC_Button.h>
-#include <OneWire.h>
-#include <DallasTemperature.h>
-#include "Boiler.h"
-#include "Storage.h"
-#include "IInput.h"
 #include "ILifeCycle.h"
 #include "IActivity.h"
 
         : public ILifeCycle
 {
 public:
+    AppCore();
+
     void begin() override;
 
     void loop() override;
 
     void setActivity(IActivity* activity);
+
+    IActivity* getCurrentActivity() const;
+
+protected:
+    IActivity* m_currentActivity;
 };

BaseActivity.cpp

 #include "BaseActivity.h"
 #include "globals.h"
 #include "Helpers.h"
+#include "Logs.h"
 
 BaseActivity::BaseActivity(
         IActivity* mParentActivity
     {
         if (g_btnCancel.wasReleased())
         {
+            LOG(1, "BaseActivity: Cancel pressed");
             onButtonReleased(Cancel);
         }
         else if (g_btnOk.wasReleased())
         {
+            LOG(1, "BaseActivity: Ok pressed");
             onButtonReleased(Ok);
         }
         else if (g_btnMinus.wasReleased())
         {
+            LOG(1, "BaseActivity: Minus pressed");
             onButtonReleased(Minus);
         }
         else if (g_btnPlus.wasReleased())
         {
+            LOG(1, "BaseActivity: Plus pressed");
             onButtonReleased(Plus);
         }
     }
 
 void BaseActivity::updateLcd()
 {
+    LOG(1, "BaseActivity: Updating LCD");
     char lines[2][17];
     lines[0][0] = 0;
     lines[1][0] = 0;

Boiler.h

 {
     enum Mode
     {
-        Auto,
-        On,
-        Off
+        Auto = 1,
+        On = 2,
+        Off = 3
     };
 
     Mode mode;
     temp_t setting;
     temp_t tempTrigger;
-//    uint8_t sensorAddress[8];
     TempInput* input;
     DigitalOutput* relay;
 };

BoilerTankModeEditorActivity.cpp

         {
             m_tmpValue = *m_value;
             m_isEditMode = false;
+            g_hibernateService.setPaused(false);
         }
         else if (button == Ok)
         {
             *m_value = m_tmpValue;
             g_storage.save();
             m_isEditMode = false;
+            g_hibernateService.setPaused(false);
         }
         else if (button == Minus)
         {
         {
             m_isEditMode = true;
             m_lcdUpdateNeeded = true;
+            g_hibernateService.setPaused(true);
         }
         else
         {

HibernateService.cpp

         nullptr
 }
           , m_lastEventMs(0)
+          , m_paused(false)
 {
 }
 
             break;
         }
     }
-    if (!m_lastValue && currentMs - m_lastEventMs > HIBERNATE_DELAY)
+    if (!m_lastValue && !m_paused && currentMs - m_lastEventMs > HIBERNATE_DELAY)
     {
         shouldHibernate = true;
     }
     {
         LOG(1, "Hibernate event");
         g_lcdLed.setEnabled(!m_lastValue);
+        if (m_lastValue && g_appCore.getCurrentActivity() != &g_homeActivity)
+        {
+            g_appCore.setActivity(&g_homeActivity);
+        }
     }
 }
+
+void HibernateService::setPaused(bool paused)
+{
+    m_paused = paused;
+}

HibernateService.h

 
     void loop() override;
 
+    void setPaused(bool paused);
+
 protected:
     Button* m_buttons[5];
 
     timestamp_t m_lastEventMs;
+
+    bool m_paused;
 };

HomeActivity.cpp

 {
     if (g_appState.tanks[0].input->hasChanged() || g_appState.tanks[1].input->hasChanged())
     {
+        LOG(1, "HomeActivity: Input has changed");
         m_lcdUpdateNeeded = true;
     }
     BaseActivity::loop();

LoaderActivity.cpp

     }
     else
     {
+        g_hibernateService.setPaused(true);
         BaseActivity::begin();
     }
 }
 {
     LOG(1, "%s: Resetting settings", __FUNCTION__);
     g_storage.save();
+    g_hibernateService.setPaused(false);
     g_appCore.setActivity(&g_homeActivity);
 }
 

TempEditorActivity.cpp

         {
             m_tmpValue = *m_value;
             m_isEditMode = false;
+            g_hibernateService.setPaused(false);
         }
         else if (button == Ok)
         {
             *m_value = m_tmpValue;
             g_storage.save();
             m_isEditMode = false;
+            g_hibernateService.setPaused(false);
         }
         else if (button == Minus)
         {
         {
             m_isEditMode = true;
             m_lcdUpdateNeeded = true;
+            g_hibernateService.setPaused(true);
         }
         else
         {

TempInput.cpp

 #include "TempInput.h"
 #include "globals.h"
 #include "defines.h"
+#include "Logs.h"
 
 TempInput::TempInput(uint8_t index)
         : m_address{0}
 
     if (currentMs - m_lastSensorRequestMs >= SENSORS_CHECK_INTERVAL)
     {
+        LOG(5, "TempInput: requesting value");
         m_lastSensorRequestMs = currentMs;
         m_hasReadSensor = false;
         g_dallasTemperature.requestTemperaturesByAddress(m_address);
     if (currentMs - m_lastSensorRequestMs >= SENSORS_REQUEST_DELAY &&
         !m_hasReadSensor)
     {
+        LOG(5, "TempInput: reading value");
         m_hasReadSensor = true;
         auto raw = g_dallasTemperature.getTempC(m_address);
         temp_t temp = TEMP_T_INVALID;
         }
         setValue(temp);
     }
+    else
+    {
+        setValue(m_lastValue);
+    }
 }