logging: switch to yal

Author: alexmohr

src/Filesystem.cpp

@@ -150,7 +150,7 @@ void Filesystem::format()
 String Filesystem::formatBytes(size_t bytes)
 {
   static constexpr const auto bitsPerByte = 1024.0;
-  if (bytes < bitsPerByte) {
+  if (bytes <bitsPerByte ) {
     return String(bytes) + "B";
   }
   if (bytes < (bitsPerByte * bitsPerByte)) {

src/RTCMemory.cpp

@@ -5,8 +5,8 @@
 
 #include <RTCMemory.hpp>
 #include <user_interface.h>
-#include <yal/yal.hpp>
 #include <string>
+#include <yal/yal.hpp>
 
 namespace open_heat {
 namespace rtc {
@@ -57,8 +57,7 @@ Memory readWithoutLock()
 {
   Memory rtcMemory{};
 
-  if (!ESP.rtcUserMemoryRead(
-        0, reinterpret_cast<uint32_t*>(&rtcMemory), sizeof(Memory))) {
+  if (!ESP.rtcUserMemoryRead(0, reinterpret_cast<uint32_t*>(&rtcMemory), sizeof(Memory))) {
     m_logger.log(yal::Level::ERROR, "Failed to read RTC user memory");
   }
 
@@ -181,7 +180,7 @@ void wifiDeepSleep(uint64_t timeInMs, bool enableRF, Filesystem& filesystem)
   pinMode(static_cast<uint8_t>(config.MotorPins.Ground), INPUT);
   pinMode(static_cast<uint8_t>(LED_BUILTIN), INPUT);
 
-  m_logger.log(yal::Level::INFO, "Sleeping for % ms", timeInMs);
+  m_logger.log(yal::Level::INFO, "Sleeping for %lu ms", timeInMs);
   setMillisOffset(offsetMillis() + timeInMs);
 
   EspClass::deepSleep(timeInMs * 1000, enableRF ? RF_CAL : RF_DISABLED);

src/heating/RadiatorValve.cpp

@@ -31,7 +31,7 @@ uint64_t open_heat::heating::RadiatorValve::loop()
     rtc::setValveNextCheckMillis(nextCheck);
     rtc::read().mode == OFF ? closeValve(VALVE_FULL_ROTATE_TIME * 2)
                             : openValve(VALVE_FULL_ROTATE_TIME * 2);
-
+    
     m_logger.log(yal::Level::DEBUG, "Heating is turned off, disabled heating");
     return nextCheck;
   }
@@ -64,10 +64,10 @@ uint64_t open_heat::heating::RadiatorValve::loop()
   m_logger.log(
     yal::Level::INFO,
     "Valve loop\n"
-    "\tpredictTemp % in % ms\n"
-    "\tpredictPart: %, predictionError: %\n"
-    "\tmeasuredTemp: %, lastMeasuredTemp %, setTemp % \n"
-    "\ttemperatureChange %, absTempDiff: %",
+    "\tpredictTemp %.2f in %lu ms\n"
+    "\tpredictPart: %.2f, predictionError: %.2f\n"
+    "\tmeasuredTemp: %.2f, lastMeasuredTemp %.2f, setTemp %.2f \n"
+    "\ttemperatureChange %.2f, absTempDiff: %.2f",
     predictTemp,
     m_checkIntervalMillis,
     predictPart,
@@ -91,7 +91,7 @@ uint64_t open_heat::heating::RadiatorValve::loop()
     } else {
       m_logger.log(
         yal::Level::INFO,
-        "RISE, NO ADJUST: Temp old %, temp now %, temp change %",
+        "RISE, NO ADJUST: Temp old %.2f, temp now %.2f, temp change %.2f",
         rtcData.lastMeasuredTemp,
         measuredTemp,
         temperatureChange);
@@ -103,7 +103,7 @@ uint64_t open_heat::heating::RadiatorValve::loop()
     } else {
       m_logger.log(
         yal::Level::INFO,
-        "SINK, NO ADJUST: Temp old %, temp now %, temp change %",
+        "SINK, NO ADJUST: Temp old %.2f, temp now %.2f, temp change %.2f",
         rtc::read().lastMeasuredTemp,
         measuredTemp,
         temperatureChange);
@@ -122,7 +122,7 @@ void open_heat::heating::RadiatorValve::handleTempTooHigh(
 {
   auto closeTime = 200;
   const auto predictDiff = rtcData.setTemp - predictTemp - closeHysteresis;
-  m_logger.log(yal::Level::INFO, "Close predict diff: %", predictDiff);
+  m_logger.log(yal::Level::INFO, "Close predict diff: %f", predictDiff);
   if (predictDiff <= 2) {
     closeTime = 5000;
   } else if (predictDiff <= 1.5) {
@@ -150,7 +150,7 @@ void open_heat::heating::RadiatorValve::handleTempTooLow(
   auto openTime = 350;
   const float largeTempDiff = 3;
   const auto predictDiff = rtcData.setTemp - predictTemp - openHysteresis;
-  m_logger.log(yal::Level::INFO, "Open predict diff: %", predictDiff);
+  m_logger.log(yal::Level::INFO, "Open predict diff: %f", predictDiff);
 
   if (
     rtcData.setTemp - predictTemp > largeTempDiff
@@ -190,7 +190,7 @@ void open_heat::heating::RadiatorValve::setConfiguredTemp(float temp)
     return;
   }
 
-  m_logger.log(yal::Level::INFO, "New target temperature %", temp);
+  m_logger.log(yal::Level::INFO, "New target temperature %f", temp);
   rtc::setSetTemp(temp);
   setNextCheckTimeNow();
 
@@ -215,7 +215,7 @@ void open_heat::heating::RadiatorValve::closeValve(unsigned int rotateTime)
   if (rtc::read().currentRotateTime <= (-VALVE_FULL_ROTATE_TIME)) {
     m_logger.log(
       yal::Level::DEBUG,
-      "Valve already fully closed, current rotate time: %",
+      "Valve already fully closed, current rotate time: %i",
       rtc::read().currentRotateTime);
     return;
   }
@@ -230,7 +230,7 @@ void open_heat::heating::RadiatorValve::closeValve(unsigned int rotateTime)
 
   m_logger.log(
     yal::Level::DEBUG,
-    "Closing valve for %ms, currentRotateTime: %ms, vin: %, ground: %",
+    "Closing valve for %ims, currentRotateTime: %ims, vin: %i, ground: %i",
     rotateTime,
     rtc::read().currentRotateTime,
     config.Vin,

src/heating/RadiatorValve.hpp

@@ -9,8 +9,8 @@
 #include <Filesystem.hpp>
 #include <RTCMemory.hpp>
 #include <sensors/Temperature.hpp>
-#include <yal/yal.hpp>
 #include <chrono>
+#include <yal/yal.hpp>
 
 namespace open_heat::heating {
 
@@ -87,6 +87,6 @@ class RadiatorValve {
 
   yal::Logger m_logger;
 };
-} // namespace open_heat::heating
+} // namespace open_heat
 
 #endif // OPEN_HEAT_RADIATORVALVE_HPP

src/main.cpp

@@ -17,8 +17,8 @@
 #include <sensors/BMP280.hpp>
 #include <sensors/WindowSensor.hpp>
 
-#include <yal/appender/ArduinoSerial.hpp>
 #include <yal/yal.hpp>
+#include <yal/appender/ArduinoSerial.hpp>
 
 // external voltage
 ADC_MODE(ADC_TOUT)
@@ -66,23 +66,25 @@ void setupPins()
     pinMode(static_cast<uint8_t>(config.MotorPins.Vin), OUTPUT);
     digitalWrite(static_cast<uint8_t>(config.MotorPins.Ground), LOW);
   } else {
-    g_logger.log(yal::Level::ERROR, "Motor pin vin invalid: %", config.MotorPins.Vin);
+    g_logger.log(
+      yal::Level::ERROR, "Motor pin vin invalid: %i", config.MotorPins.Vin);
   }
   if (config.MotorPins.Ground > 1) {
     pinMode(static_cast<uint8_t>(config.MotorPins.Ground), OUTPUT);
     digitalWrite(static_cast<uint8_t>(config.MotorPins.Ground), LOW);
 
   } else {
     g_logger.log(
-      yal::Level::ERROR, "Motor pin ground invalid: %", config.MotorPins.Ground);
+      yal::Level::ERROR, "Motor pin ground invalid: %i", config.MotorPins.Ground);
   }
 
   // enable temp sensor
   if (config.TempVin > 0) {
     pinMode(static_cast<uint8_t>(config.TempVin), OUTPUT);
     digitalWrite(static_cast<uint8_t>(config.TempVin), HIGH);
   } else {
-    g_logger.log(yal::Level::ERROR, "Temp pin vin invalid: %", config.TempVin);
+    g_logger.log(
+      yal::Level::ERROR, "Temp pin vin invalid: %i", config.TempVin);
   }
 }
 
@@ -117,25 +119,25 @@ void setupTemperatureSensor()
 
 bool isDoubleReset()
 {
-  if (EspClass::getResetInfoPtr()->reason != REASON_EXT_SYS_RST) {
+  if (ESP.getResetInfoPtr()->reason != REASON_EXT_SYS_RST) {
     g_logger.log(
       yal::Level::DEBUG,
-      "no double reset, resetInfo: %",
-      EspClass::getResetInfo().c_str());
+      "no double reset, resetInfo: %s",
+      ESP.getResetInfo().c_str());
     open_heat::rtc::setDrdDisabled(true);
     return false;
   }
 
   const auto drdDetected = g_drd.detectDoubleReset();
 
-  g_logger.log(yal::Level::DEBUG, "DRD detected: %", drdDetected);
+  g_logger.log(yal::Level::DEBUG, "DRD detected: %i", drdDetected);
 
   const auto millisSinceReset
     = open_heat::rtc::read().lastResetTime - open_heat::rtc::offsetMillis();
 
   g_logger.log(
     yal::Level::DEBUG,
-    "millis since reset: %, last reset time %, offset millis: %",
+    "millis since reset: %lu, last reset time %lu, offset millis: %lu",
     millisSinceReset,
     open_heat::rtc::read().lastResetTime,
     open_heat::rtc::offsetMillis());
@@ -169,7 +171,8 @@ void setup()
   }
 
   const auto offsetMillis = open_heat::rtc::offsetMillis();
-  g_logger.log(yal::Level::DEBUG, "Set last reset time to %", offsetMillis);
+  g_logger.log(
+    yal::Level::DEBUG, "Set last reset time to %lu", offsetMillis);
   open_heat::rtc::setLastResetTime(offsetMillis);
 
   setupPins();
@@ -236,7 +239,7 @@ void loop()
   if (nextCheckMillis < (open_heat::rtc::offsetMillis() + minSleepTime)) {
     g_logger.log(
       yal::Level::DEBUG,
-      "Minimal sleep or underflow prevented, sleep set to % ms",
+      "Minimal sleep or underflow prevented, sleep set to %ul ms",
       minSleepTime);
     idleTime = minSleepTime;
   } else {

src/network/MQTT.cpp

@@ -10,12 +10,12 @@
 void open_heat::network::MQTT::setup()
 {
   m_logger.log(yal::Level::INFO, "Running MQTT setup");
-  m_mqttClient.onMessage(
-    [this](String& topic, String& payload) { messageReceivedCallback(topic, payload); });
+  m_mqttClient.onMessage([this] (String& topic, String& payload) {
+    messageReceivedCallback(topic, payload);
+  });
 
   m_valve.registerModeChangedHandler([this](OperationMode mode) {
-    m_mqttAppender.queue().push(
-      {m_getModeTopic, heating::RadiatorValve::modeToCharArray(mode)});
+    m_mqttAppender.queue().push({m_getModeTopic, heating::RadiatorValve::modeToCharArray(mode)});
   });
 
   m_valve.registerSetTempChangedHandler([this](float temp) {
@@ -70,6 +70,7 @@ uint64_t open_heat::network::MQTT::loop()
   publish(m_getConfiguredTempTopic, String(rtc::read().setTemp));
   publish(m_getModeTopic, String(rtc::read().mode));
 
+
   // drain message queue for new messages
   sendMessageQueue();
 
@@ -161,10 +162,9 @@ void open_heat::network::MQTT::handleSetModemSleep(const String& payload)
 
 void open_heat::network::MQTT::publish(const String& topic, const String& message)
 {
-  m_logger.log(
-    yal::Level::DEBUG, "MQTT send '%' in topic '%'", message.c_str(), topic.c_str());
+  m_logger.log(yal::Level::DEBUG, "MQTT send '%' in topic '%'", message.c_str(), topic.c_str());
   if (!m_mqttClient.publish(topic, message)) {
-    m_logger.log(yal::Level::ERROR, "MQTT publish failed: %", m_mqttClient.lastError());
+    m_logger.log(yal::Level::ERROR,"MQTT publish failed: %", m_mqttClient.lastError());
   }
 }
 
@@ -173,8 +173,7 @@ void open_heat::network::MQTT::connect()
   const auto& config = m_filesystem.getConfig();
   if ((std::strlen(config.MQTT.Server) == 0 || config.MQTT.Port == 0)) {
     if (m_configValid) {
-      m_logger.log(
-        yal::Level::ERROR,
+      m_logger.log(yal::Level::ERROR,
         "MQTT Server (%) or port (%) not set up",
         config.MQTT.Server,
         config.MQTT.Port);
@@ -201,8 +200,7 @@ void open_heat::network::MQTT::connect()
   }
 
   if (!m_mqttClient.connect(config.Hostname, username, password)) {
-    m_logger.log(
-      yal::Level::ERROR,
+    m_logger.log(yal::Level::ERROR,
       "Failed to connect to mqtt server host %, user: %, pw: %",
       config.MQTT.Server,
       config.MQTT.Username,
@@ -212,8 +210,7 @@ void open_heat::network::MQTT::connect()
 
   setTopic(config.MQTT.Topic, "log", m_logTopic);
 
-  m_logger.log(
-    yal::Level::INFO,
+  m_logger.log(yal::Level::INFO,
     "MQTT topic: %, topic len: %",
     config.MQTT.Topic,
     std::strlen(config.MQTT.Topic));
@@ -252,12 +249,8 @@ void open_heat::network::MQTT::subscribe(const String& topic)
   if (m_mqttClient.subscribe(topic)) {
     m_logger.log(yal::Level::INFO, "MQTT subscribed to topic: %", topic.c_str());
   } else {
-    m_logger.log(
-      yal::Level::ERROR, "MQTT failed to subscribe to topic: %", topic.c_str());
-    m_logger.log(
-      yal::Level::ERROR,
-      "MQTT last error: %",
-      static_cast<int>(m_mqttClient.lastError()));
+    m_logger.log(yal::Level::ERROR,"MQTT failed to subscribe to topic: %", topic.c_str());
+    m_logger.log(yal::Level::ERROR, "MQTT last error: %", static_cast<int>(m_mqttClient.lastError()));
   }
 }
 

src/network/MQTT.hpp

@@ -8,13 +8,13 @@
 
 #include "WifiManager.hpp"
 #include <Filesystem.hpp>
+#include <yal/yal.hpp>
+#include <yal/appender/ArduinoMQTT.hpp>
 #include <MQTT.h>
 #include <heating/RadiatorValve.hpp>
 #include <sensors/Battery.hpp>
 #include <sensors/Humidity.hpp>
 #include <sensors/Temperature.hpp>
-#include <yal/appender/ArduinoMQTT.hpp>
-#include <yal/yal.hpp>
 #include <chrono>
 #include <queue>
 
@@ -35,18 +35,15 @@ class MQTT {
       m_filesystem(filesystem),
       m_valve(valve),
       m_logger(yal::Logger("MQTT")),
-      m_mqttAppender(yal::appender::ArduinoMQTT<MQTTClient>(
-        &m_logger,
-        &m_mqttClient,
-        s_logTopic.c_str()))
+      m_mqttAppender(yal::appender::ArduinoMQTT<MQTTClient>(&m_logger, &m_mqttClient, s_logTopic.c_str()))
   {
   }
 
   ~MQTT() = default;
-  MQTT(const MQTT&) = delete;
-  MQTT(const MQTT&&) = delete;
-  MQTT& operator=(MQTT&) = delete;
-  MQTT& operator=(MQTT&&) = delete;
+  MQTT(const MQTT &) = delete;
+  MQTT(const MQTT &&) = delete;
+  MQTT &operator=(MQTT &) = delete;
+  MQTT &operator=(MQTT &&) = delete;
 
   void setup();
   bool needLoop();