Added logs; switch temp_t to short; display 1/10 temperature

AppCore.cpp

 #include "AppCore.h"
+#include "Logs.h"
 
 #define HIBERNATE_DELAY 5000
 #define SENSORS_CHECK_INTERVAL 2000
 #define SENSORS_REQUEST_DELAY 750
-#define TEMP_TRIGGER 10
+#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 12
 #define MODE_SEQUENCE_COUNT (sizeof(m_modeSequence) / sizeof(*m_modeSequence))
 
 AppCore::AppCore()
-        : m_appCoreState{
+        : m_appCoreState(new AppCoreState{
         .appState = {
                 .lastSensorRequestMs = 0,
                 .hasReadSensors = true,
                 .modeSequenceIndex = MODE_SEQUENCE_COUNT - 1,
                 .isUpdateNeeded = true
         }
-}
+})
           , m_modeSequence{WaterSetting, HeaterSetting, Lighting}
           , m_btnMode{PIN_BTN_MODE}
           , m_btnMinus{PIN_BTN_MINUS}
           , m_oneWire{PIN_ONEWIRE}
           , m_sensors{&m_oneWire}
           , m_sensor1{0}
+          , m_sensor2{0}
 {
 }
 
 void AppCore::setup()
 {
+    Serial.begin(9600);
+    LOG_FN_BEGIN(1);
+
     m_sensors.begin();
+    LOG(5, "Found %i sensors", m_sensors.getDeviceCount());
     m_sensors.getAddress(m_sensor1, 0);
+    m_sensors.getAddress(m_sensor2, 1);
     m_sensors.setWaitForConversion(false);
 
     for (auto& g_button : m_buttons)
     };
     m_lcd.createChar(LCD_CHAR_SENSOR, sensorChar);
 
-    Serial.begin(9600);
 
     bool allButtonsPressed = true;
     for (auto& g_button : m_buttons)
     }
     if (!allButtonsPressed)
     {
-        m_storage.load(m_appCoreState);
+        LOG(5, "%s: Loading settings", __FUNCTION__);
+        m_storage.load(*m_appCoreState);
     }
     else
     {
-        m_storage.save(m_appCoreState);
+        LOG(5, "%s: Resetting settings", __FUNCTION__);
+        m_storage.save(*m_appCoreState);
     }
+
+    LOG_FN_END(1);
 }
 
 void AppCore::loop()
 {
+    LOG_FN_BEGIN(50);
+
     const auto& currentMs = millis();
 
-    if (currentMs - m_appCoreState.appState.lastSensorRequestMs >= SENSORS_CHECK_INTERVAL)
+    if (currentMs - m_appCoreState->appState.lastSensorRequestMs >= SENSORS_CHECK_INTERVAL)
     {
-        m_appCoreState.appState.lastSensorRequestMs = currentMs;
-        m_appCoreState.appState.hasReadSensors = false;
+        m_appCoreState->appState.lastSensorRequestMs = currentMs;
+        m_appCoreState->appState.hasReadSensors = false;
         m_sensors.requestTemperaturesByAddress(m_sensor1);
+        m_sensors.requestTemperaturesByAddress(m_sensor2);
     }
-    if (currentMs - m_appCoreState.appState.lastSensorRequestMs >= SENSORS_REQUEST_DELAY &&
-        !m_appCoreState.appState.hasReadSensors)
+    if (currentMs - m_appCoreState->appState.lastSensorRequestMs >= SENSORS_REQUEST_DELAY &&
+        !m_appCoreState->appState.hasReadSensors)
     {
-        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 != m_appCoreState.appState.water.current)
-        {
-            m_appCoreState.appState.water.current = temp;
-            m_appCoreState.uiState.isUpdateNeeded = true;
-        }
+        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);
     }
 
 
         pButton->read();
         if (pButton->isPressed())
         {
-            m_appCoreState.uiState.lastOpMs = currentMs;
+            m_appCoreState->uiState.lastOpMs = currentMs;
             break;
         }
     }
 
 
-    if (m_appCoreState.uiState.state == Hibernate)
+    if (m_appCoreState->uiState.state == Hibernate)
     {
         for (auto& pButton : m_buttons)
         {
     }
     else
     {
-        if (currentMs - m_appCoreState.uiState.lastOpMs >= HIBERNATE_DELAY)
+        if (currentMs - m_appCoreState->uiState.lastOpMs >= HIBERNATE_DELAY)
         {
             setState(Hibernate);
         }
         {
             if (m_btnMode.wasReleased())
             {
-                m_appCoreState.uiState.modeSequenceIndex =
-                        (m_appCoreState.uiState.modeSequenceIndex + 1) % MODE_SEQUENCE_COUNT;
-                setState(m_modeSequence[m_appCoreState.uiState.modeSequenceIndex]);
+                m_appCoreState->uiState.modeSequenceIndex =
+                        (m_appCoreState->uiState.modeSequenceIndex + 1) % MODE_SEQUENCE_COUNT;
+                setState(m_modeSequence[m_appCoreState->uiState.modeSequenceIndex]);
             }
             else if (m_btnMinus.wasReleased() || m_btnPlus.wasReleased())
             {
                 BoilerItemState* itemState = nullptr;
-                if (m_appCoreState.uiState.state == WaterSetting)
+                if (m_appCoreState->uiState.state == WaterSetting)
                 {
-                    itemState = &m_appCoreState.appState.water;
+                    itemState = &m_appCoreState->appState.water;
                 }
-                else if (m_appCoreState.uiState.state == HeaterSetting)
+                else if (m_appCoreState->uiState.state == HeaterSetting)
                 {
-                    itemState = &m_appCoreState.appState.heater;
+                    itemState = &m_appCoreState->appState.heater;
                 }
 
                 if (itemState)
                 {
                     if (m_btnMinus.wasReleased())
                     {
-                        --itemState->setting;
+                        itemState->setting -= TEMP_INTERVAL;
                     }
                     else if (m_btnPlus.wasReleased())
                     {
-                        ++itemState->setting;
+                        itemState->setting += TEMP_INTERVAL;
                     }
-                    m_appCoreState.uiState.isUpdateNeeded = true;
+                    LOG(1, "Setting temp to %i (%i)", itemState->setting, TEMP_INTERVAL);
+                    m_appCoreState->uiState.isUpdateNeeded = true;
                 }
             }
         }
     }
 
-    checkBoilerItem(m_appCoreState.appState.water);
-    checkBoilerItem(m_appCoreState.appState.heater);
-
-    if (m_appCoreState.uiState.isUpdateNeeded)
+    if (m_appCoreState->uiState.isUpdateNeeded)
     {
         printState();
     }
+
+    LOG_FN_END(50);
 }
 
 void AppCore::setState(
         UiStateEnum state
 )
 {
-    char tmp[50];
-    snprintf(tmp, sizeof(tmp), "Changing state %i => %i", m_appCoreState.uiState.state, state);
-    Serial.println(tmp);
+    LOG_FN_BEGIN(1);
+    LOG(5, "Changing state %i => %i", m_appCoreState->uiState.state, state);
 
     if (state == Lighting)
     {
     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.modeSequenceIndex = MODE_SEQUENCE_COUNT - 1;
+        m_storage.save(*m_appCoreState);
     }
-    m_appCoreState.uiState.state = state;
-    m_appCoreState.uiState.isUpdateNeeded = true;
+    m_appCoreState->uiState.state = state;
+    m_appCoreState->uiState.isUpdateNeeded = true;
+
+    LOG_FN_END(1);
 }
 
 void AppCore::checkBoilerItem(
-        BoilerItemState& boilerItemState
+        BoilerItemState* boilerItemState
 )
 {
-    if (!boilerItemState.isActive && boilerItemState.current != TEMP_T_INVALID &&
-        boilerItemState.current <= boilerItemState.setting - TEMP_TRIGGER)
+    LOG_FN_BEGIN(2);
+
+    if (!boilerItemState->isActive && boilerItemState->current != TEMP_T_INVALID &&
+        boilerItemState->current <= boilerItemState->setting - TEMP_TRIGGER)
     {
-        boilerItemState.isActive = true;
-        m_appCoreState.uiState.isUpdateNeeded = true;
+        boilerItemState->isActive = true;
+        m_appCoreState->uiState.isUpdateNeeded = true;
     }
-    else if (boilerItemState.isActive &&
-             (boilerItemState.current == TEMP_T_INVALID || boilerItemState.current >= boilerItemState.setting))
+    else if (boilerItemState->isActive &&
+             (boilerItemState->current == TEMP_T_INVALID || boilerItemState->current >= boilerItemState->setting))
     {
-        boilerItemState.isActive = false;
-        m_appCoreState.uiState.isUpdateNeeded = true;
+        boilerItemState->isActive = false;
+        m_appCoreState->uiState.isUpdateNeeded = true;
     }
+
+    LOG_FN_END(2);
+}
+
+void AppCore::readAndUpdateSensors(
+        BoilerItemState* boilerItemState
+        , const uint8_t* sensor
+)
+{
+    LOG_FN_BEGIN(2);
+
+    auto raw = m_sensors.getTempC(sensor);
+    temp_t temp = TEMP_T_INVALID;
+    if (raw != DEVICE_DISCONNECTED_C)
+    {
+        temp = (temp_t) (raw * 10);
+    }
+
+    if (temp != boilerItemState->current)
+    {
+        boilerItemState->current = temp;
+        m_appCoreState->uiState.isUpdateNeeded = true;
+    }
+
+    LOG_FN_END(2);
 }
 
 void AppCore::printState()
 {
-    Serial.println("Updating display");
+    LOG_FN_BEGIN(2);
 
     m_lcd.setCursor(0, 0);
-    printStateLine('S', m_appCoreState.appState.water, m_appCoreState.uiState.state == WaterSetting,
-                   m_appCoreState.appState.water.isActive);
+    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);
-    m_appCoreState.uiState.isUpdateNeeded = false;
+    printStateLine('C', &m_appCoreState->appState.heater, m_appCoreState->uiState.state == HeaterSetting,
+                   m_appCoreState->appState.heater.isActive);
+    m_appCoreState->uiState.isUpdateNeeded = false;
+
+    LOG_FN_END(2);
 }
 
 void
 AppCore::printStateLine(
         char prefix
-        , const BoilerItemState& boilerItemState
+        , const BoilerItemState* boilerItemState
         , bool isModifying
         , bool isActive
 )
 {
+    LOG_FN_BEGIN(2);
+
     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 ? '<' : ' ',
+    tempToStr(curTmp, boilerItemState->current, 5);
+    tempToStr(setTmp, boilerItemState->setting, 4);
+    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] = 0;
     m_lcd.print(tmp);
+
+    LOG_FN_END(2);
 }
 
 void AppCore::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)
     {
-        strcpy(out, " -- ");
+        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);
+        dtostrf(temp / 10.0f, width, 1, out);
     }
+
+    LOG_FN_END(2);
 }

AppCore.h

 protected:
     void setState(UiStateEnum state);
 
-    void checkBoilerItem(BoilerItemState& boilerItemState);
+    void checkBoilerItem(BoilerItemState* boilerItemState);
+
+    void readAndUpdateSensors(BoilerItemState* boilerItemState, const uint8_t* sensor);
 
     void printState();
 
     void printStateLine(
             char prefix
-            , const BoilerItemState& boilerItemState
+            , const BoilerItemState* boilerItemState
             , bool isModifying
             , bool isActive
     );
     void tempToStr(
             char* out
             , temp_t temp
+            , signed char width
     );
 
 private:
-    AppCoreState m_appCoreState;
+    AppCoreState* m_appCoreState;
     Storage m_storage;
 
     UiStateEnum m_modeSequence[3];
     OneWire m_oneWire;
     DallasTemperature m_sensors;
     DeviceAddress m_sensor1;
+    DeviceAddress m_sensor2;
 };

Boiler.h

 #pragma once
 
-typedef char temp_t;
+typedef short temp_t;
 #define TEMP_T_INVALID -127
 typedef unsigned long timestamp_t;
 

CMakeLists.txt

 set(${CMAKE_PROJECT_NAME}_ALL_SRCS main.ino JC_Button.cpp Storage.cpp AppCore.cpp)
 set(${CMAKE_PROJECT_NAME}_SKETCH main.ino)
 generate_arduino_firmware(${CMAKE_PROJECT_NAME})
+
+if (CMAKE_BUILD_TYPE MATCHES "Debug")
+    message(STATUS "Debug build detected. Enabling logs.")
+    add_definitions(-DAPP_CORE_LOGS=1)
+endif()

Logs.h

+#pragma once
+
+#if APP_CORE_LOGS
+
+#define APP_CORE_LOGS_LEVEL 1
+
+#define LOG(level_, ...) do {                           \
+    if (level_ <= APP_CORE_LOGS_LEVEL)                  \
+    {                                                   \
+        char tmp[100];                                  \
+        snprintf(tmp, sizeof(tmp), __VA_ARGS__);        \
+        Serial.println(tmp);                            \
+    }                                                   \
+} while (0)
+
+#define LOG_FN_BEGIN(level_) LOG(level_, "%s: Begin", __FUNCTION__)
+#define LOG_FN_END(level_) LOG(level_, "%s: End", __FUNCTION__)
+
+#else
+
+#define LOG(x)
+#define LOG(x, ...)
+
+#endif