MrUnknownDE/OpenIris-ESPIDF
1
0
Fork 0
mirror of https://github.com/MrUnknownDE/OpenIris-ESPIDF.git synced 2026-04-14 12:13:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Lorow
2025-04-21 23:50:41 +02:00
parent f1cf3baf46
commit 4095f00bb0
14 changed files with 273 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
components/CameraManager/CameraManager/CameraManager.cpp
View File

@@ -2,8 +2,8 @@
const char *CAMERA_MANAGER_TAG = "[CAMERA_MANAGER]";
CameraManager::CameraManager(std::shared_ptr<ProjectConfig> projectConfig)
: projectConfig(projectConfig) {}
CameraManager::CameraManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue)
: 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);
cameraStateManager.setState(CameraState_e::Camera_Error);
SystemEvent event = {EventSource::CAMERA, CameraState_e::Camera_Error};
xQueueSend(this->eventQueue, &event, 10);
return false;
}

6
components/CameraManager/CameraManager/CameraManager.hpp
View File

@@ -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

2
components/LEDManager/LEDManager/LEDManager.cpp
View File

@@ -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)
{

21
components/MDNSManager/MDNSManager/MDNSManager.cpp
View File

@@ -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;
}

5
components/MDNSManager/MDNSManager/MDNSManager.hpp
View File

@@ -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();
};

102
components/StateManager/StateManager/StateManager.cpp
View File

@@ -1,8 +1,98 @@
#include "StateManager.hpp"
StateManager<WiFiState_e> wifiStateManager;
StateManager<MDNSState_e> mdnsStateManager;
StateManager<CameraState_e> cameraStateManager;
StateManager<LEDStates_e> ledStateManager;
StateManager<StreamState_e> streamStateManager;
StateManager<ConfigState_e> configStateManager;
StateManager::StateManager(QueueHandle_t eventQueue, QueueHandle_t ledStateQueue) : eventQueue(eventQueue), ledStateQueue(ledStateQueue) {}
void StateManager::HandleUpdateState()
{
SystemEvent eventBuffer;
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();
}
}

172
components/StateManager/StateManager/StateManager.hpp
View File

@@ -1,112 +1,90 @@
#pragma once
#ifndef STATEMANAGER_HPP
#define STATEMANAGER_HPP
/*
* StateManager
* All Project States are managed here
*/
struct DeviceStates
#include <variant>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
enum LEDStates_e
{
enum LEDStates_e
{
_LedStateNone,
_LedStateStreaming,
_LedStateStoppedStreaming,
_WiFiState_Error,
_Camera_Error,
_WiFiState_Connecting,
_WiFiState_Connected
};
enum ConfigState_e
{
configLoaded,
deviceConfigUpdated,
mdnsConfigUpdated,
networksConfigUpdated,
apConfigUpdated,
wifiTxPowerUpdated,
cameraConfigUpdated
};
enum WiFiState_e
{
WiFiState_NotInitialized,
WiFiState_Initialized,
WiFiState_ReadyToConect,
WiFiState_Connecting,
WiFiState_WaitingForIp,
WiFiState_Connected,
WiFiState_Disconnected,
WiFiState_ADHOC,
WiFiState_Error
};
enum MDNSState_e
{
MDNSState_Stopped,
MDNSState_Starting,
MDNSState_Started,
MDNSState_Stopping,
MDNSState_Error,
MDNSState_QueryStarted,
MDNSState_QueryComplete
};
enum CameraState_e
{
Camera_Disconnected,
Camera_Success,
Camera_Error
};
enum StreamState_e
{
Stream_OFF,
Stream_ON,
Stream_Error
};
_LedStateNone,
_LedStateStreaming,
_LedStateStoppedStreaming,
_Camera_Error,
_WiFiState_Error,
_WiFiState_Connecting,
_WiFiState_Connected
};
enum WiFiState_e
{
WiFiState_NotInitialized,
WiFiState_Initialized,
WiFiState_ReadyToConect,
WiFiState_Connecting,
WiFiState_WaitingForIp,
WiFiState_Connected,
WiFiState_Disconnected,
WiFiState_Error
};
enum MDNSState_e
{
MDNSState_Stopped,
MDNSState_Starting,
MDNSState_Started,
MDNSState_Stopping,
MDNSState_Error,
MDNSState_QueryStarted,
MDNSState_QueryComplete
};
enum CameraState_e
{
Camera_Disconnected,
Camera_Success,
Camera_Error
};
enum StreamState_e
{
Stream_OFF,
Stream_ON,
};
enum class EventSource
{
WIFI,
MDNS,
CAMERA,
STREAM
};
struct SystemEvent
{
EventSource source;
std::variant<WiFiState_e, MDNSState_e, CameraState_e, StreamState_e> value;
};
/*
* EventManager
* All Project Events are managed here
*/
template <class T>
class StateManager
{
public:
StateManager() { this->_current_state = static_cast<T>(0); }
virtual ~StateManager() {}
/*
* @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; }
StateManager(QueueHandle_t eventQueue, QueueHandle_t ledStateQueue);
void HandleUpdateState();
WiFiState_e GetWifiState();
CameraState_e GetCameraState();
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;
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;
void HandleStateManagerTask(void *pvParameters);
#endif // STATEMANAGER_HPP

8
components/StreamServer/StreamServer/StreamServer.cpp
View File

@@ -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);
if (cameraStateManager.getCurrentState() != CameraState_e::Camera_Success)
// this is bugged, figure this out. When logs_ws is enabled, we get no stream
// 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;

3
components/StreamServer/StreamServer/StreamServer.hpp
View File

@@ -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);

6
components/UVCStream/UVCStream/UVCStream.cpp
View File

@@ -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)

6
components/UVCStream/UVCStream/UVCStream.hpp
View File

@@ -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

38
components/wifiManager/wifiManager/wifiManager.cpp
View File

@@ -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));
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,
@@ -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);

4
components/wifiManager/wifiManager/wifiManager.hpp
View File

@@ -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();
};

43
main/openiris_main.cpp
View File

@@ -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);
MDNSManager mdnsManager(deviceConfig);
WiFiManager wifiManager(deviceConfig, eventQueue, stateManager);
MDNSManager mdnsManager(deviceConfig, eventQueue);
std::shared_ptr<CameraManager> cameraHandler = std::make_shared<CameraManager>(deviceConfig);
StreamServer streamServer(80);
std::shared_ptr<CameraManager> cameraHandler = std::make_shared<CameraManager>(deviceConfig, eventQueue);
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
// also, the entire led manager needs to be moved to a task
// 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 - 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
NULL // // it's fine for us not get a handle back, we don't need iti
);
1, // it's the rest API, we only serve commands over it so we don't really need a higher priority
NULL);
#ifdef CONFIG_WIRED_MODE
uvcStream.setup();