formatting

Now it compiles with test main code

.gitignore

@@ -91,7 +91,7 @@ dkms.conf
 .vscode/*
 !.vscode/settings.json
 !.vscode/tasks.json
-!.vscode/launch.json
+#!.vscode/launch.json
 !.vscode/extensions.json
 !.vscode/*.code-snippets
 

.vscode/launch.json

@@ -1,44 +0,0 @@
-// AUTOMATICALLY GENERATED FILE. PLEASE DO NOT MODIFY IT MANUALLY
-//
-// PlatformIO Debugging Solution
-//
-// Documentation: https://docs.platformio.org/en/latest/plus/debugging.html
-// Configuration: https://docs.platformio.org/en/latest/projectconf/sections/env/options/debug/index.html
-
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "platformio-debug",
-            "request": "launch",
-            "name": "PIO Debug",
-            "executable": "C:/Users/ematr/Documents/VScode/ETcontroller_PRO/.pio/build/esp32-s3-waveshare8/firmware.elf",
-            "projectEnvName": "esp32-s3-waveshare8",
-            "toolchainBinDir": "C:/Users/ematr/.platformio/packages/toolchain-xtensa-esp-elf/bin",
-            "internalConsoleOptions": "openOnSessionStart",
-            "preLaunchTask": {
-                "type": "PlatformIO",
-                "task": "Pre-Debug"
-            }
-        },
-        {
-            "type": "platformio-debug",
-            "request": "launch",
-            "name": "PIO Debug (skip Pre-Debug)",
-            "executable": "C:/Users/ematr/Documents/VScode/ETcontroller_PRO/.pio/build/esp32-s3-waveshare8/firmware.elf",
-            "projectEnvName": "esp32-s3-waveshare8",
-            "toolchainBinDir": "C:/Users/ematr/.platformio/packages/toolchain-xtensa-esp-elf/bin",
-            "internalConsoleOptions": "openOnSessionStart"
-        },
-        {
-            "type": "platformio-debug",
-            "request": "launch",
-            "name": "PIO Debug (without uploading)",
-            "executable": "C:/Users/ematr/Documents/VScode/ETcontroller_PRO/.pio/build/esp32-s3-waveshare8/firmware.elf",
-            "projectEnvName": "esp32-s3-waveshare8",
-            "toolchainBinDir": "C:/Users/ematr/.platformio/packages/toolchain-xtensa-esp-elf/bin",
-            "internalConsoleOptions": "openOnSessionStart",
-            "loadMode": "manual"
-        }
-    ]
-}

data/example.json

@@ -0,0 +1,3 @@
+{
+    "data": "value"
+}

docs/commands.json

@@ -0,0 +1,101 @@
+[
+    {
+        "cmd": "setHPlimit",
+        "params": {
+            "level": [
+                "UNLIMITED",
+                "P1",
+                "P2",
+                "P3",
+                "P4"
+            ]
+        }
+    },
+    {
+        "cmd": "setHeating",
+        "params": {
+            "pump": [
+                "ON",
+                "OFF"
+            ],
+            "ground": [
+                "ON",
+                "OFF"
+            ],
+            "first": [
+                "ON",
+                "OFF"
+            ]
+        }
+    },
+    {
+        "cmd": "getHPpower",
+        "params": null
+    },
+    {
+        "cmd": "getHPlimit",
+        "params": null
+    },
+    {
+        "cmd": "getInputStatus",
+        "params": null
+    },
+    {
+        "cmd": "getOutputStatus",
+        "params": null
+    },
+    {
+        "cmd": "getTemperatures",
+        "params": null
+    },
+    {
+        "cmd": "getWaterInfo",
+        "params": null
+    },
+    {
+        "cmd": "getTankLevel",
+        "params": null
+    },
+    {
+        "cmd": "getRainInfo",
+        "params": null
+    },
+    {
+        "cmd": "setIrrigation",
+        "params": {
+            "zone": [
+                "Ricircolo",
+                "1",
+                "2",
+                "3",
+                "Rubinetti"
+            ],
+            "timeOn": 120,
+            "timePause": 2
+        }
+    },
+    {
+        "cmd": "getIrrigation",
+        "params": null
+    },
+    {
+        "cmd": "setCronJob",
+        "params": {
+            "name": "nomedeljob",
+            "timeStr": "* * * 10,45 5 *",
+            "action": "qua ci va un dizionario come se arrivasse da mqtt, cosi li interpreto alla stessa maniera"
+        }
+    },
+    {
+        "cmd": "getCronJob",
+        "params": {
+            "name": "nomedeljob"
+        }
+    },
+    {
+        "cmd": "delCronJob",
+        "params": {
+            "name": "nomedeljob"
+        }
+    }
+]

docs/response.json

@@ -0,0 +1,123 @@
+[
+    {
+        "cmd": "POLL",
+        "values": {
+            "number": 1234,
+            "date": "20250810-123512"
+        }
+    },
+    {
+        "cmd": "getHPpower",
+        "values": {
+            "power": 3200,
+            "current": 16,
+            "energy": 12341234
+        }
+    },
+    {
+        "cmd": "getHPlimit",
+        "values": {
+            "level": [
+                "UNLIMITED",
+                "P1",
+                "P2",
+                "P3",
+                "P4"
+            ]
+        }
+    },
+    {
+        "cmd": "getInputStatus",
+        "values": {
+            "rain": [
+                "ON",
+                "OFF"
+            ],
+            "waterPressure": [
+                "ON",
+                "OFF"
+            ]
+        }
+    },
+    {
+        "cmd": "getOutputStatus",
+        "values": {
+            "pump": [
+                "ON",
+                "OFF"
+            ],
+            "ground": [
+                "ON",
+                "OFF"
+            ],
+            "first": [
+                "ON",
+                "OFF"
+            ]
+        }
+    },
+    {
+        "cmd": "getTemperatures",
+        "values": {
+            "solar": 1234,
+            "acs": 1234,
+            "heating": 1234
+        }
+    },
+    {
+        "cmd": "getWaterInfo",
+        "values": {
+            "flow": 1234,
+            "consumption": 1234,
+            "temperature": 1234
+        }
+    },
+    {
+        "cmd": "getTankLevel",
+        "values": {
+            "level": 10
+        }
+    },
+    {
+        "cmd": "getRainInfo",
+        "values": {
+            "rain": [
+                "ON",
+                "OFF"
+            ]
+        }
+    },
+    {
+        "cmd": "getIrrigation",
+        "values": {
+            "Ricircolo": [
+                "ON",
+                "OFF"
+            ],
+            "1": [
+                "ON",
+                "OFF"
+            ],
+            "2": [
+                "ON",
+                "OFF"
+            ],
+            "3": [
+                "ON",
+                "OFF"
+            ],
+            "Rubinetti": [
+                "ON",
+                "OFF"
+            ]
+        }
+    },
+    {
+        "cmd": "getCronJob",
+        "values": {
+            "name": "nomedeljob",
+            "timeStr": "* * * 10,45 5 *",
+            "action": "dizionario che dice cosa deve fare come e' salvato nel micro"
+        }
+    }
+]

fatfs_partition.csv

@@ -0,0 +1,6 @@
+# Name,   Type, SubType, Offset,  Size, Flags
+nvs,      data, nvs,     0x9000,  0x5000,
+otadata,  data, ota,     0xe000,  0x2000,
+app0,     app,  ota_0,   0x10000, 0x300000,
+app1,     app,  ota_1,   0x310000,0x300000,
+ffat,     data, fat,     0x610000,0x9E0000,

include/config.h

@@ -0,0 +1,316 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_DEBUG
+
+#include <DebugLog.h>
+#include <Arduino.h>
+#include <ArduinoJson.h>
+#include <FFat.h>
+
+#include <mutex>
+
+class FSmount
+{
+public:
+    FSmount()
+    {
+        if (!FFat.begin(false))
+        {
+            LOG_ERROR("Unable to mount filesystem without formatting");
+            if (!FFat.begin(true))
+            {
+                LOG_ERROR("Formatted and mounted filesystem");
+            }
+        }
+
+        LOG_INFO("Local Filesystem Mounted Correctly");
+        const auto totalBytes = FFat.totalBytes();
+        const auto freeBytes = FFat.freeBytes();
+        const auto usedBytes = FFat.usedBytes();
+        const auto mountPoint = FFat.mountpoint();
+        LOG_INFO("Local filesystem, total", totalBytes / 1024, "KB - used", usedBytes / 1024, "KB - free", freeBytes / 1024, "KB");
+        LOG_INFO("Local filesystem, mountpoint", mountPoint);
+    }
+
+    ~FSmount()
+    {
+        FFat.end(); // unmout filesystem to avoid corruption
+        LOG_INFO("Local Filesystem Unmounted Correctly");
+    }
+};
+
+class Config
+{
+
+public:
+    static Config &getInstance()
+    {
+        static Config instance;
+        return instance;
+    }
+
+private:
+    Config() = default;
+    Config(const Config &) = delete;
+    Config &operator=(const Config &) = delete;
+
+public:
+    void init()
+    {
+        FSmount mount; // scoped mount of the filesystem
+
+        // Initialize and mount filesystem
+        LOG_INFO("Initializing Config");
+
+        if (!FFat.exists("/config.json"))
+        {
+            LOG_WARN("Initializing default config");
+            saveConfig();
+        }
+
+        File file = FFat.open("/config.json", FILE_READ, false);
+        if (!file)
+        {
+            LOG_ERROR("Unable to open config.json");
+            return;
+        }
+
+        if (ArduinoJson::deserializeJson(m_configJson, file) != ArduinoJson::DeserializationError::Ok)
+        {
+            LOG_ERROR("Unable to load config.json");
+        }
+
+        std::string loadedConf;
+        ArduinoJson::serializeJsonPretty(m_configJson, loadedConf);
+        LOG_INFO("Loaded Configuration\n", loadedConf.c_str());
+
+        deserialize(); // convert from json format to class members
+        file.close();  // close config file before unmounting filesystem
+    };
+
+    void updateConfig(ArduinoJson::JsonDocument &json)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        {
+            FSmount mount;
+            m_configJson = json;
+            deserialize();
+            saveConfig();
+        }; // filesystem is unmounted here
+        delay(500);
+        esp_restart(); // configuration updates trigger a cpu restart
+    }
+
+    void resetConfig()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        {
+            FSmount mount;
+            LOG_WARN("Removing config.json");
+            if (!FFat.remove("/config.json"))
+            {
+                LOG_ERROR("Unable to remove config.json");
+            }
+            LOG_WARN("Configuration reset, Restarting");
+        }; // filesystem is unmounted here
+        delay(500);
+        esp_restart();
+    }
+
+private:
+    void saveConfig() // write configuration to flash memory
+    {
+        File file = FFat.open("/config.json", FILE_WRITE, true);
+        if (!file)
+        {
+            LOG_ERROR("Unable to open config.json for writing");
+            return;
+        }
+        serialize(); // serialize default configuration
+        if (ArduinoJson::serializeJson(m_configJson, file) == 0)
+        {
+            LOG_ERROR("Serialization Failed");
+        }
+        file.close();
+    }
+
+    //////////////////////////////////////////////////////////////
+    ////////////// SERIALIZATION + DESERIALIZATION ///////////////
+    //////////////////////////////////////////////////////////////
+
+    void serialize()
+    {
+        // form class members to json document
+        {
+            auto globals = m_configJson["globals"].to<ArduinoJson::JsonObject>();
+            globals["loopDelay"] = m_globalLoopDelay;
+        };
+
+        {
+            auto ethernet = m_configJson["ethernet"].to<ArduinoJson::JsonObject>();
+            ethernet["hostname"] = m_ethHostname;
+            ethernet["ipAddr"] = m_ethIpAddr;
+            ethernet["netmask "] = m_ethNetmask;
+            ethernet["gateway "] = m_ethGateway;
+        };
+
+        {
+            auto modbus = m_configJson["modbus"].to<ArduinoJson::JsonObject>();
+            modbus["relayAddr"] = m_modbusRelayAddr;
+            modbus["temperatureAddr"] = m_modbusTemperatureAddr;
+            modbus["senecaAddr"] = m_modbusSenecaAddr;
+            modbus["flowmeterAddr"] = m_modbusFlowmeterAddr;
+            modbus["tankLevelAddr"] = m_modbusTankLevelAddr;
+        };
+
+        {
+            auto temperature = m_configJson["temperature"].to<ArduinoJson::JsonObject>();
+            temperature["expectedSensors"] = m_tempExpectedSensors;
+            auto values = temperature["correctionValues"].to<ArduinoJson::JsonArray>();
+            for (auto v : m_tempCorrectionValues)
+            {
+                values.add(v);
+            }
+        };
+
+        {
+            auto ntp = m_configJson["ntp"].to<ArduinoJson::JsonObject>();
+            ntp["pool"] = m_ntpPool;
+            ntp["timezone"] = m_ntpTimezone;
+            ntp["updateInterval"] = m_ntpUpdateInterval;
+            ntp["retries"] = m_ntpRetries;
+        };
+
+        {
+            auto mqtt = m_configJson["mqtt"].to<ArduinoJson::JsonObject>();
+            mqtt["host"] = m_mqttHost;
+            mqtt["port"] = m_mqttPort;
+            mqtt["loopTime"] = m_mqttLoopTime;
+            mqtt["clientName"] = m_mqttClientName;
+            mqtt["retries"] = m_mqttRetries;
+            auto publish = mqtt["publish"].to<ArduinoJson::JsonObject>();
+            for (auto v : m_mqttSubscribe)
+            {
+                publish[v.first] = v.second;
+            }
+            auto subscribe = mqtt["subscribe"].to<ArduinoJson::JsonObject>();
+            for (auto v : m_mqttPublish)
+            {
+                subscribe[v.first] = v.second;
+            }
+        };
+    };
+
+    void deserialize()
+    { // from json document to class members
+        if (m_configJson.isNull())
+        {
+            LOG_ERROR("NUll config document");
+            return;
+        }
+
+        {
+            auto globals = m_configJson["globals"];
+            m_globalLoopDelay = globals["loopDelay"].as<uint16_t>();
+        };
+
+        {
+            auto ethernet = m_configJson["ethernet"];
+            m_ethHostname = ethernet["hostname"].as<std::string>();
+            m_ethIpAddr = ethernet["ipAddr"].as<std::string>();
+            m_ethNetmask = ethernet["netmask"].as<std::string>();
+            m_ethGateway = ethernet["gateway"].as<std::string>();
+        };
+
+        {
+            auto modbus = m_configJson["modbus"];
+            m_modbusRelayAddr = modbus["relayAddr"].as<uint8_t>();
+            m_modbusTemperatureAddr = modbus["temperatureAddr"].as<uint8_t>();
+            m_modbusSenecaAddr = modbus["senecaAddr"].as<uint8_t>();
+            m_modbusFlowmeterAddr = modbus["flowmeterAddr"].as<uint8_t>();
+            m_modbusTankLevelAddr = modbus["tankLevelAddr"].as<uint8_t>();
+        };
+
+        {
+            auto temperature = m_configJson["temperature"];
+            m_tempExpectedSensors = temperature["expectedSensors"].as<uint8_t>();
+            auto values = temperature["correctionValues"].as<JsonArray>();
+            m_tempCorrectionValues.reserve(values.size());
+            for (auto v : values)
+            {
+                m_tempCorrectionValues.push_back(v.as<float>());
+            }
+        };
+
+        {
+            auto ntp = m_configJson["ntp"];
+            m_ntpPool = ntp["pool"].as<std::string>();
+            m_ntpTimezone = ntp["timezone"].as<uint16_t>();
+            m_ntpUpdateInterval = ntp["updateInterval"].as<uint16_t>();
+            m_ntpRetries = ntp["retries"].as<uint8_t>();
+        };
+
+        {
+            auto mqtt = m_configJson["mqtt"];
+            m_mqttHost = mqtt["host"].as<std::string>();
+            m_mqttPort = mqtt["port"].as<uint16_t>();
+            m_mqttLoopTime = mqtt["loopTime"].as<uint16_t>();
+            m_mqttRetries = mqtt["retries"].as<uint16_t>();
+            auto subscribe = mqtt["subsribe"].as<ArduinoJson::JsonObject>();
+            for (auto v : subscribe)
+            {
+                m_mqttSubscribe[v.key().c_str()] = v.value().as<std::string>();
+            }
+            auto publish = mqtt["publish"].as<ArduinoJson::JsonObject>();
+            for (auto v : publish)
+            {
+                m_mqttPublish[v.key().c_str()] = v.value().as<std::string>();
+            }
+        };
+    };
+
+private:
+    ArduinoJson::JsonDocument m_configJson;
+    std::mutex m_mutex;
+
+public:
+    // Globals
+    std::uint16_t m_globalLoopDelay = 1000; // in milliseconds
+
+    // Ethernet
+    std::string m_ethHostname = "ETcontroller_PRO";
+    std::string m_ethIpAddr = "10.0.2.251";
+    std::string m_ethNetmask = "255.255.255.0";
+    std::string m_ethGateway = "10.0.2.1";
+
+    // MODBUS
+    uint8_t m_modbusRelayAddr = 0x01;
+    uint8_t m_modbusTemperatureAddr = 0xAA;
+    uint8_t m_modbusSenecaAddr = 0xBB;
+    uint8_t m_modbusFlowmeterAddr = 0xCC;
+    uint8_t m_modbusTankLevelAddr = 0xDD;
+
+    // Temperature Board
+    uint8_t m_tempExpectedSensors = 1;
+    std::vector<float> m_tempCorrectionValues = std::vector<float>(8, 0.0f);
+
+    // NTP
+    std::string m_ntpPool = "pool.ntp.org";
+    uint16_t m_ntpTimezone = 3600;       // GTM +1
+    uint16_t m_ntpUpdateInterval = 3600; // every hour
+    uint8_t m_ntpRetries = 5;
+
+    // MQTT
+    std::string m_mqttHost = "10.0.2.249";
+    uint16_t m_mqttPort = 1883;
+    uint16_t m_mqttLoopTime = 100; // in milliseconds
+    uint8_t m_mqttRetries = 5;
+    std::string m_mqttClientName = "etcontrollerPRO";
+
+    std::map<const std::string, std::string> m_mqttSubscribe = {
+        {"commands", "test/etcontroller/commands"}};
+    std::map<const std::string, std::string> m_mqttPublish = {
+        {"heatpump", "test/etcontroller/heatpump"},
+        {"temperature", "test/etcontroller/temperatures"},
+        {"irrigation", "test/etcontroller/irrigation"}};
+};

lib/ETH/ETH_Driver.cpp

@@ -0,0 +1,72 @@
+#include "ETH_Driver.h"
+
+namespace drivers
+{
+
+    Ethernet::Ethernet(const std::string hostname) : m_hostname(hostname), m_connected(false), m_localIP(IPAddress()), m_udp(NetworkUDP()), m_timeClient(m_udp)
+    {
+        SPI.begin(ETH_SPI_SCK, ETH_SPI_MISO, ETH_SPI_MOSI);
+        ETH.begin(ETH_PHY_TYPE, ETH_PHY_ADDR, ETH_PHY_CS, ETH_PHY_IRQ, ETH_PHY_RST, SPI);
+
+        m_timeClient = std::move(NTPClient(m_udp, "pool.ntp.org", 0, 3600)); // NTP server, time offset in seconds, update interval
+        m_timeClient.begin();
+    }
+
+    Ethernet::~Ethernet()
+    {
+        m_timeClient.end();
+        ETH.end();
+        SPI.end();
+    }
+
+    const bool Ethernet::getNtpTime(time_t &time)
+    {
+        if (m_connected && m_timeClient.update())
+        {
+            time = m_timeClient.getEpochTime();
+            LOG_DEBUG("Epoch Time:", (long)time);
+            return true;
+        }
+        return false;
+    }
+
+    const bool Ethernet::isConnected()
+    {
+        return m_connected;
+    }
+
+    void Ethernet::onEvent(arduino_event_id_t event, arduino_event_info_t info)
+    {
+        switch (event)
+        {
+        case ARDUINO_EVENT_ETH_START:
+            ETH.setHostname("waveshare-esp32s3");
+            break;
+        case ARDUINO_EVENT_ETH_CONNECTED:
+            LOG_INFO("ETH Connected");
+            break;
+        case ARDUINO_EVENT_ETH_GOT_IP:
+            m_localIP = ETH.localIP();
+            LOG_INFO("ETH ", esp_netif_get_desc(info.got_ip.esp_netif), " Got IP:", m_localIP.toString().c_str());
+            LOG_INFO("ETH ", esp_netif_get_desc(info.got_ip.esp_netif), " Gateway:", ETH.gatewayIP().toString().c_str());
+            LOG_INFO("ETH ", esp_netif_get_desc(info.got_ip.esp_netif), " Netmask:", ETH.subnetMask().toString().c_str());
+            m_connected = true;
+            break;
+        case ARDUINO_EVENT_ETH_LOST_IP:
+            LOG_INFO("ETH Lost IP");
+            m_connected = false;
+            break;
+        case ARDUINO_EVENT_ETH_DISCONNECTED:
+            LOG_INFO("ETH Disconnected");
+            m_connected = false;
+            break;
+        case ARDUINO_EVENT_ETH_STOP:
+            LOG_INFO("ETH Stopped");
+            m_connected = false;
+            break;
+        default:
+            break;
+        }
+    }
+
+}

lib/ETH/ETH_Driver.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <DebugLog.h>
+#include <Arduino.h>
+#include <Network.h>
+#include <NTPClient.h>
+#include <ETH.h>
+#include <SPI.h>
+
+// PHY defines hardware related
+#ifndef ETH_PHY_TYPE
+#define ETH_PHY_TYPE ETH_PHY_W5500
+#define ETH_PHY_ADDR 1
+#define ETH_PHY_CS 16
+#define ETH_PHY_IRQ 12
+#define ETH_PHY_RST 39
+#endif
+
+// SPI pins
+#define ETH_SPI_SCK 15
+#define ETH_SPI_MISO 14
+#define ETH_SPI_MOSI 13
+
+namespace drivers
+{
+
+    class Ethernet : public ETHClass
+    {
+
+    public:
+        Ethernet(const std::string hostname);
+        ~Ethernet();
+
+        void onEvent(arduino_event_id_t event, arduino_event_info_t info);
+        const bool isConnected();
+        const bool getNtpTime(time_t &time);
+
+    private:
+        const std::string m_hostname;
+        bool m_connected;
+        NetworkUDP m_udp;
+        IPAddress m_localIP;
+        NTPClient m_timeClient;
+    };
+
+}

lib/GPIO/BUZZER_Driver.cpp

@@ -0,0 +1,70 @@
+#include <BUZZER_Driver.h>
+
+#define TASK_PRIORITY 20
+#define TASK_STACK    2048
+#define OCTAVE        6
+
+namespace drivers
+{
+
+    Buzzer::Buzzer()
+    {
+        LOG_INFO("Initializing Beeper");
+        pinMode(c_buzzerPin, OUTPUT);
+        ledcAttach(c_buzzerPin, 1000, 8);
+        m_bp.pin = c_buzzerPin;
+        m_bp.beeperTask = NULL;
+        beep(50, NOTE_G);
+    }
+
+    Buzzer::~Buzzer()
+    {
+        beepStop();
+        ledcDetach(c_buzzerPin);
+        pinMode(c_buzzerPin, INPUT);
+    }
+
+    void Buzzer::beep(const uint16_t tBeep, const note_t note)
+    {
+        beepStop();
+        m_bp.tOn = tBeep;
+        m_bp.tOff = 0;
+        m_bp.note = note;
+        xTaskCreate(beepTask, "beeper", TASK_STACK, static_cast<void *>(&m_bp), TASK_PRIORITY, &m_bp.beeperTask);
+    }
+    
+    void Buzzer::beepRepeat(const uint16_t tOn, const uint16_t tOff, const note_t note)
+    {
+        beepStop();
+        m_bp.tOn = tOn;
+        m_bp.tOff = tOff;
+        m_bp.note = note;
+        xTaskCreate(beepTask, "beeper", TASK_STACK, static_cast<void *>(&m_bp), TASK_PRIORITY, &m_bp.beeperTask);     
+    }
+
+    void Buzzer::beepStop()
+    {
+        if (m_bp.beeperTask != NULL)
+            vTaskDelete(m_bp.beeperTask);
+        ledcWriteTone(m_bp.pin, 0); // off
+        m_bp.beeperTask = NULL;
+    }
+    
+    void Buzzer::beepTask(void *params)
+    {
+        LOG_DEBUG("Beeper Task Created");
+        beep_params_t *bPar = static_cast<beep_params_t *>(params);
+        while (true)
+        {
+            ledcWriteNote(bPar->pin, bPar->note, OCTAVE); // on with selected note
+            delay(bPar->tOn);
+            ledcWriteTone(bPar->pin, 0); // off
+            if (bPar->tOff == 0)
+                break;
+            delay(bPar->tOff);
+        }
+        LOG_DEBUG("Beeper Task Ended");
+        bPar->beeperTask = NULL;
+        vTaskDelete(NULL);
+    }
+}

lib/GPIO/BUZZER_Driver.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <Arduino.h>
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+#include <DebugLog.h>
+
+namespace drivers
+{
+
+    class Buzzer
+    {
+        const uint8_t c_buzzerPin = 46; // hardware assigned
+        
+        typedef struct
+        {
+            note_t note;
+            uint8_t pin;
+            uint16_t tOn;
+            uint16_t tOff;
+            TaskHandle_t beeperTask;
+        } beep_params_t;
+
+    public:
+        Buzzer();
+        ~Buzzer();
+
+        void beep(const uint16_t tBeep, const note_t note);
+        void beepRepeat(const uint16_t tOn, const uint16_t tOff, const note_t note);
+        void beepStop();
+
+    private:
+        static void beepTask(void *params);
+
+    private:
+        beep_params_t m_bp;
+    };
+
+}

lib/GPIO/LED_Driver.cpp

@@ -0,0 +1,75 @@
+#include <LED_Driver.h>
+
+#define TASK_PRIORITY 20
+#define TASK_STACK 2048
+
+namespace drivers
+{
+
+    Led::Led()
+    {
+        LOG_INFO("Inizializing RGB Led");
+        pinMode(c_ledPin, OUTPUT);
+        m_lp.pin = c_ledPin;
+        m_lp.blinkTask = NULL;
+    }
+
+    Led::~Led()
+    {
+        setColor({0, 0, 0});
+        pinMode(c_ledPin, INPUT);
+    }
+
+    void Led::setColor(const color_t color)
+    {
+        blinkStop();
+        rgbLedWrite(c_ledPin, color.r, color.g, color.b);
+    }
+
+    void Led::blinkColor(const uint16_t tOn, const uint16_t tOff, const color_t color)
+    {
+        blinkStop();
+        m_lp.color1 = color;
+        m_lp.color2 = {0, 0, 0};
+        m_lp.tOn = tOn;
+        m_lp.tOff = tOff;
+        xTaskCreate(blinkTask, "blinker", TASK_STACK, static_cast<void *>(&m_lp), TASK_PRIORITY, &m_lp.blinkTask);
+    }
+
+    void Led::blinkAlternate(const uint16_t tOn, const uint16_t tOff, const color_t color1, const color_t color2)
+    {
+        {
+            blinkStop();
+            m_lp.color1 = color1;
+            m_lp.color2 = color2;
+            m_lp.tOn = tOn;
+            m_lp.tOff = tOff;
+            xTaskCreate(blinkTask, "blinker", TASK_STACK, static_cast<void *>(&m_lp), TASK_PRIORITY, &m_lp.blinkTask);
+        }
+    }
+
+    void Led::blinkStop()
+    {
+        if (m_lp.blinkTask != NULL)
+            vTaskDelete(m_lp.blinkTask);
+        m_lp.blinkTask = NULL;
+    }
+
+    void Led::blinkTask(void *params)
+    {
+        LOG_DEBUG("Blinker Task Created");
+        led_params_t *lPar = static_cast<led_params_t *>(params);
+        while (true)
+        {
+            rgbLedWrite(lPar->pin, lPar->color1.g, lPar->color1.r, lPar->color1.b);
+            delay(lPar->tOn);
+            rgbLedWrite(lPar->pin, lPar->color2.g, lPar->color2.r, lPar->color2.b); // off
+            if (lPar->tOff == 0)
+                break;
+            delay(lPar->tOff);
+        }
+        LOG_DEBUG("Blinker Task Ended");
+        lPar->blinkTask = NULL;
+        vTaskDelete(NULL);
+    }
+}

lib/GPIO/LED_Driver.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <Arduino.h>
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+#include <DebugLog.h>
+
+namespace drivers
+{
+
+    class Led
+    {
+        const uint8_t c_ledPin = 38;
+
+    public:
+        typedef struct
+        {
+            uint8_t r;
+            uint8_t g;
+            uint8_t b;
+        } color_t;
+
+    private:
+        typedef struct
+        {
+            color_t color1;
+            color_t color2;
+            uint8_t pin;
+            uint16_t tOn;
+            uint16_t tOff;
+            TaskHandle_t blinkTask;
+        } led_params_t;
+
+    public:
+        Led();
+        ~Led();
+
+        void setColor(const color_t color);
+        void blinkColor(const uint16_t tOn, const uint16_t tOff, const color_t color);
+        void blinkAlternate(const uint16_t tOn, const uint16_t tOff, const color_t color1, const color_t color2);
+        void blinkStop();
+
+    private:
+        static void blinkTask(void *params);
+
+    private:
+        led_params_t m_lp;
+    };
+
+}

lib/GPIO/TCA9554PWR_Driver.cpp

@@ -0,0 +1,85 @@
+#include "TCA9554PWR_Driver.h"
+
+namespace drivers
+{
+
+  TCA9554PWR::TCA9554PWR(I2C &i2c, const uint8_t address) : m_i2c(i2c), m_address(address)
+  {
+    writeRegister(TCA9554_OUTPUT_REG, Low);              // set all pins to Low state
+    writeRegister(TCA9554_CONFIG_REG, TCA9554_OUT_MODE); // set all pins as output (relay mode for this board)
+  }
+
+  TCA9554PWR::~TCA9554PWR() {
+    writeRegister(TCA9554_OUTPUT_REG, Low);              // set all pins to Low state
+    writeRegister(TCA9554_CONFIG_REG, TCA9554_OUT_MODE); // set all pins as output (relay mode for this board)
+  }
+
+  const bool TCA9554PWR::writeRegister(const uint8_t reg, const uint8_t val)
+  {
+    if (m_i2c.write(m_address, reg, {val}))
+      return true;
+    LOG_ERROR("Unable to write register: reg[%d], val[%d] ", reg, val);
+    return false;
+  }
+
+  const bool TCA9554PWR::readRegister(const uint8_t reg, uint8_t &val)
+  {
+    std::vector<uint8_t> data;
+    if (m_i2c.read(m_address, reg, 1, data))
+    {
+      val = data.back();
+      return true;
+    }
+    LOG_ERROR("Unable to read register: reg[%d]");
+    return false;
+  }
+
+  const bool TCA9554PWR::setOut(const uint8_t ch, const bool state)
+  {
+    uint8_t currState(0);
+    uint8_t newState(0);
+
+    if (ch < DO1 || ch > DO8)
+    {
+      LOG_ERROR("Invalid write to output channel: [%d]", ch);
+      return false;
+    }
+    if (!readPort(currState))
+      return false;
+    if (state)
+      newState = (High << ch) | currState;
+    else
+      newState = (~(High << ch)) & currState;
+    return setPort(newState);
+  }
+
+  const bool TCA9554PWR::setPort(const uint8_t state)
+  {
+    if (writeRegister(TCA9554_OUTPUT_REG, state))
+      return true;
+    LOG_ERROR("Unable to write IO port: state[%02x]", state);
+    return false;
+  }
+
+  const bool TCA9554PWR::readOut(const uint8_t ch)
+  {
+    uint8_t currState(0);
+    if (ch < DO1 || ch > DO8)
+    {
+      LOG_ERROR("Invalid read to output channel: [%d]", ch);
+      return false;
+    }
+    if (!readPort(currState))
+      return false;
+    return (currState && (High >> ch));
+  }
+
+  const bool TCA9554PWR::readPort(uint8_t &state)
+  {
+    if (readRegister(TCA9554_INPUT_REG, state))
+      return true;
+    LOG_ERROR("Unable to read IO port: state[%02x]", state);
+    return false;
+  }
+
+}

lib/GPIO/TCA9554PWR_Driver.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <DebugLog.h>
+#include "I2C_Driver.h"
+
+/****************************************************** The macro defines the TCA9554PWR information ******************************************************/
+
+#define TCA9554_ADDRESS 0x20      // TCA9554PWR I2C address
+#define TCA9554_INPUT_REG 0x00    // Input register, input level
+#define TCA9554_OUTPUT_REG 0x01   // Output register, high and low level output
+#define TCA9554_POLARITY_REG 0x02 // The Polarity Inversion register (register 2) allows polarity inversion of pins defined as inputs by the Configuration register.
+#define TCA9554_CONFIG_REG 0x03   // Configuration register, mode configuration
+
+#define TCA9554_OUT_MODE 0x00 // Configuration register value, output mode
+#define TCA9554_IN_MODE 0xff  // Configuration register value, input mode
+
+#define Low 0x00
+#define High 0x01
+
+namespace drivers
+{
+    class TCA9554PWR
+    {
+
+    public:
+        typedef enum
+        {
+            DO1,
+            DO2,
+            DO3,
+            DO4,
+            DO5,
+            DO6,
+            DO7,
+            DO8,
+            DO_MAX
+        } channel_t;
+
+        TCA9554PWR(I2C &i2c, const uint8_t address);
+        ~TCA9554PWR();
+
+        const bool setOut(const uint8_t channel, const bool state);
+        const bool setPort(const uint8_t state);
+
+        const bool readOut(const uint8_t channel);
+        const bool readPort(uint8_t &state);
+
+    private:
+        I2C &m_i2c;
+        uint8_t m_address;
+        const bool writeRegister(const uint8_t reg, const uint8_t val);
+        const bool readRegister(const uint8_t reg, uint8_t &val);
+    };
+}

lib/I2C/I2C_Driver.cpp

@@ -0,0 +1,77 @@
+#include "I2C_Driver.h"
+
+namespace drivers
+{
+
+  I2C::I2C(): m_initialized(true)
+  {
+    Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
+  }
+
+  I2C::~I2C()
+  {
+    Wire.end();
+    m_initialized = false;
+  }
+
+  const bool I2C::read(const uint8_t deviceAddr, const uint8_t deviceReg, const uint8_t len, std::vector<uint8_t> &data)
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    Wire.beginTransmission(deviceAddr);
+    Wire.write(deviceReg);
+    switch (Wire.endTransmission(true))
+    {
+    case 0:
+      break; // no error, break switch
+    case 1:
+      LOG_ERROR("Data to long to fit in buffer: [%d]", len);
+    case 2:
+      LOG_ERROR("Received NAK on address transmit");
+    case 3:
+      LOG_ERROR("Received NAK on data transmit");
+    case 4:
+      LOG_ERROR("Unknown Error");
+      return false;
+    }
+    const uint8_t nBytes = Wire.requestFrom(deviceAddr, len);
+    if (nBytes < len)
+    {
+      LOG_ERROR("Received data is less than expected: len[%d], nBytes[%d]", len, nBytes);
+    }
+    data.clear();
+    data.resize(nBytes); // resize out buffer to received data len, no check if data len is correct
+    for (auto i = 0; i < nBytes; i++)
+    {
+      data[i] = static_cast<uint8_t>(Wire.read());
+    }
+    return true;
+  }
+
+  const bool I2C::write(const uint8_t deviceAddr, const uint8_t deviceReg, const std::vector<uint8_t> &data)
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    Wire.beginTransmission(deviceAddr);
+    Wire.write(deviceReg);
+    for (auto d : data)
+    {
+      Wire.write(d);
+    }
+
+    switch (Wire.endTransmission(true))
+    {
+    case 0:
+      break; // no error, break switch
+    case 1:
+      LOG_ERROR("Data to long to fit in buffer: [%d]", data.size());
+    case 2:
+      LOG_ERROR("Received NAK on address transmit");
+    case 3:
+      LOG_ERROR("Received NAK on data transmit");
+    case 4:
+      LOG_ERROR("Unknown Error");
+      return false;
+    }
+    return true;
+  }
+
+} // namespace drivers

lib/I2C/I2C_Driver.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <DebugLog.h>
+#include <Arduino.h>
+#include <Wire.h>
+#include <vector>
+#include <mutex>
+
+#define I2C_SCL_PIN 41
+#define I2C_SDA_PIN 42
+
+namespace drivers
+{
+
+    class I2C
+    {
+    public:
+        I2C(void);
+        ~I2C(void);
+
+        const bool read(const uint8_t deviceAddr, const uint8_t deviceReg, const uint8_t len, std::vector<uint8_t> &data);
+        const bool write(const uint8_t deviceAddr, const uint8_t deviceReg, const std::vector<uint8_t> &data);
+
+    private:
+        bool m_initialized;
+        std::mutex m_mutex;
+    };
+
+}

lib/RS485/RS485_Driver.cpp

@@ -0,0 +1,434 @@
+#include "RS485_driver.h"
+#include <algorithm>
+#include <cstring>
+#include <endian.h>
+
+#include "utils.h"
+
+namespace drivers
+{
+
+  ////////////////////////////////
+  //////////// RS485  ////////////
+  ////////////////////////////////
+
+  RS485::RS485(const uint32_t baud, const SerialConfig conf) : m_serial(Serial1)
+  {
+    LOG_INFO("Init serial port 1");
+    // RS485 is hardwired to serial port 1
+    m_serial.begin(baud, conf, 18, 17);
+    m_serial.setTimeout(1000);
+    m_serial.flush();
+  }
+
+  const bool RS485::write(const std::vector<uint8_t> data)
+  {
+    return data.size() == m_serial.write(data.data(), data.size());
+  }
+
+  const bool RS485::readAll(std::vector<uint8_t> &data)
+  {
+    const uint32_t avail(m_serial.available());
+    if (avail == 0)
+      return true;
+    data.resize(avail);
+    return data.size() == m_serial.readBytes(data.data(), avail);
+  }
+
+  const bool RS485::readN(const uint16_t nBytes, std::vector<uint8_t> &data)
+  {
+    std::vector<uint8_t> buf;
+    buf.resize(nBytes);
+    if (m_serial.readBytes(buf.data(), nBytes) == nBytes)
+    {
+      data = std::move(buf);
+      return true;
+    }
+    return false;
+  }
+
+  const bool RS485::readUntil(const uint8_t ch, std::vector<uint8_t> &data)
+  {
+    const uint32_t avail(m_serial.available());
+    data.resize(avail);
+    m_serial.readBytesUntil(ch, data.data(), avail);
+    data.shrink_to_fit();
+    return true;
+  }
+
+  ////////////////////////////////
+  //////////// MODBUS ////////////
+  ////////////////////////////////
+  MODBUS::MODBUS(const uint32_t baud, const SerialConfig conf) : RS485::RS485(baud, conf)
+  {
+    std::vector<uint8_t> garbage;
+    readAll(garbage);
+    LOG_INFO("Init MODBUS Master Mode");
+    m_crc.reset(CRC16_MODBUS_POLYNOME, CRC16_MODBUS_INITIAL, CRC16_MODBUS_XOR_OUT, CRC16_MODBUS_REV_IN, CRC16_MAXIM_REV_OUT);
+    m_lastAccess = millis();
+  }
+
+  void MODBUS::delayAccess(const uint8_t device)
+    {
+      if (device == m_lastDevice) return;
+        auto now = millis();
+        if ((now - m_lastAccess) < c_minDelay) // fixed 10 milliseconds delay between commands
+        { // minimum m_lastRequest between requests
+            delay(now - m_lastAccess);
+        }
+        m_lastAccess = now;
+        m_lastDevice = device;
+    }
+
+  // Func 0x01
+  const bool MODBUS::readCoils(const uint8_t device, const uint16_t reg, const uint16_t num, std::vector<bool> &coils)
+  {
+    constexpr uint8_t func = 0x01;
+    delayAccess(device);
+    LOG_DEBUG("Read coils: dev[", device, "], reg[", reg, "], num[", num, "]");
+    return readBinary(device, func, reg, num, coils);
+  }
+  
+  // Func 0x02
+  const bool MODBUS::readInputs(const uint8_t device, const uint16_t reg, const uint8_t num, std::vector<bool> &inputs)
+  {
+    constexpr uint8_t func = 0x02;
+    delayAccess(device);
+    LOG_DEBUG("Read multi inputs: dev[", device, "], reg[", reg, "], num[", num, "]");
+    return readBinary(device, func, reg, num, inputs);
+  }
+  
+  // Func 0x03
+  const bool MODBUS::readHoldingRegisters(const uint8_t device, const uint16_t reg, const uint8_t num, std::vector<uint16_t> &values)
+  {
+    constexpr uint8_t func = 0x03;
+    delayAccess(device);
+    LOG_DEBUG("Read multi holding registers: dev[", device, "], reg[", reg, "], num[", num, "]");
+    return readInteger(device, func, reg, num, values);
+  }
+  
+  // Func 0x04
+  const bool MODBUS::readInputRegisters(const uint8_t device, const uint16_t reg, const uint8_t num, std::vector<uint16_t> &values)
+  {
+    constexpr uint8_t func = 0x04;
+    delayAccess(device);
+    LOG_DEBUG("Read multi input registers: dev[", device, "], reg[", reg, "], num[", num, "]");
+    return readInteger(device, func, reg, num, values);
+  }
+  
+  // Func 0x05
+  const bool MODBUS::writeCoil(const uint8_t device, const uint16_t coil, const bool value)
+  {
+    constexpr uint8_t func = 0x05;
+    delayAccess(device);
+    LOG_DEBUG("Write single coil: dev[", device, "], coil[", coil, "], value[", value ? "true" : "false", "]");
+    return writeBinary(device, func, coil, {value});
+  }
+  
+  // Func 0x06
+  const bool MODBUS::writeRegister(const uint8_t device, const uint16_t reg, const uint16_t value)
+  {
+    constexpr uint8_t func = 0x06;
+    delayAccess(device);
+    LOG_DEBUG("Write single register: dev[", device, "], reg[", reg, "], value[", value, "]");
+    return writeInteger(device, func, reg, {value}, false);
+  }
+  
+  // Func 0x0F
+  const bool MODBUS::writeCoils(const uint8_t device, const uint16_t coils, const std::vector<bool> &values)
+  {
+    constexpr uint8_t func = 0x0F;
+    delayAccess(device);
+    LOG_DEBUG("Write multi coils: dev[", device, "], start[", coils, "], num[", values.size(), "]");
+    return writeBinary(device, func, coils, values);
+  }
+  
+  // Func 0x10
+  const bool MODBUS::writeRegisters(const uint8_t device, const uint16_t reg, const std::vector<uint16_t> &values)
+  {
+    constexpr uint8_t func = 0x10;
+    delayAccess(device);
+    LOG_DEBUG("Write multi registers: dev[", device, "], start[", reg, "], num[", values.size(), "]");
+    return writeInteger(device, func, reg, values, true);
+  }
+
+  /////////////////////////////////////////////////////////////////
+  /////////////////////// Utility Functions ///////////////////////
+  /////////////////////////////////////////////////////////////////
+
+  const bool MODBUS::readBinary(const uint8_t device, const uint8_t func, const uint16_t reg, const uint16_t bits, std::vector<bool> &out)
+  {
+    if (!write(singleRequest(device, func, reg, bits)))
+    {
+      LOG_ERROR("Failed send readBinary command");
+      return false;
+    }
+    const uint16_t nRespDataBytes = (uint16_t)ceil(bits / 8.0f);                          // 1 bit for every coil, if not 8 mutiple padded with zeroes
+    const uint16_t expectedRespLen = (c_respHeaderSize + c_respCrcSize) + nRespDataBytes; // device + function + nbytes + data[] + crc(16b)
+    std::vector<uint8_t> response;
+    if (!readN(expectedRespLen, response))
+    {
+      LOG_ERROR("Failed receive readBinary response, expected[", expectedRespLen, "], received[", response.size(), "]");
+      return false;
+    }
+#ifdef DEBUGLOG_DEFAULT_LOG_LEVEL_TRACE
+    printBytes("readBinary Response", response);
+#endif
+
+    // element 2 of response has the response data bytes expected
+    const uint8_t actualRespLen(response.at(2));
+    if (actualRespLen != nRespDataBytes)
+    {
+      LOG_ERROR("Failed receive, data to short: actual[", actualRespLen, "], expected[", nRespDataBytes, "]");
+      return false;
+    }
+
+    // compute crc of current message
+    if (!verifyCrc(response))
+      return false;
+
+    // extract coils data from data portion of response
+    out.clear();
+    out.reserve(bits);
+    uint16_t bitNum(0);
+
+    // get response data bytes excluding header and crc
+    const std::vector<uint8_t> respData(response.begin() + c_respHeaderSize, response.end() - sizeof(crc_t));
+    for (auto it = respData.begin(); it < respData.end(); it++)
+    {
+      for (uint8_t j(0); j < 8 && bitNum < bits; j++)
+      {
+        const bool cv((0x01 << j) & *it);
+        out.push_back(cv);
+        bitNum++;
+      }
+    }
+    return true;
+  }
+
+  const bool MODBUS::readInteger(const uint8_t device, const uint8_t func, const uint16_t reg, const uint16_t num, std::vector<uint16_t> &out)
+  {
+    if (!write(singleRequest(device, func, reg, num)))
+    {
+      LOG_ERROR("Failed send readInteger command");
+      return false;
+    }
+    const uint16_t nRespDataBytes = num * sizeof(uint16_t);
+    const uint16_t expectedRespLen = (c_respHeaderSize + sizeof(crc_t)) + nRespDataBytes; // device + function + nbytes + data[] + crc(16b)
+    std::vector<uint8_t> response;
+    if (!readN(expectedRespLen, response))
+    {
+      LOG_ERROR("Failed receive readInteger response, expected[", expectedRespLen, "], received[", response.size(), "]");
+      return false;
+    }
+#ifdef DEBUGLOG_DEFAULT_LOG_LEVEL_TRACE
+    printBytes("readInteger Response", response);
+#endif
+
+    // element 2 of response has the response data bytes expected
+    const uint8_t actualRespLen(response.at(2));
+    if (actualRespLen != nRespDataBytes)
+    {
+      LOG_ERROR("Failed receive, data to short: actual[", actualRespLen, "], expected[", nRespDataBytes, "]");
+      return false;
+    }
+
+    // compute crc of current message
+    if (!verifyCrc(response))
+      return false;
+
+    // extract coils data from data portion of response
+    out.clear();
+    out.reserve(nRespDataBytes / sizeof(uint16_t));
+    // get response data bytes excluding header and crc
+    const std::vector<uint8_t> respData(response.begin() + c_respHeaderSize, response.end() - c_respCrcSize);
+    for (auto it = respData.begin(); it < respData.end(); it++)
+    {
+      const uint8_t lo(*it++);
+      const uint8_t hi(*it);
+      const uint16_t val(0xFFFF & ((hi << 8) | lo));
+      out.push_back(be16toh(val));
+    }
+    return true;
+  }
+
+  const bool MODBUS::writeBinary(const uint8_t device, const uint8_t func, const uint16_t reg, const std::vector<bool> &in)
+  {
+    const uint16_t bits(in.size());
+    std::vector<uint8_t> bitsOut;
+    if (bits == 1) // if single coil value must be 0x00FF[00] for on[off]
+    {
+      if (!write(singleRequest(device, func, reg, in.front() ? 0xFF00 : 0x0000)))
+      {
+        LOG_ERROR("Failed send writeSingleBinary command");
+        return false;
+      }
+    }
+    else // if multiple coils value is 0x01 shifted for the number of coil intended
+    {
+      const uint16_t numBytes((uint16_t)ceil(bits / 8.0f));
+      bitsOut.resize(numBytes, 0x00);
+      for (uint16_t i(0); i < in.size(); i++)
+      {
+        if (!in[i]) // if value is false skip
+          continue;
+        bitsOut[i / 8] |= 0x01 << i % 8;
+      }
+#ifdef DEBUGLOG_DEFAULT_LOG_LEVEL_TRACE
+      LOG_DEBUG("\nnumBytes", numBytes);
+      printBool("bitsOut", in);
+      printBytes("bitsOut", bitsOut);
+#endif
+      if (!write(multiRequest(device, func, reg, bits, bitsOut)))
+      {
+        LOG_ERROR("Failed send writeMultiBinary command");
+        return false;
+      }
+    }
+
+    const uint16_t expectedRespLen(sizeof(resp_t) + sizeof(crc_t));
+    std::vector<uint8_t> response;
+    if (!readN(expectedRespLen, response))
+    {
+      LOG_ERROR("Failed receive writeBinary response, expected[", expectedRespLen, "], received[", response.size(), "]");
+      return false;
+    }
+#ifdef DEBUGLOG_DEFAULT_LOG_LEVEL_TRACE
+    printBytes("writeBinary Response", response);
+#endif
+
+    // compute crc of current message
+    if (!verifyCrc(response))
+      return false;
+
+    return true;
+  }
+
+  const bool MODBUS::writeInteger(const uint8_t device, const uint8_t func, const uint16_t reg, const std::vector<uint16_t> &in, const bool multi)
+  {
+    const uint16_t num(in.size());
+    if (!multi)
+    {
+      if (!write(singleRequest(device, func, reg, in[0])))
+      {
+        LOG_ERROR("Failed send writeSingleInteger command");
+        return false;
+      }
+    }
+    else
+    {
+      // build data vector for request, inverting bytes if necessary
+      std::vector<uint8_t> requestData;
+      requestData.resize(in.size() * sizeof(uint16_t), 0xff);
+      auto it = requestData.begin();
+      for (auto inV : in)
+      {
+        const uint16_t beV(htobe16(inV));
+        *(it++) = lowByte(beV);
+        *(it++) = highByte(beV);
+      }
+      if (!write(multiRequest(device, func, reg, num, requestData)))
+      {
+        LOG_ERROR("Failed send writeMultiInteger command");
+        return false;
+      }
+    }
+
+    const uint16_t expectedRespLen(sizeof(resp_t) + sizeof(crc_t));
+    std::vector<uint8_t> response;
+    if (!readN(expectedRespLen, response))
+    {
+      LOG_ERROR("Failed receive writeInteger response, expected[", expectedRespLen, "], received[", response.size(), "]");
+      return false;
+    }
+#ifdef DEBUGLOG_DEFAULT_LOG_LEVEL_TRACE
+    printBytes("writeInteger Response", response);
+#endif
+
+    // compute crc of current message
+    if (!verifyCrc(response))
+      return false;
+
+    return true;
+  }
+
+  const std::vector<uint8_t> MODBUS::singleRequest(const uint8_t device, const uint8_t func, const uint16_t reg, const uint16_t data)
+  {
+    req_t header;
+    header.device = device;
+    header.func = func;
+    header.reg = htobe16(reg);
+    header.data = htobe16(data);
+
+    const uint8_t headerBytes(sizeof(req_t));
+    const uint8_t crcBytes(sizeof(crc_t));
+
+    // compute crc for header + data
+    m_crc.restart();
+    m_crc.add((uint8_t *)&header, headerBytes); // exclude last two bytes of crc
+    const uint16_t crc(htole16(m_crc.calc()));
+
+    std::vector<uint8_t> dataOut(headerBytes + crcBytes, 0);
+    std::memcpy(dataOut.data(), &header, headerBytes);
+    std::memcpy(dataOut.data() + headerBytes, &crc, crcBytes);
+
+#ifdef DEBUGLOG_DEFAULT_LOG_LEVEL_TRACE
+    printBytes("singleRequest", dataOut);
+#endif
+    return dataOut;
+  }
+
+  const std::vector<uint8_t> MODBUS::multiRequest(const uint8_t device, const uint8_t func, const uint16_t reg, const uint16_t qty, const std::vector<uint8_t> &data)
+  {
+    req_multi_t header;
+    header.device = device;
+    header.func = func;
+    header.reg = htobe16(reg);
+    header.qty = htobe16(qty);
+    header.bytes = data.size(); // 8 bit value
+
+    // const uint8_t headerBytes(sizeof(req_multi_t)); // sizeof not working because of memory padding
+    const uint8_t headerBytes(7);
+    const uint8_t dataBytes(data.size());
+    const uint8_t crcBytes(sizeof(crc_t));
+
+    // compute crc for header + data
+    m_crc.restart();
+    m_crc.add((uint8_t *)&header, headerBytes); // add the request excluding the CRC code
+    m_crc.add((uint8_t *)data.data(), dataBytes);
+    const uint16_t crc(htole16(m_crc.calc()));
+
+    std::vector<uint8_t> dataOut;
+    dataOut.resize(headerBytes + dataBytes + crcBytes);                    // header message + data values + crc code
+    std::memcpy(dataOut.data(), &header, headerBytes);                     // copy message
+    std::memcpy(dataOut.data() + headerBytes, data.data(), dataBytes);     // copy data
+    std::memcpy(dataOut.data() + headerBytes + dataBytes, &crc, crcBytes); // copy crc
+
+#ifdef DEBUGLOG_DEFAULT_LOG_LEVEL_TRACE
+    printBytes("multiRequest", dataOut);
+#endif
+    return dataOut;
+  }
+
+  const bool MODBUS::verifyCrc(const std::vector<uint8_t> &data)
+  {
+    // compute crc of current message
+    m_crc.restart();
+    m_crc.add(data.data(), data.size() - sizeof(crc_t));
+    const uint16_t computedCrc(m_crc.calc());
+    // extract crc from response
+    const uint16_t size(data.size());
+    const uint8_t crcLo(data.at(size - 2));
+    const uint8_t crcHi(data.at(size - 1));
+    const uint16_t receivedCrc(0xFFFF & ((crcHi << 8) | crcLo));
+
+    // verify crc code
+    if (highByte(computedCrc) != crcHi || lowByte(computedCrc) != crcLo)
+    {
+      LOG_ERROR("Failed verify CRC code: comp[", computedCrc, "], rec[", receivedCrc, "]");
+      return false;
+    }
+    return true;
+  }
+
+}

lib/RS485/RS485_Driver.h

@@ -0,0 +1,107 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <DebugLog.h>
+#include <Arduino.h>
+#include <HardwareSerial.h> // Reference the ESP32 built-in serial port library
+#include <CRC16.h>
+#include <memory>
+#include <mutex>
+
+namespace drivers
+{
+    class RS485
+    {
+        const uint8_t c_port = 1;
+
+    public:
+        RS485(const uint32_t baud, const SerialConfig conf);
+        RS485(const RS485 &) = delete; // remove copy constructors
+        RS485 &operator=(const RS485 &) = delete;
+
+        const bool write(const std::vector<uint8_t> data);
+        const bool readAll(std::vector<uint8_t> &data);
+        const bool readN(const uint16_t nBytes, std::vector<uint8_t> &data);
+        const bool readUntil(const uint8_t ch, std::vector<uint8_t> &data);
+
+    private:
+        HardwareSerial &m_serial;
+    };
+
+    class MODBUS : private RS485
+    {
+
+        const uint8_t c_respHeaderSize = 3;
+        const uint8_t c_respCrcSize = 2;
+        const uint16_t c_minDelay = 50;
+
+        typedef struct
+        {
+            uint8_t device;
+            uint8_t func;
+            uint16_t reg;
+            uint16_t data;
+        } req_t;
+
+        typedef struct
+        {
+            uint8_t device;
+            uint8_t func;
+            uint16_t reg;
+            uint16_t qty;
+            uint8_t bytes;
+        } req_multi_t;
+
+        typedef req_t resp_t;
+        typedef uint16_t crc_t;
+
+    public:
+        MODBUS(const uint32_t baud, const SerialConfig conf);
+        MODBUS(const MODBUS &) = delete; // remove copy constructors
+        MODBUS &operator=(const MODBUS &) = delete;
+
+        // Get transaction lock
+        std::unique_lock<std::mutex> getLock() {
+            return std::unique_lock<std::mutex>(m_mutex);
+        }
+
+        // Func 0x01
+        const bool readCoils(const uint8_t device, const uint16_t reg, const uint16_t num, std::vector<bool> &coils);
+
+        // Func 0x02
+        const bool readInputs(const uint8_t device, const uint16_t reg, const uint8_t num, std::vector<bool> &inputs);
+
+        // Func 0x03
+        const bool readHoldingRegisters(const uint8_t device, const uint16_t reg, const uint8_t num, std::vector<uint16_t> &values);
+
+        // Func 0x04
+        const bool readInputRegisters(const uint8_t device, const uint16_t reg, const uint8_t num, std::vector<uint16_t> &values);
+
+        // Func 0x05
+        const bool writeCoil(const uint8_t device, const uint16_t coil, const bool value);
+
+        // Func 0x06
+        const bool writeRegister(const uint8_t device, const uint16_t reg, const uint16_t value);
+
+        // Func 0x0F
+        const bool writeCoils(const uint8_t device, const uint16_t coils, const std::vector<bool> &values);
+
+        // Func 0x10
+        const bool writeRegisters(const uint8_t device, const uint16_t reg, const std::vector<uint16_t> &values);
+
+    private:
+        CRC16 m_crc;
+        std::mutex m_mutex;
+        uint8_t m_lastDevice;
+        uint32_t m_lastAccess;
+        void delayAccess(const uint8_t device);
+        const std::vector<uint8_t> singleRequest(const uint8_t device, const uint8_t func, const uint16_t reg, const uint16_t data);
+        const std::vector<uint8_t> multiRequest(const uint8_t device, const uint8_t func, const uint16_t reg, const uint16_t qty, const std::vector<uint8_t> &data);
+        const bool readBinary(const uint8_t device, const uint8_t func, const uint16_t reg, const uint16_t bits, std::vector<bool> &out);
+        const bool readInteger(const uint8_t device, const uint8_t func, const uint16_t reg, const uint16_t num, std::vector<uint16_t> &out);
+        const bool writeBinary(const uint8_t device, const uint8_t func, const uint16_t reg, const std::vector<bool> &in);
+        const bool writeInteger(const uint8_t device, const uint8_t func, const uint16_t reg, const std::vector<uint16_t> &in, const bool multi);
+        const bool verifyCrc(const std::vector<uint8_t> &data);
+    };
+}

lib/RTC/PCF85063_Driver.cpp

@@ -0,0 +1,204 @@
+#include "PCF85063_Driver.h"
+#include <ctime>
+
+namespace drivers
+{
+
+    PCF85063::PCF85063(I2C &i2c, const uint8_t address, const uint8_t ctrl1, const uint8_t ctrl2) : m_i2c(i2c), m_address(address)
+    {
+        bool success(true);
+        if (ctrl1 == RTC_CTRL_1_DEFAULT)
+        {
+            const uint8_t def_conf1 = RTC_CTRL_1_DEFAULT | RTC_CTRL_1_CAP_SEL; // 12.5pF cap and 24h format
+            success &= m_i2c.write(m_address, RTC_CTRL_1_ADDR, {def_conf1});
+        }
+        if (ctrl2 == RTC_CTRL_2_DEFAULT)
+        {
+            const uint8_t def_conf2 = RTC_CTRL_2_DEFAULT | RTC_CTRL_2_MI; // enable 1 minute interrupt
+            success &= m_i2c.write(m_address, RTC_CTRL_2_ADDR, {def_conf2});
+        }
+        if (!success)
+            LOG_ERROR("RTC Init Failure");
+    }
+
+    const bool PCF85063::reset(void)
+    {
+        LOG_INFO("RTC Reset Initiated");
+        const uint8_t cfg = RTC_CTRL_1_DEFAULT | RTC_CTRL_1_CAP_SEL | RTC_CTRL_1_SR;
+        if (m_i2c.write(m_address, RTC_CTRL_1_ADDR, {cfg}))
+            return true;
+        LOG_ERROR("RTC Reset Failure");
+        return false;
+    }
+
+    const bool PCF85063::setTime(const datetime_t time)
+    {
+        const std::vector<uint8_t> buf = {
+            decToBcd(time.second),
+            decToBcd(time.minute),
+            decToBcd(time.hour)};
+        if (m_i2c.write(m_address, RTC_SECOND_ADDR, buf))
+            return true;
+        LOG_ERROR("RTC setTime failure");
+        return false;
+    }
+
+    const bool PCF85063::setDate(const datetime_t date)
+    {
+        const std::vector<uint8_t> buf = {
+            decToBcd(date.day),
+            decToBcd(date.dotw),
+            decToBcd(date.month),
+            decToBcd(date.year - YEAR_OFFSET)};
+        if (m_i2c.write(m_address, RTC_DAY_ADDR, buf))
+            return true;
+        LOG_ERROR("RTC setDate failure");
+        return false;
+    }
+
+    const bool PCF85063::setDatetime(const datetime_t datetime)
+    {
+        return setDate(datetime) && setTime(datetime);
+    }
+
+    const bool PCF85063::readDate(datetime_t &datetime)
+    {
+        std::vector<uint8_t> buf;
+        if (m_i2c.read(m_address, RTC_DAY_ADDR, 4, buf))
+        {
+            datetime.day = bcdToDec(buf[0] & 0x3F);
+            datetime.dotw = bcdToDec(buf[1] & 0x07);
+            datetime.month = bcdToDec(buf[2] & 0x1F);
+            datetime.year = bcdToDec(buf[3]) + YEAR_OFFSET;
+            return true;
+        }
+        LOG_ERROR("RTC readDate Failure");
+        return false;
+    }
+
+    const bool PCF85063::readTime(datetime_t &datetime)
+    {
+        std::vector<uint8_t> buf;
+        if (m_i2c.read(m_address, RTC_SECOND_ADDR, 3, buf))
+        {
+            datetime.second = bcdToDec(buf[0] & 0x7F);
+            datetime.minute = bcdToDec(buf[1] & 0x7F);
+            datetime.hour = bcdToDec(buf[2] & 0x3F);
+            return true;
+        }
+        LOG_ERROR("RTC readTime Failure");
+        return false;
+    }
+
+    const bool PCF85063::readDatetime(datetime_t &datetime)
+    {
+        return readTime(datetime) && readDate(datetime);
+    }
+
+    const bool PCF85063::enableAlarm(const bool enable)
+    {
+        bool success(true);
+        std::vector<uint8_t> currStatus(1, RTC_CTRL_2_DEFAULT);
+
+        success &= m_i2c.read(m_address, RTC_CTRL_2_ADDR, 1, currStatus);
+        currStatus.at(0) &= ~RTC_CTRL_2_AF; // clear alarm flag
+
+        if (enable)
+            currStatus.at(0) |= RTC_CTRL_2_AIE; // enable alarm
+        else
+            currStatus.at(0) &= ~RTC_CTRL_2_AIE; // disable alarm
+
+        if (m_i2c.write(m_address, RTC_CTRL_2_ADDR, currStatus))
+            return true;
+        LOG_ERROR("RTC enableAlarm failure");
+        return false;
+    }
+
+    const bool PCF85063::setAlarm(datetime_t time)
+    {
+        const std::vector<uint8_t> buf = {
+            (uint8_t)(decToBcd(time.second) & (~RTC_ALARM)),
+            (uint8_t)(decToBcd(time.minute) & (~RTC_ALARM)),
+            (uint8_t)(decToBcd(time.hour) & (~RTC_ALARM)),
+            (uint8_t)(RTC_ALARM), // disalbe day
+            (uint8_t)(RTC_ALARM)  // disalbe weekday
+        };
+        if (m_i2c.write(m_address, RTC_SECOND_ALARM, buf))
+            return true;
+        LOG_ERROR("RTC setAlarm failure");
+        return false;
+    }
+
+    const bool PCF85063::readAlarm(datetime_t &time)
+    {
+        std::vector<uint8_t> buf;
+        if (m_i2c.read(m_address, RTC_SECOND_ALARM, 5, buf))
+        {
+            time.second = (uint8_t)bcdToDec(buf[0] & 0x7F);
+            time.minute = (uint8_t)bcdToDec(buf[1] & 0x7F);
+            time.hour = (uint8_t)bcdToDec(buf[2] & 0x3F);
+            time.day = (uint8_t)bcdToDec(buf[3] & 0x3F);
+            time.dotw = (uint8_t)bcdToDec(buf[4] & 0x07);
+            return true;
+        }
+        LOG_ERROR("RTC readAlarm failure");
+        return false;
+    }
+
+    const bool PCF85063::getAlarmFlag(uint8_t &flags)
+    {
+        std::vector<uint8_t> buf;
+        if (m_i2c.read(m_address, RTC_CTRL_2_ADDR, 1, buf))
+        {
+            flags = buf.at(0);
+            return true;
+        }
+        LOG_ERROR("RTC readAlarmFlags failure");
+        return false;
+    }
+
+    const std::string PCF85063::getTimeStr()
+    {
+        datetime_t dt;
+        readDatetime(dt);
+        return datetime2str(dt);
+    }
+
+    const PCF85063::datetime_t PCF85063::fromEpoch(const time_t currentTime)
+    {
+        PCF85063::datetime_t tm;
+        struct tm *localTime = std::localtime(&currentTime);
+        tm.year = localTime->tm_year + 1900;
+        tm.month = localTime->tm_mon + 1;
+        tm.day = localTime->tm_mday;
+        tm.dotw = localTime->tm_wday;
+        tm.hour = localTime->tm_hour;
+        tm.minute = localTime->tm_min;
+        tm.second = localTime->tm_sec;
+        return tm;
+    }
+
+    const std::string PCF85063::datetime2str(const datetime_t &datetime)
+    {
+        tm dtime;
+        dtime.tm_sec = datetime.second;
+        dtime.tm_min = datetime.minute;
+        dtime.tm_hour = datetime.hour;
+        dtime.tm_wday = datetime.dotw;
+        dtime.tm_mday = datetime.day;
+        dtime.tm_mon = datetime.month - 1;
+        dtime.tm_year = datetime.year - 1900; // time offset in structure according cpp reference
+        const std::string buf(std::asctime(&dtime));
+        return buf.substr(0, std::min(buf.find('\n'),buf.find('\r')));
+    }
+
+    const uint8_t PCF85063::decToBcd(const int val)
+    {
+        return (uint8_t)((val / 10 * 16) + (val % 10));
+    }
+
+    const int PCF85063::bcdToDec(uint8_t val)
+    {
+        return (const int)((val / 16 * 10) + (val % 16));
+    }
+}

lib/RTC/PCF85063_Driver.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <DebugLog.h>
+#include "I2C_Driver.h"
+#include <string>
+
+// PCF85063_ADDRESS
+#define PCF85063_ADDRESS (0x51)
+
+#define YEAR_OFFSET (1970)
+// registar overview - crtl & status reg
+#define RTC_CTRL_1_ADDR (0x00)
+#define RTC_CTRL_2_ADDR (0x01)
+#define RTC_OFFSET_ADDR (0x02)
+#define RTC_RAM_by_ADDR (0x03)
+// registar overview - time & data reg
+#define RTC_SECOND_ADDR (0x04)
+#define RTC_MINUTE_ADDR (0x05)
+#define RTC_HOUR_ADDR (0x06)
+#define RTC_DAY_ADDR (0x07)
+#define RTC_WDAY_ADDR (0x08)
+#define RTC_MONTH_ADDR (0x09)
+#define RTC_YEAR_ADDR (0x0A) // years 0-99; calculate real year = 1970 + RCC reg year
+// registar overview - alarm reg
+#define RTC_SECOND_ALARM (0x0B)
+#define RTC_MINUTE_ALARM (0x0C)
+#define RTC_HOUR_ALARM (0x0D)
+#define RTC_DAY_ALARM (0x0E)
+#define RTC_WDAY_ALARM (0x0F)
+// registar overview - timer reg
+#define RTC_TIMER_VAL (0x10)
+#define RTC_TIMER_MODE (0x11)
+
+// RTC_CTRL_1 registar
+#define RTC_CTRL_1_EXT_TEST (0x80)
+#define RTC_CTRL_1_STOP (0x20)    // 0-RTC clock runs 1- RTC clock is stopped
+#define RTC_CTRL_1_SR (0X10)      // 0-no software reset 1-initiate software rese
+#define RTC_CTRL_1_CIE (0X04)     // 0-no correction interrupt generated 1-interrupt pulses are generated at every correction cycle
+#define RTC_CTRL_1_12_24 (0X02)   // 0-24H 1-12H
+#define RTC_CTRL_1_CAP_SEL (0X01) // 0-7PF 1-12.5PF
+
+// RTC_CTRL_2 registar
+#define RTC_CTRL_2_AIE (0X80) // alarm interrupt 0-disalbe 1-enable
+#define RTC_CTRL_2_AF (0X40)  // alarm flag  0-inactive/cleared 1-active/unchanged
+#define RTC_CTRL_2_MI (0X20)  // minute interrupt 0-disalbe 1-enable
+#define RTC_CTRL_2_HMI (0X10) // half minute interrupt
+#define RTC_CTRL_2_TF (0X08)
+
+//
+#define RTC_OFFSET_MODE (0X80)
+
+//
+#define RTC_TIMER_MODE_TE (0X04)    // timer enable 0-disalbe 1-enable
+#define RTC_TIMER_MODE_TIE (0X02)   // timer interrupt enable 0-disalbe 1-enable
+#define RTC_TIMER_MODE_TI_TP (0X01) // timer interrupt mode 0-interrupt follows timer flag 1-interrupt generates a pulse
+
+// format
+#define RTC_ALARM (0x80) // set AEN_x registers
+#define RTC_CTRL_1_DEFAULT (0x00)
+#define RTC_CTRL_2_DEFAULT (0x00)
+
+#define RTC_TIMER_FLAG (0x08)
+
+namespace drivers
+{
+
+  class PCF85063
+  {
+    I2C &m_i2c;
+    uint8_t m_address;
+
+  public:
+    typedef struct
+    {
+      uint16_t year;
+      uint8_t month;
+      uint8_t day;
+      uint8_t dotw;
+      uint8_t hour;
+      uint8_t minute;
+      uint8_t second;
+    } datetime_t;
+
+  public:
+    PCF85063(I2C &i2c, const uint8_t address, const uint8_t ctrl1 = RTC_CTRL_1_DEFAULT, const uint8_t ctrl2 = RTC_CTRL_2_DEFAULT);
+
+    const bool reset(void);
+
+    const bool setTime(const datetime_t time);
+    const bool setDate(const datetime_t date);
+    const bool setDatetime(const datetime_t datetime);
+
+    const bool readDate(datetime_t &datetime);
+    const bool readTime(datetime_t &datetime);
+    const bool readDatetime(datetime_t &datetime);
+
+    const bool enableAlarm(const bool enable);
+    const bool setAlarm(const datetime_t time);
+    const bool readAlarm(datetime_t &time);
+    const bool getAlarmFlag(uint8_t &flags);
+
+    const std::string getTimeStr();
+    
+    static const  std::string datetime2str(const datetime_t &datetime);
+    static const PCF85063::datetime_t fromEpoch(const time_t currentTime);
+
+  private:
+    const uint8_t decToBcd(const int val);
+    const int bcdToDec(const uint8_t val);
+  };
+
+}

lib/SENECA/S50140_Driver.cpp

@@ -0,0 +1,153 @@
+#include <S50140_Driver.h>
+
+namespace drivers
+{
+
+    S50140::S50140(drivers::MODBUS &bus, const uint8_t address) : m_bus(bus), m_address(address), m_lastRequest(millis())
+    {
+    }
+    S50140::~S50140()
+    {
+    }
+    
+    const S50140::powerinfo_t S50140::getAll()
+    {
+        powerinfo_t info{MAXFLOAT};
+        info.v = getV();
+        info.a = getA();
+        info.pAct = getPact();
+        info.pApp = getPapp();
+        info.pRea = getPrea();
+        info.pf = getPf();
+        info.f = getF();
+        info.whTot = getWhTot();
+        info.whPar = getWhPar();
+        return info;
+    }
+    
+    const float_t S50140::getV()
+    {
+        auto lock = m_bus.getLock();
+        return readFloatReg(REG_V);
+    }
+    const float_t S50140::getA()
+    {
+        auto lock = m_bus.getLock();
+        return readFloatReg(REG_A);
+    }
+    const float_t S50140::getPact()
+    {
+        auto lock = m_bus.getLock();
+        return readFloatReg(REG_Pact);
+    }
+    const float_t S50140::getPapp()
+    {
+        auto lock = m_bus.getLock();
+        return readFloatReg(REG_Papp);
+    }
+    const float_t S50140::getPrea()
+    {
+        auto lock = m_bus.getLock();
+        return readFloatReg(REG_Prea);
+    }
+    const float_t S50140::getPf()
+    {
+        auto lock = m_bus.getLock();
+        return readFloatReg(REG_Pf);
+    }
+    const float_t S50140::getF()
+    {
+        auto lock = m_bus.getLock();
+        return readFloatReg(REG_Freq);
+    }
+    const float_t S50140::getWhTot()
+    {
+        auto lock = m_bus.getLock();
+        return readFloatReg(REG_WhTot);
+    }
+    const float_t S50140::getWhPar()
+    {
+        auto lock = m_bus.getLock();
+        return readFloatReg(REG_WhPart);
+    }
+    
+    void S50140::delayRequest()
+    {
+        auto now = millis();
+        if ((now - m_lastRequest) < c_minDelay)
+        { // minimum m_lastRequest between requests
+            delay(now - m_lastRequest);
+        }
+        m_lastRequest = now;
+    }
+    
+    const uint8_t S50140::getRegset()
+    {
+        std::vector<uint16_t> value;
+        delayRequest();
+        auto lock = m_bus.getLock();
+        m_bus.readHoldingRegisters(m_address, REG_Regset, 2, value);
+        if (value.empty())
+        return UINT8_MAX;
+        return value.front() + value.back();
+    }
+
+    const uint16_t S50140::getCounterStatus()
+    {
+        std::vector<uint16_t> value;
+        delayRequest();
+        auto lock = m_bus.getLock();
+        m_bus.readHoldingRegisters(m_address, REG_PartCount, 2, value);
+        if (value.empty())
+            return UINT16_MAX;
+        return value.front() + value.back();
+    }
+
+    void S50140::resetPartialCounters()
+    {
+        uint8_t retries(0);
+        constexpr uint16_t nullVal = 0x0000;
+        constexpr uint16_t resetAll = 0x0A03;
+        constexpr uint16_t stopAll = 0x0A02;
+        constexpr uint16_t startAll = 0x0A01;
+        while (retries++ < c_maxRetries)
+        {
+            bool ok(true);
+            delayRequest();
+            auto lock = m_bus.getLock();
+            LOG_WARN("Powermeter Counter STOP");
+            ok &= m_bus.writeRegisters(m_address, REG_PartCount, {nullVal, stopAll});
+            delayRequest();
+            LOG_WARN("Powermeter Counter RESET");
+            ok &= m_bus.writeRegisters(m_address, REG_PartCount, {nullVal, resetAll});
+            delayRequest();
+            LOG_WARN("Powermeter Counter START");
+            ok &= m_bus.writeRegisters(m_address, REG_PartCount, {nullVal, startAll});
+            if (ok)
+                return;
+            LOG_ERROR("Unable to Reset Powermeter Partial Counters, device", m_address);
+        }
+        return;
+    }
+
+    float_t S50140::readFloatReg(const uint16_t reg)
+    {
+        uint8_t retries(0);
+        std::vector<uint16_t> values;
+
+        while (retries++ < c_maxRetries)
+        {
+            delayRequest();
+            if (m_bus.readHoldingRegisters(m_address, reg, c_dataWords, values) && values.size() == c_dataWords)
+            {
+                floatval_t fv;           // potrebbe essere il contrario, vedremo
+                fv.words.lo = values[0]; // magari va invertita ancora l'endianness
+                fv.words.hi = values[1];
+                return fv.f;
+            }
+            LOG_ERROR("Unable to Read Powermeter values, device", m_address);
+        }
+        return MAXFLOAT;
+    }
+
+}

lib/SENECA/S50140_Driver.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <DebugLog.h>
+#include <RS485_Driver.h>
+
+namespace drivers
+{
+
+    class S50140
+    {
+    private:
+        const uint8_t c_maxRetries = 5;
+        const uint8_t c_dataWords = 2;
+        const uint16_t c_minDelay = 200;
+
+        const uint16_t REG_V = 0x100C;
+        const uint16_t REG_A = 0x1016;
+        const uint16_t REG_Pact = 0x1026;
+        const uint16_t REG_Papp = 0x102E;
+        const uint16_t REG_Prea = 0x1036;
+        const uint16_t REG_Freq = 0x1038;
+        const uint16_t REG_Pf = 0x101E;
+        const uint16_t REG_WhTot = 0x1106;
+        const uint16_t REG_WhPart = 0x1400;
+        const uint16_t REG_Serial = 0x0500;
+        const uint16_t REG_Regset = 0x0538;
+        const uint16_t REG_PartCount = 0x0526;
+
+        typedef union
+        {
+            float_t f;
+            struct
+            {
+                uint16_t hi;
+                uint16_t lo;
+            } words;
+        } floatval_t;
+
+    public:
+        typedef struct
+        {
+            float_t v;
+            float_t a;
+            float_t pAct;
+            float_t pApp;
+            float_t pRea;
+            float_t pf;
+            float_t f;
+            float_t whTot;
+            float_t whPar;
+        } powerinfo_t;
+
+    public:
+        S50140(drivers::MODBUS &bus, const uint8_t address);
+        ~S50140();
+
+        const powerinfo_t getAll();
+
+        const float_t getV();
+        const float_t getA();
+        const float_t getPact();
+        const float_t getPapp();
+        const float_t getPrea();
+        const float_t getPf();
+        const float_t getF();
+        const float_t getWhTot();
+        const float_t getWhPar();
+
+        const uint8_t getRegset();
+        const uint16_t getCounterStatus();
+
+        void resetPartialCounters();
+
+    private:
+        void delayRequest();
+        float_t readFloatReg(const uint16_t reg);
+
+    private:
+        const uint8_t m_address;
+        drivers::MODBUS &m_bus;
+        uint64_t m_lastRequest;
+    };
+}

lib/TEMP/R4DCB08_Driver.cpp

@@ -0,0 +1,138 @@
+#include <R4DCB08_Driver.h>
+
+namespace drivers
+{
+    R4DCB08::R4DCB08(drivers::MODBUS &bus, const uint8_t address) : m_address(address), m_bus(bus), m_sensors(0)
+    {
+        m_sensors = getNum();
+    }
+
+    R4DCB08::~R4DCB08()
+    {
+    }
+
+    const float R4DCB08::getTemp(const uint8_t ch)
+    {
+        uint8_t retries(0);
+        std::vector<uint16_t> rawT;
+        if (ch < 0 || ch > getNum())
+        {
+            LOG_ERROR("Invalid Temperature Channel number", ch);
+            return MAXFLOAT;
+        }
+        auto lock = m_bus.getLock();
+        while (retries++ < maxRetries)
+        {
+            if (m_bus.readHoldingRegisters(m_address, REG_TEMP + ch, 1, rawT) && !rawT.empty())
+            {
+                return rawT.front() / 10.0f;
+            }
+            LOG_ERROR("Failed to Read Temperature, device", m_address, "channel", ch);
+            rawT.clear();
+            delay(50);
+        }
+        return MAXFLOAT;
+    }
+
+    const std::vector<float> R4DCB08::getTempAll()
+    {
+        uint8_t retries(0);
+        std::vector<uint16_t> rawT;
+        std::vector<float> out;
+        auto lock = m_bus.getLock();
+        while (retries++ < maxRetries)
+        {
+            if (m_bus.readHoldingRegisters(m_address, REG_TEMP, getNum(), rawT) && !rawT.empty())
+            {
+                out.reserve(rawT.size());
+                for (auto v : rawT)
+                {
+                    out.push_back(v / 10.0f);
+                }
+                return out;
+            }
+            LOG_ERROR("Failed to Read All Temperature, device", m_address);
+            rawT.clear();
+            delay(50);
+        }
+        out.clear();
+        return out;
+    }
+
+    void R4DCB08::setCorrection(std::vector<float> corr)
+    {
+        uint8_t retries(0);
+        uint8_t channel(0);
+        corr.resize(getNum()); // max number of temperature correction values is equal to number of sensors
+
+        auto lock = m_bus.getLock();
+        for (auto v : corr)
+        {
+            while (retries++ < maxRetries)
+            {
+                if (m_bus.writeRegister(m_address, REG_TEMPCORR + channel, v * 10)) // convert to decimal degreees to register value
+                {
+                    channel++;
+                    delay(50);
+                    break;
+                }
+                LOG_ERROR("Failed to Set Temperature Correction, device", m_address);
+                delay(50);
+            }
+        }
+    }
+
+    std::vector<float> R4DCB08::getCorrection()
+    {
+        uint8_t retries(0);
+        std::vector<uint16_t> rawV;
+        std::vector<float> out;
+        rawV.reserve(getNum());
+
+        while (retries++ < maxRetries)
+        {
+            auto lock = m_bus.getLock();
+            if (m_bus.readHoldingRegisters(m_address, REG_TEMPCORR, getNum(), rawV))
+            {
+                out.reserve(rawV.size());
+                for (auto v : rawV)
+                {
+                    out.push_back(v / 10.0f);
+                }
+                return out;
+            }
+            LOG_ERROR("Failed to Get Temperature Correction, device", m_address);
+            rawV.clear();
+            delay(50);
+        }
+        out.clear();
+        return out;
+    }
+
+    const uint8_t R4DCB08::getNum()
+    {
+        if (m_sensors)
+            return m_sensors;
+        uint8_t retries(0);
+        uint8_t sensors(0);
+        std::vector<uint16_t> rawT;
+        while (retries++ < maxRetries)
+        {
+            auto lock = m_bus.getLock();
+            if (m_bus.readHoldingRegisters(m_address, REG_TEMP, T_MAX, rawT))
+            {
+                for (auto v : rawT)
+                {
+                    if (v <= INT16_MAX)
+                        sensors++; // 32768 is returned if sensor is disconnected
+                }
+                m_sensors = sensors;
+                return m_sensors;
+            }
+            LOG_ERROR("Failed to Get Sensor Number, device", m_address);
+            delay(50);
+        }
+        LOG_ERROR("No Temperature Sensors Detected, device", m_address);
+        return 0;
+    }
+}

lib/TEMP/R4DCB08_Driver.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <DebugLog.h>
+#include <RS485_Driver.h>
+
+namespace drivers
+{
+
+    class R4DCB08
+    {
+
+    public:
+        enum tempCh
+        {
+            T1,
+            T2,
+            T3,
+            T4,
+            T5,
+            T6,
+            T7,
+            T8,
+            T_MAX
+        };
+
+        const uint8_t maxRetries = 5;
+        const uint16_t REG_TEMP = 0x0000;
+        const uint16_t REG_TEMPCORR = 0x0008;
+
+    public:
+        R4DCB08(drivers::MODBUS &bus, const uint8_t address);
+        ~R4DCB08();
+
+        const float getTemp(const uint8_t ch);
+        const std::vector<float> getTempAll();
+
+        void setCorrection(std::vector<float> corr);
+        std::vector<float> getCorrection();
+
+        const uint8_t getNum();
+
+    private:
+        const uint8_t m_address;
+        uint8_t m_sensors;
+        MODBUS &m_bus;
+    };
+}

lib/utils/utils.cpp

@@ -0,0 +1,37 @@
+#include "utils.h"
+
+void printBytes(const char title[], const std::vector<uint8_t> &b)
+{
+  Serial0.flush();
+  printf("%s: ", title);
+  for (auto v : b)
+  {
+    printf("0x%02x ", v);
+  }
+  printf("\n");
+  Serial0.flush();
+}
+
+void printBytes(const char title[], const std::vector<uint16_t> &b)
+{
+  Serial0.flush();
+  printf("%s: ", title);
+  for (auto v : b)
+  {
+      printf("0x%04x ", v);
+    }
+    printf("\n");
+    Serial0.flush();
+}
+
+void printBool(const char title[], const std::vector<bool> &vals)
+{
+    Serial0.flush();
+    printf("%s: ", title);
+    for (auto j(0); j < vals.size(); j++)
+    {
+        printf("%s ", vals.at(j) ? "True" : "False");
+    }
+    printf("\n");
+    Serial0.flush();
+}

lib/utils/utils.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <Arduino.h>
+#include <DebugLog.h>
+#include <vector>
+
+///////////// UTIL Functions /////////////////
+
+void printBytes(const char title[], const std::vector<uint8_t> &b);
+
+void printBytes(const char title[], const std::vector<uint16_t> &b);
+
+void printBool(const char title[], const std::vector<bool> &vals);

platformio.ini

@@ -16,3 +16,33 @@ lib_deps =
 	bblanchon/ArduinoJson@^7.4.2
 	arduino-libraries/NTPClient@^3.2.1
 	knolleary/PubSubClient@^2.8
+	robtillaart/CRC@^1.0.3
+	hideakitai/DebugLog@^0.8.4
+build_type = release
+
+board_build.filesystem = ffat
+board_build.partitions = fatfs_partition.csv  ; se stai usando uno custom
+
+
+[env:esp32-s3-waveshare8-debug]
+platform = ${env:esp32-s3-waveshare8.platform}
+board = ${env:esp32-s3-waveshare8.board}
+framework = ${env:esp32-s3-waveshare8.framework}
+lib_deps = 
+	bblanchon/ArduinoJson@^7.4.2
+	arduino-libraries/NTPClient@^3.2.1
+	knolleary/PubSubClient@^2.8
+	robtillaart/CRC@^1.0.3
+	hideakitai/DebugLog@^0.8.4
+build_type = debug
+build_flags =
+    -O0
+    -g3
+    -ggdb
+    -fno-inline
+    -fno-ipa-sra
+    -fno-tree-sra
+    -fno-builtin
+
+board_build.filesystem = ffat
+board_build.partitions = fatfs_partition.csv  ; se stai usando uno custom

src/I2C_Driver.cpp

@@ -1,36 +0,0 @@
-#include "I2C_Driver.h"
-
-
-void I2C_Init(void) {
-  Wire.begin( I2C_SDA_PIN, I2C_SCL_PIN);                       
-}
-
-
-bool I2C_Read(uint8_t Driver_addr, uint8_t Reg_addr, uint8_t *Reg_data, uint32_t Length)
-{
-  Wire.beginTransmission(Driver_addr);
-  Wire.write(Reg_addr); 
-  if ( Wire.endTransmission(true)){
-    printf("The I2C transmission fails. - I2C Read\r\n");
-    return -1;
-  }
-  Wire.requestFrom(Driver_addr, Length);
-  for (int i = 0; i < Length; i++) {
-    *Reg_data++ = Wire.read();
-  }
-  return 0;
-}
-bool I2C_Write(uint8_t Driver_addr, uint8_t Reg_addr, const uint8_t *Reg_data, uint32_t Length)
-{
-  Wire.beginTransmission(Driver_addr);
-  Wire.write(Reg_addr);       
-  for (int i = 0; i < Length; i++) {
-    Wire.write(*Reg_data++);
-  }
-  if ( Wire.endTransmission(true))
-  {
-    printf("The I2C transmission fails. - I2C Write\r\n");
-    return -1;
-  }
-  return 0;
-}

src/I2C_Driver.h

@@ -1,10 +0,0 @@
-#pragma once
-#include <Wire.h> 
-
-#define I2C_SCL_PIN       41
-#define I2C_SDA_PIN       42
-
-void I2C_Init(void);
-
-bool I2C_Read(uint8_t Driver_addr, uint8_t Reg_addr, uint8_t *Reg_data, uint32_t Length);
-bool I2C_Write(uint8_t Driver_addr, uint8_t Reg_addr, const uint8_t *Reg_data, uint32_t Length);

src/MAIN_WIFI_MQTT.cpp

@@ -1,37 +0,0 @@
-#include <Arduino.h>
-#include <HardwareSerial.h>     // Reference the ESP32 built-in serial port library
-#include "WS_MQTT.h"
-#include "WS_Bluetooth.h"
-#include "WS_GPIO.h"
-#include "WS_Serial.h"
-#include "WS_RTC.h"
-#include "WS_GPIO.h"
-#include "WS_DIN.h"
-#include "WS_SD.h"
-#include "WS_ETH.h"
-
-
-uint32_t Simulated_time=0;      // Analog time counting
-
-/********************************************************  Initializing  ********************************************************/
-void setup() { 
-  Flash_test(); 
-  GPIO_Init();  // RGB . Buzzer GPIO
-  I2C_Init();
-  RTC_Init();// RTC
-  SD_Init();
-  Serial_Init();   // UART(RS485/CAN)
-  MQTT_Init();// MQTT
-  Bluetooth_Init();// Bluetooth
-  ETH_Init();
-  
-  DIN_Init();                 // If you don't want to control the relay through DIN, change Relay_Immediate_Default to 0 in WS_DIN.h and re-burn the program
-  Relay_Init();
-
-  printf("Connect to the WIFI network named \"ESP32-S3-POE-ETH-8DI-8RO\" and access the Internet using the connected IP address!!!\r\n");
-}
-
-/**********************************************************  While  **********************************************************/
-void loop() {
-
-}

src/WS_Bluetooth.cpp

@@ -1,152 +0,0 @@
-#include "WS_Bluetooth.h"
-
-BLEServer* pServer;                                                             // Used to represent a BLE server
-BLECharacteristic* pTxCharacteristic;
-BLECharacteristic* pRxCharacteristic;
-
-/**********************************************************  Bluetooth   *********************************************************/
-
-class MyServerCallbacks : public BLEServerCallbacks {                           //By overriding the onConnect() and onDisconnect() functions
-    void onConnect(BLEServer* pServer) {                                        // When the Device is connected, "Device connected" is printed.
-    Serial.println("Device connected"); 
-  }
-
-  void onDisconnect(BLEServer* pServer) {                                       // "Device disconnected" will be printed when the device is disconnected
-    Serial.println("Device disconnected");
-
-    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();                 // Re-broadcast so that the device can query
-    pAdvertising->addServiceUUID(SERVICE_UUID);                                 // Re-broadcast so that the device can query
-    pAdvertising->setScanResponse(true);                                        // Re-broadcast so that the device can query
-    pAdvertising->setMinPreferred(0x06);                                        // Re-broadcast so that the device can query 
-    pAdvertising->setMinPreferred(0x12);                                        // Re-broadcast so that the device can query 
-    BLEDevice::startAdvertising();                                              // Re-broadcast so that the device can query 
-    pRxCharacteristic->notify();                                                // Re-broadcast so that the device can query  
-    pAdvertising->start();                                                      // Re-broadcast so that the device can query
-  }
-};
-class MyRXCallback : public BLECharacteristicCallbacks {
-  void onWrite(BLECharacteristic* pCharacteristic) {                            // The onWrite function is called when the remote device sends data to your feature
-    String rxValue = String(pCharacteristic->getValue().c_str());
-    if (!rxValue.isEmpty()) {
-      // The received data rxValue is processed here
-      if(rxValue.length() == 1)
-      {
-        printf("%s\n", rxValue.c_str());                                        // Print output through the serial port
-        uint8_t* valueBytes = reinterpret_cast<uint8_t*>(const_cast<char*>(rxValue.c_str())); // Convert value to uint8 t*
-        Relay_Analysis(valueBytes,Bluetooth_Mode);                              // pilot relay
-      }
-      else if(rxValue.length() == 2)
-      {
-        if(Extension_Enable)
-        {
-          printf("%s\n", rxValue.c_str());                                      // Print output through the serial port       
-          uint8_t* valueBytes = reinterpret_cast<uint8_t*>(const_cast<char*>(rxValue.c_str())); // Convert value to uint8 t*
-          if(valueBytes[0] == 0x06)                                             // Instruction check correct
-            RS485_Analysis(valueBytes);                                         // Control external relay
-          else
-            printf("Note : Non-instruction data was received - Bluetooth !\r\n");
-        }
-        else
-          printf("Note : Non-instruction data was received or external relays are not enabled - Bluetooth !\r\n");
-      }
-      
-      else if(rxValue.length() == 14)
-      {
-        if(RTC_Event_Enable)
-        {   
-          // printf("%s\n", rxValue.c_str());                                      // Print output through the serial port  
-          uint8_t* valueBytes = reinterpret_cast<uint8_t*>(const_cast<char*>(rxValue.c_str())); 
-          BLE_Set_RTC_Event(valueBytes);
-        }
-        else
-          printf("Note : Non-instruction data was received or RTC events were not enabled - Bluetooth !\r\n");
-      }
-      else
-      {
-        printf("Note : Non-instruction data was received - Bluetooth !\r\n");
-      }
-      pRxCharacteristic->setValue("");                                           // After data is read, set it to blank for next read
-    }
-  }
-};
-
-void BLE_Set_RTC_Event(uint8_t* valueBytes){
-  if(valueBytes[0] == 0xA1 && valueBytes[6] == 0xAA  && valueBytes[13] == 0xFF ){
-    datetime_t Event_Time={0};
-    Event_Time.year = (valueBytes[1]/16*10 + valueBytes[1] % 16) *100 + valueBytes[2]/16*10 + valueBytes[2] % 16;
-    Event_Time.month = valueBytes[3]/16*10 + valueBytes[3] % 16;
-    Event_Time.day = valueBytes[4]/16*10 + valueBytes[4] % 16;
-    Event_Time.dotw = valueBytes[5]/16*10 + valueBytes[5] % 16;
-    // valueBytes[6] == 0xAA; // check
-    Event_Time.hour = valueBytes[7]/16*10 + valueBytes[7] % 16;
-    Event_Time.minute = valueBytes[8]/16*10 + valueBytes[8] % 16;
-    Event_Time.second = valueBytes[9]/16*10 + valueBytes[9] % 16;
-    Repetition_event Repetition = (Repetition_event)valueBytes[12];       // cyclical indicators
-    if(valueBytes[11]){                                                   // Whether to control all relays   1:Control all relays    0：Control a relay
-      uint8_t CHxs = valueBytes[10];                                      // relay control
-      TimerEvent_CHxs_Set(Event_Time, CHxs, Repetition);
-    }
-    else{
-      uint8_t CHx = valueBytes[10]/16;
-      bool State =  (valueBytes[10] % 16);
-      TimerEvent_CHx_Set(Event_Time,CHx, State, Repetition);
-    } 
-  }
-}
-void Bluetooth_SendData(char* Data) {  // Send data using Bluetooth
-  if (Data != nullptr && strlen(Data) > 0) {
-    if (pServer->getConnectedCount() > 0) {
-      String SendValue = String(Data);  // Convert char* to String
-      pTxCharacteristic->setValue(SendValue.c_str());  // Set SendValue to the eigenvalue (String type)
-      pTxCharacteristic->notify();  // Sends a notification to all connected devices
-    }
-  }
-}
-void Bluetooth_Init()
-{
-  /*************************************************************************
-  Bluetooth
-  *************************************************************************/
-  BLEDevice::init("ESP32-S3-POE-ETH-8DI-8RO");                                        // Initialize Bluetooth and start broadcasting                           
-  pServer = BLEDevice::createServer();                                          
-  pServer->setCallbacks(new MyServerCallbacks());                               
-  BLEService* pService = pServer->createService(SERVICE_UUID);                  
-  pTxCharacteristic = pService->createCharacteristic(
-                                    TX_CHARACTERISTIC_UUID,
-                                    BLECharacteristic:: PROPERTY_READ);         // The eigenvalues are readable and can be read by remote devices
-  pRxCharacteristic = pService->createCharacteristic(
-                                    RX_CHARACTERISTIC_UUID,
-                                    BLECharacteristic::PROPERTY_WRITE);         // The eigenvalues are writable and can be written to by remote devices
-  pRxCharacteristic->setCallbacks(new MyRXCallback());
-
-  pRxCharacteristic->setValue("Successfully Connect To ESP32-S3-POE-ETH-8DI-8RO");      
-  pService->start();   
-
-  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();                   
-  pAdvertising->addServiceUUID(SERVICE_UUID);                                   
-  pAdvertising->setScanResponse(true);                                          
-  pAdvertising->setMinPreferred(0x06);                                          
-  pAdvertising->setMinPreferred(0x12);                                          
-  BLEDevice::startAdvertising();                                                
-  pRxCharacteristic->notify();                                                    
-  pAdvertising->start();
-  RGB_Open_Time(0, 0, 60,1000, 0); 
-  printf("Now you can read it in your phone!\r\n");
-  xTaskCreatePinnedToCore(
-    BLETask,    
-    "BLETask",   
-    4096,                
-    NULL,                 
-    2,                   
-    NULL,                 
-    0                   
-  );
-}
-
-void BLETask(void *parameter) {
-  while(1){
-    Bluetooth_SendData(ipStr);
-    vTaskDelay(pdMS_TO_TICKS(100));
-  }
-  vTaskDelete(NULL);
-}

src/WS_Bluetooth.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <HardwareSerial.h>     // Reference the ESP32 built-in serial port library
-#include <BLEDevice.h>
-#include <BLEUtils.h>
-#include <BLEServer.h>
-#include "WS_GPIO.h"
-#include "WS_Serial.h"
-#include "WS_Information.h"
-#include "WS_Relay.h"
-#include "WS_MQTT.h"
-#include "WS_RTC.h"
-
-#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"                     // UUID of the server
-#define RX_CHARACTERISTIC_UUID  "beb5483e-36e1-4688-b7f5-ea07361b26a8"          // UUID of the characteristic Tx
-#define TX_CHARACTERISTIC_UUID  "beb5484a-36e1-4688-b7f5-ea07361b26a8"          // UUID of the characteristic Rx
-
-#define Bluetooth_Mode    2
-
-
-void Bluetooth_SendData(char * Data);   
-void Bluetooth_Init();
-void BLETask(void *parameter);
-void BLE_Set_RTC_Event(uint8_t* valueBytes);

src/WS_CAN.cpp

@@ -1,219 +0,0 @@
-#include "WS_CAN.h"
-
-static bool driver_installed = false;
-
-void CAN_Init(void)
-{                                // Initializing serial port
-  // Initialize configuration structures using macro initializers
-  twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT((gpio_num_t)TXD1, (gpio_num_t)RXD1, TWAI_MODE_NORMAL);
-  twai_timing_config_t t_config = TWAI_TIMING_CONFIG_250KBITS();  //Look in the api-reference for other speed sets.
-  twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();
-
-  // Install TWAI driver
-  if (twai_driver_install(&g_config, &t_config, &f_config) == ESP_OK) {
-    printf("Driver installed\r\n");
-  } else {
-    printf("Failed to install driver\r\n");
-    return;
-  }
-
-  // Start TWAI driver
-  if (twai_start() == ESP_OK) {
-    printf("Driver started\r\n");
-  } else {
-    printf("Failed to start driver\r\n");
-    return;
-  }
-
-  // Reconfigure alerts to detect TX alerts and Bus-Off errors
-  uint32_t alerts_to_enable = TWAI_ALERT_RX_DATA | TWAI_ALERT_ERR_PASS | TWAI_ALERT_BUS_ERROR | TWAI_ALERT_RX_QUEUE_FULL | TWAI_ALERT_TX_IDLE | TWAI_ALERT_TX_SUCCESS | TWAI_ALERT_TX_FAILED;
-  if (twai_reconfigure_alerts(alerts_to_enable, NULL) == ESP_OK) {
-    printf("CAN Alerts reconfigured\r\n");
-  } else {
-    printf("Failed to reconfigure alerts\r\n");
-    return;
-  }
-
-  // TWAI driver is now successfully installed and started
-  driver_installed = true;
-
-  xTaskCreatePinnedToCore(
-    CANTask,    
-    "CANTask",   
-    4096,                
-    NULL,                 
-    3,                   
-    NULL,                 
-    0                   
-  );
-}
-
-static void send_message_Test(void) {
-  // Send message
-  // Configure message to transmit
-  twai_message_t message;
-  message.identifier = 0x0F6;
-  message.data_length_code = 4;
-  for (int i = 0; i < 4; i++) {
-    message.data[i] = i;
-  }
-
-  // Queue message for transmission
-  if (twai_transmit(&message, pdMS_TO_TICKS(1000)) == ESP_OK) {
-    printf("Message queued for transmission\n");
-  } else {
-    printf("Failed to queue message for transmission\n");
-  }
-}
-// Standard frames ID: 0x000 to 0x7FF
-// Extended frames ID: 0x00000000  to 0x1FFFFFFF
-// Frame_type : 1：Extended frames   0：Standard frames
-void send_message(uint32_t CAN_ID, uint8_t* Data, uint8_t Data_length, bool Frame_type) {
-  // Send message
-  // Configure message to transmit
-  twai_message_t message;
-  message.identifier = CAN_ID;
-  message.rtr = 0;                              // Disable remote frame
-  if(CAN_ID > 0x7FF){
-    if(!Frame_type)
-      printf("The frame type is set incorrectly and data will eventually be sent as an extended frame!!!!\r\n");
-    message.extd = 1;
-  }
-  else
-    message.extd = Frame_type;
-  if(Data_length > 8){
-    uint16_t Frame_count = (Data_length / 8);
-    for (int i = 0; i < Frame_count; i++) {
-      message.data_length_code = 8;
-      for (int j = 0; j < 8; j++) {
-        message.data[j] = Data[j + (i * 8)];
-      }
-      // Queue message for transmission
-      if (twai_transmit(&message, pdMS_TO_TICKS(1000)) == ESP_OK) {
-        printf("Message queued for transmission\n");
-      } else {
-        printf("Failed to queue message for transmission\n");
-      }
-    }
-    if(Data_length % 8){
-      uint8_t Data_length_Now = Data_length % 8;
-      message.data_length_code = Data_length_Now;
-      for (int k = 0; k < Data_length_Now; k++) {
-        message.data[k] = Data[k + (Data_length - Data_length_Now)];
-      }
-      // Queue message for transmission
-      if (twai_transmit(&message, pdMS_TO_TICKS(1000)) == ESP_OK) {
-        printf("Message queued for transmission\n");
-      } else {
-        printf("Failed to queue message for transmission\n");
-      }
-    }
-  }
-  else{
-    message.data_length_code = Data_length;
-    for (int i = 0; i < Data_length; i++) {
-      message.data[i] = Data[i];
-    }
-    // Queue message for transmission
-    if (twai_transmit(&message, pdMS_TO_TICKS(1000)) == ESP_OK) {
-      printf("Message queued for transmission\n");
-    } else {
-      printf("Failed to queue message for transmission\n");
-    }
-  }
-}
-
-
-
-static void handle_rx_message(twai_message_t &message) {
-  // Process received message
-  if (message.extd) {
-    printf("Message is in Extended Format\r\n");
-  } else {
-    printf("Message is in Standard Format\r\n");
-  }
-  printf("ID: %lx\nByte:", message.identifier);
-  if (!(message.rtr)) {
-    if (message.data_length_code > 0) {
-      printf(" Data: ");
-      for (int i = 0; i < message.data_length_code; i++) {
-        printf("%02x ", message.data[i]);
-      }
-      printf("\r\n");
-      // printf("Send back the received data!\r\n");
-      // send_message(message.identifier,  message.data, message.data_length_code, message.extd);
-    } else {
-      printf(" No data available\r\n");
-    }
-  } else {
-    printf("This is a Remote Transmission Request (RTR) frame.\r\n");
-  }
-}
-
-unsigned long previousMillis = 0;  // will store last time a message was send
-#if Communication_failure_Enable
-  static unsigned long previous_bus_error_time = 0; // To store the last time a BUS_ERROR was printed
-#endif
-void CAN_Loop(void)
-{
-  if(driver_installed){
-    // Check if an alert happened
-    uint32_t alerts_triggered;
-    twai_read_alerts(&alerts_triggered, pdMS_TO_TICKS(POLLING_RATE_MS));
-    twai_status_info_t twaistatus;
-    twai_get_status_info(&twaistatus);
-
-    // Handle alerts
-    if (alerts_triggered & TWAI_ALERT_ERR_PASS) {
-      printf("Alert: TWAI controller has become error passive.\r\n");
-    }
-    if (alerts_triggered & TWAI_ALERT_BUS_ERROR) {
-      // printf("Alert: A (Bit, Stuff, CRC, Form, ACK) error has occurred on the bus.\r\n");
-      // printf("Bus error count: %ld\n", twaistatus.bus_error_count);
-      #if Communication_failure_Enable
-        unsigned long currentMillis = millis();
-        // Only print the message if more than 2 seconds have passed since the last time it was printed
-        if (currentMillis - previous_bus_error_time >= BUS_ERROR_INTERVAL_MS) {
-          printf("Note if there are other devices on the CAN bus (other devices must be present) and that the rate of the device is the same as set in this program\r\n");
-          previous_bus_error_time = currentMillis; // Update the last print time
-        }
-      #endif
-    }
-    if (alerts_triggered & TWAI_ALERT_RX_QUEUE_FULL) {
-      printf("Alert: The RX queue is full causing a received frame to be lost.\r\n");
-      printf("RX buffered: %ld\t", twaistatus.msgs_to_rx);
-      printf("RX missed: %ld\t", twaistatus.rx_missed_count);
-      printf("RX overrun %ld\n", twaistatus.rx_overrun_count);
-    }
-    if (alerts_triggered & TWAI_ALERT_TX_FAILED) {
-      printf("Alert: The Transmission failed.\r\n");
-      printf("TX buffered: %ld\t", twaistatus.msgs_to_tx);
-      printf("TX error: %ld\t", twaistatus.tx_error_counter);
-      printf("TX failed: %ld\n", twaistatus.tx_failed_count);
-    }
-    if (alerts_triggered & TWAI_ALERT_TX_SUCCESS) {
-      printf("Alert: The Transmission was successful.\r\n");
-      printf("TX buffered: %ld\t \r\n", twaistatus.msgs_to_tx);
-    }
-
-    // Receive messages if any are available
-    if (alerts_triggered & TWAI_ALERT_RX_DATA) {
-      // One or more messages received. Handle all.
-      twai_message_t message;                             // This is the structure used to store the received CAN message.
-      while (twai_receive(&message, 0) == ESP_OK) {
-        handle_rx_message(message);                       // This function will process the received message.
-      }
-    }
-  }
-}
-
-void CANTask(void *parameter) {
-  // send_message_Test();
-  // uint8_t Data[27]={0x80, 0x2A, 0xC3, 0x58, 0x17, 0x11, 0x4D, 0x3F, 0x3B, 0xCE, 0x0F, 0xFF, 0x79, 0x20, 0xB4, 0x40, 0x5D, 0x29, 0x05, 0x49, 0xE6, 0x12, 0x57, 0x0E, 0x6D, 0xC9, 0xAE};
-  // send_message(0x079,Data,27);
-  while(1){
-    CAN_Loop();
-    vTaskDelay(pdMS_TO_TICKS(50));
-  }
-  vTaskDelete(NULL);
-}

src/WS_CAN.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "driver/twai.h"
-#include "WS_GPIO.h"
-
-// Interval:
-#define TRANSMIT_RATE_MS      1000
-// Interval:
-#define POLLING_RATE_MS       1000
-
-#define Communication_failure_Enable    0         // If the CAN bus is faulty for a long time, determine whether to forcibly exit
-
-#if Communication_failure_Enable
-  #define BUS_ERROR_INTERVAL_MS         5000      // Send a message every 2 seconds (2000 ms)
-#endif
-
-
-void CAN_Init(void);
-void CAN_Loop(void);
-void CANTask(void *parameter);
-
-void send_message(uint32_t CAN_ID, uint8_t* Data, uint8_t Data_length);

src/WS_DIN.cpp

@@ -1,151 +0,0 @@
-#include "WS_DIN.h"
-
-bool DIN_Flag[8] = {0};                   // DIN current status flag
-uint8_t DIN_Data = 0;
-bool Relay_Immediate_Enable = Relay_Immediate_Default;
-
-bool DIN_Read_CH1(void){
-  DIN_Flag[0] = digitalRead(DIN_PIN_CH1);
-  if(DIN_Flag[0]){
-    DIN_Data |= (1 << 0); 
-    return 1;
-  }
-  else{
-    DIN_Data &= (~(1 << 0)); 
-    return 0;
-  }
-}
-bool DIN_Read_CH2(void){
-  DIN_Flag[1] = digitalRead(DIN_PIN_CH2);
-  if(DIN_Flag[1]){
-    DIN_Data |= (1 << 1); 
-    return 1;
-  }
-  else{
-    DIN_Data &= (~(1 << 1)); 
-    return 0;
-  }
-}
-bool DIN_Read_CH3(void){
-  DIN_Flag[2] = digitalRead(DIN_PIN_CH3);
-  if(DIN_Flag[2]){
-    DIN_Data |= (1 << 2); 
-    return 1;
-  }
-  else{
-    DIN_Data &= (~(1 << 2)); 
-    return 0;
-  }
-}
-bool DIN_Read_CH4(void){
-  DIN_Flag[3] = digitalRead(DIN_PIN_CH4);
-  if(DIN_Flag[3]){
-    DIN_Data |= (1 << 3); 
-    return 1;
-  }
-  else{
-    DIN_Data &= (~(1 << 3)); 
-    return 0;
-  }
-}
-bool DIN_Read_CH5(void){
-  DIN_Flag[4] = digitalRead(DIN_PIN_CH5);
-  if(DIN_Flag[4]){
-    DIN_Data |= (1 << 4); 
-    return 1;
-  }
-  else{
-    DIN_Data &= (~(1 << 4)); 
-    return 0;
-  }
-}
-bool DIN_Read_CH6(void){
-  DIN_Flag[5] = digitalRead(DIN_PIN_CH6);
-  if(DIN_Flag[5]){
-    DIN_Data |= (1 << 5); 
-    return 1;
-  }
-  else{
-    DIN_Data &= (~(1 << 5)); 
-    return 0;
-  }
-}
-bool DIN_Read_CH7(void){
-  DIN_Flag[6] = digitalRead(DIN_PIN_CH7);
-  if(DIN_Flag[6]){
-    DIN_Data |= (1 << 6); 
-    return 1;
-  }
-  else{
-    DIN_Data &= (~(1 << 6)); 
-    return 0;
-  }
-}
-bool DIN_Read_CH8(void){
-  DIN_Flag[7] = digitalRead(DIN_PIN_CH8);
-  if(DIN_Flag[7]){
-    DIN_Data |= (1 << 7); 
-    return 1;
-  }
-  else{
-    DIN_Data &= (~(1 << 7)); 
-    return 0;
-  }
-}
-uint8_t DIN_Read_CHxs(){
-  DIN_Read_CH1();
-  DIN_Read_CH2();
-  DIN_Read_CH3();
-  DIN_Read_CH4();
-  DIN_Read_CH5();
-  DIN_Read_CH6();
-  DIN_Read_CH7();
-  DIN_Read_CH8();
-  return DIN_Data;
-}
-
-static uint8_t DIN_Data_Old = 0;
-void DINTask(void *parameter) {
-  while(1){
-    if(Relay_Immediate_Enable){
-      DIN_Read_CHxs();
-      if(DIN_Data_Old != DIN_Data){
-        if(DIN_Inverse_Enable)
-          Relay_Immediate_CHxs(~DIN_Data , DIN_Mode);
-        else
-          Relay_Immediate_CHxs(DIN_Data , DIN_Mode);
-        DIN_Data_Old = DIN_Data;
-      }
-    }
-    vTaskDelay(pdMS_TO_TICKS(20));
-  }
-  vTaskDelete(NULL);
-}
-
-void DIN_Init(void)
-{
-  pinMode(DIN_PIN_CH1, INPUT_PULLUP);
-  pinMode(DIN_PIN_CH2, INPUT_PULLUP);
-  pinMode(DIN_PIN_CH3, INPUT_PULLUP);
-  pinMode(DIN_PIN_CH4, INPUT_PULLUP);
-  pinMode(DIN_PIN_CH5, INPUT_PULLUP);
-  pinMode(DIN_PIN_CH6, INPUT_PULLUP);
-  pinMode(DIN_PIN_CH7, INPUT_PULLUP);
-  pinMode(DIN_PIN_CH8, INPUT_PULLUP);
-
-  DIN_Read_CHxs();
-  if(DIN_Inverse_Enable)
-    DIN_Data_Old = 0xFF;
-  else
-    DIN_Data_Old = 0x00;
-
-  xTaskCreatePinnedToCore(
-    DINTask,    
-    "DINTask",   
-    4096,                
-    NULL,                 
-    4,                   
-    NULL,                 
-    0                   
-  );
-}

src/WS_DIN.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "WS_GPIO.h"
-#include "WS_Relay.h"
-/*************************************************************  I/O  *************************************************************/
-#define DIN_PIN_CH1      4      // DIN CH1 GPIO
-#define DIN_PIN_CH2      5      // DIN CH2  GPIO
-#define DIN_PIN_CH3      6      // DIN CH3  GPIO
-#define DIN_PIN_CH4      7      // DIN CH4  GPIO
-#define DIN_PIN_CH5      8      // DIN CH5  GPIO
-#define DIN_PIN_CH6      9      // DIN CH6  GPIO
-#define DIN_PIN_CH7      10     // DIN CH7  GPIO
-#define DIN_PIN_CH8      11     // DIN CH8  GPIO
-
-#define Relay_Immediate_Default   1       // Enable the input control relay
-#define DIN_Inverse_Enable        1       // Input is reversed from control
-
-void DIN_Init(void);

src/WS_ETH.cpp

@@ -1,120 +0,0 @@
-#include "WS_ETH.h"
-
-#include <NTPClient.h>
-#include <WiFiUdp.h>
-
-static bool eth_connected = false;
-static bool eth_connected_Old = false;
-IPAddress ETH_ip;
-// NTP setup
-WiFiUDP udp;
-NTPClient timeClient(udp, "pool.ntp.org", timezone*3600, 60000);  // NTP server, time offset in seconds, update interval
-
-void onEvent(arduino_event_id_t event, arduino_event_info_t info) {
-  switch (event) {
-    case ARDUINO_EVENT_ETH_START:
-      printf("ETH Started\r\n");
-      //set eth hostname here
-      ETH.setHostname("esp32-eth0");
-      break;
-    case ARDUINO_EVENT_ETH_CONNECTED: printf("ETH Connected\r\n"); break;
-    case ARDUINO_EVENT_ETH_GOT_IP:    printf("ETH Got IP: '%s'\n", esp_netif_get_desc(info.got_ip.esp_netif)); //printf("%s\r\n",ETH);
-      ETH_ip = ETH.localIP(); 
-      printf("ETH Got IP: %d.%d.%d.%d\n", ETH_ip[0], ETH_ip[1], ETH_ip[2], ETH_ip[3]);
-#if USE_TWO_ETH_PORTS
-      // printf("%d\r\n",ETH1);
-#endif
-      eth_connected = true;
-      break;
-    case ARDUINO_EVENT_ETH_LOST_IP:
-      printf("ETH Lost IP\r\n");
-      eth_connected = false;
-      break;
-    case ARDUINO_EVENT_ETH_DISCONNECTED:
-      printf("ETH Disconnected\r\n");
-      eth_connected = false;
-      break;
-    case ARDUINO_EVENT_ETH_STOP:
-      printf("ETH Stopped\r\n");
-      eth_connected = false;
-      break;
-    default: break;
-  }
-}
-
-void testClient(const char *host, uint16_t port) {
-  printf("\nconnecting to \r\n");;
-  printf("%s\r\n",host);
-
-  NetworkClient client;
-  if (!client.connect(host, port)) {
-    printf("connection failed\r\n");
-    return;
-  }
-  client.printf("GET / HTTP/1.1\r\nHost: %s\r\n\r\n", host);
-  while (client.connected() && !client.available());
-  while (client.available()) {
-    printf("%c",(char)client.read());
-  }
-
-  printf("closing connection\n");
-  client.stop();
-}
-
-void ETH_Init(void) {
-  printf("Ethernet Start\r\n");
-  Network.onEvent(onEvent);
-
-  SPI.begin(ETH_SPI_SCK, ETH_SPI_MISO, ETH_SPI_MOSI);
-  ETH.begin(ETH_PHY_TYPE, ETH_PHY_ADDR, ETH_PHY_CS, ETH_PHY_IRQ, ETH_PHY_RST, SPI);
-#if USE_TWO_ETH_PORTS
-  ETH1.begin(ETH1_PHY_TYPE, ETH1_PHY_ADDR, ETH1_PHY_CS, ETH1_PHY_IRQ, ETH1_PHY_RST, SPI);
-#endif
-  xTaskCreatePinnedToCore(
-    EthernetTask,    
-    "EthernetTask",   
-    4096,                
-    NULL,                 
-    2,                   
-    NULL,                 
-    0                   
-  );
-}
-void EthernetTask(void *parameter) {
-  while(1){
-    if (eth_connected && !eth_connected_Old) {
-      eth_connected_Old = eth_connected;
-      RGB_Open_Time(0, 60, 0,1000, 0); 
-      printf("Network port connected!\r\n");
-      Acquisition_time();
-    }
-    else if(!eth_connected && eth_connected_Old){
-      eth_connected_Old = eth_connected;
-      printf("Network port disconnected!\r\n");
-    }
-    vTaskDelay(pdMS_TO_TICKS(100));
-  }
-  vTaskDelete(NULL);
-}
-void Acquisition_time(void) {                                   // Get the network time and set to DS3231 to be called after the WIFI connection is successful
-  timeClient.begin();
-  timeClient.update();
-
-  time_t currentTime = timeClient.getEpochTime();
-  while(currentTime < 1609459200)                           // Using the current timestamp to compare with a known larger value,1609459200 is a known larger timestamp value that corresponds to January 1, 2021
-  {
-    timeClient.update();  
-    currentTime = timeClient.getEpochTime();
-    printf("ETH - Online clock error!!!\r\n");
-  }
-  struct tm *localTime = localtime(&currentTime);
-  static datetime_t PCF85063_Time = {0};
-  PCF85063_Time.year = localTime->tm_year + 1900;
-  PCF85063_Time.month = localTime->tm_mon + 1;
-  PCF85063_Time.day = localTime->tm_mday;
-  PCF85063_Time.dotw = localTime->tm_wday;
-  PCF85063_Time.hour = localTime->tm_hour;
-  PCF85063_Time.minute = localTime->tm_min;
-  PCF85063_Time.second = localTime->tm_sec;
-  PCF85063_Set_All(PCF85063_Time);
-}

src/WS_ETH.h

@@ -1,44 +0,0 @@
-#pragma once
-#include <Arduino.h>
-#include <ETH.h>
-#include <SPI.h>
-
-#include "WS_PCF85063.h"
-#include "WS_GPIO.h"
-#include "WS_RTC.h"
-
-// Set this to 1 to enable dual Ethernet support
-#define USE_TWO_ETH_PORTS 0
-
-#ifndef ETH_PHY_TYPE
-  #define ETH_PHY_TYPE ETH_PHY_W5500
-  #define ETH_PHY_ADDR 1
-  #define ETH_PHY_CS   16
-  #define ETH_PHY_IRQ  12
-  #define ETH_PHY_RST  39
-#endif
-
-// SPI pins
-#define ETH_SPI_SCK  15
-#define ETH_SPI_MISO 14
-#define ETH_SPI_MOSI 13
-
-#if USE_TWO_ETH_PORTS
-  // Second port on shared SPI bus
-  #ifndef ETH1_PHY_TYPE
-    #define ETH1_PHY_TYPE ETH_PHY_W5500
-    #define ETH1_PHY_ADDR 1
-    #define ETH1_PHY_CS   32
-    #define ETH1_PHY_IRQ  33
-    #define ETH1_PHY_RST  18
-  #endif
-  ETHClass ETH1(1);
-#endif
-
-#define timezone 8        // china 
-
-void ETH_Init(void);
-void ETH_Loop(void);
-void EthernetTask(void *parameter);
-
-void Acquisition_time(void);

src/WS_GPIO.cpp

@@ -1,166 +0,0 @@
-#include "WS_GPIO.h"
-
-/*************************************************************  I/O Init  *************************************************************/
-void GPIO_Init() {
-  pinMode(GPIO_PIN_RGB, OUTPUT);     // Initialize the control GPIO of RGB
-  pinMode(GPIO_PIN_Buzzer, OUTPUT);  // Initialize the control GPIO of Buzzer
-
-  // TODO: Re enable this
-  //ledcAttach(GPIO_PIN_Buzzer, Frequency, Resolution);   
-  Set_Dutyfactor(0);                //0~100  
-
-  xTaskCreatePinnedToCore(
-    RGBTask,    
-    "RelayFailTask",   
-    4096,                
-    NULL,                 
-    2,                   
-    NULL,                 
-    0                   
-  );
-  xTaskCreatePinnedToCore(
-    BuzzerTask,    
-    "RelayFailTask",   
-    4096,                
-    NULL,                 
-    2,                   
-    NULL,                 
-    0                   
-  );
-}
-
-/*************************************************************  RGB  *************************************************************/
-void RGB_Light(uint8_t red_val, uint8_t green_val, uint8_t blue_val) {
-  rgbLedWrite(GPIO_PIN_RGB, green_val, red_val, blue_val);  // RGB color adjustment
-}
-RGB_Indicate RGB_indicate[RGB_Indicate_Number];
-static uint8_t RGB_indicate_Num = 0;
-void RGB_Open_Time(uint8_t red_val, uint8_t green_val, uint8_t blue_val, uint16_t Time, uint16_t flicker_time) {
-
-  if(RGB_indicate_Num + 1 >= RGB_Indicate_Number)
-  {
-    printf("Note : The RGB indicates that the cache is full and has been ignored\r\n");
-  }
-  else{
-    RGB_indicate[RGB_indicate_Num].Red = red_val;
-    RGB_indicate[RGB_indicate_Num].Green = green_val;
-    RGB_indicate[RGB_indicate_Num].Blue = blue_val;
-    RGB_indicate[RGB_indicate_Num].RGB_Time = Time;
-    if(flicker_time<51)
-      flicker_time = 0;                                         // If the blinking interval is less than 50ms, the blinking is ignored
-    RGB_indicate[RGB_indicate_Num].RGB_Flicker = flicker_time;
-    RGB_indicate_Num ++;
-  }
-}
-void RGBTask(void *parameter) {
-  bool RGB_Flag = 0;
-  while(1){
-    if(RGB_indicate[0].RGB_Time)
-    {
-      RGB_Flag = 1;
-      RGB_Light(RGB_indicate[0].Red, RGB_indicate[0].Green, RGB_indicate[0].Blue); 
-      if(RGB_indicate[0].RGB_Flicker){
-        vTaskDelay(pdMS_TO_TICKS(RGB_indicate[0].RGB_Flicker));
-        RGB_Light(0, 0, 0);  
-        vTaskDelay(pdMS_TO_TICKS(RGB_indicate[0].RGB_Flicker));
-      }
-      if(RGB_indicate[0].RGB_Time > (RGB_indicate[0].RGB_Flicker * 2 +50))
-        RGB_indicate[0].RGB_Time = RGB_indicate[0].RGB_Time -(RGB_indicate[0].RGB_Flicker * 2 +50);
-      else
-        RGB_indicate[0].RGB_Time = 0;
-    }
-    else if(RGB_Flag && !RGB_indicate[0].RGB_Time){
-      RGB_Light(0, 0, 0);  
-      RGB_Flag = 0;
-      RGB_indicate[0].Red = 0;
-      RGB_indicate[0].Green = 0;
-      RGB_indicate[0].Blue = 0;
-      RGB_indicate[0].RGB_Time = 0;
-      RGB_indicate[0].RGB_Flicker = 0;
-      if(RGB_indicate_Num > 0){
-        for (int i = 1; i < RGB_Indicate_Number; i++) {
-          RGB_indicate[i-1] = RGB_indicate[i];  
-        }
-        RGB_indicate[RGB_Indicate_Number -1].Red = 0;
-        RGB_indicate[RGB_Indicate_Number -1].Green = 0;
-        RGB_indicate[RGB_Indicate_Number -1].Blue = 0;
-        RGB_indicate[RGB_Indicate_Number -1].RGB_Time = 0;
-        RGB_indicate[RGB_Indicate_Number -1].RGB_Flicker = 0;
-        RGB_indicate_Num --;
-        vTaskDelay(pdMS_TO_TICKS(RGB_Indicating_interval));
-      }
-    }
-    vTaskDelay(pdMS_TO_TICKS(50));
-  }
-  vTaskDelete(NULL);
-}
-
-
-/*************************************************************  Buzzer  *************************************************************/
-void Set_Dutyfactor(uint16_t dutyfactor)                     
-{
-  if(dutyfactor > Dutyfactor_MAX || dutyfactor < 0)
-    printf("Set Backlight parameters in the range of 0 to %d \r\n",Dutyfactor_MAX);
-  else{
-    ledcWrite(GPIO_PIN_Buzzer, dutyfactor);
-  }
-}
-void Buzzer_Open(void)  
-{
-  Set_Dutyfactor(Dutyfactor);
-}
-void Buzzer_Closs(void)  
-{
-  Set_Dutyfactor(0);
-}
-Buzzer_Indicate Buzzer_indicate[Buzzer_Indicate_Number];
-static uint8_t Buzzer_indicate_Num = 0;
-void Buzzer_Open_Time(uint16_t Time, uint16_t flicker_time) 
-{
-  if(Buzzer_indicate_Num + 1 >= Buzzer_Indicate_Number)
-  {
-    printf("Note : The buzzer indicates that the cache is full and has been ignored\r\n");
-  }
-  else{
-    Buzzer_indicate[Buzzer_indicate_Num].Buzzer_Time = Time;
-    if(flicker_time<51)
-      flicker_time = 0;                                         // If the blinking interval is less than 50ms, the blinking is ignored
-    Buzzer_indicate[Buzzer_indicate_Num].Buzzer_Flicker = flicker_time;
-    Buzzer_indicate_Num ++;
-  }
-}
-void BuzzerTask(void *parameter) {
-  bool Buzzer_Flag = 0;
-  while(1){
-    if(Buzzer_indicate[0].Buzzer_Time)
-    {
-      Buzzer_Flag = 1;
-      Buzzer_Open(); 
-      if(Buzzer_indicate[0].Buzzer_Flicker){
-        vTaskDelay(pdMS_TO_TICKS(Buzzer_indicate[0].Buzzer_Flicker));
-        Buzzer_Closs();  
-        vTaskDelay(pdMS_TO_TICKS(Buzzer_indicate[0].Buzzer_Flicker));
-      }
-      if(Buzzer_indicate[0].Buzzer_Time > (Buzzer_indicate[0].Buzzer_Flicker * 2 +50))
-        Buzzer_indicate[0].Buzzer_Time = Buzzer_indicate[0].Buzzer_Time -(Buzzer_indicate[0].Buzzer_Flicker * 2 +50);
-      else
-        Buzzer_indicate[0].Buzzer_Time = 0;
-    }
-    else if(Buzzer_Flag && !Buzzer_indicate[0].Buzzer_Time){
-      Buzzer_Closs();  
-      Buzzer_Flag = 0;
-      Buzzer_indicate[0].Buzzer_Time = 0;
-      Buzzer_indicate[0].Buzzer_Flicker = 0;
-      if(Buzzer_indicate_Num > 0){
-        for (int i = 1; i < Buzzer_indicate_Num; i++) {
-          Buzzer_indicate[i-1] = Buzzer_indicate[i];  
-        }
-        Buzzer_indicate[Buzzer_indicate_Num - 1].Buzzer_Time = 0;
-        Buzzer_indicate[Buzzer_indicate_Num - 1].Buzzer_Flicker = 0;
-        Buzzer_indicate_Num --;
-      }
-    }
-    vTaskDelay(pdMS_TO_TICKS(50));
-  }
-  vTaskDelete(NULL);
-}

src/WS_GPIO.h

@@ -1,44 +0,0 @@
-#pragma once
-#include <Arduino.h>
-#include <HardwareSerial.h>     // Reference the ESP32 built-in serial port library
-
-/*************************************************************  I/O  *************************************************************/
-#define TXD1              17    //The TXD of UART1 corresponds to GPIO   RS485/CAN
-#define RXD1              18    //The RXD of UART1 corresponds to GPIO   RS485/CAN
-#define GPIO_PIN_RGB      38    // RGB Control GPIO
-
-/***********************************************************  Buzzer  ***********************************************************/
-#define GPIO_PIN_Buzzer 46      // Buzzer Control GPIO
-#define PWM_Channel     1       // PWM Channel   
-#define Frequency       1000    // PWM frequencyconst
-#define Resolution      8       // PWM resolution ratio
-#define Dutyfactor      200     // PWM Dutyfactor
-#define Dutyfactor_MAX  255
-
-
-#define RGB_Indicate_Number  10         // Number of saved RGB indicator signals
-#define RGB_Indicating_interval 500     // Time interval of each indication signal(unit: ms)
-typedef struct { 
-  uint8_t Red = 0;
-  uint8_t Green = 0;
-  uint8_t Blue = 0;
-  uint16_t RGB_Time = 0;                // RGB lighting duration
-  uint16_t RGB_Flicker = 0;             // RGB flicker interval
-} RGB_Indicate;
-
-#define Buzzer_Indicate_Number  10      // Number of saved RGB indicator signals
-typedef struct { 
-  uint16_t Buzzer_Time = 0;             // Buzzer duration
-  uint16_t Buzzer_Flicker = 0;          // Buzzer interval duration
-} Buzzer_Indicate;
-/*************************************************************  I/O  *************************************************************/
-void GPIO_Init();
-void RGB_Light(uint8_t red_val, uint8_t green_val, uint8_t blue_val);
-void RGB_Open_Time(uint8_t red_val, uint8_t green_val, uint8_t blue_val, uint16_t Time, uint16_t flicker_time);
-void RGBTask(void *parameter);
-
-void Set_Dutyfactor(uint16_t dutyfactor);
-void Buzzer_Open(void);
-void Buzzer_Closs(void);
-void Buzzer_Open_Time(uint16_t Time, uint16_t flicker_time); 
-void BuzzerTask(void *parameter);

src/WS_Information.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#define Extension_Enable      1                   // Whether to extend the connection to external devices     1:Expansion device Modbus RTU Relay     0:No extend
-#define RS485_CAN_Enable      1                   // This item is configured according to product selection   1:Select RS485                          0:Select CAN
-#define RTC_Event_Enable      1                   // Whether to enable RTC events  (Bluetooth)                1:Enable                                0:Disable
-
-
-
-// Name and password of the WiFi access point
-#define STASSID       "JSBPI"
-#define STAPSK        "waveshare0755"
-
-// Details about devices on the Waveshare cloud
-#define MQTT_Server   "mqtt.waveshare.cloud"
-#define MQTT_Port     1883
-#define MQTT_ID       "fc2d8db5"
-#define MQTT_Pub      "Pub/59/54/fc2d8db5"
-#define MQTT_Sub      "Sub/59/54/fc2d8db5"

src/WS_MQTT.cpp

@@ -1,248 +0,0 @@
-#include "WS_MQTT.h"
-
-// The name and password of the WiFi access point
-const char* ssid = STASSID;
-const char* password = STAPSK;
-// Details about devices on the Waveshare cloud
-const char* mqtt_server = MQTT_Server;
-int PORT = MQTT_Port;
-const char* ID = MQTT_ID;   // Defining device ID
-char pub[] = MQTT_Pub;      // MQTT release topic
-char sub[] = MQTT_Sub;      // MQTT subscribe to topics
-
-
-WiFiClient espClient;       //MQTT initializes the contents
-PubSubClient client(espClient);
-
-JsonDocument sendJson;
-JsonDocument readJson;
-unsigned long lastUpdateTime = 0;
-char msg[MSG_BUFFER_SIZE];
-bool WIFI_Connection = 0;
-bool WIFI_Connection_Old = 0;
-char ipStr[16];
-
-const unsigned long updateInterval = 5000;
-
-void WIFI_Init(void)
-{
-  xTaskCreatePinnedToCore(
-    WifiStaTask,    
-    "WifiStaTask",   
-    4096,                
-    NULL,                 
-    3,                   
-    NULL,                 
-    0                   
-  );
-}
-
-
-void WifiStaTask(void *parameter) {
-  uint8_t Count = 0;
-  WiFi.mode(WIFI_STA);                                   
-  WiFi.setSleep(true);      
-  WiFi.begin(ssid, password);                         // Connect to the specified Wi-Fi network
-  while(1){
-    if(WiFi.status() != WL_CONNECTED)
-    {
-      WIFI_Connection = 0;
-      printf(".\n");  
-      RGB_Open_Time(50, 0, 0, 500, 0); 
-      Count++;
-      if(Count >= 10){
-        Count = 0;
-        printf("\r\n"); 
-        WiFi.disconnect();
-        vTaskDelay(pdMS_TO_TICKS(100));
-        WiFi.mode(WIFI_OFF);
-        vTaskDelay(pdMS_TO_TICKS(100));
-        WiFi.mode(WIFI_STA);
-        vTaskDelay(pdMS_TO_TICKS(100));
-        WiFi.begin(ssid, password);
-      }
-    }
-    else{
-      WIFI_Connection = 1;
-      IPAddress myIP = WiFi.localIP();
-      printf("IP Address: ");
-      sprintf(ipStr, "%d.%d.%d.%d", myIP[0], myIP[1], myIP[2], myIP[3]);
-      printf("%s\r\n", ipStr);
-      RGB_Open_Time(0, 50, 0, 1000, 0); 
-    
-      printf("WIFI connection is successful, relay control can be performed via Waveshare cloud.\r\n");
-
-      while (WiFi.status() == WL_CONNECTED){
-        vTaskDelay(pdMS_TO_TICKS(100));
-      }
-    }
-    vTaskDelay(pdMS_TO_TICKS(1000));
-  }
-  vTaskDelete(NULL);
-}
-
-// MQTT subscribes to callback functions for processing received messages
-void callback(char* topic, byte* payload, unsigned int length) {  
-  uint8_t CH_Flag = 0;
-  String inputString;
-  for (int i = 0; i < length; i++) {
-    inputString += (char)payload[i];
-  }
-  printf("%s\r\n",inputString.c_str());                                     // Format of data sent back by the server {"data":{"CH1":1}}
-  int dataBegin = inputString.indexOf("\"data\"");                          // Finds if "data" is present in the string (quotes also)
-  if (dataBegin == -1) {
-    printf("Missing 'data' field in JSON. - MQTT\r\n");                     
-    return;
-  }
-  int CH_Begin = -1;      
-  if (inputString.indexOf("\"CH1\"", dataBegin) != -1){                     
-    CH_Flag = 1;
-    CH_Begin = inputString.indexOf("\"CH1\"", dataBegin);
-  }
-  else if (inputString.indexOf("\"CH2\"", dataBegin) != -1){             
-    CH_Flag = 2;
-    CH_Begin = inputString.indexOf("\"CH2\"", dataBegin);
-  }  
-  else if (inputString.indexOf("\"CH3\"", dataBegin) != -1){             
-    CH_Flag = 3;
-    CH_Begin = inputString.indexOf("\"CH3\"", dataBegin);
-  }  
-  else if (inputString.indexOf("\"CH4\"", dataBegin) != -1){             
-    CH_Flag = 4;
-    CH_Begin = inputString.indexOf("\"CH4\"", dataBegin);
-  }  
-  else if (inputString.indexOf("\"CH5\"", dataBegin) != -1){             
-    CH_Flag = 5;
-    CH_Begin = inputString.indexOf("\"CH5\"", dataBegin);
-  }   
-  else if (inputString.indexOf("\"CH6\"", dataBegin) != -1){             
-    CH_Flag = 6;
-    CH_Begin = inputString.indexOf("\"CH6\"", dataBegin);
-  }   
-  else if (inputString.indexOf("\"CH7\"", dataBegin) != -1){             
-    CH_Flag = 7;
-    CH_Begin = inputString.indexOf("\"CH7\"", dataBegin);
-  }   
-  else if (inputString.indexOf("\"CH8\"", dataBegin) != -1){             
-    CH_Flag = 8;
-    CH_Begin = inputString.indexOf("\"CH8\"", dataBegin);
-  }   
-  else if (inputString.indexOf("\"ALL\"", dataBegin) != -1){             
-    CH_Flag = 9;
-    CH_Begin = inputString.indexOf("\"ALL\"", dataBegin);
-  }   
-  else{
-    printf("Note : Non-instruction data was received - MQTT!\r\n");
-    CH_Flag = 0;
-    return;
-  }
-  int valueBegin = inputString.indexOf(':', CH_Begin);
-  int valueEnd = inputString.indexOf('}', valueBegin);
-  if (valueBegin != -1 && valueEnd != -1) {
-    if(CH_Flag != 0)
-    {
-      String ValueStr = inputString.substring(valueBegin + 1, valueEnd);
-      int Value = ValueStr.toInt();
-      if(CH_Flag < 9){
-        if(Value == 1 && Relay_Flag[CH_Flag - 1] == 0){
-          uint8_t Data[1]={CH_Flag+48};
-          Relay_Analysis(Data,MQTT_Mode);
-        }
-        else if(Value == 0 && Relay_Flag[CH_Flag - 1] == 1){
-          uint8_t Data[1]={CH_Flag+48};
-          Relay_Analysis(Data,MQTT_Mode);
-        }
-      }
-      else if(CH_Flag == 9){
-        if(Value == 1 && ((Relay_Flag[0] & Relay_Flag[1] & Relay_Flag[2] & Relay_Flag[3] & Relay_Flag[4] & Relay_Flag[5] & Relay_Flag[6] & Relay_Flag[7]) == 0)){
-          uint8_t Data[1]={9+48};
-          Relay_Analysis(Data,MQTT_Mode);
-        }
-        else if(Value == 0 && ((Relay_Flag[0] | Relay_Flag[1] | Relay_Flag[2] | Relay_Flag[3] | Relay_Flag[4] | Relay_Flag[5] | Relay_Flag[6] | Relay_Flag[7] )== 1)){
-          uint8_t Data[1]={0+48};
-          Relay_Analysis(Data,MQTT_Mode);
-        }
-      }
-    }
-  }
-}
-
-
-// Reconnect to the MQTT server
-void reconnect(void) {
-  uint8_t Count = 0;
-  while (!client.connected()) {
-    Count++;    
-    if (client.connect(ID)) {
-      client.subscribe(sub);
-      printf("Waveshare Cloud connection is successful and now you can use all features.\r\n"); 
-    } 
-    else{
-      delay(500);
-      if(Count % 2 == 0 && Count != 0){ 
-        printf("%d\r\n", client.state());      
-        RGB_Open_Time(50, 0, 50, 1000, 0); 
-      } 
-      if(Count % 10 == 0){                               // 10 attempts failed to connect, cancel the connection, try again
-        client.disconnect();
-        delay(100);
-        client.setServer(mqtt_server, PORT);
-        delay(100);
-        client.setCallback(callback);
-        delay(100);
-      }
-      if(Count > 32){                                   // connection fail
-        Count = 0;
-        printf("warning: Waveshare cloud connection fails. Currently, only Bluetooth control is available !!!\r\n"); 
-      } 
-
-    }
-  }
-}
-// Send data in JSON format to MQTT server
-void sendJsonData(void) {
-  sendJson["ID"] = ID;
-  String pubres;
-  serializeJson(sendJson, pubres);
-  int str_len = pubres.length() + 1;
-  char char_array[str_len];
-  pubres.toCharArray(char_array, str_len);
-  client.publish(pub, char_array);
-}
-
-void MQTTTask(void *parameter) {
-  bool WIFI_Connection_Old;
-  while(1){
-    if(WIFI_Connection == 1)
-    { 
-      if(!WIFI_Connection_Old){
-        WIFI_Connection_Old = 1;
-        client.setServer(mqtt_server, PORT);
-        client.setCallback(callback);
-      }
-      if (!client.connected()) {
-        reconnect();
-      }
-      client.loop();
-    }
-    else{
-      WIFI_Connection_Old = 0;
-    }
-    vTaskDelay(pdMS_TO_TICKS(10));
-  }
-  vTaskDelete(NULL);
-}
-void MQTT_Init(void)
-{
-  WIFI_Init();
-  xTaskCreatePinnedToCore(
-    MQTTTask,    
-    "MQTTTask",   
-    4096,                
-    NULL,                 
-    3,                   
-    NULL,                 
-    0                   
-  );
-}
-

src/WS_MQTT.h

@@ -1,25 +0,0 @@
-#ifndef _WS_MQTT_H_
-#define _WS_MQTT_H_
-
-#include <ArduinoJson.h>
-#include <Arduino.h>
-#include <PubSubClient.h>
-#include <WiFi.h>
-#include <WiFiClientSecure.h>
-#include "WS_GPIO.h"
-#include "WS_Information.h"
-#include "WS_Relay.h"
-
-
-#define MSG_BUFFER_SIZE (50)
-
-extern char ipStr[16];
-
-void WIFI_Init(void);
-void WifiStaTask(void *parameter);
-void callback(char* topic, byte* payload, unsigned int length);   // MQTT subscribes to callback functions for processing received messages
-void reconnect(void);                                                 // Reconnect to the MQTT server
-void sendJsonData(void);                                              // Send data in JSON format to MQTT server
-void MQTT_Init(void);
-
-#endif

src/WS_PCF85063.cpp

@@ -1,189 +0,0 @@
-#include "WS_PCF85063.h"
-
-datetime_t datetime= {0};
-datetime_t Update_datetime= {0};
-static uint8_t decToBcd(int val);
-static int bcdToDec(uint8_t val);
-
-
-void Time_printf(void *parameter) {
-  while(1){
-    char datetime_str[50];
-    datetime_to_str(datetime_str,datetime);
-    printf("Time:%s\r\n",datetime_str);
-    vTaskDelay(pdMS_TO_TICKS(500));
-  }
-  vTaskDelete(NULL);
-}
-void PCF85063_Init(void)      // PCF85063 initialized
-{
-	uint8_t Value = RTC_CTRL_1_DEFAULT|RTC_CTRL_1_CAP_SEL;
-
-	I2C_Write(PCF85063_ADDRESS, RTC_CTRL_1_ADDR, &Value, 1);
-  I2C_Read(PCF85063_ADDRESS, RTC_CTRL_1_ADDR,  &Value, 1);
-	if(Value & RTC_CTRL_1_STOP)
-		printf("PCF85063 failed to be initialized.state :%d\r\n",Value);
-	else
-		printf("PCF85063 is running,state :%d\r\n",Value);
-    
-  // 
-  // Update_datetime.year = 2024;
-  // Update_datetime.month = 9;
-  // Update_datetime.day = 20;
-  // Update_datetime.dotw = 5;
-  // Update_datetime.hour = 9;
-  // Update_datetime.minute = 50;
-  // Update_datetime.second = 0;
-  // PCF85063_Set_All(Update_datetime);
-  xTaskCreatePinnedToCore(
-    PCF85063Task,    
-    "PCF85063Task",   
-    4096,                
-    NULL,                 
-    3,                   
-    NULL,                 
-    0                   
-  );  
-  // xTaskCreatePinnedToCore(
-  //   Time_printf,    
-  //   "Time_printf",   
-  //   4096,                
-  //   NULL,                 
-  //   3,                   
-  //   NULL,                 
-  //   0                   
-  // );
-}
-
-void PCF85063Task(void *parameter) {
-  while(1){
-    PCF85063_Read_Time(&datetime);
-    vTaskDelay(pdMS_TO_TICKS(100));
-  }
-  vTaskDelete(NULL);
-}
-
-void PCF85063_Reset()  // Reset PCF85063
-{
-	uint8_t Value = RTC_CTRL_1_DEFAULT|RTC_CTRL_1_CAP_SEL|RTC_CTRL_1_SR;
-	esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_CTRL_1_ADDR, &Value, 1);
-	if(ret != ESP_OK)
-		printf("PCF85063 : Reset failure\r\n");
-}
-void PCF85063_Set_Time(datetime_t time) // Set Time 
-{
-	uint8_t buf[3] = {decToBcd(time.second),
-					  decToBcd(time.minute),
-					  decToBcd(time.hour)};
-	esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_SECOND_ADDR, buf, sizeof(buf));
-	if(ret != ESP_OK)
-		printf("PCF85063 : Time setting failure\r\n");
-}
-void PCF85063_Set_Date(datetime_t date) // Set Date
-{
-	uint8_t buf[4] = {decToBcd(date.day),
-					  decToBcd(date.dotw),
-					  decToBcd(date.month),
-					  decToBcd(date.year - YEAR_OFFSET)};
-	esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_DAY_ADDR, buf, sizeof(buf));
-	if(ret != ESP_OK)
-		printf("PCF85063 : Date setting failed\r\n");
-}
-
-void PCF85063_Set_All(datetime_t time) // Set Time And Date
-{
-	uint8_t buf[7] = {decToBcd(time.second),
-					  decToBcd(time.minute),
-					  decToBcd(time.hour),
-					  decToBcd(time.day),
-					  decToBcd(time.dotw),
-					  decToBcd(time.month),
-					  decToBcd(time.year - YEAR_OFFSET)};
-	esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_SECOND_ADDR, buf, sizeof(buf));
-	if(ret != ESP_OK)
-		printf("PCF85063 : Failed to set the date and time\r\n");
-}
-
-void PCF85063_Read_Time(datetime_t *time) // Read Time And Date
-{
-	uint8_t buf[7] = {0};
-	esp_err_t ret = I2C_Read(PCF85063_ADDRESS, RTC_SECOND_ADDR, buf, sizeof(buf));
-	if(ret != ESP_OK)
-		printf("PCF85063 : Time read failure\r\n");
-	else{
-		time->second = bcdToDec(buf[0] & 0x7F);
-		time->minute = bcdToDec(buf[1] & 0x7F);
-		time->hour = bcdToDec(buf[2] & 0x3F);
-		time->day = bcdToDec(buf[3] & 0x3F);
-		time->dotw = bcdToDec(buf[4] & 0x07);
-		time->month = bcdToDec(buf[5] & 0x1F);
-		time->year = bcdToDec(buf[6]) + YEAR_OFFSET;
-	}
-}
-
-void PCF85063_Enable_Alarm() // Enable Alarm and Clear Alarm flag
-{
-	uint8_t Value = RTC_CTRL_2_DEFAULT | RTC_CTRL_2_AIE;
-	Value &= ~RTC_CTRL_2_AF;
-	esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_CTRL_2_ADDR, &Value, 1);
-	if(ret != ESP_OK)
-		printf("PCF85063 : Failed to enable Alarm Flag and Clear Alarm Flag \r\n");
-}
-
-uint8_t PCF85063_Get_Alarm_Flag() // Get Alarm flag
-{
-	uint8_t Value = 0;
-	esp_err_t ret = I2C_Read(PCF85063_ADDRESS, RTC_CTRL_2_ADDR, &Value, 1);
-	if(ret != ESP_OK)
-		printf("PCF85063 : Failed to obtain a warning flag.\r\n");
-	else
-		Value &= RTC_CTRL_2_AF | RTC_CTRL_2_AIE;
-	//printf("Value = 0x%x",Value);
-	return Value;
-}
-
-void PCF85063_Set_Alarm(datetime_t time) // Set Alarm
-{
-
-	uint8_t buf[5] ={
-		decToBcd(time.second)&(~RTC_ALARM),
-		decToBcd(time.minute)&(~RTC_ALARM),
-		decToBcd(time.hour)&(~RTC_ALARM),
-		//decToBcd(time.day)&(~RTC_ALARM),
-		//decToBcd(time.dotw)&(~RTC_ALARM)
-		RTC_ALARM, 	//disalbe day
-		RTC_ALARM	//disalbe weekday
-	};
-	esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_SECOND_ALARM, buf, sizeof(buf));
-	if(ret != ESP_OK)
-		printf("PCF85063 : Failed to set alarm flag\r\n");
-}
-
-void PCF85063_Read_Alarm(datetime_t *time) // Read Alarm
-{
-	uint8_t buf[5] = {0};
-	esp_err_t ret = I2C_Read(PCF85063_ADDRESS, RTC_SECOND_ALARM, buf, sizeof(buf));
-	if(ret != ESP_OK)
-		printf("PCF85063 : Failed to read the alarm sign\r\n");
-	else{
-		time->second = bcdToDec(buf[0] & 0x7F);
-		time->minute = bcdToDec(buf[1] & 0x7F);
-		time->hour = bcdToDec(buf[2] & 0x3F);
-		time->day = bcdToDec(buf[3] & 0x3F);
-		time->dotw = bcdToDec(buf[4] & 0x07);
-	}
-}
-
-static uint8_t decToBcd(int val) // Convert normal decimal numbers to binary coded decimal
-{
-	return (uint8_t)((val / 10 * 16) + (val % 10));
-}
-static int bcdToDec(uint8_t val) // Convert binary coded decimal to normal decimal numbers
-{
-	return (int)((val / 16 * 10) + (val % 16));
-}
-void datetime_to_str(char *datetime_str,datetime_t time)
-{
-	sprintf(datetime_str, " %d.%d.%d  %d:%d:%d  %s", time.year, time.month, 
-			time.day, time.hour, time.minute, time.second, Week[time.dotw]);
-} 

src/WS_PCF85063.h

@@ -1,103 +0,0 @@
-#pragma once
-
-#include "I2C_Driver.h"
-
-//PCF85063_ADDRESS
-#define PCF85063_ADDRESS    (0x51)
-//
-#define YEAR_OFFSET			    (1970)
-// registar overview - crtl & status reg
-#define RTC_CTRL_1_ADDR     (0x00)
-#define RTC_CTRL_2_ADDR     (0x01)
-#define RTC_OFFSET_ADDR     (0x02)
-#define RTC_RAM_by_ADDR     (0x03)
-// registar overview - time & data reg
-#define RTC_SECOND_ADDR		  (0x04)
-#define RTC_MINUTE_ADDR		  (0x05)
-#define RTC_HOUR_ADDR		    (0x06)
-#define RTC_DAY_ADDR		    (0x07)
-#define RTC_WDAY_ADDR		    (0x08)
-#define RTC_MONTH_ADDR		  (0x09)
-#define RTC_YEAR_ADDR		    (0x0A)	// years 0-99; calculate real year = 1970 + RCC reg year
-// registar overview - alarm reg
-#define RTC_SECOND_ALARM	  (0x0B)
-#define RTC_MINUTE_ALARM	  (0x0C)
-#define RTC_HOUR_ALARM		  (0x0D)
-#define RTC_DAY_ALARM		    (0x0E)
-#define RTC_WDAY_ALARM		  (0x0F)
-// registar overview - timer reg
-#define RTC_TIMER_VAL 	    (0x10)
-#define RTC_TIMER_MODE	    (0x11)
-
-//RTC_CTRL_1 registar
-#define RTC_CTRL_1_EXT_TEST (0x80)
-#define RTC_CTRL_1_STOP     (0x20) //0-RTC clock runs 1- RTC clock is stopped
-#define RTC_CTRL_1_SR       (0X10) //0-no software reset 1-initiate software rese
-#define RTC_CTRL_1_CIE      (0X04) //0-no correction interrupt generated 1-interrupt pulses are generated at every correction cycle
-#define RTC_CTRL_1_12_24    (0X02) //0-24H 1-12H
-#define RTC_CTRL_1_CAP_SEL  (0X01) //0-7PF 1-12.5PF
-
-//RTC_CTRL_2 registar
-#define RTC_CTRL_2_AIE      (0X80) //alarm interrupt 0-disalbe 1-enable
-#define RTC_CTRL_2_AF       (0X40) //alarm flag  0-inactive/cleared 1-active/unchanged
-#define RTC_CTRL_2_MI       (0X20) //minute interrupt 0-disalbe 1-enable
-#define RTC_CTRL_2_HMI      (0X10) //half minute interrupt 
-#define RTC_CTRL_2_TF       (0X08)
-
-//
-#define RTC_OFFSET_MODE     (0X80)
-
-//
-#define RTC_TIMER_MODE_TE   (0X04) //timer enable 0-disalbe 1-enable
-#define RTC_TIMER_MODE_TIE  (0X02) //timer interrupt enable 0-disalbe 1-enable
-#define RTC_TIMER_MODE_TI_TP    (0X01) //timer interrupt mode 0-interrupt follows timer flag 1-interrupt generates a pulse
-
-// format 
-#define RTC_ALARM 			    (0x80)	// set AEN_x registers
-#define RTC_CTRL_1_DEFAULT	(0x00)
-#define RTC_CTRL_2_DEFAULT	(0x00)
-
-#define RTC_TIMER_FLAG		  (0x08)
-
-typedef struct {
-  uint16_t year;
-  uint8_t month;
-  uint8_t day;
-  uint8_t dotw;
-  uint8_t hour;
-  uint8_t minute;
-  uint8_t second;
-}datetime_t;
-
-
-const unsigned char MonthStr[12][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov","Dec"};
-const unsigned char Week[7][5] = {"SUN","Mon","Tues","Wed","Thur","Fri","Sat"};
-
-extern datetime_t datetime;
-void PCF85063_Init(void);
-void PCF85063_Reset(void);
-void PCF85063Task(void *parameter);
-
-void PCF85063_Set_Time(datetime_t time);
-void PCF85063_Set_Date(datetime_t date);
-void PCF85063_Set_All(datetime_t time);
-
-void PCF85063_Read_Time(datetime_t *time);
-
-
-void PCF85063_Enable_Alarm(void);
-uint8_t PCF85063_Get_Alarm_Flag();
-void PCF85063_Set_Alarm(datetime_t time);
-void PCF85063_Read_Alarm(datetime_t *time);
-
-void datetime_to_str(char *datetime_str,datetime_t time);
-
-
-// weekday format
-// 0 - sunday
-// 1 - monday
-// 2 - tuesday
-// 3 - wednesday
-// 4 - thursday
-// 5 - friday
-// 6 - saturday

src/WS_RS485.cpp

@@ -1,163 +0,0 @@
-#include "WS_RS485.h"
-#include <algorithm>
-
-HardwareSerial lidarSerial(1);  // Using serial port 1
-uint8_t data[][8] = {                                       // ESP32-S3-POE-ETH-8DI-8RO Control Command (RS485 receiving data)
-  { 0x06, 0x05, 0x00, 0x01, 0x55, 0x00, 0xA2, 0xED },       // ESP32-S3-POE-ETH-8DI-8RO CH1 Toggle
-  { 0x06, 0x05, 0x00, 0x02, 0x55, 0x00, 0x52, 0xED },       // ESP32-S3-POE-ETH-8DI-8RO CH2 Toggle
-  { 0x06, 0x05, 0x00, 0x03, 0x55, 0x00, 0x03, 0x2D },       // ESP32-S3-POE-ETH-8DI-8RO CH3 Toggle
-  { 0x06, 0x05, 0x00, 0x04, 0x55, 0x00, 0xB2, 0xEC },       // ESP32-S3-POE-ETH-8DI-8RO CH4 Toggle
-  { 0x06, 0x05, 0x00, 0x05, 0x55, 0x00, 0xE3, 0x2C },       // ESP32-S3-POE-ETH-8DI-8RO CH5 Toggle
-  { 0x06, 0x05, 0x00, 0x06, 0x55, 0x00, 0x13, 0x2C },       // ESP32-S3-POE-ETH-8DI-8RO CH6 Toggle
-  { 0x06, 0x05, 0x00, 0x07, 0x55, 0x00, 0x42, 0xEC },       // ESP32-S3-POE-ETH-8DI-8RO CH7 Toggle
-  { 0x06, 0x05, 0x00, 0x08, 0x55, 0x00, 0x72, 0xEF },       // ESP32-S3-POE-ETH-8DI-8RO CH8 Toggle
-  { 0x06, 0x05, 0x00, 0xFF, 0xFF, 0x00, 0xBD, 0xBD },       // ESP32-S3-POE-ETH-8DI-8RO ALL ON
-  { 0x06, 0x05, 0x00, 0xFF, 0x00, 0x00, 0xFC, 0x4D },       // ESP32-S3-POE-ETH-8DI-8RO ALL OFF
-};
-uint8_t Send_Data[][8] = {                                  // Modbus RTU Relay Control Command (RS485 send data)
-  { 0x01, 0x05, 0x00, 0x00, 0x55, 0x00, 0xF2, 0x9A },       // Modbus RTU Relay CH1 Toggle
-  { 0x01, 0x05, 0x00, 0x01, 0x55, 0x00, 0xA3, 0x5A },       // Modbus RTU Relay CH2 Toggle
-  { 0x01, 0x05, 0x00, 0x02, 0x55, 0x00, 0x53, 0x5A },       // Modbus RTU Relay CH3 Toggle
-  { 0x01, 0x05, 0x00, 0x03, 0x55, 0x00, 0x02, 0x9A },       // Modbus RTU Relay CH4 Toggle
-  { 0x01, 0x05, 0x00, 0x04, 0x55, 0x00, 0xB3, 0x5B },       // Modbus RTU Relay CH5 Toggle
-  { 0x01, 0x05, 0x00, 0x05, 0x55, 0x00, 0xE2, 0x9B },       // Modbus RTU Relay CH6 Toggle
-  { 0x01, 0x05, 0x00, 0x06, 0x55, 0x00, 0x12, 0x9B },       // Modbus RTU Relay CH7 Toggle
-  { 0x01, 0x05, 0x00, 0x07, 0x55, 0x00, 0x43, 0x5B },       // Modbus RTU Relay CH8 Toggle
-  { 0x01, 0x05, 0x00, 0xFF, 0xFF, 0xFF, 0xFC, 0x4A },       // Modbus RTU Relay ALL ON
-  { 0x01, 0x05, 0x00, 0xFF, 0x00, 0x00, 0xFD, 0xFA },       // Modbus RTU Relay ALL OFF
-};
-uint8_t buf[20] = {0};          // Data storage area
-int numRows = sizeof(data) / sizeof(data[0]);
-
-void SetData(uint8_t* data, size_t length) {
-  lidarSerial.write(data, length);                          // Send data from the RS485
-}
-void ReadData(uint8_t* buf, uint8_t length) {
-  uint8_t Receive_Flag = 0;       
-  Receive_Flag = lidarSerial.available();
-  if (Receive_Flag >= length) {
-    lidarSerial.readBytes(buf, length); 
-    char printBuf[length * 3 + 1];
-    sprintf(printBuf, "Received data: ");
-    for (int i = 0; i < length; i++) {
-      sprintf(printBuf + strlen(printBuf), "%02X ", buf[i]); 
-    }
-    printf(printBuf); 
-    /*************************
-    Add a receiving data handler
-    *************************/
-    Receive_Flag = 0;
-    memset(buf, 0, sizeof(buf));   
-  }
-}
-void RS485_Analysis(uint8_t *buf)
-{
-  switch(buf[1])
-  {
-    case Extension_CH1:
-      SetData(Send_Data[0],sizeof(Send_Data[0])); 
-      printf("|***  Toggle expansion channel 1 ***|\r\n");
-      break;
-    case Extension_CH2:
-      SetData(Send_Data[1],sizeof(Send_Data[1])); 
-      printf("|***  Toggle expansion channel 2 ***|\r\n");
-      break;
-    case Extension_CH3:
-      SetData(Send_Data[2],sizeof(Send_Data[2])); 
-      printf("|***  Toggle expansion channel 3 ***|\r\n");
-      break;
-    case Extension_CH4:
-      SetData(Send_Data[3],sizeof(Send_Data[3])); 
-      printf("|***  Toggle expansion channel 4 ***|\r\n");
-      break;
-    case Extension_CH5:
-      SetData(Send_Data[4],sizeof(Send_Data[4])); 
-      printf("|***  Toggle expansion channel 5 ***|\r\n");
-      break;
-    case Extension_CH6:
-      SetData(Send_Data[5],sizeof(Send_Data[5])); 
-      printf("|***  Toggle expansion channel 6 ***|\r\n");
-      break;
-    case Extension_CH7:
-      SetData(Send_Data[6],sizeof(Send_Data[6])); 
-      printf("|***  Toggle expansion channel 7 ***|\r\n");
-      break;
-    case Extension_CH8:
-      SetData(Send_Data[7],sizeof(Send_Data[7])); 
-      printf("|***  Toggle expansion channel 8 ***|\r\n");
-      break;
-    case Extension_ALL_ON:
-      SetData(Send_Data[8],sizeof(Send_Data[8])); 
-      printf("|***  Enable all extension channels ***|\r\n");
-      break;
-    case Extension_ALL_OFF:
-      SetData(Send_Data[9],sizeof(Send_Data[9])); 
-      printf("|***  Close all expansion channels ***|\r\n");
-      break;
-    default:
-      printf("Note : Non-control external device instructions !\r\n");
-  }
-}
-uint32_t Baudrate = 0;
-double  transmission_time = 0;
-double RS485_cmd_Time = 0;
-void RS485_Init()                                             // Initializing serial port
-{    
-  Baudrate = 9600;                                            // Set the baud rate of the serial port                                              
-  lidarSerial.begin(Baudrate, SERIAL_8N1, RXD1, TXD1);        // Initializing serial port
-  transmission_time = 10.0 / Baudrate * 1000 ;
-  RS485_cmd_Time = transmission_time*8;                       // 8:data length
-  xTaskCreatePinnedToCore(
-    RS485Task,    
-    "RS485Task",   
-    4096,                
-    NULL,                 
-    3,                   
-    NULL,                 
-    0                   
-  );
-}
-
-void RS485Task(void *parameter) {
-  while(1){
-    RS485_Loop();
-    vTaskDelay(pdMS_TO_TICKS(50));
-  }
-  vTaskDelete(NULL);
-}
-
-void RS485_Loop()
-{
-  uint8_t Receive_Flag = 0;       // Receiving mark
-  Receive_Flag = lidarSerial.available();    
-
-  if (Receive_Flag > 0) {
-    if(RS485_cmd_Time > 1)              // Time greater than 1 millisecond
-      delay((uint16_t)RS485_cmd_Time);
-    else                      // Time is less than 1 millisecond 
-      delay(1);
-    Receive_Flag = lidarSerial.available();
-    lidarSerial.readBytes(buf, Receive_Flag);              // The Receive_Flag length is read
-    if(Receive_Flag == 8){
-      uint8_t i=0;
-      for(i=0;i<numRows;i++){
-        bool result = std::equal(std::begin(buf), std::begin(buf) + 8, std::begin(data[i]));    // Compare two arrays
-        if(result){
-          if(i < numRows-1)
-            buf[0] = i+1+48;
-          else if(i == numRows-1)
-            buf[0] = 48;
-          Relay_Analysis(buf,RS485_Mode);
-          break;
-        }
-      }   
-      if(i > numRows-1)
-        printf("Note : Non-instruction data was received - RS485 !\r\n");
-    }
-    else{
-      printf("Note : Non-instruction data was received .Number of bytes: %d - RS485 !\r\n",Receive_Flag);
-    }
-    Receive_Flag=0;
-    memset(buf,0, sizeof(buf));
-  }
-}

src/WS_RS485.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <HardwareSerial.h>       // Reference the ESP32 built-in serial port library
-#include "WS_GPIO.h"
-#include "WS_Relay.h"
-
-#define Extension_CH1       1     // Expansion Channel 1
-#define Extension_CH2       2     // Expansion Channel 2
-#define Extension_CH3       3     // Expansion Channel 3
-#define Extension_CH4       4     // Expansion Channel 4
-#define Extension_CH5       5     // Expansion Channel 5
-#define Extension_CH6       6     // Expansion Channel 6
-#define Extension_CH7       7     // Expansion Channel 7
-#define Extension_CH8       8     // Expansion Channel 8
-#define Extension_ALL_ON    9     // Expansion ALL ON
-#define Extension_ALL_OFF   10    // Expansion ALL OFF
-
-
-
-void SetData(uint8_t* data, size_t length);   // Send data from the RS485
-void ReadData(uint8_t* buf, uint8_t length);  // Data is received over RS485
-
-void RS485_Analysis(uint8_t *buf);            // External relay control
-void RS485_Init();         // Example Initialize the system serial port and RS485
-void RS485_Loop();         // Read RS485 data, parse and control relays
-void RS485Task(void *parameter);

src/WS_RTC.cpp

@@ -1,350 +0,0 @@
-#include "WS_RTC.h"
-
-Timing_RTC CHx_State[Timing_events_Number_MAX];       // Set a maximum of Timing_events_Number_MAX timers
-char Event_str[Timing_events_Number_MAX][1000];
-static Timing_RTC CHx_State_Default;            // Event initial state
-const unsigned char Event_cycle[4][13] = {"Aperiodicity","everyday","Weekly","monthly"};
-
-void RTC_Init(void){
-  PCF85063_Init();
-  xTaskCreatePinnedToCore(
-    RTCTask,    
-    "RTCTask",   
-    4096,                
-    NULL,                 
-    3,                   
-    NULL,                 
-    0                   
-  );
-}
-uint8_t Timing_events_Num = 0;
-void RTCTask(void *parameter)
-{ 
-  static uint8_t Time_Old = 0;
-  while(1){
-    if(Timing_events_Num){
-      for (int i = 0; i < Timing_events_Number_MAX; i++){
-        if(CHx_State[i].Enable_Flag){
-          if(CHx_State[i].Time.hour == datetime.hour && CHx_State[i].Time.minute == datetime.minute && CHx_State[i].Time.second == datetime.second && datetime.second != Time_Old){       // The event time is consistent with the current time
-            switch(CHx_State[i].repetition_State){
-              case Repetition_NONE:
-                if(CHx_State[i].Time.year == datetime.year && CHx_State[i].Time.month == datetime.month && CHx_State[i].Time.day == datetime.day){ // Executes at the defined date and time
-                  TimerEvent_handling(CHx_State[i]);
-                  TimerEvent_Del(CHx_State[i]);
-                }
-                break;
-              case Repetition_everyday:
-                TimerEvent_handling(CHx_State[i]);
-                break;
-              case Repetition_Weekly:
-                if(CHx_State[i].Time.dotw == datetime.dotw){
-                  TimerEvent_handling(CHx_State[i]);
-                }
-                break;
-              case Repetition_monthly:
-                if(CHx_State[i].Time.day == datetime.day){
-                  TimerEvent_handling(CHx_State[i]);
-                }
-                break;
-              default:
-                printf("Event error!!!!\n");
-                break;
-            }
-          }
-        }
-      }
-    }
-    Time_Old = datetime.second;
-    vTaskDelay(pdMS_TO_TICKS(100));
-  }
-  vTaskDelete(NULL);
-}
-
-void TimerEvent_handling(Timing_RTC event){
-  uint8_t Retain_channels = 0;  
-  printf("Event %d : \r\n", event.Event_Number);
-  char datetime_str[50];
-  datetime_to_str(datetime_str,event.Time);
-  for (int i = 0; i < Relay_Number_MAX; i++) {
-    if(*(&(event.Relay_CH1)+i) == STATE_Retain)                     // Find the modified channel
-      Retain_channels ++;                                     // Number of unmodified channels  
-  }
-  if(Retain_channels < Relay_Number_MAX - 1){  
-    printf("%s\r\n", datetime_str);
-    printf("CHx Open   : ");  
-    int j = 0;       
-    for (j = 0; j < Relay_Number_MAX; j++) {
-      if(*(&(event.Relay_CH1)+j) == STATE_Open)                          
-        printf("CH%d    ", j+1); 
-    } 
-    printf("\r\nCHx Closs  : ");         
-    for (j = 0; j < Relay_Number_MAX; j++) {
-      if(*(&(event.Relay_CH1)+j) == STATE_Closs)                          
-        printf("CH%d    ", j+1); 
-    }
-    if(Retain_channels){
-      printf("\r\nCHx Retain : ");         
-      for (j = 0; j < Relay_Number_MAX; j++) {
-        if(*(&(event.Relay_CH1)+j) == STATE_Retain)                          
-          printf("CH%d    ", j+1); 
-      }
-    }
-    printf("\r\n");   
-    Relay_Immediate_CHxn(&(event.Relay_CH1), RTC_Mode);
-    printf("\r\n");
-  }
-  else if(Retain_channels == Relay_Number_MAX - 1){           // Modified a channel                (use TimerEvent_CHx_Set())
-    printf("%s\r\n", datetime_str);
-    for (int x = 0; x < Relay_Number_MAX; x++) {
-      if(*(&(event.Relay_CH1)+x) != STATE_Retain){                   // Find the modified channel
-        if(*(&(event.Relay_CH1)+x)){
-          printf("CH%d Open\r\n", x); 
-          Relay_Immediate(x, true, RTC_Mode);
-          printf("\r\n");
-        }
-        else{
-          printf("CH%d Closs\r\n", x); 
-          Relay_Immediate(x, false, RTC_Mode);
-          printf("\r\n");
-        }
-        break;
-      }
-    }
-  }
-  else{
-    printf("Event error or no relay control!!!\r\n");
-  }
-}
-
-void TimerEvent_CHx_Set(datetime_t time,uint8_t CHx, bool State, Repetition_event Repetition)
-{
-  char datetime_str[50];
-  datetime_to_str(datetime_str,datetime);
-  printf("Now Time: %s!!!!\r\n", datetime_str);
-  if(CHx > Relay_Number_MAX){
-    printf("Timing_CHx_Set(function): Error passing parameter CHx!!!!\r\n");
-    return;
-  }
-  if(Timing_events_Num + 1 >= Timing_events_Number_MAX)
-  {
-    printf("Note : The number of scheduled events is full.\r\n");
-  }
-  else{
-    RGB_Open_Time(50, 36, 0, 1000, 0); 
-    CHx_State[Timing_events_Num].Enable_Flag = true;
-    CHx_State[Timing_events_Num].Event_Number = Timing_events_Num + 1;
-    *(&(CHx_State[Timing_events_Num].Relay_CH1)+CHx) = (Status_adjustment)State;
-    CHx_State[Timing_events_Num].Time = time;
-    CHx_State[Timing_events_Num].repetition_State = Repetition;
-    Timing_events_Num ++;
-    datetime_to_str(datetime_str,time);
-    if(State){
-      printf("New timing event%d :\r\n        %s set CH%d Open  ----- %s\r\n\r\n", Timing_events_Num, datetime_str, CHx, Event_cycle[Repetition]);
-      sprintf(Event_str[Timing_events_Num-1], "Event %d : %s set CH%d Open  ----- %s\\n\\n", Timing_events_Num, datetime_str, CHx, Event_cycle[Repetition]);
-    }
-    else{
-      printf("New timing event%d :\r\n        %s set CH%d Closs ----- %s\r\n\r\n", Timing_events_Num, datetime_str, CHx, Event_cycle[Repetition]);
-      sprintf(Event_str[Timing_events_Num-1], "Event %d : %s set CH%d Closs  ----- %s\\n\\n", Timing_events_Num, datetime_str, CHx, Event_cycle[Repetition]);
-    }
-    Buzzer_Open_Time(700, 0);
-  }
-}
-
-void TimerEvent_CHxs_Set(datetime_t time,uint8_t PinState, Repetition_event Repetition)
-{
-
-  char datetime_str[50];
-  datetime_to_str(datetime_str,datetime);
-  printf("Now Time: %s!!!!\r\n", datetime_str);
-  if(Timing_events_Num + 1 >= Timing_events_Number_MAX)
-  {
-    printf("Note : The number of scheduled events is full.\r\n");
-  }
-  else{
-    RGB_Open_Time(50, 36, 0, 1000, 0); 
-    CHx_State[Timing_events_Num].Enable_Flag = true;
-    CHx_State[Timing_events_Num].Event_Number = Timing_events_Num + 1;
-    for (int i = 0; i < Relay_Number_MAX; i++) {
-      *(&(CHx_State[Timing_events_Num].Relay_CH1)+i) = (Status_adjustment)((PinState >> i) & 0x01); 
-    }
-    CHx_State[Timing_events_Num].Time = time;
-    CHx_State[Timing_events_Num].repetition_State = Repetition;
-    Timing_events_Num ++;
-    datetime_to_str(datetime_str,time);
-    printf("New timing event%d :\r\n       %s \r\n",Timing_events_Num, datetime_str);
-    printf("        CHx   :");
-    for (int i = 0; i < Relay_Number_MAX; i++) 
-      printf("CH%d      ", i+1);
-    printf("\r\n        State :");
-    for (int i = 0; i < Relay_Number_MAX; i++) {
-      if((PinState >> i) & 0x01)
-        printf("Open     ");
-      else
-        printf("Closs    ");
-    }
-    printf("\r\n");
-    printf("        ----- %s\r\n\r\n", Event_cycle[Repetition]);
-    printf("\r\n");  
-    Buzzer_Open_Time(700, 0);
-
-    int len = 0;  
-    char Event_content[1000];  
-    len += snprintf(Event_content + len, sizeof(Event_content) - len, "&nbsp;&nbsp;&nbsp;&nbsp;CHx&nbsp;&nbsp;:");
-    for (int i = 0; i < Relay_Number_MAX; i++) {
-      len += snprintf(Event_content + len, sizeof(Event_content) - len, "CH%d&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", i + 1);
-    }
-    len += snprintf(Event_content + len, sizeof(Event_content) - len, "\\n &nbsp;&nbsp;&nbsp;&nbsp;State :");
-    for (int i = 0; i < Relay_Number_MAX; i++) {
-      if ((PinState >> i) & 0x01)  
-        len += snprintf(Event_content + len, sizeof(Event_content) - len, "Open&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
-      else
-        len += snprintf(Event_content + len, sizeof(Event_content) - len, "Closs&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
-    }
-    len += snprintf(Event_content + len, sizeof(Event_content) - len, "\\n&nbsp;&nbsp;&nbsp;&nbsp;----- %s\\n\\n", Event_cycle[Repetition]);
-    // printf("%s\r\n", Event_content);
-    sprintf(Event_str[Timing_events_Num-1], "Event %d : %s \\n%s", Timing_events_Num, datetime_str,Event_content);
-  }
-}
-void TimerEvent_CHxn_Set(datetime_t time,Status_adjustment *Relay_n, Repetition_event Repetition)
-{
-  char datetime_str[50];
-  datetime_to_str(datetime_str,datetime);
-  printf("Now Time: %s!!!!\r\n", datetime_str);
-  if(Timing_events_Num + 1 >= Timing_events_Number_MAX)
-  {
-    printf("Note : The number of scheduled events is full.\r\n");
-  }
-  else{
-    RGB_Open_Time(50, 36, 0, 1000, 0); 
-    CHx_State[Timing_events_Num].Enable_Flag = true;
-    CHx_State[Timing_events_Num].Event_Number = Timing_events_Num + 1;
-    for (int i = 0; i < Relay_Number_MAX; i++) {
-      *(&(CHx_State[Timing_events_Num].Relay_CH1)+i) = Relay_n[i]; 
-    }
-    CHx_State[Timing_events_Num].Time = time;
-    CHx_State[Timing_events_Num].repetition_State = Repetition;
-    Timing_events_Num ++;
-    datetime_to_str(datetime_str,time);
-    printf("New timing event%d :\r\n       %s \r\n",Timing_events_Num, datetime_str);
-    printf("        CHx   :");
-    for (int i = 0; i < Relay_Number_MAX; i++) 
-      printf("CH%d      ", i+1);
-    printf("\r\n        State :");
-    for (int i = 0; i < Relay_Number_MAX; i++) {
-      if(Relay_n[i] == STATE_Open)
-        printf("Open     ");
-      else if(Relay_n[i] == STATE_Closs)
-        printf("Closs    ");
-      else if(Relay_n[i] == STATE_Retain)
-        printf("Retain   ");
-    }
-    printf("\r\n");
-    printf("        ----- %s\r\n\r\n", Event_cycle[Repetition]);
-    printf("\r\n");
-    Buzzer_Open_Time(700, 0);
-    
-    int len = 0;  
-    char Event_content[1000];  
-    len += snprintf(Event_content + len, sizeof(Event_content) - len, "&nbsp;&nbsp;&nbsp;&nbsp;CHx&nbsp;&nbsp;:");
-    for (int i = 0; i < Relay_Number_MAX; i++) {
-      len += snprintf(Event_content + len, sizeof(Event_content) - len, "CH%d&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", i + 1);
-    }
-    len += snprintf(Event_content + len, sizeof(Event_content) - len, "\\n&nbsp;&nbsp;&nbsp;&nbsp;State&nbsp;:");
-    for (int i = 0; i < Relay_Number_MAX; i++) {
-      if (Relay_n[i] == STATE_Open)
-        len += snprintf(Event_content + len, sizeof(Event_content) - len, "Open&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
-      else if(Relay_n[i] == STATE_Closs)
-        len += snprintf(Event_content + len, sizeof(Event_content) - len, "Closs&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
-      else if(Relay_n[i] == STATE_Retain)
-        len += snprintf(Event_content + len, sizeof(Event_content) - len, "Retain&nbsp;&nbsp;&nbsp;");
-    }
-    len += snprintf(Event_content + len, sizeof(Event_content) - len, "\\n&nbsp;&nbsp;&nbsp;&nbsp;----- %s\\n\\n", Event_cycle[Repetition]);
-    // printf("%s\r\n", Event_content);  
-    sprintf(Event_str[Timing_events_Num-1], "Event %d : %s \\n%s", Timing_events_Num, datetime_str,Event_content);
-  }
-}
-
-void TimerEvent_printf(Timing_RTC event){
-  uint8_t Retain_channels = 0;
-  uint8_t open[8]={0};      
-  printf("Event %d : \r\n", event.Event_Number);
-  char datetime_str[50];
-  datetime_to_str(datetime_str,event.Time);
-  for (int i = 0; i < Relay_Number_MAX; i++) {
-    if(*(&(event.Relay_CH1)+i) == STATE_Retain)                     // Find the modified channel
-      Retain_channels ++;                                     // Number of unmodified channels  
-    else
-      open[i] = *(&(event.Relay_CH1)+i);
-  }
-  if(Retain_channels == 0){                                   // All channels have been modified   (use TimerEvent_CHxs_Set())   
-    printf("%s\r\n", datetime_str);
-    printf(" CHx Open  : ");         
-    for (int j = 0; j < Relay_Number_MAX; j++) {
-      if(open[j])                          
-        printf("CH%d    ", j); 
-    } 
-    printf("\r\n CHx Closs : ");         
-    for (int k = 0; k < Relay_Number_MAX; k++) {
-      if(!open[k])                          
-        printf("CH%d    ", k); 
-    }
-    printf("\r\n");    
-  }
-  else if(Retain_channels == Relay_Number_MAX - 1){           // Modified a channel                (use TimerEvent_CHx_Set())
-    printf("%s    ,", datetime_str);
-    for (int x = 0; x < Relay_Number_MAX; x++) {
-      if(*(&(event.Relay_CH1)+x) != STATE_Retain){                   // Find the modified channel
-        if(*(&(event.Relay_CH1)+x))
-          printf("CH%d Open\r\n", x); 
-        else
-          printf("CH%d Closs\r\n", x); 
-        break;
-      }
-    }
-  }
-  else{
-    printf("%s\r\n", datetime_str);
-    printf("CHx Open   : ");  
-    int j = 0;       
-    for (j = 0; j < Relay_Number_MAX; j++) {
-      if(open[j] == STATE_Open)                          
-        printf("CH%d    ", j+1); 
-    } 
-    printf("\r\nCHx Closs  : ");         
-    for (j = 0; j < Relay_Number_MAX; j++) {
-      if(open[j] == STATE_Closs)                          
-        printf("CH%d    ", j+1); 
-    }
-    printf("\r\nCHx Retain : ");         
-    for (j = 0; j < Relay_Number_MAX; j++) {
-      if(open[j] == STATE_Retain)                          
-        printf("CH%d    ", j+1); 
-    }
-    printf("\r\n");   
-  }
-}
-
-void TimerEvent_printf_ALL(void)
-{
-  printf("/******************* Current RTC event *******************/ \r\n");
-  for (int i = 0; i < Timing_events_Number_MAX; i++) {
-    if(CHx_State[i].Enable_Flag)
-      TimerEvent_printf(CHx_State[i]);
-  }
-  printf("/******************* Current RTC event *******************/\r\n\r\n ");
-}
-void TimerEvent_Del(Timing_RTC event){
-  RGB_Open_Time(20, 0, 50, 1000, 0); 
-  printf("Example Delete an RTC event%d\r\n\r\n",event.Event_Number);
-  for (int i = event.Event_Number; i < Timing_events_Number_MAX; i++) {
-    CHx_State[i].Event_Number = CHx_State[i].Event_Number -1;
-    CHx_State[i-1] = CHx_State[i];  
-  }
-  CHx_State[Timing_events_Number_MAX - 1] = CHx_State_Default;
-  memset(Event_str[Timing_events_Number_MAX - 1], 0, sizeof(Event_str[Timing_events_Number_MAX - 1]));
-  Timing_events_Num --;
-}
-void TimerEvent_Del_Number(uint8_t Event_Number){
-  TimerEvent_Del(CHx_State[Event_Number - 1]);
-  Buzzer_Open_Time(700, 300); 
-}

src/WS_RTC.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "WS_PCF85063.h"
-#include "WS_Relay.h"
-#include "WS_GPIO.h"
-
-#define Timing_events_Number_MAX    10              // Indicates the number of timers that can be set
-
-typedef enum {
-  Repetition_NONE = 0,        // aperiodicity
-  Repetition_everyday = 1,    // The event is repeated at this time every day
-  Repetition_Weekly = 2,      // This event is repeated every week at this time
-  Repetition_monthly = 3,     // This event is repeated every month at this time
-} Repetition_event;
-
-typedef struct {
-  bool Enable_Flag = false;                                   // The timer event enabled flag.    
-  uint8_t Event_Number = 0;                                   // Current event sequence number   
-  Status_adjustment Relay_CH1 = STATE_Retain;                       // The CH1 status is changed periodically
-  Status_adjustment Relay_CH2 = STATE_Retain;                       // The CH2 status is changed periodically
-  Status_adjustment Relay_CH3 = STATE_Retain;                       // The CH3 status is changed periodically
-  Status_adjustment Relay_CH4 = STATE_Retain;                       // The CH4 status is changed periodically
-  Status_adjustment Relay_CH5 = STATE_Retain;                       // The CH5 status is changed periodically
-  Status_adjustment Relay_CH6 = STATE_Retain;                       // The CH6 status is changed periodically
-  Status_adjustment Relay_CH7 = STATE_Retain;                       // The CH7 status is changed periodically
-  Status_adjustment Relay_CH8 = STATE_Retain;                       // The CH8 status is changed periodically
-  datetime_t Time;
-  Repetition_event repetition_State = Repetition_NONE;         // Periodic execution
-}Timing_RTC;
-
-extern uint8_t Timing_events_Num;
-extern Timing_RTC CHx_State[Timing_events_Number_MAX];
-extern char Event_str[Timing_events_Number_MAX][1000];
-
-void RTCTask(void *parameter);
-void TimerEvent_handling(Timing_RTC event);
-void TimerEvent_printf(Timing_RTC event);
-void TimerEvent_Del(Timing_RTC event);
-
-void RTC_Init(void);
-void TimerEvent_CHx_Set(datetime_t time,uint8_t CHx, bool State, Repetition_event Repetition);
-void TimerEvent_CHxs_Set(datetime_t time,uint8_t PinState, Repetition_event Repetition);
-void TimerEvent_CHxn_Set(datetime_t time,Status_adjustment *Relay_n, Repetition_event Repetition);
-void TimerEvent_printf_ALL(void);
-void TimerEvent_Del_Number(uint8_t Event_Number);

src/WS_Relay.cpp

@@ -1,273 +0,0 @@
-#include "WS_Relay.h"
-
-bool Failure_Flag = 0;
-/*************************************************************  Relay I/O  *************************************************************/
-bool Relay_Open(uint8_t CHx)
-{
-  if(!Set_EXIO(CHx, true)){
-    printf("Failed to Open CH%d!!!\r\n", CHx);
-    Failure_Flag = 1;
-    return 0;
-  }
-  return 1;
-}
-bool Relay_Closs(uint8_t CHx)
-{
-  if(!Set_EXIO(CHx, false)){
-    printf("Failed to Closs CH%d!!!\r\n", CHx);
-    Failure_Flag = 1;
-    return 0;
-  }
-  return 1;
-}
-bool Relay_CHx_Toggle(uint8_t CHx)
-{
-   if(!Set_Toggle(CHx)){
-    printf("Failed to Toggle CH%d!!!\r\n", CHx);
-    Failure_Flag = 1;
-    return 0;
-  }
-  return 1;
-}
-bool Relay_CHx(uint8_t CHx, bool State)
-{
-  bool result = 0;
-  if(State)
-    result = Relay_Open(CHx);
-  else
-    result = Relay_Closs(CHx);
-  if(!result)
-    Failure_Flag = 1;
-  return result;
-}
-bool Relay_CHxs_PinState(uint8_t PinState)
-{
-  if(!Set_EXIOS(PinState)){
-    printf("Failed to set the relay status!!!\r\n");
-    Failure_Flag = 1;
-    return 0;
-  }
-  return 1;
-}
-
-void RelayFailTask(void *parameter) {
-  while(1){
-    if(Failure_Flag)
-    {
-      Failure_Flag = 0;
-      printf("Error: Relay control failed!!!\r\n");
-      RGB_Open_Time(60,0,0,5000,500);
-      Buzzer_Open_Time(5000, 500);
-    }
-    vTaskDelay(pdMS_TO_TICKS(50));
-  }
-  vTaskDelete(NULL);
-}
-void Relay_Init(void)
-{
-  TCA9554PWR_Init(0x00);
-  xTaskCreatePinnedToCore(
-    RelayFailTask,    
-    "RelayFailTask",   
-    4096,                
-    NULL,                 
-    3,                   
-    NULL,                 
-    0                   
-  );
-}
-
-/********************************************************  Data Analysis  ********************************************************/
-bool Relay_Flag[8] = {0};       // Relay current status flag
-void Relay_Analysis(uint8_t *buf,uint8_t Mode_Flag)
-{
-  uint8_t ret = 0;
-  if(Mode_Flag == Bluetooth_Mode)
-    printf("Bluetooth Data :\r\n");
-  else if(Mode_Flag == WIFI_Mode)
-    printf("WIFI Data :\r\n");
-  else if(Mode_Flag == MQTT_Mode)
-    printf("MQTT Data :\r\n");
-  else if(Mode_Flag == RS485_Mode)
-    printf("RS485 Data :\r\n");  
-  switch(buf[0])
-  {
-    case CH1: 
-      ret = Relay_CHx_Toggle(GPIO_PIN_CH1);                                              //Toggle the level status of the GPIO_PIN_CH1 pin
-      if(ret){
-        Relay_Flag[0] =! Relay_Flag[0];
-        Buzzer_Open_Time(200, 0);
-        if(Relay_Flag[0])
-          printf("|***  Relay CH1 on  ***|\r\n");
-        else
-          printf("|***  Relay CH1 off ***|\r\n");
-      }
-      break;
-    case CH2: 
-      ret = Relay_CHx_Toggle(GPIO_PIN_CH2);                                             //Toggle the level status of the GPIO_PIN_CH2 pin
-      if(ret){
-        Relay_Flag[1] =! Relay_Flag[1];
-        Buzzer_Open_Time(200, 0);
-        if(Relay_Flag[1])
-          printf("|***  Relay CH2 on  ***|\r\n");
-        else
-          printf("|***  Relay CH2 off ***|\r\n");
-      }
-      break;
-    case CH3:
-      ret = Relay_CHx_Toggle(GPIO_PIN_CH3);                                             //Toggle the level status of the GPIO_PIN_CH3 pin
-      if(ret){
-        Relay_Flag[2] =! Relay_Flag[2];
-        Buzzer_Open_Time(200, 0);
-        if(Relay_Flag[2])
-          printf("|***  Relay CH3 on  ***|\r\n");
-        else
-          printf("|***  Relay CH3 off ***|\r\n");
-      }
-      break;
-    case CH4:
-      ret = Relay_CHx_Toggle(GPIO_PIN_CH4);                                             //Toggle the level status of the GPIO_PIN_CH4 pin
-      if(ret){
-        Relay_Flag[3] =! Relay_Flag[3];
-        Buzzer_Open_Time(200, 0);
-        if(Relay_Flag[3])
-          printf("|***  Relay CH4 on  ***|\r\n");
-        else
-          printf("|***  Relay CH4 off ***|\r\n");
-      }
-      break;
-    case CH5:
-      ret = Relay_CHx_Toggle(GPIO_PIN_CH5);                                             //Toggle the level status of the GPIO_PIN_CH5 pin
-      if(ret){  
-        Relay_Flag[4] =! Relay_Flag[4];
-        Buzzer_Open_Time(200, 0);
-        if(Relay_Flag[4])
-          printf("|***  Relay CH5 on  ***|\r\n");
-        else
-          printf("|***  Relay CH5 off ***|\r\n");
-      }
-      break;
-    case CH6:
-      ret = Relay_CHx_Toggle(GPIO_PIN_CH6);                                             //Toggle the level status of the GPIO_PIN_CH6 pin
-      if(ret){
-        Relay_Flag[5] =! Relay_Flag[5];
-        Buzzer_Open_Time(200, 0);
-        if(Relay_Flag[5])
-          printf("|***  Relay CH6 on  ***|\r\n");
-        else
-          printf("|***  Relay CH6 off ***|\r\n");
-      }
-      break;
-    case CH7:
-      ret = Relay_CHx_Toggle(GPIO_PIN_CH7);                                             //Toggle the level status of the GPIO_PIN_CH6 pin
-      if(ret){
-        Relay_Flag[6] =! Relay_Flag[6];
-        Buzzer_Open_Time(200, 0);
-        if(Relay_Flag[6])
-          printf("|***  Relay CH7 on  ***|\r\n");
-        else
-          printf("|***  Relay CH7 off ***|\r\n");
-      }
-      break;
-    case CH8:
-      ret = Relay_CHx_Toggle(GPIO_PIN_CH8);                                             //Toggle the level status of the GPIO_PIN_CH6 pin
-      if(ret){
-        Relay_Flag[7] =! Relay_Flag[7];
-        Buzzer_Open_Time(200, 0);
-        if(Relay_Flag[7])
-          printf("|***  Relay CH8 on  ***|\r\n");
-        else
-          printf("|***  Relay CH8 off ***|\r\n");
-      }
-      break;
-    case ALL_ON:
-      ret = Relay_CHxs_PinState(0xFF);                                              // Turn on all relay
-      if(ret){
-        memset(Relay_Flag,1, sizeof(Relay_Flag));
-        printf("|***  Relay ALL on  ***|\r\n");
-        Buzzer_Open_Time(500, 0);
-      }
-
-      break;
-    case ALL_OFF:
-      ret = Relay_CHxs_PinState(0x00);                                                // Turn off all relay
-      if(ret){
-        memset(Relay_Flag,0, sizeof(Relay_Flag));
-        printf("|***  Relay ALL off ***|\r\n");
-        Buzzer_Open_Time(500, 150); 
-      }
-      break;
-    default:
-      printf("Note : Non-instruction data was received !  -  %c\r\n", buf[0]);
-  }
-}
-
-void Relay_Immediate(uint8_t CHx, bool State, uint8_t Mode_Flag)
-{
-  if(!CHx || CHx > 8){
-    printf("Relay_Immediate(function): Incoming parameter error!!!!\r\n");
-    Failure_Flag = 1;
-  }
-  else{
-    uint8_t ret = 0;
-    if(Mode_Flag == DIN_Mode)
-      printf("DIN Data :\r\n"); 
-    else if(Mode_Flag == RTC_Mode)
-      printf("RTC Data :\r\n");
-    ret = Relay_CHx(CHx,State);                                               
-    if(ret){
-      Relay_Flag[CHx-1] = State;
-      Buzzer_Open_Time(200, 0);
-      if(Relay_Flag[0])
-        printf("|***  Relay CH%d on  ***|\r\n",CHx);
-      else
-        printf("|***  Relay CH%d off ***|\r\n",CHx);
-    }
-  }
-}
-void Relay_Immediate_CHxn(Status_adjustment * Relay_n, uint8_t Mode_Flag)
-{
-  uint8_t ret = 0;
-  if(Mode_Flag == DIN_Mode)
-    printf("DIN Data :\r\n"); 
-  else if(Mode_Flag == RTC_Mode)
-    printf("RTC Data :\r\n");            
-  for (int i = 0; i < 8; i++) {
-    if(Relay_n[i] == STATE_Open || Relay_n[i] == STATE_Closs){
-      Relay_Flag[i] = (bool)Relay_n[i];
-      ret = Relay_CHx(i+1,Relay_n[i]);  
-      if(Relay_n[i] == STATE_Open)
-        printf("|***  Relay CH%d on  ***|\r\n",i+1);
-      else if(Relay_n[i] == STATE_Closs)
-        printf("|***  Relay CH%d off ***|\r\n",i+1);
-    }
-  }
-  Buzzer_Open_Time(200, 0);
-}
-
-void Relay_Immediate_CHxs(uint8_t PinState, uint8_t Mode_Flag)
-{
-  uint8_t ret = 0;
-  if(Mode_Flag == DIN_Mode)
-    printf("DIN Data :\r\n"); 
-  else if(Mode_Flag == RTC_Mode)
-    printf("RTC Data :\r\n");
-  for (int i = 0; i < 8; i++) {
-    Relay_Flag[i] = (PinState >> i) & 0x01; // 提取每一位并赋值
-  }
-  ret = Relay_CHxs_PinState(PinState);                                               
-  if(ret){
-    for (int j = 0; j < 8; j++) {
-      if(Relay_Flag[j])
-        printf("|***  Relay CH%d on  ***|\r\n",j+1);
-      else
-        printf("|***  Relay CH%d off ***|\r\n",j+1);
-    }
-    Buzzer_Open_Time(200, 0);
-  }
-  else
-  {
-    printf("Relay_Immediate_CHxs(function): Relay control failure!!!!\r\n");
-    Failure_Flag = 1;
-  }
-}

src/WS_Relay.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#include "WS_TCA9554PWR.h"
-#include <HardwareSerial.h>     // Reference the ESP32 built-in serial port library
-#include "WS_GPIO.h"
-
-
-/*************************************************************  I/O  *************************************************************/
-#define Relay_Number_MAX  8 
-#define GPIO_PIN_CH1      EXIO_PIN1    // CH1 Control GPIO
-#define GPIO_PIN_CH2      EXIO_PIN2    // CH2 Control GPIO
-#define GPIO_PIN_CH3      EXIO_PIN3    // CH3 Control GPIO
-#define GPIO_PIN_CH4      EXIO_PIN4    // CH4 Control GPIO
-#define GPIO_PIN_CH5      EXIO_PIN5    // CH5 Control GPIO
-#define GPIO_PIN_CH6      EXIO_PIN6    // CH6 Control GPIO
-#define GPIO_PIN_CH7      EXIO_PIN7    // CH7 Control GPIO
-#define GPIO_PIN_CH8      EXIO_PIN8    // CH8 Control GPIO
-
-
-#define CH1 '1'                 // CH1 Enabled Instruction              Hex : 0x31
-#define CH2 '2'                 // CH2 Enabled Instruction              Hex : 0x32
-#define CH3 '3'                 // CH3 Enabled Instruction              Hex : 0x33
-#define CH4 '4'                 // CH4 Enabled Instruction              Hex : 0x34
-#define CH5 '5'                 // CH5 Enabled Instruction              Hex : 0x35
-#define CH6 '6'                 // CH6 Enabled Instruction              Hex : 0x36
-#define CH7 '7'                 // CH5 Enabled Instruction              Hex : 0x37
-#define CH8 '8'                 // CH6 Enabled Instruction              Hex : 0x38
-#define ALL_ON  '9'             // Start all channel instructions       Hex : 0x39
-#define ALL_OFF '0'             // Disable all channel instructions     Hex : 0x30
-
-#define DIN_Mode          1
-#define RS485_Mode        2     // Used to distinguish data sources
-#define Bluetooth_Mode    3
-#define WIFI_Mode         4
-#define MQTT_Mode         5
-#define RTC_Mode          6
-
-typedef enum {
-  STATE_Closs = 0,    // Closs Relay
-  STATE_Open = 1,     // Open Relay
-  STATE_Retain = 2,   // Stay in place
-} Status_adjustment;
-
-extern bool Relay_Flag[8];  // Relay current status flag
-
-void Relay_Init(void);
-bool Relay_Closs(uint8_t CHx);
-bool Relay_Open(uint8_t CHx);
-bool Relay_CHx_Toggle(uint8_t CHx);
-bool Relay_CHx(uint8_t CHx, bool State);
-bool Relay_CHxs_PinState(uint8_t PinState);
-
-void Relay_Analysis(uint8_t *buf,uint8_t Mode_Flag);
-void Relay_Immediate(uint8_t CHx, bool State, uint8_t Mode_Flag);
-void Relay_Immediate_CHxs(uint8_t PinState, uint8_t Mode_Flag);
-void Relay_Immediate_CHxn(Status_adjustment * Relay_n, uint8_t Mode_Flag);

src/WS_SD.cpp

@@ -1,113 +0,0 @@
-#include "WS_SD.h"
-
-bool SDCard_Flag = 0;
-bool SDCard_Finish = 0;
-
-uint16_t SDCard_Size = 0;
-uint16_t Flash_Size = 0;
-
-void SD_Init() {
-  // SD MMC
-  if(!SD_MMC.setPins(SD_CLK_PIN, SD_CMD_PIN, SD_D0_PIN,-1,-1,-1)){
-    printf("SD MMC: Pin change failed!\r\n");
-    return;
-  }
-  if (SD_MMC.begin("/sdcard", true, true)) {                // "/sdcard", true, true     or  "/sdcard", true, false                            
-    printf("SD card initialization successful!\r\n");
-  } else {
-    printf("SD card initialization failed!\r\n");
-  }
-  uint8_t cardType = SD_MMC.cardType();
-  if(cardType == CARD_NONE){
-    printf("No SD card attached\r\n");
-    return;
-  }
-  else{
-    printf("SD Card Type: ");
-    if(cardType == CARD_MMC){
-      printf("MMC\r\n");
-    } else if(cardType == CARD_SD){
-      printf("SDSC\r\n");
-    } else if(cardType == CARD_SDHC){
-      printf("SDHC\r\n");
-    } else {
-      printf("UNKNOWN\r\n");
-    }
-    uint64_t totalBytes = SD_MMC.totalBytes();
-    uint64_t usedBytes = SD_MMC.usedBytes();
-    SDCard_Size = totalBytes/(1024*1024);
-    printf("Total space: %llu\n", totalBytes);
-    printf("Used space: %llu\n", usedBytes);
-    printf("Free space: %llu\n", totalBytes - usedBytes);
-  }
-}
-bool File_Search(const char* directory, const char* fileName)    
-{
-  File Path = SD_MMC.open(directory);
-  if (!Path) {
-    printf("Path: <%s> does not exist\r\n",directory);
-    return false;
-  }
-  File file = Path.openNextFile();
-  while (file) {
-    if (strcmp(file.name(), fileName) == 0) {                           
-      if (strcmp(directory, "/") == 0)
-        printf("File '%s%s' found in root directory.\r\n",directory,fileName);  
-      else
-        printf("File '%s/%s' found in root directory.\r\n",directory,fileName); 
-      Path.close();                                                     
-      return true;                                                     
-    }
-    file = Path.openNextFile();                                        
-  }
-  if (strcmp(directory, "/") == 0)
-    printf("File '%s%s' not found in root directory.\r\n",directory,fileName);           
-  else
-    printf("File '%s/%s' not found in root directory.\r\n",directory,fileName);          
-  Path.close();                                                         
-  return false;                                                         
-}
-uint16_t Folder_retrieval(const char* directory, const char* fileExtension, char File_Name[][100],uint16_t maxFiles)    
-{
-  File Path = SD_MMC.open(directory);
-  if (!Path) {
-    printf("Path: <%s> does not exist\r\n",directory);
-    return false;
-  }
-  
-  uint16_t fileCount = 0;
-  char filePath[100];
-  File file = Path.openNextFile();
-  while (file && fileCount < maxFiles) {
-    if (!file.isDirectory() && strstr(file.name(), fileExtension)) {
-      strncpy(File_Name[fileCount], file.name(), sizeof(File_Name[fileCount])); 
-      if (strcmp(directory, "/") == 0) {                                      
-        snprintf(filePath, 100, "%s%s", directory, file.name());   
-      } else {                                                            
-        snprintf(filePath, 100, "%s/%s", directory, file.name());
-      }
-      printf("File found: %s\r\n", filePath);
-      fileCount++;
-    }
-    file = Path.openNextFile();                                      
-  }
-  Path.close();                                                         
-  if (fileCount > 0) {
-    printf("Retrieved %d mp3 files\r\n",fileCount);
-    return fileCount;                                                 
-  } else {
-    printf("No files with extension '%s' found in directory: %s\r\n", fileExtension, directory);
-    return 0;                                                         
-  }
-}
-
-void Flash_test()
-{
-  printf("/********** RAM Test**********/\r\n");
-  // Get Flash size
-  uint32_t flashSize = ESP.getFlashChipSize();
-  Flash_Size = flashSize/1024/1024;
-  printf("Flash size: %d MB \r\n", flashSize/1024/1024);
-
-  printf("/******* RAM Test Over********/\r\n\r\n");
-}

src/WS_SD.h

@@ -1,18 +0,0 @@
-#pragma once
-#include "Arduino.h"
-#include <cstring>
-#include "FS.h"
-#include "SD_MMC.h"
-
-#define SD_CLK_PIN      48
-#define SD_CMD_PIN      47 
-#define SD_D0_PIN       45 
-
-extern uint16_t SDCard_Size;
-extern uint16_t Flash_Size;
-
-void SD_Init();
-void Flash_test();
-
-bool File_Search(const char* directory, const char* fileName);
-uint16_t Folder_retrieval(const char* directory, const char* fileExtension, char File_Name[][100],uint16_t maxFiles);

src/WS_Serial.cpp

@@ -1,8 +0,0 @@
-#include "WS_Serial.h"
-void Serial_Init()
-{
-  if(RS485_CAN_Enable)
-    RS485_Init();
-  else
-    CAN_Init();
-}

src/WS_Serial.h

@@ -1,8 +0,0 @@
-#pragma once
-
-#include "WS_Information.h"
-#include "WS_RS485.h"
-#include "WS_CAN.h"
-
-void Serial_Init();         // Example Initialize the system serial port and RS485
-void Serial_Loop();         // Read RS485 data, parse and control relays

src/WS_TCA9554PWR.cpp

@@ -1,107 +0,0 @@
-#include "WS_TCA9554PWR.h"
-
-/*****************************************************  Operation register REG   ****************************************************/   
-uint8_t Read_REG(uint8_t REG)                             // Read the value of the TCA9554PWR register REG
-{
-  Wire.beginTransmission(TCA9554_ADDRESS);                
-  Wire.write(REG);                                        
-  uint8_t result = Wire.endTransmission();               
-  if (result != 0) {                                     
-    printf("Data Transfer Failure !!!\r\n");
-  }
-  Wire.requestFrom(TCA9554_ADDRESS, 1);                   
-  uint8_t bitsStatus = Wire.read();                        
-  return bitsStatus;                                     
-}
-uint8_t Write_REG(uint8_t REG,uint8_t Data)              // Write Data to the REG register of the TCA9554PWR
-{
-  Wire.beginTransmission(TCA9554_ADDRESS);                
-  Wire.write(REG);                                        
-  Wire.write(Data);                                       
-  uint8_t result = Wire.endTransmission();                  
-  if (result != 0) {    
-    printf("Data write failure!!!\r\n");
-    return -1;
-  }
-  return 0;                                             
-}
-/********************************************************** Set EXIO mode **********************************************************/       
-void Mode_EXIO(uint8_t Pin,uint8_t State)                 // Set the mode of the TCA9554PWR Pin. The default is Output mode (output mode or input mode). State: 0= Output mode 1= input mode   
-{
-  uint8_t bitsStatus = Read_REG(TCA9554_CONFIG_REG);      
-  uint8_t Data = (0x01 << (Pin-1)) | bitsStatus;   
-  uint8_t result = Write_REG(TCA9554_CONFIG_REG,Data); 
-  if (result != 0) { 
-    printf("I/O Configuration Failure !!!\r\n");
-  }
-}
-void Mode_EXIOS(uint8_t PinState)                         // Set the mode of the 7 pins from the TCA9554PWR with PinState   
-{
-  uint8_t result = Write_REG(TCA9554_CONFIG_REG,PinState);  
-  if (result != 0) {   
-    printf("I/O Configuration Failure !!!\r\n");
-  }
-}
-/********************************************************** Read EXIO status **********************************************************/       
-uint8_t Read_EXIO(uint8_t Pin)                            // Read the level of the TCA9554PWR Pin
-{
-  uint8_t inputBits = Read_REG(TCA9554_INPUT_REG);          
-  uint8_t bitStatus = (inputBits >> (Pin-1)) & 0x01; 
-  return bitStatus;                                  
-}
-uint8_t Read_EXIOS(uint8_t REG = TCA9554_INPUT_REG)       // Read the level of all pins of TCA9554PWR, the default read input level state, want to get the current IO output state, pass the parameter TCA9554_OUTPUT_REG, such as Read_EXIOS(TCA9554_OUTPUT_REG);
-{
-  uint8_t inputBits = Read_REG(REG);                     
-  return inputBits;     
-}
-
-/********************************************************** Set the EXIO output status **********************************************************/  
-bool Set_EXIO(uint8_t Pin,uint8_t State)                  // Sets the level state of the Pin without affecting the other pins
-{
-  uint8_t Data;
-  if(State < 2 && Pin < 9 && Pin > 0){  
-    uint8_t bitsStatus = Read_EXIOS(TCA9554_OUTPUT_REG);
-    if(State == 1)                                     
-      Data = (0x01 << (Pin-1)) | bitsStatus; 
-    else if(State == 0)                  
-      Data = (~(0x01 << (Pin-1))) & bitsStatus;      
-    uint8_t result = Write_REG(TCA9554_OUTPUT_REG,Data);  
-    if (result != 0) {                         
-      printf("Failed to set GPIO!!!\r\n");
-      return 0;
-    }
-    return 1;
-  }
-  else                                           
-  {
-    printf("Parameter error, please enter the correct parameter!\r\n");
-    return 0;
-  }
-}
-bool Set_EXIOS(uint8_t PinState)                          // Set 7 pins to the PinState state such as :PinState=0x23, 0010 0011 state (the highest bit is not used)
-{
-  uint8_t result = Write_REG(TCA9554_OUTPUT_REG,PinState); 
-  if (result != 0) {                  
-    printf("Failed to set GPIO!!!\r\n");
-    return 0;
-  }
-  return 1;
-}
-/********************************************************** Flip EXIO state **********************************************************/  
-bool Set_Toggle(uint8_t Pin)                              // Flip the level of the TCA9554PWR Pin
-{
-    uint8_t bitsStatus = Read_EXIO(Pin);    
-    uint8_t result = Set_EXIO(Pin,(bool)!bitsStatus); 
-    if (!result) {                         
-      printf("Failed to Toggle GPIO!!!\r\n");
-      return 0;
-    }
-    return 1;
-}
-/********************************************************* TCA9554PWR Initializes the device ***********************************************************/  
-void TCA9554PWR_Init(uint8_t PinMode, uint8_t PinState)                  // Set the seven pins to PinState state, for example :PinState=0x23, 0010 0011 State  (Output mode or input mode) 0= Output mode 1= Input mode. The default value is output mode
-{                       
-  Set_EXIOS(PinState);
-  Mode_EXIOS(PinMode); 
-}
-

src/WS_TCA9554PWR.h

@@ -1,41 +0,0 @@
-#pragma once
-
-#include <stdio.h>
-#include "I2C_Driver.h"
-
-/****************************************************** The macro defines the TCA9554PWR information ******************************************************/ 
-
-#define TCA9554_ADDRESS         0x20                      // TCA9554PWR I2C address
-#define TCA9554_INPUT_REG       0x00                      // Input register,input level
-#define TCA9554_OUTPUT_REG      0x01                      // Output register, high and low level output 
-#define TCA9554_Polarity_REG    0x02                      // The Polarity Inversion register (register 2) allows polarity inversion of pins defined as inputs by the Configuration register.  
-#define TCA9554_CONFIG_REG      0x03                      // Configuration register, mode configuration
-
-
-#define Low   0
-#define High  1
-#define EXIO_PIN1   1
-#define EXIO_PIN2   2
-#define EXIO_PIN3   3
-#define EXIO_PIN4   4
-#define EXIO_PIN5   5
-#define EXIO_PIN6   6
-#define EXIO_PIN7   7
-#define EXIO_PIN8   8
-
-/*****************************************************  Operation register REG   ****************************************************/   
-uint8_t Read_REG(uint8_t REG);                                                      // Read the value of the TCA9554PWR register REG
-uint8_t Write_REG(uint8_t REG,uint8_t Data);                                        // Write Data to the REG register of the TCA9554PWR
-/********************************************************** Set EXIO mode **********************************************************/       
-void Mode_EXIO(uint8_t Pin,uint8_t State);                                          // Set the mode of the TCA9554PWR Pin. The default is Output mode (output mode or input mode). State: 0= Output mode 1= input mode   
-void Mode_EXIOS(uint8_t PinState);                                                  // Set the mode of the 7 pins from the TCA9554PWR with PinState  
-/********************************************************** Read EXIO status **********************************************************/       
-uint8_t Read_EXIO(uint8_t Pin);                                                     // Read the level of the TCA9554PWR Pin
-uint8_t Read_EXIOS(uint8_t REG);                                                    // Read the level of all pins of TCA9554PWR, the default read input level state, want to get the current IO output state, pass the parameter TCA9554_OUTPUT_REG, such as Read_EXIOS(TCA9554_OUTPUT_REG);
-/********************************************************** Set the EXIO output status **********************************************************/  
-bool Set_EXIO(uint8_t Pin,uint8_t State);                                           // Sets the level state of the Pin without affecting the other pins
-bool Set_EXIOS(uint8_t PinState);                                                   // Set 7 pins to the PinState state such as :PinState=0x23, 0010 0011 state (the highest bit is not used)
-/********************************************************** Flip EXIO state **********************************************************/  
-bool Set_Toggle(uint8_t Pin);                                                       // Flip the level of the TCA9554PWR Pin
-/********************************************************* TCA9554PWR Initializes the device ***********************************************************/  
-void TCA9554PWR_Init(uint8_t PinMode = 0x00, uint8_t PinState = 0x00);              // Set the seven pins to PinState state, for example :PinState=0x23, 0010 0011 State (the highest bit is not used) (Output mode or input mode) 0= Output mode 1= Input mode. The default value is output mode

src/digitalIO.cpp

@@ -0,0 +1,124 @@
+#include <digitalIO.h>
+
+digitalIO::digitalIO(drivers::I2C &i2c, drivers::MODBUS &bus, std::vector<uint8_t> remotes) : m_localOuts(drivers::TCA9554PWR(i2c, TCA9554_ADDRESS)), m_remoteAddrs(remotes)
+{
+    for (uint8_t i(DI1); i < DI_MAX; i++)
+    {
+        pinMode(i, INPUT_PULLUP); // set all local pins as digitalInput
+    }
+
+    for (auto a : remotes)
+    {
+        m_remotes.emplace_back(remoteIO(a, bus));
+    }
+}
+
+digitalIO::~digitalIO()
+{
+}
+
+void digitalIO::digitalIOWrite(const uint8_t ch, const bool value)
+{
+    if (ch < 0 || ch > getOutNum())
+    {
+        LOG_ERROR("Invalid digitalIOWrite channel number", ch);
+    }
+
+    if (ch < drivers::TCA9554PWR::DO_MAX) // write to i2c device for local outputs
+    {
+        digitalWriteLocal(ch, value);
+    }
+    else
+    {
+        digitalWriteRemote(ch - drivers::TCA9554PWR::DO_MAX, value);
+    }
+}
+const bool digitalIO::digitalIORead(const uint8_t ch)
+{
+    if (ch < 0 || ch > getInNum())
+    {
+        LOG_ERROR("Invalid digitalIORead channel number", ch);
+    }
+
+    if (ch < (DI_MAX - DI1)) // read from local inputs not as gpio numbers
+    {
+        return digitalReadLocal(ch);
+    }
+    else
+    {
+        return digitalReadRemote(ch - (DI_MAX - DI1));
+    }
+}
+
+void digitalIO::reset()
+{
+    // set all local and remote outputs to 0
+    m_localOuts.setPort(0x00);
+    for (auto r: m_remotes)
+        r.resetAll(false);
+}
+
+const uint8_t digitalIO::getOutNum()
+{
+    return drivers::TCA9554PWR::DO_MAX + m_remotes.size() * remoteIO::CH_MAX;
+}
+
+const uint8_t digitalIO::getInNum()
+{
+    return DI_MAX + m_remotes.size() * remoteIO::CH_MAX;
+}
+
+void digitalIO::digitalWriteLocal(const uint8_t ch, const bool value)
+{
+    uint8_t retries(0);
+    while (retries++ < maxRetries)
+    {
+        if (m_localOuts.setOut(ch, value))
+        {
+            LOG_DEBUG("digitalWriteLocal channel", ch, " status", value ? "True" : "False");
+            break;
+        }
+        LOG_ERROR("Failed digitalWriteLocal channel ", ch, " status", value ? "True" : "False");
+    }
+}
+
+void digitalIO::digitalWriteRemote(const uint8_t ch, const bool value)
+{
+    uint8_t retries(0);
+    const uint8_t selectedRemote(floor(ch / 8.0f));
+    const uint8_t selectedChannel(ch % remoteIO::CH_MAX);
+    while (retries++ < maxRetries)
+    {
+        if (m_remotes[selectedRemote].setOut((remoteIO::channel_t)selectedChannel, value))
+        {
+            LOG_DEBUG("digitalWriteRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
+            break;
+        }
+        LOG_ERROR("Failed digitalWriteRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
+    }
+}
+
+const bool digitalIO::digitalReadLocal(const uint8_t ch)
+{
+    bool value = !digitalRead(ch + DI1); // base pin number in enum, inverted input
+    LOG_DEBUG("digitalReadLocal pin", (ch + DI1), " status", value ? "True" : "False");
+    return value;
+}
+
+const bool digitalIO::digitalReadRemote(const uint8_t ch)
+{
+    uint8_t retries(0);
+    const uint8_t selectedRemote(floor(ch / 8.0f));
+    const uint8_t selectedChannel(ch % remoteIO::CH_MAX);
+    bool value;
+    while (retries++ < maxRetries)
+    {
+        if (m_remotes[selectedRemote].getIn((remoteIO::channel_t)selectedChannel, value))
+        {
+            LOG_DEBUG("digitalReadRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
+            return value;
+        }
+        LOG_ERROR("Failed digitalReadRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
+    }
+    return false;
+}

src/digitalIO.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <DebugLog.h>
+#include <Arduino.h>
+
+#include <remoteIO.h>
+#include <TCA9554PWR_Driver.h>
+
+#define ON true
+#define OFF false
+
+class digitalIO
+{
+
+private:
+    enum localInputs
+    {
+        DI1 = 4, // gpio for local inputs starts at 4 as per manufacturer documentation
+        DI2,
+        DI3,
+        DI4,
+        DI5,
+        DI6,
+        DI7,
+        DI8,
+        DI_MAX
+    };
+
+    const uint8_t maxRetries = 5;
+
+public:
+    digitalIO(drivers::I2C &i2c, drivers::MODBUS &bus, std::vector<uint8_t> remotes);
+    ~digitalIO();
+
+    void digitalIOWrite(const uint8_t ch, const bool value);
+    const bool digitalIORead(const uint8_t ch);
+    void reset();
+
+    const uint8_t getOutNum();
+    const uint8_t getInNum();
+
+private:
+    void digitalWriteLocal(const uint8_t ch, const bool value);
+    void digitalWriteRemote(const uint8_t ch, const bool value);
+
+    const bool digitalReadLocal(const uint8_t ch);
+    const bool digitalReadRemote(const uint8_t ch);
+
+private:
+    std::vector<uint8_t> m_remoteAddrs;
+    drivers::TCA9554PWR m_localOuts;
+    std::vector<remoteIO> m_remotes;
+};

src/main.cpp

@@ -0,0 +1,179 @@
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_DEBUG
+
+#include <Arduino.h>
+#include <DebugLog.h>
+#include <DebugLogEnable.h>
+
+#include <config.h>
+#include <PCF85063_Driver.h>
+#include <R4DCB08_Driver.h>
+#include <S50140_Driver.h>
+#include <BUZZER_Driver.h>
+#include <LED_Driver.h>
+#include <ETH_Driver.h>
+
+#include <digitalIO.h>
+#include <mqtt.h>
+#include "utils.h"
+
+/////////////// GLOBALS ///////////////
+Config &conf = Config::getInstance();
+/////////////// GLOBALS ///////////////
+
+void testAction(const ArduinoJson::JsonDocument &doc)
+{
+  std::string message;
+  ArduinoJson::serializeJsonPretty(doc, message);
+  LOG_INFO("Received on testAction\n", message.c_str());
+}
+
+void setup()
+{
+  Serial.begin(9600);
+  LOG_ATTACH_SERIAL(Serial);
+  conf.init(); // read the configuration from internal flash
+}
+
+void loop()
+{
+  uint16_t k(0);
+  uint8_t sensors(0);
+  bool buzzing(false);
+
+  //////////////// DEVICES ////////////////
+  // Declared here to keep devices local to the main loop otherwise the kernel crashes //
+  auto i2c = drivers::I2C();
+  auto bus = drivers::MODBUS(9600, SERIAL_8N1);
+  auto rtc = drivers::PCF85063(i2c, PCF85063_ADDRESS);
+  auto eth = drivers::Ethernet(conf.m_ethHostname);
+  auto tmp = drivers::R4DCB08(bus, conf.m_modbusTemperatureAddr);
+  auto seneca = drivers::S50140(bus, conf.m_modbusSenecaAddr);
+  auto buzzer = drivers::Buzzer();
+  auto led = drivers::Led();
+  auto io = digitalIO(i2c, bus, {conf.m_modbusRelayAddr});
+  // Initialize temperature sensors
+  sensors = tmp.getNum();
+  LOG_INFO("Temperature sensors connected ->", sensors);
+  //////////////// DEVICES ////////////////
+
+  //////////////// NETWORK ////////////////
+  auto mqtt = MQTTwrapper();
+  //////////////// NETWORK ////////////////
+
+  std::function<void(const ArduinoJson::JsonDocument &)> mycallback =
+      [&io](const ArduinoJson::JsonDocument &doc)
+  {
+    io.digitalIOWrite(0, doc["stat"].as<bool>());
+    io.digitalIOWrite(15, doc["stat"].as<bool>());
+  };
+
+  //////////////// NETWORK ////////////////
+  /////////////// CALLBACK ////////////////
+  Network.onEvent(
+      [&eth, &rtc, &mqtt, &buzzer, &led, &mycallback](arduino_event_id_t event, arduino_event_info_t info) -> void
+      {
+        eth.onEvent(event, info); // Arduino Ethernet event handler
+        if (!eth.isConnected())
+          return;
+        // Get RTC time at ethernet connection
+        time_t ntpTime;
+        uint8_t timeRetries(0);
+        uint8_t mqttRetries(0);
+        while (timeRetries++ < conf.m_ntpRetries)
+        {
+          if (eth.getNtpTime(ntpTime) && rtc.setDatetime(drivers::PCF85063::fromEpoch(ntpTime)))
+          {
+            // buzzer.beep(250, NOTE_F);
+            led.setColor({255, 255, 0});
+            const drivers::PCF85063::datetime_t dt(drivers::PCF85063::fromEpoch(ntpTime));
+            LOG_INFO("NTP Time: ", drivers::PCF85063::datetime2str(dt).c_str());
+            delay(100);
+          }
+          break;
+        }
+        while (mqttRetries++ < conf.m_mqttRetries)
+        {
+          if (mqtt.connect())
+          {
+            mqtt.subscribe("test/esp32-in", testAction);
+            mqtt.subscribe("test/esp32-functional", mycallback);
+            break;
+          }
+          delay(100);
+        }
+      });
+
+  ////////////////////////////////////////
+  ///////// MAIN LOOP INSIDE LOOP ////////
+  ////////////////////////////////////////
+
+  while (true)
+  {
+    LOG_INFO("[", k++, "] Loop");
+
+    const std::string timeStr(rtc.getTimeStr());
+    LOG_INFO("Current Datetime", timeStr.c_str());
+    ArduinoJson::JsonDocument ts;
+    ts["loopIterator"] = k;
+    ts["currentTime"] = timeStr;
+    mqtt.publish("test/esp32-out", ts);
+
+    uint8_t i(0);
+    for (auto v : tmp.getTempAll())
+    {
+      LOG_INFO("Temperature channel", i++, "->", v);
+    }
+    i = 0;
+    delay(10);
+    for (auto v : tmp.getCorrection())
+    {
+      LOG_INFO("Temperature correction channel", i++, "tc", v);
+    }
+
+    delay(100);
+    drivers::S50140::powerinfo_t pinfo = seneca.getAll();
+    LOG_INFO("Power Info ==> V:", pinfo.v, "- A:", pinfo.a, "- W:", pinfo.pAct, "- F:", pinfo.f, "- Wh_t:", pinfo.whTot, "- Wh_p:", pinfo.whPar);
+
+    if (io.digitalIORead(0)) // rosso
+    {
+      uint8_t regset(seneca.getRegset());
+      uint16_t countStat(seneca.getCounterStatus());
+      LOG_INFO("Register Set: ", regset);
+      LOG_INFO("Counter Status: ", countStat);
+      seneca.resetPartialCounters();
+    }
+    delay(100);
+    if (io.digitalIORead(8)) // blu
+    {
+      if (!buzzing)
+      {
+        buzzing = true;
+        buzzer.beepRepeat(100, 1000, NOTE_C);
+        led.blinkColor(100, 500, {255, 0, 255});
+      }
+      else
+      {
+        buzzer.beepStop();
+        led.blinkAlternate(500, 500, {255, 255, 0}, {0, 255, 255});
+        buzzing = false;
+      }
+      LOG_INFO("Buzzing -> ", buzzing ? "True" : "False");
+    }
+
+    if (io.digitalIORead(9))
+    { // verde
+      conf.resetConfig();
+    }
+
+    if (io.digitalIORead(10))
+    { // giallo
+      esp_restart();
+    }
+
+    delay(conf.m_globalLoopDelay);
+  }
+
+  ////////////////////////////////////////
+  ///////// MAIN LOOP INSIDE LOOP ////////
+  ////////////////////////////////////////
+}

src/mqtt.cpp

@@ -0,0 +1,176 @@
+#include <mqtt.h>
+
+#define STACK_DEPTH 4096
+#define PRIOTITY 2
+
+MQTTwrapper::MQTTwrapper() : m_config(Config::getInstance()), m_tcp(NetworkClient()), m_client(PubSubClient(m_tcp)), m_loopHandle(NULL)
+{
+    m_client.setServer(m_config.m_mqttHost.c_str(), m_config.m_mqttPort);
+    m_client.setKeepAlive(15);
+    getInstance(this);
+}
+
+MQTTwrapper::~MQTTwrapper()
+{
+    disconnect();
+}
+
+const bool MQTTwrapper::connect()
+{
+    if (!m_client.connect(m_config.m_mqttClientName.c_str()))
+    {
+        LOG_ERROR("MQTT unable to connect to host", m_config.m_mqttHost.c_str());
+        return false;
+    }
+    LOG_INFO("MQTT client connected to", m_config.m_mqttHost.c_str());
+    if (m_loopHandle == NULL)
+    {
+        xTaskCreate(clientLoop, "mqttLoop", STACK_DEPTH, this, PRIOTITY, &m_loopHandle);
+        m_client.setCallback(MQTTwrapper::callback);
+    }
+    return true;
+}
+
+const bool MQTTwrapper::disconnect()
+{
+    m_client.disconnect();
+    if (m_loopHandle)
+    {
+        vTaskDelete(m_loopHandle); // immediate terminate loop
+        m_loopHandle = NULL;
+    }
+    return true;
+}
+
+const bool MQTTwrapper::subscribe(topic_t topic, action_t action)
+{
+    if (m_actionMap.contains(topic))
+    {
+        LOG_WARN("MQTT was already subscribed to", topic.c_str());
+        return true;
+    }
+    if (m_client.subscribe(topic.c_str()))
+    {
+        m_actionMap[topic] = action;
+        LOG_INFO("MQTT subscribed to", topic.c_str());
+        return true;
+    }
+    LOG_ERROR("MQTT unable to subscribe to", topic.c_str());
+    return false;
+}
+
+const bool MQTTwrapper::unsubscribe(topic_t topic)
+{
+    if (!m_actionMap.contains(topic))
+    {
+        LOG_WARN("MQTT was NOT subscribed to", topic.c_str());
+        return false;
+    }
+    if (m_client.unsubscribe(topic.c_str()))
+    {
+        LOG_INFO("MQTT unsubscribed to", topic.c_str());
+        m_actionMap.erase(topic);
+        return true;
+    }
+    LOG_ERROR("MQTT unable to unsubscribe to", topic.c_str());
+    return false;
+}
+
+const bool MQTTwrapper::connected()
+{
+    return m_loopHandle != NULL;
+}
+
+const bool MQTTwrapper::publish(topic_t topic, const ArduinoJson::JsonDocument obj)
+{
+    std::string message;
+    if (!m_client.connected())
+    {
+        LOG_ERROR("MQTT client not connected");
+        return false;
+    }
+    if (!ArduinoJson::serializeJson(obj, message))
+    {
+        LOG_ERROR("MQTT failed to serialize object");
+        return false;
+    }
+    if (m_client.publish(topic.c_str(), message.c_str()))
+    {
+        LOG_DEBUG("MQTT published topic [", topic.c_str(), "] - message [", message.c_str(), "]");
+        return true;
+    }
+    LOG_ERROR("MQTT failed to publish topic [", topic.c_str(), "] - message [", message.c_str(), "]");
+    return false;
+}
+
+void MQTTwrapper::callback(char *topic, uint8_t *payload, unsigned int length)
+{
+    std::string pl;
+    pl.resize(length + 1);
+    std::snprintf(pl.data(), length + 1, "%s", payload);
+    auto inst = getInstance();
+    if (inst)
+    {
+        inst->onMessage(std::string(topic), pl);
+        return;
+    }
+    LOG_ERROR("MQTT no client instance set");
+    return;
+}
+
+void MQTTwrapper::onMessage(const std::string topic, const std::string message)
+{
+    ArduinoJson::JsonDocument obj;
+    LOG_DEBUG("MQTT received topic [", topic.c_str(), "] - message [", message.c_str(), "]");
+    if (ArduinoJson::deserializeJson(obj, message) == ArduinoJson::DeserializationError::Ok)
+    {
+        m_actionMap[topic](obj);
+        return;
+    }
+    LOG_ERROR("MQTT failed to deserialize message\n", message.c_str());
+    return;
+}
+
+void MQTTwrapper::clientLoop(void *params)
+{
+    auto wrapper = (MQTTwrapper *)(params);
+    auto &client = wrapper->m_client;
+    auto &config = wrapper->m_config;
+    auto &stateMap = wrapper->stateMap;
+    const auto loopTime = config.m_mqttLoopTime;
+    const auto mqttRetries = config.m_mqttRetries;
+    const auto clientName = config.m_mqttClientName;
+    uint8_t connectAttempt(0);
+    LOG_INFO("MQTT starting client loop");
+    while (connectAttempt++ < mqttRetries)
+    {
+        while (client.connected())
+        {
+            client.loop();
+            delay(loopTime);
+        }
+        if (client.state() != MQTT_CONNECTED)
+        {
+            LOG_ERROR("MQTT disconnect reason ", stateMap.at(client.state()).c_str());
+            delay(loopTime * 50);
+            const bool ok = client.connect(clientName.c_str());
+            LOG_WARN("MQTT reconnected", ok ? "True" : "False");
+            if (ok)
+            {
+                for (auto &v : wrapper->m_actionMap)
+                {
+                    const std::string &topic(v.first);
+                    LOG_WARN("MQTT resubscribing to", topic.c_str());
+                    if (!wrapper->m_client.subscribe(topic.c_str()))
+                    {
+                        LOG_ERROR("Unable to resubscribe to", topic.c_str());
+                    }
+                }
+                connectAttempt = 0;
+            }
+        }
+    }
+    LOG_ERROR("MQTT client loop terminated, disconnected");
+    wrapper->m_loopHandle = NULL;
+    vTaskDelete(NULL); // delete the current task
+}

src/mqtt.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_DEBUG
+
+#include <DebugLog.h>
+#include <Arduino.h>
+#include <ArduinoJson.h>
+#include <Network.h>
+#include <PubSubClient.h>
+
+#include <config.h>
+
+#include <mutex>
+#include <functional>
+
+typedef std::string topic_t;
+typedef std::function<void(const ArduinoJson::JsonDocument &)> action_t; // the actions receive a JsonObject containing the received message
+typedef std::map<topic_t, action_t> action_map_t;
+
+class MQTTwrapper
+{
+
+private:
+    const std::map<int, std::string> stateMap = {
+        {-4, "MQTT_CONNECTION_TIMEOUT"},
+        {-3, "MQTT_CONNECTION_LOST"},
+        {-2, "MQTT_CONNECT_FAILED"},
+        {-1, "MQTT_DISCONNECTED"},
+        {0, "MQTT_CONNECTED"},
+        {1, "MQTT_CONNECT_BAD_PROTOCOL"},
+        {2, "MQTT_CONNECT_BAD_CLIENT_ID"},
+        {3, "MQTT_CONNECT_UNAVAILABLE"},
+        {4, "MQTT_CONNECT_BAD_CREDENTIALS"},
+        {5, "MQTT_CONNECT_UNAUTHORIZED"}
+    };
+
+private:
+    static MQTTwrapper *
+    getInstance(MQTTwrapper *inst = nullptr)
+    {
+        static std::unique_ptr<MQTTwrapper> m_instance;
+        if (inst)
+            m_instance.reset(inst);
+        if (m_instance)
+            return m_instance.get();
+        return nullptr;
+    }
+
+public:
+    MQTTwrapper();
+    ~MQTTwrapper();
+
+    const bool connect();
+    const bool disconnect();
+    const bool connected();
+
+    const bool subscribe(topic_t topic, action_t action);
+    const bool unsubscribe(topic_t topic);
+
+    const bool publish(topic_t topic, const ArduinoJson::JsonDocument obj);
+
+private:
+    static void callback(char *topic, uint8_t *payload, unsigned int length); // C-style callback only to invoke onMessage
+    void onMessage(const std::string topic, const std::string message);
+
+    // infinite loop to call the client loop method in a taskHandle
+    static void clientLoop(void *params);
+
+private:
+    const Config &m_config;
+    action_map_t m_actionMap;
+    NetworkClient m_tcp;
+    PubSubClient m_client;
+    TaskHandle_t m_loopHandle;
+};

src/remoteIO.cpp

@@ -0,0 +1,101 @@
+#include <remoteIO.h>
+
+remoteIO::remoteIO(const uint8_t address, drivers::MODBUS &bus) : m_address(address), m_initialized(false), m_bus(bus)
+{
+    LOG_INFO("Initializing relay module");
+    std::vector<uint16_t> response;
+    auto lock = m_bus.getLock();
+    if (!m_bus.readHoldingRegisters(m_address, REG_VERSION, 1, response))
+    {
+        LOG_ERROR("Unable to inizialize relay module");
+    };
+    LOG_INFO("Software version", std::to_string(response.at(0) / 100.0f).c_str());
+    m_initialized = true;
+    resetAll(false);
+}
+
+remoteIO::~remoteIO()
+{
+    m_initialized = false;
+    resetAll(false);
+}
+
+const bool remoteIO::setOut(const channel_t ch, const bool value)
+{
+    if (!m_initialized)
+        return false;
+    auto lock = m_bus.getLock();
+    LOG_DEBUG("Write Channel", ch, "->", value ? "True" : "False");
+    return m_bus.writeCoil(m_address, REG_COILS + ch, value);
+}
+
+const bool remoteIO::toggleOut(const channel_t ch)
+{
+    if (!m_initialized)
+        return false;
+    auto lock = m_bus.getLock();
+    std::vector<bool> value;
+    if (!m_bus.readCoils(m_address, REG_COILS + ch, 1, value))
+        return false;
+    LOG_DEBUG("Toggle Channel", ch, "->", !value.front() ? "True" : "False");
+    return m_bus.writeCoil(m_address, REG_COILS + ch, !value.front());
+}
+
+const bool remoteIO::setOutPort(const std::vector<bool> values)
+{
+    if (!m_initialized)
+        return false;
+    auto lock = m_bus.getLock();
+    LOG_DEBUG("Write Port", CH_MAX);
+    return m_bus.writeCoils(m_address, CH_MAX, values);
+}
+
+const bool remoteIO::getOut(const channel_t ch, bool &value)
+{
+    if (!m_initialized)
+        return false;
+    auto lock = m_bus.getLock();
+    std::vector<bool> values;
+    if (!m_bus.readCoils(m_address, REG_COILS + ch, 1, values))
+        return false;
+    value = values.front();
+    LOG_DEBUG("Read Channel", ch, "->", value ? "True" : "False");
+    return true;
+}
+
+const bool remoteIO::getOutPort(std::vector<bool> &values)
+{
+    if (!m_initialized)
+        return false;
+    auto lock = m_bus.getLock();
+    LOG_DEBUG("Read Port", CH_MAX);
+    return m_bus.readCoils(m_address, REG_COILS, 8, values);
+}
+
+const bool remoteIO::getIn(const channel_t input, bool &value)
+{
+    if (!m_initialized)
+        return false;
+    auto lock = m_bus.getLock();
+    std::vector<bool> values;
+    if (!m_bus.readInputs(m_address, REG_INPUT + input, 1, values))
+        return false;
+    value = values.front();
+    LOG_DEBUG("Read Input", input, "->", values.front() ? "True" : "False");
+    return true;
+}
+
+const bool remoteIO::getInPort(std::vector<bool> &values)
+{
+    if (!m_initialized)
+        return false;
+    auto lock = m_bus.getLock();
+    LOG_DEBUG("Read Inputs", CH_MAX);
+    return m_bus.readInputs(m_address, REG_INPUT, CH_MAX, values);
+}
+
+void remoteIO::resetAll(const bool value)
+{
+    LOG_DEBUG("Reset All ->", value ? "True" : "False");
+    m_bus.writeCoil(m_address, REG_ALLCOILS, value);
+}

src/remoteIO.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
+
+#include <DebugLog.h>
+#include <RS485_Driver.h>
+
+class remoteIO
+{
+public:
+    typedef enum {CH1, CH2, CH3, CH4, CH5, CH6, CH7, CH8, CH_MAX} channel_t;
+
+private:
+    const uint16_t REG_VERSION = 0x8000;
+    const uint16_t REG_COILS = 0x0000;
+    const uint16_t REG_INPUT = 0x0000;
+    const uint16_t REG_ALLCOILS = 0x00FF;
+
+public:
+    remoteIO(const uint8_t address, drivers::MODBUS &bus);
+    ~remoteIO();
+
+    const bool setOut(const channel_t ch, const bool value);
+    const bool toggleOut(const channel_t ch);
+    const bool setOutPort(const std::vector<bool> values);
+
+    const bool getOut(const channel_t ch, bool &value);
+    const bool getOutPort(std::vector<bool> &values);
+
+    const bool getIn(const channel_t input, bool &value);
+    const bool getInPort(std::vector<bool> &values);
+
+    void resetAll(const bool value);
+
+private:
+    bool m_initialized;
+    drivers::MODBUS &m_bus;
+    const uint8_t m_address;
+};