some big change using state machine

src/appcontext.hpp

@@ -19,6 +19,6 @@ struct AppContext {
     Network *network = nullptr;
     Light *light = nullptr;
     Mqtt *mqtt = nullptr;
-    OTAHandler *ota = nullptr;
+    OTAHandler *otaHandler = nullptr;
     Scheduler *scheduler = nullptr;
 };

src/main.cpp

@@ -11,15 +11,16 @@
 #include "TaskScheduler.h"
 #include "wifimanager.h"
 
-Network* network = nullptr;
-OTAHandler* otaHandler = nullptr;
-Mqtt* mqttClient = nullptr;
-Light *light = nullptr;
+// Network* network = nullptr;
+// OTAHandler* otaHandler = nullptr;
+// Mqtt* mqttClient = nullptr;
+// Light *light = nullptr;
 
 
-Task *updateTask = nullptr;
-Task *mqttTickTask = nullptr;
-Task *mqttCheckConnectionTask = nullptr;
+// Task *updateTask = nullptr;
+// Task *mqttTickTask = nullptr;
+// Task *mqttCheckConnectionTask = nullptr;
+Task *appStateMachineUpdateTask = nullptr;
 
 Pin *pinR = new Pin(ledPinR, true, true, 5000, 0);
 Pin *pinG = new Pin(ledPinG, true, true, 5000, 1);
@@ -29,6 +30,9 @@ 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;
 
@@ -38,8 +42,9 @@ void initializeScheduler();
 
 void setup() {
     // put your setup code here, to run once:
-    // Serial.begin(115200);
-    // Serial.println("Starting Smart RGB ESP32...");
+    Serial.begin(115200);
+    Serial.println("Starting Smart RGB ESP32...");
+    initializeScheduler();
     stateMachine = new StateMachine<maxNumberOfStates>();
     appContext->pinR = pinR;
     appContext->pinG = pinG;
@@ -47,14 +52,15 @@ void setup() {
     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->setInitialState(StateId::StartState);
-    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, mqttClient, "smart_rgb_light");
-    initializeScheduler();
+
+    // 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, mqttClient, "smart_rgb_light");
 }
 
 void loop() {
@@ -64,14 +70,15 @@ void loop() {
 
 void initializeScheduler() {
     scheduler = new Scheduler();
-    updateTask = new Task(TASK_SECOND, TASK_FOREVER, []() {
-        otaHandler->poll(); // Poll for OTA updates
-
-    }, scheduler, true, nullptr, nullptr);
-    mqttTickTask = new Task(TASK_MILLISECOND * 100, TASK_FOREVER, []() {
-        Mqtt::poll(); // Poll MQTT client for messages
-    }, scheduler, true, nullptr, nullptr);
-    mqttCheckConnectionTask = new Task(TASK_SECOND * 30, TASK_FOREVER, []() {
-        Mqtt::checkConnection(); // Check MQTT connection status
+    appStateMachineUpdateTask = new Task(TASK_MILLISECOND, TASK_FOREVER, []() {
+        if (stateMachine) {
+            stateMachine->update();
+        }
     }, scheduler, true, nullptr, nullptr);
+    // mqttTickTask = new Task(TASK_MILLISECOND * 100, TASK_FOREVER, []() {
+    //     Mqtt::poll(); // Poll MQTT client for messages
+    // }, scheduler, true, nullptr, nullptr);
+    // mqttCheckConnectionTask = new Task(TASK_SECOND * 30, TASK_FOREVER, []() {
+    //     Mqtt::checkConnection(); // Check MQTT connection status
+    // }, scheduler, true, nullptr, nullptr);
 }

src/states.hpp

@@ -1,11 +1,21 @@
+#include <Arduino.h>
 #include "appcontext.hpp"
+#include "config.h"
+#include "mqtt.h"
 #include "pin.h"
 #include "statemachine.hpp"
 
 enum class StateId
 {
     StartState,
-    NetworkInitializeState
+    NetworkInitializeState,
+    RunningState
+};
+
+enum class EventId
+{
+    PinInitialized,
+    WifiConnected
 };
 
 class StartState : public State
@@ -21,6 +31,7 @@ public:
             appContext->pinCW->setLedLevel(0);
             appContext->pinWW->setLedLevel(0);
         }
+        stateMachine.postEvent(EventId::PinInitialized);
     }
 
     void onExit(StateMachineBase &stateMachine) override {
@@ -36,14 +47,68 @@ private:
 class NetworkInitializeState : public State
 {
 public:
-    NetworkInitializeState() : State("NetworkInitializeState", StateId::NetworkInitializeState) {}
+    NetworkInitializeState(AppContext *appContext) : State("NetworkInitializeState", StateId::NetworkInitializeState), appContext(appContext) {}
 
     void onEnter(StateMachineBase &stateMachine) override {
+        if (appContext) {
+            appContext->network = new Network(hostName, friendlyName);
+        }
+    }
+
+    void onExit(StateMachineBase &stateMachine) override {
+        if (appContext && appContext->network) {
+            appContext->network->registerMDNS();
+            appContext->otaHandler = new OTAHandler(hostName);
+        }
+        Mqtt::connect(mqttBroker.data(), 1883, "smart_rgb_dev", "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;
     }
 
     void onExit(StateMachineBase &stateMachine) override {
     }
 
     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();
+        }
     }
+
+private:
+    AppContext *appContext = nullptr;
+    uint32_t lastOtaPollMs = 0;
+    static constexpr uint32_t otaPollInterval = 1000; // Poll every second
+    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
 };