Rewrite state manager, clean up states, fixup typos - todo test state display

components/CameraManager/CameraManager/CameraManager.cpp

@@ -2,8 +2,8 @@
 
 const char *CAMERA_MANAGER_TAG = "[CAMERA_MANAGER]";
 
-CameraManager::CameraManager(std::shared_ptr<ProjectConfig> projectConfig)
+CameraManager::CameraManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue)
-    : projectConfig(projectConfig) {}
+    : projectConfig(projectConfig), eventQueue(eventQueue) {}
 
 void CameraManager::setupCameraPinout()
 {
@@ -184,7 +184,8 @@ bool CameraManager::setupCamera()
     ESP_LOGI(CAMERA_MANAGER_TAG, "Camera initialized: %s \r\n",
              esp_err_to_name(hasCameraBeenInitialized));
 
-    cameraStateManager.setState(CameraState_e::Camera_Success);
+    SystemEvent event = {EventSource::CAMERA, CameraState_e::Camera_Success};
+    xQueueSend(this->eventQueue, &event, 10);
   }
   else
   {
@@ -194,8 +195,8 @@ bool CameraManager::setupCamera()
                                  "Please "
                                  "fix the "
                                  "camera and reboot the device.\r\n");
-    ledStateManager.setState(LEDStates_e::_Camera_Error);
+    SystemEvent event = {EventSource::CAMERA, CameraState_e::Camera_Error};
-    cameraStateManager.setState(CameraState_e::Camera_Error);
+    xQueueSend(this->eventQueue, &event, 10);
     return false;
   }
 

components/CameraManager/CameraManager/CameraManager.hpp

@@ -8,6 +8,9 @@
 #include "esp_psram.h"
 #include "sdkconfig.h"
 
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+
 #include <StateManager.hpp>
 #include <ProjectConfig.hpp>
 
@@ -22,10 +25,11 @@ class CameraManager
 private:
   sensor_t *camera_sensor;
   std::shared_ptr<ProjectConfig> projectConfig;
+  QueueHandle_t eventQueue;
   camera_config_t config;
 
 public:
-  CameraManager(std::shared_ptr<ProjectConfig> projectConfigl);
+  CameraManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue);
   int setCameraResolution(framesize_t frameSize);
   bool setupCamera(); // todo, once we have observers, make it private
 

components/LEDManager/LEDManager/LEDManager.cpp

@@ -170,7 +170,7 @@ void LEDManager::toggleLED(bool state) const
 
 void HandleLEDDisplayTask(void *pvParameter)
 {
-  LEDManager *ledManager = (LEDManager *)pvParameter;
+  LEDManager *ledManager = static_cast<LEDManager *>(pvParameter);
 
   while (1)
   {

components/MDNSManager/MDNSManager/MDNSManager.cpp

@@ -2,17 +2,22 @@
 
 static const char *MDNS_MANAGER_TAG = "[MDNS MANAGER]";
 
-MDNSManager::MDNSManager(std::shared_ptr<ProjectConfig> projectConfig) : projectConfig(projectConfig) {}
+MDNSManager::MDNSManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue) : projectConfig(projectConfig), eventQueue(eventQueue) {}
 
 esp_err_t MDNSManager::start()
 {
   const std::string &mdnsName = "_openiristracker";
 
-  mdnsStateManager.setState(MDNSState_e::MDNSState_Starting);
+  {
+    SystemEvent event = {EventSource::MDNS, MDNSState_e::MDNSState_Starting};
+    xQueueSend(this->eventQueue, &event, 10);
+  }
+
   esp_err_t result = mdns_init();
   if (result != ESP_OK)
   {
-    mdnsStateManager.setState(MDNSState_e::MDNSState_Error);
+    SystemEvent event = {EventSource::MDNS, MDNSState_e::MDNSState_Error};
+    xQueueSend(this->eventQueue, &event, 10);
     ESP_LOGE(MDNS_MANAGER_TAG, "Failed to initialize mDNS server: %s", esp_err_to_name(result));
     return result;
   }
@@ -21,7 +26,8 @@ esp_err_t MDNSManager::start()
   result = mdns_hostname_set(mdnsConfig.hostname.c_str());
   if (result != ESP_OK)
   {
-    mdnsStateManager.setState(MDNSState_e::MDNSState_Error);
+    SystemEvent event = {EventSource::MDNS, MDNSState_e::MDNSState_Error};
+    xQueueSend(this->eventQueue, &event, 10);
     ESP_LOGE(MDNS_MANAGER_TAG, "Failed to set hostname: %s", esp_err_to_name(result));
     return result;
   }
@@ -36,12 +42,15 @@ esp_err_t MDNSManager::start()
   result = mdns_service_instance_name_set(mdnsName.c_str(), "_tcp", mdnsName.c_str());
   if (result != ESP_OK)
   {
-    mdnsStateManager.setState(MDNSState_e::MDNSState_Error);
+    SystemEvent event = {EventSource::MDNS, MDNSState_e::MDNSState_Error};
+    xQueueSend(this->eventQueue, &event, 10);
+
     ESP_LOGE(MDNS_MANAGER_TAG, "Failed to set mDNS instance name: %s", esp_err_to_name(result));
     return result;
   }
 
-  mdnsStateManager.setState(MDNSState_e::MDNSState_Started);
+  SystemEvent event = {EventSource::MDNS, MDNSState_e::MDNSState_Started};
+  xQueueSend(this->eventQueue, &event, 10);
 
   return result;
 }

components/MDNSManager/MDNSManager/MDNSManager.hpp

@@ -5,15 +5,18 @@
 #include <ProjectConfig.hpp>
 #include <StateManager.hpp>
 #include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
 #include "mdns.h"
 
 class MDNSManager
 {
 private:
   std::shared_ptr<ProjectConfig> projectConfig;
+  QueueHandle_t eventQueue;
 
 public:
-  MDNSManager(std::shared_ptr<ProjectConfig> projectConfig);
+  MDNSManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue);
   esp_err_t start();
 };
 

components/StateManager/StateManager/StateManager.cpp

@@ -1,8 +1,98 @@
 #include "StateManager.hpp"
 
-StateManager<WiFiState_e> wifiStateManager;
+StateManager::StateManager(QueueHandle_t eventQueue, QueueHandle_t ledStateQueue) : eventQueue(eventQueue), ledStateQueue(ledStateQueue) {}
-StateManager<MDNSState_e> mdnsStateManager;
+
-StateManager<CameraState_e> cameraStateManager;
+void StateManager::HandleUpdateState()
-StateManager<LEDStates_e> ledStateManager;
+{
-StateManager<StreamState_e> streamStateManager;
+  SystemEvent eventBuffer;
-StateManager<ConfigState_e> configStateManager;
+  auto ledStreamState = LEDStates_e::_LedStateNone;
+
+  if (xQueueReceive(this->eventQueue, &eventBuffer, portMAX_DELAY))
+  {
+    switch (eventBuffer.source)
+    {
+
+    case EventSource::WIFI:
+    {
+      this->wifi_state = std::get<WiFiState_e>(eventBuffer.value);
+
+      if (this->wifi_state == WiFiState_e::WiFiState_Connecting)
+      {
+        ledStreamState = LEDStates_e::_WiFiState_Connecting;
+        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+      }
+      if (this->wifi_state == WiFiState_e::WiFiState_Connected)
+      {
+        ledStreamState = LEDStates_e::_WiFiState_Connected;
+        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+      }
+      if (this->wifi_state == WiFiState_e::WiFiState_Error)
+      {
+        ledStreamState = LEDStates_e::_WiFiState_Error;
+        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+      }
+
+      break;
+    }
+
+    case EventSource::MDNS:
+    {
+      this->mdns_state = std::get<MDNSState_e>(eventBuffer.value);
+      break;
+    }
+
+    case EventSource::CAMERA:
+    {
+      this->camera_state = std::get<CameraState_e>(eventBuffer.value);
+
+      if (this->camera_state == CameraState_e::Camera_Error)
+      {
+        ledStreamState = LEDStates_e::_Camera_Error;
+        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+      }
+
+      break;
+    }
+
+    case EventSource::STREAM:
+    {
+      this->stream_state = std::get<StreamState_e>(eventBuffer.value);
+
+      if (this->stream_state == StreamState_e::Stream_ON)
+      {
+        ledStreamState = LEDStates_e::_LedStateStreaming;
+        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+      }
+      if (this->stream_state == StreamState_e::Stream_ON)
+      {
+        ledStreamState = LEDStates_e::_LedStateStreaming;
+        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+      }
+      break;
+    }
+
+    default:
+      break;
+    }
+  }
+}
+
+WiFiState_e StateManager::GetWifiState()
+{
+  return this->wifi_state;
+}
+
+CameraState_e StateManager::GetCameraState()
+{
+  return this->camera_state;
+}
+
+void HandleStateManagerTask(void *pvParameters)
+{
+  StateManager *stateManager = static_cast<StateManager *>(pvParameters);
+
+  while (1)
+  {
+    stateManager->HandleUpdateState();
+  }
+}

components/StateManager/StateManager/StateManager.hpp

@@ -1,112 +1,90 @@
 #pragma once
 #ifndef STATEMANAGER_HPP
 #define STATEMANAGER_HPP
-/*
+#include <variant>
- * StateManager
+
- * All Project States are managed here
+#include "freertos/FreeRTOS.h"
- */
+#include "freertos/queue.h"
-struct DeviceStates
+
+enum LEDStates_e
 {
-  enum LEDStates_e
+  _LedStateNone,
-  {
+  _LedStateStreaming,
-    _LedStateNone,
+  _LedStateStoppedStreaming,
-    _LedStateStreaming,
+  _Camera_Error,
-    _LedStateStoppedStreaming,
+  _WiFiState_Error,
-    _WiFiState_Error,
+  _WiFiState_Connecting,
-    _Camera_Error,
+  _WiFiState_Connected
-    _WiFiState_Connecting,
+};
-    _WiFiState_Connected
+
-  };
+enum WiFiState_e
-
+{
-  enum ConfigState_e
+  WiFiState_NotInitialized,
-  {
+  WiFiState_Initialized,
-    configLoaded,
+  WiFiState_ReadyToConect,
-    deviceConfigUpdated,
+  WiFiState_Connecting,
-    mdnsConfigUpdated,
+  WiFiState_WaitingForIp,
-    networksConfigUpdated,
+  WiFiState_Connected,
-    apConfigUpdated,
+  WiFiState_Disconnected,
-    wifiTxPowerUpdated,
+  WiFiState_Error
-    cameraConfigUpdated
+};
-  };
+
-
+enum MDNSState_e
-  enum WiFiState_e
+{
-  {
+  MDNSState_Stopped,
-    WiFiState_NotInitialized,
+  MDNSState_Starting,
-    WiFiState_Initialized,
+  MDNSState_Started,
-    WiFiState_ReadyToConect,
+  MDNSState_Stopping,
-    WiFiState_Connecting,
+  MDNSState_Error,
-    WiFiState_WaitingForIp,
+  MDNSState_QueryStarted,
-    WiFiState_Connected,
+  MDNSState_QueryComplete
-    WiFiState_Disconnected,
+};
-    WiFiState_ADHOC,
+
-    WiFiState_Error
+enum CameraState_e
-  };
+{
-
+  Camera_Disconnected,
-  enum MDNSState_e
+  Camera_Success,
-  {
+  Camera_Error
-    MDNSState_Stopped,
+};
-    MDNSState_Starting,
+
-    MDNSState_Started,
+enum StreamState_e
-    MDNSState_Stopping,
+{
-    MDNSState_Error,
+  Stream_OFF,
-    MDNSState_QueryStarted,
+  Stream_ON,
-    MDNSState_QueryComplete
+};
-  };
+
-
+enum class EventSource
-  enum CameraState_e
+{
-  {
+  WIFI,
-    Camera_Disconnected,
+  MDNS,
-    Camera_Success,
+  CAMERA,
-    Camera_Error
+  STREAM
-  };
+};
-
+
-  enum StreamState_e
+struct SystemEvent
-  {
+{
-    Stream_OFF,
+  EventSource source;
-    Stream_ON,
+  std::variant<WiFiState_e, MDNSState_e, CameraState_e, StreamState_e> value;
-    Stream_Error
-  };
 };
 
-/*
- * EventManager
- * All Project Events are managed here
- */
-template <class T>
 class StateManager
 {
 public:
-  StateManager() { this->_current_state = static_cast<T>(0); }
+  StateManager(QueueHandle_t eventQueue, QueueHandle_t ledStateQueue);
-
+  void HandleUpdateState();
-  virtual ~StateManager() {}
+  WiFiState_e GetWifiState();
-
+  CameraState_e GetCameraState();
-  /*
-   * @brief Sets the  state of the stateManager
-   * @param T state - the state to be set
-   */
-  void setState(T state) { _current_state = state; }
-
-  /*
-   * @brief Returns the current state of the stateManager
-   */
-  T getCurrentState() { return _current_state; }
 
 private:
-  T _current_state;
+  QueueHandle_t eventQueue;
+  QueueHandle_t ledStateQueue;
+
+  WiFiState_e wifi_state;
+  MDNSState_e mdns_state;
+  CameraState_e camera_state;
+  StreamState_e stream_state;
 };
 
-typedef DeviceStates::WiFiState_e WiFiState_e;
+void HandleStateManagerTask(void *pvParameters);
-typedef DeviceStates::MDNSState_e MDNSState_e;
-typedef DeviceStates::CameraState_e CameraState_e;
-typedef DeviceStates::LEDStates_e LEDStates_e;
-typedef DeviceStates::StreamState_e StreamState_e;
-typedef DeviceStates::ConfigState_e ConfigState_e;
-
-extern StateManager<WiFiState_e> wifiStateManager;
-extern StateManager<MDNSState_e> mdnsStateManager;
-extern StateManager<CameraState_e> cameraStateManager;
-extern StateManager<LEDStates_e> ledStateManager;
-extern StateManager<StreamState_e> streamStateManager;
-extern StateManager<ConfigState_e> configStateManager;
 
 #endif // STATEMANAGER_HPP

components/StreamServer/StreamServer/StreamServer.cpp

@@ -6,7 +6,7 @@ constexpr static const char *STREAM_PART = "Content-Type: image/jpeg\r\nContent-
 
 static const char *STREAM_SERVER_TAG = "[STREAM_SERVER]";
 
-StreamServer::StreamServer(const int STREAM_PORT) : STREAM_SERVER_PORT(STREAM_PORT)
+StreamServer::StreamServer(const int STREAM_PORT, StateManager *stateManager) : STREAM_SERVER_PORT(STREAM_PORT), stateManager(stateManager)
 {
 }
 
@@ -87,7 +87,6 @@ esp_err_t StreamHelpers::ws_logs_handle(httpd_req_t *req)
 
 esp_err_t StreamServer::startStreamServer()
 {
-
   httpd_config_t config = HTTPD_DEFAULT_CONFIG();
   config.stack_size = 20480;
   config.max_uri_handlers = 1;
@@ -117,8 +116,9 @@ esp_err_t StreamServer::startStreamServer()
     return status;
   }
 
-  httpd_register_uri_handler(camera_stream, &logs_ws);
+  // this is bugged, figure this out. When logs_ws is enabled, we get no stream
-  if (cameraStateManager.getCurrentState() != CameraState_e::Camera_Success)
+  // httpd_register_uri_handler(camera_stream, &logs_ws);
+  if (this->stateManager->GetCameraState() != CameraState_e::Camera_Success)
   {
     ESP_LOGE(STREAM_SERVER_TAG, "Camera not initialized. Cannot start stream server. Logs server will be running.");
     return ESP_FAIL;

components/StreamServer/StreamServer/StreamServer.hpp

@@ -24,10 +24,11 @@ class StreamServer
 {
 private:
   int STREAM_SERVER_PORT;
+  StateManager *stateManager;
   httpd_handle_t camera_stream = nullptr;
 
 public:
-  StreamServer(const int STREAM_PORT);
+  StreamServer(const int STREAM_PORT, StateManager *StateManager);
   esp_err_t startStreamServer();
 
   esp_err_t stream(httpd_req_t *req);

components/UVCStream/UVCStream/UVCStream.cpp

@@ -31,6 +31,9 @@ static esp_err_t UVCStreamHelpers::camera_start_cb(uvc_format_t format, int widt
   cameraHandler->setCameraResolution(frame_size);
   cameraHandler->resetCamera(0);
 
+  SystemEvent event = {EventSource::STREAM, StreamState_e::Stream_ON};
+  xQueueSend(eventQueue, &event, 10);
+
   return ESP_OK;
 }
 
@@ -43,7 +46,8 @@ static void UVCStreamHelpers::camera_stop_cb(void *cb_ctx)
     s_fb.cam_fb_p = nullptr;
   }
 
-  ESP_LOGI(UVC_STREAM_TAG, "Camera Stop");
+  SystemEvent event = {EventSource::STREAM, StreamState_e::Stream_OFF};
+  xQueueSend(eventQueue, &event, 10);
 }
 
 static uvc_fb_t *UVCStreamHelpers::camera_fb_get_cb(void *cb_ctx)

components/UVCStream/UVCStream/UVCStream.hpp

@@ -4,13 +4,19 @@
 #include "esp_timer.h"
 #include "esp_camera.h"
 #include <CameraManager.hpp>
+#include <StateManager.hpp>
 #include "esp_log.h"
 #include "usb_device_uvc.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
 
 // we need access to the camera manager
 // in order to update the frame settings
 extern std::shared_ptr<CameraManager> cameraHandler;
 
+// we also need a way to inform the rest of the system of what's happening
+extern QueueHandle_t eventQueue;
+
 namespace UVCStreamHelpers
 {
   // TODO move the camera handling code to the camera manager and have the uvc maanger initialize it in wired mode

components/wifiManager/wifiManager/wifiManager.cpp

@@ -36,7 +36,7 @@ void WiFiManagerHelpers::event_handler(void *arg, esp_event_base_t event_base,
   }
 }
 
-WiFiManager::WiFiManager(std::shared_ptr<ProjectConfig> deviceConfig) : deviceConfig(deviceConfig) {}
+WiFiManager::WiFiManager(std::shared_ptr<ProjectConfig> deviceConfig, QueueHandle_t eventQueue, StateManager *stateManager) : deviceConfig(deviceConfig), eventQueue(eventQueue), stateManager(stateManager) {}
 
 void WiFiManager::SetCredentials(const char *ssid, const char *password)
 {
@@ -47,13 +47,17 @@ void WiFiManager::SetCredentials(const char *ssid, const char *password)
 
 void WiFiManager::ConnectWithHardcodedCredentials()
 {
+  SystemEvent event = {EventSource::WIFI, WiFiState_e::WiFiState_ReadyToConect};
+
   this->SetCredentials(CONFIG_WIFI_SSID, CONFIG_WIFI_PASSOWRD);
   ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &_wifi_cfg));
 
-  wifiStateManager.setState(WiFiState_e::WiFiState_ReadyToConect);
+  xQueueSend(this->eventQueue, &event, 10);
   esp_wifi_start();
 
-  wifiStateManager.setState(WiFiState_e::WiFiState_Connecting);
+  event.value = WiFiState_e::WiFiState_Connecting;
+  xQueueSend(this->eventQueue, &event, 10);
+
   EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
                                          WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
                                          pdFALSE,
@@ -67,14 +71,17 @@ void WiFiManager::ConnectWithHardcodedCredentials()
     ESP_LOGI(WIFI_MAMANGER_TAG, "connected to ap SSID:%s password:%s",
              _wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
 
-    wifiStateManager.setState(WiFiState_e::WiFiState_Connected);
+    event.value = WiFiState_e::WiFiState_Connected;
+    xQueueSend(this->eventQueue, &event, 10);
   }
 
   else if (bits & WIFI_FAIL_BIT)
   {
     ESP_LOGE(WIFI_MAMANGER_TAG, "Failed to connect to SSID:%s, password:%s",
              _wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
-    wifiStateManager.setState(WiFiState_e::WiFiState_Error);
+
+    event.value = WiFiState_e::WiFiState_Error;
+    xQueueSend(this->eventQueue, &event, 10);
   }
   else
   {
@@ -84,6 +91,8 @@ void WiFiManager::ConnectWithHardcodedCredentials()
 
 void WiFiManager::ConnectWithStoredCredentials()
 {
+  SystemEvent event = {EventSource::WIFI, WiFiState_e::WiFiState_ReadyToConect};
+
   auto networks = this->deviceConfig->getWifiConfigs();
   for (auto network : networks)
   {
@@ -92,11 +101,12 @@ void WiFiManager::ConnectWithStoredCredentials()
 
     // we need to update the config after every credentials change
     ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &_wifi_cfg));
-
+    xQueueSend(this->eventQueue, &event, 10);
-    wifiStateManager.setState(WiFiState_e::WiFiState_ReadyToConect);
 
     esp_wifi_start();
-    wifiStateManager.setState(WiFiState_e::WiFiState_Connecting);
+
+    event.value = WiFiState_e::WiFiState_Connecting;
+    xQueueSend(this->eventQueue, &event, 10);
 
     EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
                                            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
@@ -108,14 +118,17 @@ void WiFiManager::ConnectWithStoredCredentials()
       ESP_LOGI(WIFI_MAMANGER_TAG, "connected to ap SSID:%s password:%s",
                _wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
 
-      wifiStateManager.setState(WiFiState_e::WiFiState_Connected);
+      event.value = WiFiState_e::WiFiState_Connected;
+      xQueueSend(this->eventQueue, &event, 10);
+
       return;
     }
     ESP_LOGE(WIFI_MAMANGER_TAG, "Failed to connect to SSID:%s, password:%s, trying next stored network",
              _wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
   }
 
-  wifiStateManager.setState(WiFiState_e::WiFiState_Error);
+  event.value = WiFiState_e::WiFiState_Error;
+  xQueueSend(this->eventQueue, &event, 10);
   ESP_LOGE(WIFI_MAMANGER_TAG, "Failed to connect to all saved networks");
 }
 
@@ -141,7 +154,6 @@ void WiFiManager::SetupAccessPoint()
   ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &ap_wifi_config));
   ESP_ERROR_CHECK(esp_wifi_start());
   ESP_LOGI(WIFI_MAMANGER_TAG, "AP started.");
-  wifiStateManager.setState(WiFiState_e::WiFiState_ADHOC);
 }
 
 void WiFiManager::Begin()
@@ -181,14 +193,14 @@ void WiFiManager::Begin()
     this->ConnectWithHardcodedCredentials();
   }
 
-  if (wifiStateManager.getCurrentState() != WiFiState_e::WiFiState_Connected || !hasHardcodedCredentials)
+  if (this->stateManager->GetWifiState() != WiFiState_e::WiFiState_Connected || !hasHardcodedCredentials)
   {
     ESP_LOGI(WIFI_MAMANGER_TAG, "Hardcoded credentials failed or missing, trying stored credentials");
     xEventGroupClearBits(s_wifi_event_group, WIFI_FAIL_BIT);
     this->ConnectWithStoredCredentials();
   }
 
-  if (wifiStateManager.getCurrentState() != WiFiState_e::WiFiState_Connected)
+  if (this->stateManager->GetWifiState() != WiFiState_e::WiFiState_Connected)
   {
     ESP_LOGI(WIFI_MAMANGER_TAG, "Stored netoworks failed or hardcoded credentials missing, starting AP");
     xEventGroupClearBits(s_wifi_event_group, WIFI_FAIL_BIT);

components/wifiManager/wifiManager/wifiManager.hpp

@@ -31,6 +31,8 @@ class WiFiManager
 private:
   uint8_t channel;
   std::shared_ptr<ProjectConfig> deviceConfig;
+  QueueHandle_t eventQueue;
+  StateManager *stateManager;
   wifi_init_config_t _wifi_init_cfg = WIFI_INIT_CONFIG_DEFAULT();
   wifi_config_t _wifi_cfg = {};
 
@@ -45,7 +47,7 @@ private:
   void SetupAccessPoint();
 
 public:
-  WiFiManager(std::shared_ptr<ProjectConfig> deviceConfig);
+  WiFiManager(std::shared_ptr<ProjectConfig> deviceConfig, QueueHandle_t eventQueue, StateManager *stateManager);
   void Begin();
 };
 

main/openiris_main.cpp

@@ -13,6 +13,7 @@
 #include <openiris_logo.hpp>
 #include <wifiManager.hpp>
 #include <ProjectConfig.hpp>
+#include <StateManager.hpp>
 #include <LEDManager.hpp>
 #include <MDNSManager.hpp>
 #include <CameraManager.hpp>
@@ -32,20 +33,22 @@
 
 static const char *TAG = "[MAIN]";
 
-QueueHandle_t ledStateQueue = xQueueCreate(10, sizeof(DeviceStates::LEDStates_e));
+QueueHandle_t eventQueue = xQueueCreate(10, sizeof(SystemEvent));
+QueueHandle_t ledStateQueue = xQueueCreate(10, sizeof(uint32_t));
 
-std::shared_ptr<DependencyRegistry> dependencyRegistry = std::make_unique<DependencyRegistry>();
+StateManager *stateManager = new StateManager(eventQueue, ledStateQueue);
+std::shared_ptr<DependencyRegistry> dependencyRegistry = std::make_shared<DependencyRegistry>();
 std::shared_ptr<CommandManager> commandManager = std::make_shared<CommandManager>(dependencyRegistry);
 
 WebSocketLogger webSocketLogger;
 Preferences preferences;
 
 std::shared_ptr<ProjectConfig> deviceConfig = std::make_shared<ProjectConfig>(&preferences);
-WiFiManager wifiManager(deviceConfig);
+WiFiManager wifiManager(deviceConfig, eventQueue, stateManager);
-MDNSManager mdnsManager(deviceConfig);
+MDNSManager mdnsManager(deviceConfig, eventQueue);
 
-std::shared_ptr<CameraManager> cameraHandler = std::make_shared<CameraManager>(deviceConfig);
+std::shared_ptr<CameraManager> cameraHandler = std::make_shared<CameraManager>(deviceConfig, eventQueue);
-StreamServer streamServer(80);
+StreamServer streamServer(80, stateManager);
 
 RestAPI *restAPI = new RestAPI("http://0.0.0.0:81", commandManager);
 
@@ -107,20 +110,19 @@ extern "C" void app_main(void)
     // here I can decouple the loading, initializing and saving logic from the config class and move
     // that into the separate modules, and have the config class only act as a container
 
-    // rethink led manager - we need to move the state change sending into a queue and rethink the state lighting logic
+    // rethink led manager - we need to move the state change sending into a queue and rethink the state lighting logic - DONE
-    // also, the entire led manager needs to be moved to a task
+    // also, the entire led manager needs to be moved to a task - DONE
     // with that, I couuld use vtaskdelayuntil to advance and display states
     // and with that, I should rethink how state management works
 
+    // rethink state management - DONE
+
     // port serial manager
-    // implement OTA stuff, but prepare it for future use
+    // add support of commands to UVC
     // add endpoint to check firmware version
     // add firmware version somewhere
     // setup CI and building for other boards
-
-    // then port the Elegant OTA stuff - I'll roll my own
     // finish todos, overhaul stuff a bit
-    // maybe swich websocket logging to udp logging
 
     Logo::printASCII();
     initNVSStorage();
@@ -128,14 +130,22 @@ extern "C" void app_main(void)
     // esp_log_set_vprintf(&test_log);
     ledManager->setup();
 
+    xTaskCreate(
+        HandleStateManagerTask,
+        "HandleLEDDisplayTask",
+        1024 * 2,
+        stateManager,
+        3,
+        NULL // it's fine for us not get a handle back, we don't need it
+    );
+
     xTaskCreate(
         HandleLEDDisplayTask,
         "HandleLEDDisplayTask",
         1024 * 2,
         ledManager,
         3,
-        NULL // // it's fine for us not get a handle back, we don't need it
+        NULL);
-    );
 
     deviceConfig->load();
     wifiManager.Begin();
@@ -150,9 +160,8 @@ extern "C" void app_main(void)
         "HandleRestAPIPollTask",
         1024 * 2,
         restAPI,
-        1,   // it's the rest API, we only serve commands over it so we don't really need a higher priority
+        1, // it's the rest API, we only serve commands over it so we don't really need a higher priority
-        NULL // // it's fine for us not get a handle back, we don't need iti
+        NULL);
-    );
 
 #ifdef CONFIG_WIRED_MODE
     uvcStream.setup();