Merge remote-tracking branch 'origin/main' into feature/add_state_machine_usage

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/state-machine"]
+	path = lib/state-machine
+	url = https://github.com/t-liu93/state-machine

include/config.h

@@ -0,0 +1,15 @@
+#pragma once
+#include <cstdint>
+#include <string>
+
+inline constexpr uint8_t ledPinR = 16;
+inline constexpr uint8_t ledPinG = 17;
+inline constexpr uint8_t ledPinB = 18;
+inline constexpr uint8_t ledPinCW = 19;
+inline constexpr uint8_t ledPinWW = 21;
+
+inline constexpr std::string_view hostName = "smart-rgb-dev";
+inline constexpr std::string_view friendlyName = "Smart RGB Dev";
+inline constexpr uint32_t maxNumberOfStates = 10;
+
+inline constexpr std::string_view mqttBroker = "10.238.75.81";

lib/network/network.cpp

@@ -5,18 +5,31 @@
 WIFIMANAGER Network::WifiManager;
 AsyncWebServer Network::webServer(80);
 
-Network::Network(std::string hostname, std::string apSsid) : hostname(hostname), apSsid(apSsid) {
+Network::Network(std::string_view hostname, std::string_view apSsid) {
+    this->hostname = std::string(hostname);
+    this->apSsid = std::string(apSsid);
     setHostname(hostname);
-    WifiManager.startBackgroundTask(apSsid.c_str(), "");
+    WifiManager.startBackgroundTask(apSsid.data(), "");
     WifiManager.fallbackToSoftAp(true);
     WifiManager.attachWebServer(&webServer);
     WifiManager.attachUI();
     webServer.on("/", HTTP_GET, [this](AsyncWebServerRequest *request) {
-        request->send(200, "text/html", this->defaultHomepage.c_str());
+        request->send(200, "text/html", this->defaultHomepage.data());
     });
     webServer.begin();
 }
 
+Network::~Network() {
+    webServer.end();
+    WifiManager.detachUI();
+    WifiManager.detachWebServer();
+}
+
+void Network::reconnect() {
+    WifiManager.stopWifi(true);
+    WifiManager.startBackgroundTask(apSsid.data(), "");
+}
+
 bool Network::isConnected() const {
     return WiFi.status() == WL_CONNECTED;
 }
@@ -25,14 +38,15 @@ std::string Network::getHostname() const {
     return WiFi.getHostname();
 }
 
-bool Network::setHostname(const std::string &hostname) {
+bool Network::setHostname(const std::string_view &hostname) {
-    return WiFi.setHostname(hostname.c_str());
+    this->hostname = std::string(hostname);
+    return WiFi.setHostname(this->hostname.c_str());
 }
 
 void Network::registerMDNS() {
-    if (!MDNS.begin(hostname.c_str())) {
+    if (!MDNS.begin(this->hostname.c_str())) {
         Serial.println("Error setting up MDNS responder!");
     } else {
-        Serial.printf("mDNS responder started with hostname: %s\n", hostname.c_str());
+        Serial.printf("mDNS responder started with hostname: %s\n", this->hostname.c_str());
     }
 }

lib/network/network.h

@@ -1,12 +1,15 @@
 #include <Arduino.h>
+#include <string_view>
 #include "wifimanager.h"
 
 class Network {
 public:
-    Network(std::string hostname, std::string apSsid = "Smart RGB");
+    Network(std::string_view hostname, std::string_view apSsid = "Smart RGB");
+    ~Network();
+    void reconnect();
     bool isConnected() const;
     std::string getHostname() const;
-    bool setHostname(const std::string &hostname);
+    bool setHostname(const std::string_view &hostname);
     void registerMDNS();
 private:
     static WIFIMANAGER WifiManager;

lib/ota/ota.cpp

@@ -1,8 +1,8 @@
 #include <ArduinoOTA.h>
 #include "ota.h"
 
-OTAHandler::OTAHandler(std::string hostname) {
+OTAHandler::OTAHandler(std::string_view hostname) {
-    ArduinoOTA.setHostname(hostname.c_str());
+    ArduinoOTA.setHostname(hostname.data());
     ArduinoOTA.onStart([]() {
         Serial.println("OTA Start");
     });

lib/ota/ota.h

@@ -1,9 +1,9 @@
 #pragma once
-#include <string>
+#include <string_view>
 
 class OTAHandler {
 public:
-    OTAHandler(std::string hostname);
+    OTAHandler(std::string_view hostname);
 
     void poll();
 };

platformio.ini

@@ -13,6 +13,10 @@ platform = espressif32
 board = esp32dev
 framework = arduino
 monitor_speed = 115200
+build_unflags = -std=gnu++11
+build_flags =
+	-std=c++17
+	-std=gnu++17
 lib_deps =
 	martinverges/ESP32 Wifi Manager@^1.5.0
 	esp32async/ESPAsyncWebServer@^3.7.10
@@ -24,4 +28,4 @@ lib_deps =
 
 [env:esp32dev-ota]
 upload_protocol = espota
-upload_port = smart-rgb.local
+upload_port = smart-rgb-dev.local

src/appcontext.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+class Pin;
+template <uint32_t MAX_NUMBER_OF_STATES, uint32_t MAX_NUMBER_OF_TRANSITIONS>
+class StateMachine;
+class OTAHandler;
+class Mqtt;
+class Light;
+class Network;
+class Scheduler;
+
+struct AppContext {
+    Pin *pinR = nullptr;
+    Pin *pinG = nullptr;
+    Pin *pinB = nullptr;
+    Pin *pinCW = nullptr;
+    Pin *pinWW = nullptr;
+
+    Network *network = nullptr;
+    Light *light = nullptr;
+    Mqtt *mqtt = nullptr;
+    OTAHandler *otaHandler = nullptr;
+    Scheduler *scheduler = nullptr;
+};

src/main.cpp

@@ -1,28 +1,42 @@
 #include <Arduino.h>
+#include "appcontext.hpp"
+#include "config.h"
 #include "light.h"
 #include "mqtt.h"
 #include "network.h"
 #include "ota.h"
 #include "pin.h"
+#include "statemachine.hpp"
+#include "states.hpp"
 #include "TaskScheduler.h"
 #include "wifimanager.h"
 
-Network* network = nullptr;
+// Network* network = nullptr;
-OTAHandler* otaHandler = nullptr;
+// OTAHandler* otaHandler = nullptr;
-Mqtt* mqttClient = nullptr;
+// Mqtt* mqttClient = nullptr;
-Light *light = nullptr;
+// Light *light = nullptr;
 
-Task *updateTask = nullptr;
-Task *mqttTickTask = nullptr;
-Task *mqttCheckConnectionTask = nullptr;
 
-Pin *pinR = new Pin(16, true, true, 5000, 0); // Example pin numbers, adjust as needed
+// Task *updateTask = nullptr;
-Pin *pinG = new Pin(17, true, true, 5000, 1);
+// Task *mqttTickTask = nullptr;
-Pin *pinB = new Pin(18, true, true, 5000, 2);
+// Task *mqttCheckConnectionTask = nullptr;
-Pin *pinCW = new Pin(19, true, true, 5000, 3);
+Task *appStateMachineUpdateTask = nullptr;
-Pin *pinWW = new Pin(21, true, true, 5000, 4);
 
-Scheduler *scheduler;
+Pin *pinR = new Pin(ledPinR, true, true, 5000, 0);
+Pin *pinG = new Pin(ledPinG, true, true, 5000, 1);
+Pin *pinB = new Pin(ledPinB, true, true, 5000, 2);
+Pin *pinCW = new Pin(ledPinCW, true, true, 5000, 3);
+Pin *pinWW = new Pin(ledPinWW, true, true, 5000, 4);
+
+AppContext *appContext = new AppContext();
+StartState *startState = new StartState(appContext);
+NetworkInitializeState *networkInitializeState = new NetworkInitializeState(appContext);
+RunningState *runningState = new RunningState(appContext);
+
+
+StateMachine<maxNumberOfStates> *stateMachine = nullptr;
+
+Scheduler *scheduler = nullptr;
 
 void initializeScheduler();
 
@@ -30,18 +44,21 @@ void setup() {
     // put your setup code here, to run once:
     Serial.begin(115200);
     Serial.println("Starting Smart RGB ESP32...");
-    pinR->setLedLevel(0);
+    stateMachine = new StateMachine<maxNumberOfStates>();
-    pinG->setLedLevel(0);
-    pinB->setLedLevel(0);
-    pinCW->setLedLevel(0);
-    pinWW->setLedLevel(0);
-    network = new Network("smart-rgb");
-    otaHandler = new OTAHandler("smart-rgb-ota");
-    network->registerMDNS();
-    Mqtt::connect("10.238.75.81", 1883, "smart_rgb_client", "mqtt", "mqtt");
-    delay(1000); // Wait for MQTT connection to stabilize
-    light = new Light(pinR, pinG, pinB, pinCW, pinWW, "smart_rgb_light");
     initializeScheduler();
+    appContext->pinR = pinR;
+    appContext->pinG = pinG;
+    appContext->pinB = pinB;
+    appContext->pinCW = pinCW;
+    appContext->pinWW = pinWW;
+    stateMachine->addStateRaw(startState);
+    stateMachine->addStateRaw(networkInitializeState);
+    stateMachine->addTransition(StateId::StartState, EventId::PinInitialized, StateId::NetworkInitializeState);
+    stateMachine->addStateRaw(runningState);
+    stateMachine->addTransition(StateId::NetworkInitializeState, EventId::WifiConnected, StateId::RunningState);
+    stateMachine->addTransition(StateId::RunningState, EventId::WifiDisconnected, StateId::NetworkInitializeState);
+    stateMachine->setInitialState(StateId::StartState);
+    // light = new Light(pinR, pinG, pinB, pinCW, pinWW, mqttClient, "smart_rgb_light");
 }
 
 void loop() {
@@ -51,14 +68,15 @@ void loop() {
 
 void initializeScheduler() {
     scheduler = new Scheduler();
-    updateTask = new Task(TASK_SECOND, TASK_FOREVER, []() {
+    appStateMachineUpdateTask = new Task(TASK_MILLISECOND, TASK_FOREVER, []() {
-        otaHandler->poll(); // Poll for OTA updates
+        if (stateMachine) {
-
+            stateMachine->update();
-    }, scheduler, true, nullptr, nullptr);
+        }
-    mqttTickTask = new Task(TASK_MILLISECOND * 100, TASK_FOREVER, []() {
+    }, scheduler, true, nullptr, nullptr);
-        Mqtt::poll(); // Poll MQTT client for messages
+    // mqttTickTask = new Task(TASK_MILLISECOND * 100, TASK_FOREVER, []() {
-    }, scheduler, true, nullptr, nullptr);
+    //     Mqtt::poll(); // Poll MQTT client for messages
-    mqttCheckConnectionTask = new Task(TASK_SECOND * 30, TASK_FOREVER, []() {
+    // }, scheduler, true, nullptr, nullptr);
-        Mqtt::checkConnection(); // Check MQTT connection status
+    // mqttCheckConnectionTask = new Task(TASK_SECOND * 30, TASK_FOREVER, []() {
-    }, scheduler, true, nullptr, nullptr);
+    //     Mqtt::checkConnection(); // Check MQTT connection status
+    // }, scheduler, true, nullptr, nullptr);
 }

src/states.hpp

@@ -0,0 +1,130 @@
+#include <Arduino.h>
+#include "appcontext.hpp"
+#include "config.h"
+#include "mqtt.h"
+#include "pin.h"
+#include "statemachine.hpp"
+
+enum class StateId
+{
+    StartState,
+    NetworkInitializeState,
+    RunningState
+};
+
+enum class EventId
+{
+    PinInitialized,
+    WifiConnected,
+    WifiDisconnected
+};
+
+class StartState : public State
+{
+public:
+    StartState(AppContext *appContext) : State("StartState", StateId::StartState), appContext(appContext) {}
+
+    void onEnter(StateMachineBase &stateMachine) override {
+        if (appContext) {
+            appContext->pinR->setLedLevel(0);
+            appContext->pinG->setLedLevel(0);
+            appContext->pinB->setLedLevel(0);
+            appContext->pinCW->setLedLevel(0);
+            appContext->pinWW->setLedLevel(0);
+        }
+        stateMachine.postEvent(EventId::PinInitialized);
+    }
+
+    void onExit(StateMachineBase &stateMachine) override {
+    }
+
+    void onUpdate(StateMachineBase &stateMachine) override {
+    }
+
+private:
+    AppContext *appContext = nullptr;
+};
+
+class NetworkInitializeState : public State
+{
+public:
+    NetworkInitializeState(AppContext *appContext) : State("NetworkInitializeState", StateId::NetworkInitializeState), appContext(appContext) {}
+
+    void onEnter(StateMachineBase &stateMachine) override {
+        Serial.println("Entering NetworkInitializeState");
+        if (appContext && !appContext->network) {
+            appContext->network = new Network(hostName, friendlyName);
+        } else if (appContext && appContext->network) {
+            appContext->network->reconnect();
+        }
+    }
+
+    void onExit(StateMachineBase &stateMachine) override {
+        if (appContext && appContext->network) {
+            appContext->network->registerMDNS();
+            if (!appContext->otaHandler) {
+                appContext->otaHandler = new OTAHandler(hostName);
+            }
+        }
+        Mqtt::connect(mqttBroker.data(), 1883, hostName.data(), "mqtt", "mqtt");
+    }
+
+    void onUpdate(StateMachineBase &stateMachine) override {
+        if (appContext && appContext->network && appContext->network->isConnected()) {
+            stateMachine.postEvent(EventId::WifiConnected);
+        }
+    }
+
+private:
+    AppContext *appContext = nullptr;
+};
+
+class RunningState : public State
+{
+public:
+    RunningState(AppContext *appContext) : State("RunningState", StateId::RunningState), appContext(appContext) {}
+    void onEnter(StateMachineBase &stateMachine) override {
+        lastOtaPollMs = millis();
+        lastMqttPollMs = millis();
+        lastMqttCheckConnectionPollSecond = millis() / 1000;
+        lastNetworkCheckPollMs = millis();
+    }
+
+    void onExit(StateMachineBase &stateMachine) override {
+        Serial.println("Exiting RunningState");
+    }
+
+    void onUpdate(StateMachineBase &stateMachine) override {
+        if ((millis() - lastOtaPollMs) >= otaPollInterval) {
+            lastOtaPollMs = millis();
+            if (appContext && appContext->otaHandler) {
+                appContext->otaHandler->poll();
+            }
+        }
+        if ((millis() - lastMqttPollMs) >= mqttPollInterval) {
+            lastMqttPollMs = millis();
+            Mqtt::poll();
+        }
+        if ((millis() - lastMqttCheckConnectionPollSecond) >= mqttCheckConnectionPollIntervalSecond * 1000) {
+            lastMqttCheckConnectionPollSecond = millis() / 1000;
+            Mqtt::checkConnection();
+        }
+        if ((millis() - lastNetworkCheckPollMs) >= networkCheckPollInterval) {
+            lastNetworkCheckPollMs = millis();
+            if (appContext && appContext->network && !appContext->network->isConnected()) {
+                stateMachine.postEvent(EventId::WifiDisconnected);
+            }
+        }
+    }
+
+private:
+    AppContext *appContext = nullptr;
+    uint32_t lastOtaPollMs = 0;
+    static constexpr uint32_t otaPollInterval = 1000; // Poll every second
+    uint32_t lastNetworkCheckPollMs = 0;
+    static constexpr uint32_t networkCheckPollInterval = 5000; // Poll every 5 seconds
+    uint32_t lastMqttPollMs = 0;
+    static constexpr uint32_t mqttPollInterval = 100; // Poll every 100 milliseconds
+    uint32_t lastMqttCheckConnectionPollSecond = 0;
+    static constexpr uint32_t mqttCheckConnectionPollIntervalSecond = 30; // Poll every 30 seconds
+};