minor fixes

include/pinlist.h

@@ -2,10 +2,10 @@
 
 enum RO // relay output channels
 {
-    P1 = 0,
-    P2 = 1,
-    P3 = 2,
-    P4 = 3,
+    P4 = 0,
+    P3 = 1,
+    P2 = 2,
+    P1 = 3,
     RO_4 = 4,
     FST_FLOOR = 5,
     GND_FLOOR = 6,
@@ -21,6 +21,25 @@ enum RO // relay output channels
     RO_MAX = 16 // unused to detect invalid values
 };
 
+static const std::map<const int, const char *> RO_2str = {
+    {RO::P1, "HPLimit1"},
+    {RO::P2, "HPLimit2"},
+    {RO::P3, "HPLimit3"},
+    {RO::P4, "HPLimit4"},
+    {RO::RO_4, "Out4"},
+    {RO::FST_FLOOR, "PianoPrimo"},
+    {RO::GND_FLOOR, "PianoTerra"},
+    {RO::PUMP_HT, "PompaRisc"},
+    {RO::PUMP_IRR, "PompaIrr"},
+    {RO::RETURN, "Ricircolo"},
+    {RO::ZONE1, "IrrZona1"},
+    {RO::ZONE2, "IrrZona2"},
+    {RO::ZONE3, "IrrZona3"},
+    {RO::DRIP, "IrrDrip"},
+    {RO::RO_14, "Out14"},
+    {RO::RO_15, "Out15"},
+    {RO::RO_MAX, "Invalid"}};
+
 enum DI // digital input channels
 {
     CONFRESET = 0,
@@ -28,6 +47,7 @@ enum DI // digital input channels
     DI_2 = 2,
     DI_3 = 3,
     DI_4 = 4,
+    DI_5 = 5,
     DI_6 = 6,
     OTAENABLE = 7,
     PUMP_PRESSURE = 8,
@@ -38,5 +58,25 @@ enum DI // digital input channels
     DI_13 = 13,
     DI_14 = 14,
     DI_15 = 15,
-    DI_MAX = 16
-}; // unused to detect invalid values
+    DI_MAX = 16 // unused to detect invalid values
+};
+
+static const std::map<const int, const char *> DI_2str =
+    {
+        {DI::CONFRESET, "ConfigReset"},
+        {DI::RESTART, "Restart"},
+        {DI::DI_2, "In2"},
+        {DI::DI_3, "In3"},
+        {DI::DI_4, "In4"},
+        {DI::DI_5, "In5"},
+        {DI::DI_6, "In6"},
+        {DI::OTAENABLE, "OtaEnable"},
+        {DI::PUMP_PRESSURE, "IrrPumpPressure"},
+        {DI::RAIN, "IrrRainSensor"},
+        {DI::IRR_OVERRIDE, "IrrRainOverride"},
+        {DI::DI_11, "In11"},
+        {DI::DI_12, "In12"},
+        {DI::DI_13, "In13"},
+        {DI::DI_14, "In14"},
+        {DI::DI_15, "In15"},
+        {DI::DI_MAX, "Invalid"}};

src/commands.cpp

@@ -109,13 +109,13 @@ namespace commands
         response["values"]["name"] = eventName;
 
         auto &cron = Cron::getInstance(dev);
-        if (!cron.c_statusStr2Enum.contains(statusStr))
+        if (Cron::str2Enum(statusStr) == Cron::str2Enum("INVALID"))
         {
             LOG_ERROR("setCronJob invalid status [", statusStr.c_str(), "]");
             response["values"]["status"] = "invalid";
             return response;
         }
-        cron.setEvent(eventName, cron.c_statusStr2Enum.at(statusStr));
+        cron.setEvent(eventName, Cron::str2Enum(statusStr));
         LOG_INFO("setCronJob set job [", eventName.c_str(), "] to [", statusStr.c_str(), "]");
         response["values"]["status"] = "valid";
         return response;
@@ -140,7 +140,12 @@ namespace commands
             uint8_t eventNum(0);
             for (const auto &[name, event] : eventMap)
             {
-                response["values"][name] = event.cmd;
+                ArduinoJson::JsonDocument action;
+                action["cmd"] = event.cmd;
+                action["params"] = event.cmdParams;
+                action["status"] = Cron::enum2Str(event.status);
+                action["next"] = drivers::PCF85063::tm2str(event.next);
+                response["values"][name] = action;
                 eventNum++;
             }
             LOG_INFO("getCronJob got [", eventNum, "] events");
@@ -159,7 +164,9 @@ namespace commands
         ArduinoJson::JsonDocument action;
         action["cmd"] = event.cmd;
         action["params"] = event.cmdParams;
-        response["values"]["cronExpr"] = cron::to_cronstr(event.cronExpr);
+        action["status"] = Cron::enum2Str(event.status);
+        action["next"] = drivers::PCF85063::tm2str(event.next);
+        action["cronExpr"] = cron::to_cronstr(event.cronExpr);
         response["values"]["action"] = action;
         LOG_INFO("getCronJob get job [", eventName.c_str(), "]");
         return response;
@@ -199,6 +206,15 @@ namespace commands
 
     // SETTERS //
     // SETTERS //
+    const ArduinoJson::JsonDocument Commands::resetHPcounters(const devices_t &dev, const ArduinoJson::JsonDocument &params)
+    {
+        ArduinoJson::JsonDocument response;
+        response["cmd"] = "resetHPcounters";
+        response["values"]["status"] = "valid";
+        dev.seneca.resetPartialCounters();
+        return response;
+    }
+
     const ArduinoJson::JsonDocument Commands::setHPlimit(const devices_t &dev, const ArduinoJson::JsonDocument &params)
     {
         ArduinoJson::JsonDocument response;
@@ -423,7 +439,7 @@ namespace commands
 
         response["values"]["status"] = "valid";
         response["values"]["time"] = rtc.getTimeStr();
-        LOG_INFO("setTimeNTP -> RTC is [", response["status"]["time"].as<std::string>().c_str(), "]");
+        LOG_INFO("setTimeNTP -> RTC is [", response["values"]["time"].as<std::string>().c_str(), "]");
         return response;
     }
     // SETTERS //
@@ -457,8 +473,7 @@ namespace commands
         uint8_t i(0);
         for (auto s : inStatus)
         {
-            const std::string k("DI" + std::to_string(i));
-            response["values"][k.c_str()] = s;
+            response["values"][DI_2str.at(i++)] = s;
         }
         LOG_INFO("getInputStatus ->", printBoolVec(inStatus).c_str());
         return response;
@@ -476,8 +491,7 @@ namespace commands
         uint8_t i(0);
         for (auto s : inStatus)
         {
-            const std::string k("DO" + std::to_string(i));
-            response["values"][k.c_str()] = s;
+            response["values"][RO_2str.at(i++)] = s;
         }
         LOG_INFO("getOutputStatus ->", printBoolVec(inStatus).c_str());
         return response;
@@ -549,11 +563,12 @@ namespace commands
 
         auto timeDiff = std::chrono::duration_cast<std::chrono::seconds>(ntpTimePoint - rtcTimePoint);
         auto direction = timeDiff.count() >= 0 ? "BEYOND" : "AHEAD";
+        const int32_t drift = timeDiff.count();
 
         response["values"]["status"] = "valid";
-        response["values"]["drift"] = (uint32_t)timeDiff.count();
+        response["values"]["drift"] = drift;
         response["values"]["direction"] = "RTC is [" + std::string(direction) + "] NTP time";
-        LOG_INFO("getTimeDrift -> RTC is [", (int32_t)timeDiff.count(), "] sec, [", std::string(direction).c_str(), "] NTP time");
+        LOG_INFO("getTimeDrift -> RTC is [", drift, "] sec, [", direction, "] NTP time");
         return response;
     }
     // GETTERS //

src/commands.h

@@ -61,6 +61,7 @@ namespace commands
         static const ArduinoJson::JsonDocument storeCronJob(const devices_t &dev, const ArduinoJson::JsonDocument &params);
 
         // SETTERS //
+        static const ArduinoJson::JsonDocument resetHPcounters(const devices_t &dev, const ArduinoJson::JsonDocument &params);
         static const ArduinoJson::JsonDocument setHPlimit(const devices_t &dev, const ArduinoJson::JsonDocument &params);
         static const ArduinoJson::JsonDocument setHeating(const devices_t &dev, const ArduinoJson::JsonDocument &params);
         static const ArduinoJson::JsonDocument setIrrigation(const devices_t &dev, const ArduinoJson::JsonDocument &params);
@@ -94,6 +95,7 @@ namespace commands
         {"delCronJob", Commands::delCronJob},
         {"storeCronJob", Commands::storeCronJob},
         // SETTERS
+        {"resetHPcounters", Commands::resetHPcounters},
         {"setHPlimit", Commands::setHPlimit},
         {"setHeating", Commands::setHeating},
         {"setIrrigation", Commands::setIrrigation},

src/cronjobs.cpp

@@ -4,6 +4,8 @@
 
 #define STACK_DEPTH 4096
 #define PRIORITY 3
+#define PROCESS_INTERVAL 1000
+#define PROCESS_CORE 0
 
 const bool Cron::loadEvents()
 {
@@ -22,8 +24,9 @@ const bool Cron::loadEvents()
     }
 
     std::string buf;
-    ArduinoJson::serializeJsonPretty(cronFileContent, buf);
-    LOG_INFO("Cron loadEvents loaded cronjobs.json\n", buf.c_str());
+    ArduinoJson::serializeJson(cronFileContent, buf);
+    LOG_INFO("Cron loadEvents loaded cronjobs.json");
+    LOG_INFO(buf.c_str());
 
     ArduinoJson::JsonArray cronjobList = cronFileContent.as<JsonArray>();
     LOG_INFO("Cron loadEvents loaded [", cronjobList.size(), "] events");
@@ -31,13 +34,12 @@ const bool Cron::loadEvents()
     {
         const auto &eventName = job["name"].as<std::string>();
         const auto &cronExpr = job["cronExpr"].as<std::string>();
-        const auto status = c_statusStr2Enum.at(job["status"].as<std::string>());
+        const auto status = str2Enum(job["status"].as<std::string>());
         ArduinoJson::JsonDocument action(job["action"]);
         if (!addEvent(eventName, cronExpr, action, status))
             LOG_ERROR("Cron failed to load event [", eventName.c_str(), "]");
         else
             LOG_INFO("Cron loaded event [", eventName.c_str(), "]");
-        delay(10);
     }
     cronFile.close();
     return true;
@@ -62,15 +64,16 @@ const bool Cron::storeEvents()
         ArduinoJson::JsonDocument thisJob;
         thisJob["name"] = eventName;
         thisJob["cronExpr"] = cron::to_cronstr(eventParams.cronExpr);
-        thisJob["status"] = c_statusEnum2Str.at(eventParams.status);
+        thisJob["status"] = enum2Str(eventParams.status);
         thisJob["action"]["cmd"] = eventParams.cmd;
         thisJob["action"]["params"] = eventParams.cmdParams;
         cronFileArray.add(thisJob);
     }
 
     std::string buf;
-    ArduinoJson::serializeJsonPretty(cronFileContent, buf);
-    LOG_INFO("Cron storeEvents generated cronjobs.json\n", buf.c_str());
+    ArduinoJson::serializeJson(cronFileContent, buf);
+    LOG_INFO("Cron storeEvents generated cronjobs.json");
+    LOG_INFO(buf.c_str());
 
     ArduinoJson::serializeJson(cronFileContent, cronFile);
     cronFile.close();
@@ -129,7 +132,7 @@ const bool Cron::setEvent(const std::string &name, const CronStatus status)
         LOG_ERROR("Cron event [", name.c_str(), "] does not exist");
         return false;
     }
-    LOG_INFO("Cron set event [", name.c_str(), "] status [", c_statusEnum2Str.at(status).c_str(), "]");
+    LOG_INFO("Cron set event [", name.c_str(), "] status [", enum2Str(status).c_str(), "]");
     m_cronMap.at(name).status = status;
     return true;
 }
@@ -171,7 +174,7 @@ void cronLoop(void *cronPtr)
     while (true)
     {
         cron.processEvents();
-        delay(1000);
+        delay(PROCESS_INTERVAL);
     }
 }
 
@@ -180,7 +183,11 @@ void Cron::startCron()
     if (!m_cronTaskHandle)
     {
         LOG_INFO("Cron starting loop");
-        xTaskCreate(cronLoop, "cronLoop", STACK_DEPTH, this, PRIORITY, &m_cronTaskHandle);
+        if (xTaskCreatePinnedToCore(cronLoop, "cronLoop", STACK_DEPTH, this, PRIORITY, &m_cronTaskHandle, PROCESS_CORE) != pdPASS)
+        {
+            LOG_ERROR("Cron failed to start loop");
+            m_cronTaskHandle = NULL;
+        }
     }
 }
 
@@ -225,7 +232,7 @@ const bool Cron::processEvents()
             resp["values"]["name"] = eventName;
             resp["values"]["now"] = drivers::PCF85063::tm2str(nowTm).c_str();
             resp["values"]["next"] = drivers::PCF85063::tm2str(eventParams.next).c_str();
-            resp["values"]["status"] = c_statusEnum2Str.at(eventParams.status).c_str();
+            resp["values"]["status"] = enum2Str(eventParams.status).c_str();
             switch (eventParams.status)
             {
             case CronStatus::ACTIVE:

src/cronjobs.h

@@ -13,25 +13,29 @@
 #include <filesystem>
 #include <croncpp.h>
 
-class Cron
-{
-public:
-    enum class CronStatus
+enum class CronStatus
     {
         ACTIVE,
         INACTIVE,
-        SKIP
+        SKIP,
+        INVALID
     };
 
-    const std::map<CronStatus, std::string> c_statusEnum2Str = {
-        {CronStatus::ACTIVE, "ACTIVE"},
-        {CronStatus::INACTIVE, "INACTIVE"},
-        {CronStatus::SKIP, "SKIP"}};
+static const std::map<const CronStatus, std::string> c_statusEnum2Str = {
+    {CronStatus::ACTIVE, "ACTIVE"},
+    {CronStatus::INACTIVE, "INACTIVE"},
+    {CronStatus::SKIP, "SKIP"},
+    {CronStatus::INVALID, "INVALID"}};
 
-    const std::map<std::string, CronStatus> c_statusStr2Enum = {
-        {"ACTIVE", CronStatus::ACTIVE},
-        {"INACTIVE", CronStatus::INACTIVE},
-        {"SKIP", CronStatus::SKIP}};
+static const std::map<const std::string, CronStatus> c_statusStr2Enum = {
+    {"ACTIVE", CronStatus::ACTIVE},
+    {"INACTIVE", CronStatus::INACTIVE},
+    {"SKIP", CronStatus::SKIP},
+    {"INVALID", CronStatus::INVALID}};
+
+class Cron
+{
+public:
     
     struct CronEvent
     {
@@ -75,6 +79,20 @@ public:
     void stopCron();
     const bool processEvents();
 
+    static const std::string enum2Str(const CronStatus status)
+    {
+        if (!c_statusEnum2Str.contains(status))
+            return "INVALID";
+        return c_statusEnum2Str.at(status);
+    }
+
+    static const CronStatus str2Enum(const std::string &status)
+    {
+        if (!c_statusStr2Enum.contains(status))
+            return CronStatus::INVALID;
+        return c_statusStr2Enum.at(status);
+    }
+
 private:
     const devices_t &m_dev;
     CronCallback m_callback;

src/mqtt.cpp

@@ -3,6 +3,7 @@
 #define STACK_DEPTH 8192
 #define BUFFER_SIZE 2048
 #define PRIORITY 2
+#define PROCESS_CORE 1
 
 MQTTwrapper::MQTTwrapper() : m_config(Config::getInstance()), m_tcp(NetworkClient()), m_client(PubSubClient(m_tcp)), m_loopHandle(NULL)
 {
@@ -27,7 +28,11 @@ const bool MQTTwrapper::connect()
     LOG_INFO("MQTT client connected to", m_config.m_mqttHost.c_str());
     if (m_loopHandle == NULL)
     {
-        xTaskCreate(clientLoop, "mqttLoop", STACK_DEPTH, this, PRIORITY, &m_loopHandle);
+        if (xTaskCreatePinnedToCore(clientLoop, "mqttLoop", STACK_DEPTH, this, PRIORITY, &m_loopHandle, PROCESS_CORE) != pdPASS)
+        {
+            m_loopHandle = NULL;
+            return false;
+        }
         m_client.setCallback(MQTTwrapper::callback);
     }
     return true;

src/ota.cpp

@@ -2,6 +2,7 @@
 
 #define STACK_DEPTH 4096
 #define TASK_PRIORITY 2
+#define PROCESS_CORE 1
 
 OTA::OTA(const devices_t &dev) : m_dev(dev), m_taskHandle(NULL), m_updating(false), m_prevPercent(0)
 {
@@ -26,10 +27,11 @@ void OTA::begin()
     ArduinoOTA.onEnd(s_onEnd);
     ArduinoOTA.onProgress(s_onProgress);
     ArduinoOTA.onError(s_onError);
-    if (xTaskCreate(handle, "otaUpdate", STACK_DEPTH, this, TASK_PRIORITY, &m_taskHandle) != pdPASS)
+    if (xTaskCreatePinnedToCore(handle, "otaUpdate", STACK_DEPTH, this, TASK_PRIORITY, &m_taskHandle, PROCESS_CORE) != pdPASS)
     {
         m_taskHandle = NULL;
         LOG_ERROR("OTA failed to create handle task");
+        return;
     }
     ArduinoOTA.begin(); // start the OTA server
     m_dev.led.blinkAlternate(100, 100, m_dev.led.COLOR_ORANGE, m_dev.led.COLOR_SKYBLUE);
@@ -72,6 +74,7 @@ void OTA::onProgress(const uint32_t progress, const uint32_t total)
         m_prevPercent = percent;
     }
 }
+
 void OTA::onStart()
 {
     LOG_WARN("OTA update started");
@@ -81,6 +84,7 @@ void OTA::onStart()
     m_dev.led.setEnforce(true);
     m_prevPercent = 0;
 }
+
 void OTA::onEnd()
 {
     LOG_WARN("OTA update end");
@@ -89,6 +93,7 @@ void OTA::onEnd()
     m_dev.led.blinkAlternate(50, 50, m_dev.led.COLOR_GREEN, m_dev.led.COLOR_YELLOW);
     m_dev.led.setEnforce(true);
 }
+
 void OTA::onError(const ota_error_t err)
 {
     LOG_ERROR("OTA Error [", err, "]");