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

Modernize the code a bit, clean up most compilation warnings

Browse Source
This commit is contained in:
Lorow
2025-05-18 17:33:05 +02:00
parent 0635bbd5c2
commit 4f0ab541cb
26 changed files with 329 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
components/CameraManager/CameraManager/CameraManager.cpp
View File

@@ -99,10 +99,8 @@ void CameraManager::setupBasicResolution()
config.fb_count = 2;
return;
}
else
{
ESP_LOGE(CAMERA_MANAGER_TAG, "PSRAM size: %u", esp_psram_get_size());
}
ESP_LOGE(CAMERA_MANAGER_TAG, "PSRAM size: %u", esp_psram_get_size());
}
void CameraManager::setupCameraSensor()
@@ -177,14 +175,13 @@ bool CameraManager::setupCamera()
// this->setupBasicResolution();
ESP_LOGI(CAMERA_MANAGER_TAG, "Initializing camera...");
esp_err_t hasCameraBeenInitialized = esp_camera_init(&config);
if (hasCameraBeenInitialized == ESP_OK)
if (auto const hasCameraBeenInitialized = esp_camera_init(&config); hasCameraBeenInitialized == ESP_OK)
{
ESP_LOGI(CAMERA_MANAGER_TAG, "Camera initialized: %s \r\n",
esp_err_to_name(hasCameraBeenInitialized));
SystemEvent event = {EventSource::CAMERA, CameraState_e::Camera_Success};
constexpr auto event = SystemEvent{EventSource::CAMERA, CameraState_e::Camera_Success};
xQueueSend(this->eventQueue, &event, 10);
}
else
@@ -195,27 +192,23 @@ bool CameraManager::setupCamera()
"Please "
"fix the "
"camera and reboot the device.\r\n");
SystemEvent event = {EventSource::CAMERA, CameraState_e::Camera_Error};
constexpr auto event = SystemEvent{EventSource::CAMERA, CameraState_e::Camera_Error};
xQueueSend(this->eventQueue, &event, 10);
return false;
}
#if CONFIG_WIRED_MODE
auto temp_sensor = esp_camera_sensor_get();
auto camera_id = temp_sensor->id.PID;
switch (camera_id)
{
const auto temp_sensor = esp_camera_sensor_get();
// Thanks to lick_it, we discovered that OV5640 likes to overheat when
// running at higher than usual xclk frequencies.
// Hence why we're limit the faster ones for OV2640
case OV5640_PID:
// Hence, why we're limiting the faster ones for OV2640
if (const auto camera_id = temp_sensor->id.PID; camera_id == OV5640_PID) {
config.xclk_freq_hz = OV5640_XCLK_FREQ_HZ;
esp_camera_deinit();
esp_camera_init(&config);
break;
default:
break;
}
#endif
this->setupCameraSensor();
@@ -229,13 +222,13 @@ void CameraManager::loadConfigData()
CameraConfig_t cameraConfig = projectConfig->getCameraConfig();
this->setHFlip(cameraConfig.href);
this->setVFlip(cameraConfig.vflip);
this->setCameraResolution((framesize_t)cameraConfig.framesize);
this->setCameraResolution(static_cast<framesize_t>(cameraConfig.framesize));
camera_sensor->set_quality(camera_sensor, cameraConfig.quality);
camera_sensor->set_agc_gain(camera_sensor, cameraConfig.brightness);
ESP_LOGD(CAMERA_MANAGER_TAG, "Loading camera config data done");
}
int CameraManager::setCameraResolution(framesize_t frameSize)
int CameraManager::setCameraResolution(const framesize_t frameSize)
{
if (camera_sensor->pixformat == PIXFORMAT_JPEG)
{
@@ -244,12 +237,12 @@ int CameraManager::setCameraResolution(framesize_t frameSize)
return -1;
}
int CameraManager::setVFlip(int direction)
int CameraManager::setVFlip(const int direction)
{
return camera_sensor->set_vflip(camera_sensor, direction);
}
int CameraManager::setHFlip(int direction)
int CameraManager::setHFlip(const int direction)
{
return camera_sensor->set_hmirror(camera_sensor, direction);
}

43
components/CommandManager/CommandManager/CommandManager.cpp
View File

@@ -17,45 +17,42 @@ std::unordered_map<std::string, CommandType> commandTypeMap = {
{"restart_device", CommandType::RESTART_DEVICE},
};
std::function<CommandResult()> CommandManager::createCommand(CommandType type, std::string_view json)
{
typedef std::function<CommandResult()> CommandFunction;
std::function<CommandResult()> CommandManager::createCommand(CommandType type, std::string_view json) const {
switch (type)
{
case CommandType::PING:
return CommandFunction(PingCommand);
return { PingCommand };
case CommandType::SET_WIFI:
return CommandFunction(std::bind(setWiFiCommand, this->registry, json));
return [this, json] { return setWiFiCommand(this->registry, json); };
case CommandType::UPDATE_WIFI:
return CommandFunction(std::bind(updateWiFiCommand, this->registry, json));
return [this, json] { return updateWiFiCommand(this->registry, json); };
case CommandType::UPDATE_AP_WIFI:
return CommandFunction(std::bind(updateAPWiFiCommand, this->registry, json));
return [this, json] { return updateAPWiFiCommand(this->registry, json); };
case CommandType::DELETE_NETWORK:
return CommandFunction(std::bind(deleteWiFiCommand, this->registry, json));
return [this, json] { return deleteWiFiCommand(this->registry, json); };
case CommandType::SET_MDNS:
return CommandFunction(std::bind(setMDNSCommand, this->registry, json));
return [this, json] { return setMDNSCommand(this->registry, json); };
// updating the mnds name is essentially the same operation
case CommandType::UPDATE_MDNS:
return CommandFunction(std::bind(setMDNSCommand, this->registry, json));
return [this, json] { return setMDNSCommand(this->registry, json); };
case CommandType::UPDATE_CAMERA:
return CommandFunction(std::bind(updateCameraCommand, this->registry, json));
return [this, json] { return updateCameraCommand(this->registry, json); };
case CommandType::RESTART_CAMERA:
return CommandFunction(std::bind(restartCameraCommand, this->registry, json));
return [this, json] { return restartCameraCommand(this->registry, json); };
case CommandType::GET_CONFIG:
return CommandFunction(std::bind(getConfigCommand, this->registry));
return [this] { return getConfigCommand(this->registry); };
case CommandType::SAVE_CONFIG:
return CommandFunction(std::bind(saveConfigCommand, this->registry));
return [this] { return saveConfigCommand(this->registry); };
case CommandType::RESET_CONFIG:
return CommandFunction(std::bind(resetConfigCommand, this->registry, json));
return [this, json] { return resetConfigCommand(this->registry, json); };
case CommandType::RESTART_DEVICE:
return CommandFunction(restartDeviceCommand);
return restartDeviceCommand;
default:
return nullptr;
}
}
CommandResult CommandManager::executeFromJson(std::string_view json)
CommandResult CommandManager::executeFromJson(const std::string_view json) const
{
cJSON *parsedJson = cJSON_Parse(json.data());
if (parsedJson == nullptr)
@@ -84,9 +81,9 @@ CommandResult CommandManager::executeFromJson(std::string_view json)
}
const cJSON *commandPayload = cJSON_GetObjectItem(commandData, "data");
auto commandType = commandTypeMap.at(std::string(commandTypeString->valuestring));
const auto commandType = commandTypeMap.at(std::string(commandTypeString->valuestring));
std::string commandPayloadString = "";
std::string commandPayloadString;
if (commandPayload != nullptr)
commandPayloadString = std::string(cJSON_Print(commandPayload));
@@ -100,16 +97,16 @@ CommandResult CommandManager::executeFromJson(std::string_view json)
cJSON_AddItemToArray(responses, response);
}
auto jsonString = cJSON_Print(responseDocument);
const auto jsonString = cJSON_Print(responseDocument);
cJSON_Delete(responseDocument);
cJSON_Delete(parsedJson);
return CommandResult::getSuccessResult(jsonString);
}
CommandResult CommandManager::executeFromType(CommandType type, std::string_view json)
CommandResult CommandManager::executeFromType(const CommandType type, const std::string_view json) const
{
auto command = createCommand(type, json);
const auto command = createCommand(type, json);
if (command == nullptr)
{

10
components/CommandManager/CommandManager/CommandManager.hpp
View File

@@ -19,7 +19,7 @@
#include "commands/device_commands.hpp"
#include <cJSON.h>
enum CommandType
enum class CommandType
{
None,
PING,
@@ -44,11 +44,11 @@ private:
std::shared_ptr<DependencyRegistry> registry;
public:
CommandManager(std::shared_ptr<DependencyRegistry> DependencyRegistry) : registry(DependencyRegistry) {};
std::function<CommandResult()> createCommand(CommandType type, std::string_view json);
explicit CommandManager(const std::shared_ptr<DependencyRegistry> &DependencyRegistry) : registry(DependencyRegistry) {};
std::function<CommandResult()> createCommand(CommandType type, std::string_view json) const;
CommandResult executeFromJson(std::string_view json);
CommandResult executeFromType(CommandType type, std::string_view json);
CommandResult executeFromJson(std::string_view json) const;
CommandResult executeFromType(CommandType type, std::string_view json) const;
};
#endif

6
components/CommandManager/CommandManager/CommandResult.hpp
View File

@@ -16,7 +16,7 @@ private:
Status status;
std::string message;
CommandResult(std::string message, Status status)
CommandResult(std::string message, const Status status)
{
this->status = status;
if (status == Status::SUCCESS)
@@ -33,12 +33,12 @@ private:
public:
bool isSuccess() const { return status == Status::SUCCESS; }
static CommandResult getSuccessResult(std::string message)
static CommandResult getSuccessResult(const std::string &message)
{
return CommandResult(message, Status::SUCCESS);
}
static CommandResult getErrorResult(std::string message)
static CommandResult getErrorResult(const std::string &message)
{
return CommandResult(message, Status::FAILURE);
}

2
components/CommandManager/CommandManager/DependencyRegistry.hpp
View File

@@ -4,7 +4,7 @@
#include <memory>
#include <unordered_map>
enum DependencyType
enum class DependencyType
{
project_config,
camera_manager

59
components/CommandManager/CommandManager/commands/wifi_commands.cpp
View File

@@ -8,11 +8,11 @@ std::optional<WifiPayload> parseSetWiFiCommandPayload(std::string_view jsonPaylo
if (parsedJson == nullptr)
return std::nullopt;
cJSON *networkName = cJSON_GetObjectItem(parsedJson, "name");
cJSON *ssidPtr = cJSON_GetObjectItem(parsedJson, "ssid");
cJSON *passwordPtr = cJSON_GetObjectItem(parsedJson, "password");
cJSON *channelPtr = cJSON_GetObjectItem(parsedJson, "channel");
cJSON *powerPtr = cJSON_GetObjectItem(parsedJson, "power");
const cJSON *networkName = cJSON_GetObjectItem(parsedJson, "name");
const cJSON *ssidPtr = cJSON_GetObjectItem(parsedJson, "ssid");
const cJSON *passwordPtr = cJSON_GetObjectItem(parsedJson, "password");
const cJSON *channelPtr = cJSON_GetObjectItem(parsedJson, "channel");
const cJSON *powerPtr = cJSON_GetObjectItem(parsedJson, "power");
if (ssidPtr == nullptr)
{
@@ -50,12 +50,12 @@ std::optional<WifiPayload> parseSetWiFiCommandPayload(std::string_view jsonPaylo
std::optional<deleteNetworkPayload> parseDeleteWifiCommandPayload(std::string_view jsonPayload)
{
deleteNetworkPayload payload;
cJSON *parsedJson = cJSON_Parse(jsonPayload.data());
auto *parsedJson = cJSON_Parse(jsonPayload.data());
if (parsedJson == nullptr)
return std::nullopt;
cJSON *networkName = cJSON_GetObjectItem(parsedJson, "name");
const auto *networkName = cJSON_GetObjectItem(parsedJson, "name");
if (networkName == nullptr)
{
cJSON_Delete(parsedJson);
@@ -76,7 +76,7 @@ std::optional<UpdateWifiPayload> parseUpdateWifiCommandPayload(std::string_view
if (parsedJson == nullptr)
return std::nullopt;
cJSON *networkName = cJSON_GetObjectItem(parsedJson, "name");
const cJSON *networkName = cJSON_GetObjectItem(parsedJson, "name");
if (networkName == nullptr)
{
cJSON_Delete(parsedJson);
@@ -85,10 +85,10 @@ std::optional<UpdateWifiPayload> parseUpdateWifiCommandPayload(std::string_view
payload.networkName = std::string(networkName->valuestring);
cJSON *ssidObject = cJSON_GetObjectItem(parsedJson, "ssid");
cJSON *passwordObject = cJSON_GetObjectItem(parsedJson, "password");
cJSON *channelObject = cJSON_GetObjectItem(parsedJson, "channel");
cJSON *powerObject = cJSON_GetObjectItem(parsedJson, "power");
const auto *ssidObject = cJSON_GetObjectItem(parsedJson, "ssid");
const auto *passwordObject = cJSON_GetObjectItem(parsedJson, "password");
const auto *channelObject = cJSON_GetObjectItem(parsedJson, "channel");
const auto *powerObject = cJSON_GetObjectItem(parsedJson, "power");
if (ssidObject != nullptr && (strcmp(ssidObject->valuestring, "") == 0))
{
@@ -113,7 +113,7 @@ std::optional<UpdateWifiPayload> parseUpdateWifiCommandPayload(std::string_view
return payload;
}
std::optional<UpdateAPWiFiPayload> parseUpdateAPWiFiCommandPayload(std::string_view jsonPayload)
std::optional<UpdateAPWiFiPayload> parseUpdateAPWiFiCommandPayload(const std::string_view jsonPayload)
{
UpdateAPWiFiPayload payload;
cJSON *parsedJson = cJSON_Parse(jsonPayload.data());
@@ -123,9 +123,9 @@ std::optional<UpdateAPWiFiPayload> parseUpdateAPWiFiCommandPayload(std::string_v
return std::nullopt;
}
cJSON *ssidObject = cJSON_GetObjectItem(parsedJson, "ssid");
cJSON *passwordObject = cJSON_GetObjectItem(parsedJson, "password");
cJSON *channelObject = cJSON_GetObjectItem(parsedJson, "channel");
const cJSON *ssidObject = cJSON_GetObjectItem(parsedJson, "ssid");
const cJSON *passwordObject = cJSON_GetObjectItem(parsedJson, "password");
const cJSON *channelObject = cJSON_GetObjectItem(parsedJson, "channel");
if (ssidObject != nullptr)
payload.ssid = std::string(ssidObject->valuestring);
@@ -142,13 +142,13 @@ std::optional<UpdateAPWiFiPayload> parseUpdateAPWiFiCommandPayload(std::string_v
CommandResult setWiFiCommand(std::shared_ptr<DependencyRegistry> registry, std::string_view jsonPayload)
{
auto payload = parseSetWiFiCommandPayload(jsonPayload);
const auto payload = parseSetWiFiCommandPayload(jsonPayload);
if (!payload.has_value())
{
return CommandResult::getErrorResult("Invalid payload");
}
auto wifiConfig = payload.value();
const auto wifiConfig = payload.value();
std::shared_ptr<ProjectConfig> projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
projectConfig->setWifiConfig(
@@ -163,11 +163,11 @@ CommandResult setWiFiCommand(std::shared_ptr<DependencyRegistry> registry, std::
CommandResult deleteWiFiCommand(std::shared_ptr<DependencyRegistry> registry, std::string_view jsonPayload)
{
auto payload = parseDeleteWifiCommandPayload(jsonPayload);
const auto payload = parseDeleteWifiCommandPayload(jsonPayload);
if (!payload.has_value())
return CommandResult::getErrorResult("Invalid payload");
std::shared_ptr<ProjectConfig> projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
projectConfig->deleteWifiConfig(payload.value().networkName);
return CommandResult::getSuccessResult("Config updated");
@@ -175,7 +175,7 @@ CommandResult deleteWiFiCommand(std::shared_ptr<DependencyRegistry> registry, st
CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, std::string_view jsonPayload)
{
auto payload = parseUpdateWifiCommandPayload(jsonPayload);
const auto payload = parseUpdateWifiCommandPayload(jsonPayload);
if (!payload.has_value())
{
return CommandResult::getErrorResult("Invalid payload");
@@ -183,13 +183,12 @@ CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, st
auto updatedConfig = payload.value();
std::shared_ptr<ProjectConfig> projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
auto storedNetworks = projectConfig->getWifiConfigs();
if (auto networkToUpdate = std::find_if(
storedNetworks.begin(),
storedNetworks.end(),
[&](auto &network)
{ return network.name == updatedConfig.networkName; });
if (const auto networkToUpdate = std::ranges::find_if(
storedNetworks,
[&](auto &network){ return network.name == updatedConfig.networkName; }
);
networkToUpdate != storedNetworks.end())
{
projectConfig->setWifiConfig(
@@ -207,15 +206,15 @@ CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, st
CommandResult updateAPWiFiCommand(std::shared_ptr<DependencyRegistry> registry, std::string_view jsonPayload)
{
auto payload = parseUpdateAPWiFiCommandPayload(jsonPayload);
const auto payload = parseUpdateAPWiFiCommandPayload(jsonPayload);
if (!payload.has_value())
return CommandResult::getErrorResult("Invalid payload");
auto updatedConfig = payload.value();
std::shared_ptr<ProjectConfig> projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
auto previousAPConfig = projectConfig->getAPWifiConfig();
auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
const auto previousAPConfig = projectConfig->getAPWifiConfig();
projectConfig->setAPWifiConfig(
updatedConfig.ssid.has_value() ? updatedConfig.ssid.value() : previousAPConfig.ssid,

151
components/LEDManager/LEDManager/LEDManager.cpp
View File

@@ -4,7 +4,7 @@ const char *LED_MANAGER_TAG = "[LED_MANAGER]";
ledStateMap_t LEDManager::ledStateMap = {
{
LEDStates_e::_LedStateNone,
LEDStates_e::LedStateNone,
{
false,
false,
@@ -12,7 +12,7 @@ ledStateMap_t LEDManager::ledStateMap = {
},
},
{
LEDStates_e::_LedStateStreaming,
LEDStates_e::LedStateStreaming,
{
false,
true,
@@ -20,7 +20,7 @@ ledStateMap_t LEDManager::ledStateMap = {
},
},
{
LEDStates_e::_LedStateStoppedStreaming,
LEDStates_e::LedStateStoppedStreaming,
{
false,
true,
@@ -28,7 +28,7 @@ ledStateMap_t LEDManager::ledStateMap = {
},
},
{
LEDStates_e::_Camera_Error,
LEDStates_e::CameraError,
{
true,
true,
@@ -36,7 +36,7 @@ ledStateMap_t LEDManager::ledStateMap = {
},
},
{
LEDStates_e::_WiFiState_Connecting,
LEDStates_e::WiFiStateConnecting,
{
false,
true,
@@ -44,15 +44,18 @@ ledStateMap_t LEDManager::ledStateMap = {
},
},
{
LEDStates_e::_WiFiState_Connected,
LEDStates_e::WiFiStateConnected,
{
false,
false,
{{LED_ON, 200}, {LED_OFF, 200}, {LED_ON, 200}, {LED_OFF, 200}, {LED_ON, 200}, {LED_OFF, 200}, {LED_ON, 200}, {LED_OFF, 200}, {LED_ON, 200}, {LED_OFF, 200}},
{
{LED_ON, 200}, {LED_OFF, 200}, {LED_ON, 200}, {LED_OFF, 200}, {LED_ON, 200}, {LED_OFF, 200},
{LED_ON, 200}, {LED_OFF, 200}, {LED_ON, 200}, {LED_OFF, 200}
},
},
},
{
LEDStates_e::_WiFiState_Error,
LEDStates_e::WiFiStateError,
{
true,
true,
@@ -61,18 +64,19 @@ ledStateMap_t LEDManager::ledStateMap = {
},
};
LEDManager::LEDManager(gpio_num_t pin, gpio_num_t illumninator_led_pin, QueueHandle_t ledStateQueue) : blink_led_pin(pin),
illumninator_led_pin(illumninator_led_pin), ledStateQueue(ledStateQueue), currentState(LEDStates_e::_LedStateNone)
{
LEDManager::LEDManager(gpio_num_t pin, gpio_num_t illumninator_led_pin,
QueueHandle_t ledStateQueue) : blink_led_pin(pin),
illumninator_led_pin(illumninator_led_pin),
ledStateQueue(ledStateQueue),
currentState(LEDStates_e::LedStateNone) {
}
void LEDManager::setup()
{
ESP_LOGD(LED_MANAGER_TAG, "Setting up status led.");
gpio_reset_pin(blink_led_pin);
/* Set the GPIO as a push/pull output */
gpio_set_direction(blink_led_pin, GPIO_MODE_OUTPUT);
this->toggleLED(LED_OFF);
void LEDManager::setup() {
ESP_LOGD(LED_MANAGER_TAG, "Setting up status led.");
gpio_reset_pin(blink_led_pin);
/* Set the GPIO as a push/pull output */
gpio_set_direction(blink_led_pin, GPIO_MODE_OUTPUT);
this->toggleLED(LED_OFF);
#ifdef CONFIG_SUPPORTS_EXTERNAL_LED_CONTROL
ESP_LOGD(LED_MANAGER_TAG, "Setting up illuminator led.");
@@ -100,81 +104,68 @@ void LEDManager::setup()
ESP_ERROR_CHECK(ledc_channel_config(&ledc_channel));
#endif
ESP_LOGD(LED_MANAGER_TAG, "Done.");
ESP_LOGD(LED_MANAGER_TAG, "Done.");
}
void LEDManager::handleLED()
{
if (!this->finishedPattern)
{
displayCurrentPattern();
return;
}
if (xQueueReceive(this->ledStateQueue, &buffer, 10))
{
this->updateState(buffer);
}
else
{
// we've finished displaying the pattern, so let's check if it's repeatable and if so - reset it
if (this->ledStateMap[this->currentState].isRepeatable || this->ledStateMap[this->currentState].isError)
{
this->currentPatternIndex = 0;
this->finishedPattern = false;
void LEDManager::handleLED() {
if (!this->finishedPattern) {
displayCurrentPattern();
return;
}
if (xQueueReceive(this->ledStateQueue, &buffer, 10)) {
this->updateState(buffer);
} else {
// we've finished displaying the pattern, so let's check if it's repeatable and if so - reset it
if (ledStateMap[this->currentState].isRepeatable || ledStateMap[this->currentState].isError) {
this->currentPatternIndex = 0;
this->finishedPattern = false;
}
}
}
}
void LEDManager::displayCurrentPattern()
{
BlinkPatterns_t ledState = this->ledStateMap[this->currentState].patterns[this->currentPatternIndex];
this->toggleLED(ledState.state);
this->timeToDelayFor = ledState.delayTime;
void LEDManager::displayCurrentPattern() {
auto [state, delayTime] = ledStateMap[this->currentState].patterns[this->currentPatternIndex];
this->toggleLED(state);
this->timeToDelayFor = delayTime;
if (!(this->currentPatternIndex >= this->ledStateMap[this->currentState].patterns.size() - 1))
this->currentPatternIndex++;
else
{
this->finishedPattern = true;
this->toggleLED(LED_OFF);
}
if (this->currentPatternIndex < ledStateMap[this->currentState].patterns.size() - 1)
this->currentPatternIndex++;
else {
this->finishedPattern = true;
this->toggleLED(LED_OFF);
}
}
void LEDManager::updateState(LEDStates_e newState)
{
// we should change the displayed state
// only if we finished displaying the current one - which is handled by the task
// if the new state is not the same as the current one
// and if can actually display the state
void LEDManager::updateState(const LEDStates_e newState) {
// we should change the displayed state
// only if we finished displaying the current one - which is handled by the task
// if the new state is not the same as the current one
// and if can actually display the state
// if we've got an error state - that's it, we'll just keep repeating it indefinitely
if (this->ledStateMap[this->currentState].isError)
return;
// if we've got an error state - that's it, we'll just keep repeating it indefinitely
if (ledStateMap[this->currentState].isError)
return;
if (newState == this->currentState)
return;
if (newState == this->currentState)
return;
if (this->ledStateMap.contains(newState))
{
this->currentState = newState;
this->currentPatternIndex = 0;
this->finishedPattern = false;
}
if (ledStateMap.contains(newState)) {
this->currentState = newState;
this->currentPatternIndex = 0;
this->finishedPattern = false;
}
}
void LEDManager::toggleLED(bool state) const
{
gpio_set_level(blink_led_pin, state);
void LEDManager::toggleLED(const bool state) const {
gpio_set_level(blink_led_pin, state);
}
void HandleLEDDisplayTask(void *pvParameter)
{
LEDManager *ledManager = static_cast<LEDManager *>(pvParameter);
void HandleLEDDisplayTask(void *pvParameter) {
auto *ledManager = static_cast<LEDManager *>(pvParameter);
while (1)
{
ledManager->handleLED();
vTaskDelay(ledManager->getTimeToDelayFor());
}
}
while (true) {
ledManager->handleLED();
vTaskDelay(ledManager->getTimeToDelayFor());
}
}

3
components/MDNSManager/MDNSManager/MDNSManager.cpp
View File

@@ -37,8 +37,7 @@ esp_err_t MDNSManager::start()
{"api_port", "81"},
};
result = mdns_service_add(nullptr, mdnsName.c_str(), "_tcp", 80, serviceTxtData, 2);
mdns_service_add(nullptr, mdnsName.c_str(), "_tcp", 80, serviceTxtData, 2);
result = mdns_service_instance_name_set(mdnsName.c_str(), "_tcp", mdnsName.c_str());
if (result != ESP_OK)
{

2
components/OpenIrisTasks/OpenIrisTasks/OpenIrisTasks.cpp
View File

@@ -3,7 +3,7 @@
void OpenIrisTasks::ScheduleRestart(int milliseconds)
{
taskYIELD();
int initialTime = Helpers::getTimeInMillis();
const auto initialTime = Helpers::getTimeInMillis();
while (Helpers::getTimeInMillis() - initialTime <= milliseconds)
{
continue;

2
components/Preferences/Preferences/Preferences.hpp
View File

@@ -8,7 +8,7 @@
#include <cstdint>
#include <string>
#include <cstring>
#include <math.h>
#include <cmath>
#include "esp_log.h"
#include "nvs_flash.h"
#include "nvs.h"

69
components/ProjectConfig/ProjectConfig/Models.hpp
View File

@@ -3,6 +3,7 @@
#define _PROJECT_CONFIG_MODELS_HPP_
#include <string>
#include <utility>
#include <vector>
#include <helpers.hpp>
#include "sdkconfig.h"
@@ -29,19 +30,18 @@ struct DeviceConfig_t : BaseConfigModel
void load()
{
this->OTALogin = this->pref->getString("OTALogin", "openiris").c_str();
this->OTAPassword = this->pref->getString("OTAPassword", "openiris").c_str();
this->OTALogin = this->pref->getString("OTALogin", "openiris");
this->OTAPassword = this->pref->getString("OTAPassword", "openiris");
this->OTAPort = this->pref->getInt("OTAPort", 3232);
};
void save()
{
void save() const {
this->pref->putString("OTALogin", this->OTALogin.c_str());
this->pref->putString("OTAPassword", this->OTAPassword.c_str());
this->pref->putInt("OTAPort", this->OTAPort);
};
std::string toRepresentation()
std::string toRepresentation() const
{
return Helpers::format_string(
"\"device_config\": {\"OTALogin\": \"%s\", \"OTAPassword\": \"%s\", "
@@ -50,7 +50,7 @@ struct DeviceConfig_t : BaseConfigModel
};
};
struct MDNSConfig_t : public BaseConfigModel
struct MDNSConfig_t : BaseConfigModel
{
MDNSConfig_t(Preferences *pref) : BaseConfigModel(pref) {}
@@ -67,11 +67,10 @@ struct MDNSConfig_t : public BaseConfigModel
default_hostname = "openiristracker";
}
this->hostname = this->pref->getString("hostname", default_hostname).c_str();
this->hostname = this->pref->getString("hostname", default_hostname);
};
void save()
{
void save() const {
this->pref->putString("hostname", this->hostname.c_str());
};
@@ -102,8 +101,7 @@ struct CameraConfig_t : BaseConfigModel
this->brightness = this->pref->getInt("brightness", 2);
};
void save()
{
void save() const {
this->pref->putInt("vflip", this->vflip);
this->pref->putInt("href", this->href);
this->pref->putInt("framesize", this->framesize);
@@ -132,12 +130,12 @@ struct WiFiConfig_t : BaseConfigModel
WiFiConfig_t(
Preferences *pref,
uint8_t index,
const std::string &name,
const std::string &ssid,
const std::string &password,
uint8_t channel,
uint8_t power)
const uint8_t index,
std::string name,
std::string ssid,
std::string password,
const uint8_t channel,
const uint8_t power)
: BaseConfigModel(pref),
index(index),
name(std::move(name)),
@@ -153,23 +151,22 @@ struct WiFiConfig_t : BaseConfigModel
uint8_t channel;
uint8_t power;
void load(uint8_t index)
void load(const uint8_t index)
{
this->index = index;
char buffer[2];
std::string iter_str = Helpers::itoa(index, buffer, 10);
this->name = this->pref->getString(("name" + iter_str).c_str(), "").c_str();
this->ssid = this->pref->getString(("ssid" + iter_str).c_str(), "").c_str();
this->password = this->pref->getString(("password" + iter_str).c_str(), "").c_str();
auto const iter_str = std::string(Helpers::itoa(index, buffer, 10));
this->name = this->pref->getString(("name" + iter_str).c_str(), "");
this->ssid = this->pref->getString(("ssid" + iter_str).c_str(), "");
this->password = this->pref->getString(("password" + iter_str).c_str(), "");
this->channel = this->pref->getUInt(("channel" + iter_str).c_str());
this->power = this->pref->getUInt(("power" + iter_str).c_str());
};
void save()
{
void save() const {
char buffer[2];
std::string iter_str = Helpers::itoa(this->index, buffer, 10);
auto const iter_str = std::string(Helpers::itoa(this->index, buffer, 10));
this->pref->putString(("name" + iter_str).c_str(), this->name.c_str());
this->pref->putString(("ssid" + iter_str).c_str(), this->ssid.c_str());
@@ -197,12 +194,11 @@ struct AP_WiFiConfig_t : BaseConfigModel
void load()
{
this->ssid = this->pref->getString("apSSID", CONFIG_AP_WIFI_SSID).c_str();
this->password = this->pref->getString("apPassword", CONFIG_AP_WIFI_PASSWORD).c_str();
this->ssid = this->pref->getString("apSSID", CONFIG_AP_WIFI_SSID);
this->password = this->pref->getString("apPassword", CONFIG_AP_WIFI_PASSWORD);
};
void save()
{
void save() const {
this->pref->putString("apSSID", this->ssid.c_str());
this->pref->putString("apPass", this->password.c_str());
this->pref->putUInt("apChannel", this->channel);
@@ -228,8 +224,7 @@ struct WiFiTxPower_t : BaseConfigModel
this->power = this->pref->getUInt("txpower", 52);
};
void save()
{
void save() const {
this->pref->putUInt("txpower", this->power);
};
@@ -255,19 +250,19 @@ public:
std::vector<WiFiConfig_t> networks,
AP_WiFiConfig_t ap_network,
MDNSConfig_t mdns,
WiFiTxPower_t txpower) : device(device),
WiFiTxPower_t txpower) : device(std::move(device)),
camera(camera),
networks(networks),
ap_network(ap_network),
mdns(mdns),
networks(std::move(networks)),
ap_network(std::move(ap_network)),
mdns(std::move(mdns)),
txpower(txpower) {}
std::string toRepresentation()
{
std::string WifiConfigRepresentation = "";
std::string WifiConfigRepresentation;
// we need a valid json representation, so we can't have a dangling comma at the end
if (this->networks.size() > 0)
if (!this->networks.empty())
{
if (this->networks.size() > 1)
{

52
components/ProjectConfig/ProjectConfig/ProjectConfig.cpp
View File

@@ -1,11 +1,13 @@
#include "ProjectConfig.hpp"
static auto CONFIGURATION_TAG = "[CONFIGURATION]";
int getNetworkCount(Preferences *pref)
{
return pref->getInt("networkcount", 0);
}
void saveNetworkCount(Preferences *pref, int count)
void saveNetworkCount(Preferences *pref, const int count)
{
pref->putInt("networkcount", count);
}
@@ -19,10 +21,9 @@ ProjectConfig::ProjectConfig(Preferences *pref) : pref(pref),
MDNSConfig_t(pref),
WiFiTxPower_t(pref)) {}
ProjectConfig::~ProjectConfig() {}
ProjectConfig::~ProjectConfig() = default;
void ProjectConfig::save()
{
void ProjectConfig::save() const {
ESP_LOGD(CONFIGURATION_TAG, "Saving project config");
this->config.device.save();
this->config.camera.save();
@@ -30,7 +31,7 @@ void ProjectConfig::save()
this->config.txpower.save();
this->config.ap_network.save();
auto networks_count = this->config.networks.size();
auto const networks_count = static_cast<int>(this->config.networks.size());
for (int i = 0; i < networks_count; i++)
{
this->config.networks[i].save();
@@ -54,7 +55,7 @@ void ProjectConfig::load()
return;
}
bool success = this->pref->begin("openiris");
const bool success = this->pref->begin("openiris");
ESP_LOGI(CONFIGURATION_TAG, "Config name: openiris");
ESP_LOGI(CONFIGURATION_TAG, "Config loaded: %s", success ? "true" : "false");
@@ -65,7 +66,7 @@ void ProjectConfig::load()
this->config.txpower.load();
this->config.ap_network.load();
auto networks_count = getNetworkCount(this->pref);
const auto networks_count = getNetworkCount(this->pref);
ESP_LOGD(CONFIGURATION_TAG, "Loading networks: %d", networks_count);
for (int i = 0; i < getNetworkCount(this->pref); i++)
{
@@ -90,7 +91,7 @@ bool ProjectConfig::reset()
//**********************************************************************************************************************
void ProjectConfig::setDeviceConfig(const std::string &OTALogin,
const std::string &OTAPassword,
int OTAPort)
const int OTAPort)
{
ESP_LOGD(CONFIGURATION_TAG, "Updating device config");
this->config.device.OTALogin.assign(OTALogin);
@@ -104,11 +105,11 @@ void ProjectConfig::setMDNSConfig(const std::string &hostname)
this->config.mdns.hostname.assign(hostname);
}
void ProjectConfig::setCameraConfig(uint8_t vflip,
uint8_t framesize,
uint8_t href,
uint8_t quality,
uint8_t brightness)
void ProjectConfig::setCameraConfig(const uint8_t vflip,
const uint8_t framesize,
const uint8_t href,
const uint8_t quality,
const uint8_t brightness)
{
ESP_LOGD(CONFIGURATION_TAG, "Updating camera config");
this->config.camera.vflip = vflip;
@@ -126,13 +127,11 @@ void ProjectConfig::setWifiConfig(const std::string &networkName,
uint8_t channel,
uint8_t power)
{
size_t size = this->config.networks.size();
const auto size = this->config.networks.size();
auto it = std::find_if(
this->config.networks.begin(),
this->config.networks.end(),
[&](WiFiConfig_t &network)
{ return network.name == networkName; });
const auto it = std::ranges::find_if(this->config.networks,
[&](const WiFiConfig_t &network)
{ return network.name == networkName; });
if (it != this->config.networks.end())
{
@@ -151,7 +150,7 @@ void ProjectConfig::setWifiConfig(const std::string &networkName,
if (size == 0)
{
ESP_LOGI(CONFIGURATION_TAG, "No networks, We're adding a new network");
this->config.networks.emplace_back(this->pref, (uint8_t)0, networkName, ssid, password, channel,
this->config.networks.emplace_back(this->pref, static_cast<uint8_t>(0), networkName, ssid, password, channel,
power);
return;
}
@@ -175,17 +174,14 @@ void ProjectConfig::setWifiConfig(const std::string &networkName,
void ProjectConfig::deleteWifiConfig(const std::string &networkName)
{
size_t size = this->config.networks.size();
if (size == 0)
if (const auto size = this->config.networks.size(); size == 0)
{
ESP_LOGI(CONFIGURATION_TAG, "No networks, nothing to delete");
}
auto it = std::find_if(
this->config.networks.begin(),
this->config.networks.end(),
[&](WiFiConfig_t &network)
{ return network.name == networkName; });
const auto it = std::ranges::find_if(this->config.networks,
[&](const WiFiConfig_t &network)
{ return network.name == networkName; });
if (it != this->config.networks.end())
{
@@ -203,7 +199,7 @@ void ProjectConfig::setWiFiTxPower(uint8_t power)
void ProjectConfig::setAPWifiConfig(const std::string &ssid,
const std::string &password,
uint8_t channel)
const uint8_t channel)
{
this->config.ap_network.ssid.assign(ssid);
this->config.ap_network.password.assign(password);

9
components/ProjectConfig/ProjectConfig/ProjectConfig.hpp
View File

@@ -1,6 +1,6 @@
#pragma once
#ifndef _PROJECT_CONFIG_HPP_
#define _PROJECT_CONFIG_HPP_
#ifndef PROJECT_CONFIG_HPP
#define PROJECT_CONFIG_HPP
#include "esp_log.h"
#include <algorithm>
#include <vector>
@@ -9,7 +9,6 @@
#include "Models.hpp"
#include <Preferences.hpp>
static const char *CONFIGURATION_TAG = "[CONFIGURATION]";
int getNetworkCount(Preferences *pref);
@@ -18,11 +17,11 @@ void saveNetworkCount(Preferences *pref, int count);
class ProjectConfig
{
public:
ProjectConfig(Preferences *pref);
explicit ProjectConfig(Preferences *pref);
virtual ~ProjectConfig();
void load();
void save();
void save() const;
void wifiConfigSave();
void cameraConfigSave();

73
components/RestAPI/RestAPI/RestAPI.cpp
View File

@@ -1,10 +1,12 @@
#include "RestAPI.hpp"
#include <utility>
#define POST_METHOD "POST"
RestAPI::RestAPI(std::string url, std::shared_ptr<CommandManager> commandManager) : command_manager(commandManager)
{
this->url = url;
this->url = std::move(url);
// updates
routes.emplace("/api/update/wifi/", &RestAPI::handle_update_wifi);
routes.emplace("/api/update/device/", &RestAPI::handle_update_device);
@@ -40,13 +42,12 @@ void RestAPI::handle_request(struct mg_connection *connection, int event, void *
{
if (event == MG_EV_HTTP_MSG)
{
struct mg_http_message *message = (struct mg_http_message *)event_data;
std::string uri = std::string(message->uri.buf, message->uri.len);
auto handler = this->routes[uri];
auto const *message = static_cast<struct mg_http_message *>(event_data);
auto const uri = std::string(message->uri.buf, message->uri.len);
if (handler)
if (auto const handler = this->routes[uri])
{
RequestContext *context = new RequestContext{
auto *context = new RequestContext{
.connection = connection,
.method = std::string(message->method.buf, message->method.len),
.body = std::string(message->body.buf, message->body.len),
@@ -62,7 +63,7 @@ void RestAPI::handle_request(struct mg_connection *connection, int event, void *
void RestAPIHelpers::event_handler(struct mg_connection *connection, int event, void *event_data)
{
RestAPI *rest_api_handler = static_cast<RestAPI *>(connection->fn_data);
auto *rest_api_handler = static_cast<RestAPI *>(connection->fn_data);
rest_api_handler->handle_request(connection, event, event_data);
}
@@ -73,8 +74,8 @@ void RestAPI::poll()
void HandleRestAPIPollTask(void *pvParameter)
{
RestAPI *rest_api_handler = static_cast<RestAPI *>(pvParameter);
while (1)
auto *rest_api_handler = static_cast<RestAPI *>(pvParameter);
while (true)
{
rest_api_handler->poll();
vTaskDelay(1000);
@@ -83,72 +84,66 @@ void HandleRestAPIPollTask(void *pvParameter)
// COMMANDS
// updates
void RestAPI::handle_update_wifi(RequestContext *context)
{
void RestAPI::handle_update_wifi(RequestContext *context) {
if (context->method != POST_METHOD)
{
mg_http_reply(context->connection, 401, JSON_RESPONSE, "{%m:%m}", MG_ESC("error"), "Method not allowed");
return;
}
auto result = command_manager->executeFromType(CommandType::UPDATE_WIFI, context->body);
int code = result.isSuccess() ? 200 : 500;
auto const result = command_manager->executeFromType(CommandType::UPDATE_WIFI, context->body);
auto const code = result.isSuccess() ? 200 : 500;
mg_http_reply(context->connection, code, JSON_RESPONSE, result.getResult().c_str());
}
void RestAPI::handle_update_device(RequestContext *context)
{
void RestAPI::handle_update_device(RequestContext *context) {
if (context->method != POST_METHOD)
{
mg_http_reply(context->connection, 401, JSON_RESPONSE, "{%m:%m}", MG_ESC("error"), "Method not allowed");
return;
}
auto result = command_manager->executeFromType(CommandType::UPDATE_DEVICE, context->body);
int code = result.isSuccess() ? 200 : 500;
auto const result = command_manager->executeFromType(CommandType::UPDATE_DEVICE, context->body);
auto const code = result.isSuccess() ? 200 : 500;
mg_http_reply(context->connection, code, JSON_RESPONSE, result.getResult().c_str());
}
void RestAPI::handle_update_camera(RequestContext *context)
{
void RestAPI::handle_update_camera(RequestContext *context) {
if (context->method != POST_METHOD)
{
mg_http_reply(context->connection, 401, JSON_RESPONSE, "{%m:%m}", MG_ESC("error"), "Method not allowed");
return;
}
auto result = command_manager->executeFromType(CommandType::UPDATE_CAMERA, context->body);
int code = result.isSuccess() ? 200 : 500;
auto const result = command_manager->executeFromType(CommandType::UPDATE_CAMERA, context->body);
auto const code = result.isSuccess() ? 200 : 500;
mg_http_reply(context->connection, code, JSON_RESPONSE, result.getResult().c_str());
}
// gets
void RestAPI::handle_get_config(RequestContext *context)
{
auto result = this->command_manager->executeFromType(CommandType::GET_CONFIG, "");
void RestAPI::handle_get_config(RequestContext *context) {
auto const result = this->command_manager->executeFromType(CommandType::GET_CONFIG, "");
mg_http_reply(context->connection, 200, JSON_RESPONSE, "{%m:%m}", MG_ESC("result"), result.getResult());
}
// resets
void RestAPI::handle_reset_config(RequestContext *context)
{
void RestAPI::handle_reset_config(RequestContext *context) {
if (context->method != POST_METHOD)
{
mg_http_reply(context->connection, 401, JSON_RESPONSE, "{%m:%m}", MG_ESC("error"), "Method not allowed");
return;
}
auto result = this->command_manager->executeFromType(CommandType::RESET_CONFIG, "{\"section\": \"all\"}");
int code = result.isSuccess() ? 200 : 500;
auto const result = this->command_manager->executeFromType(CommandType::RESET_CONFIG, "{\"section\": \"all\"}");
auto const code = result.isSuccess() ? 200 : 500;
mg_http_reply(context->connection, code, JSON_RESPONSE, "{%m:%m}", MG_ESC("result"), result.getResult());
}
// reboots
void RestAPI::handle_reboot(RequestContext *context)
{
auto result = this->command_manager->executeFromType(CommandType::RESTART_DEVICE, "");
void RestAPI::handle_reboot(RequestContext *context) {
auto const result = this->command_manager->executeFromType(CommandType::RESTART_DEVICE, "");
mg_http_reply(context->connection, 200, JSON_RESPONSE, "{%m:%m}", MG_ESC("result"), "Ok");
}
@@ -159,18 +154,16 @@ void RestAPI::handle_camera_reboot(RequestContext *context)
// heartbeat
void RestAPI::pong(RequestContext *context)
{
CommandResult result = this->command_manager->executeFromType(CommandType::PING, "");
int code = result.isSuccess() ? 200 : 500;
void RestAPI::pong(RequestContext *context) {
auto const result = this->command_manager->executeFromType(CommandType::PING, "");
auto const code = result.isSuccess() ? 200 : 500;
mg_http_reply(context->connection, code, JSON_RESPONSE, result.getResult().c_str());
}
// special
void RestAPI::handle_save(RequestContext *context)
{
CommandResult result = this->command_manager->executeFromType(CommandType::SAVE_CONFIG, "");
int code = result.isSuccess() ? 200 : 500;
void RestAPI::handle_save(RequestContext *context) {
auto const result = this->command_manager->executeFromType(CommandType::SAVE_CONFIG, "");
auto const code = result.isSuccess() ? 200 : 500;
mg_http_reply(context->connection, code, JSON_RESPONSE, result.getResult().c_str());
}
}

2
components/RestAPI/RestAPI/RestAPI.hpp
View File

@@ -25,7 +25,7 @@ class RestAPI
std::string url;
route_map routes;
struct mg_mgr mgr;
mg_mgr mgr;
std::shared_ptr<CommandManager> command_manager;
private:

16
components/SerialManager/SerialManager/SerialManager.cpp
View File

@@ -10,7 +10,10 @@
#define BUF_SIZE (1024)
SerialManager::SerialManager(std::shared_ptr<CommandManager> commandManager) : commandManager(commandManager) {}
SerialManager::SerialManager(std::shared_ptr<CommandManager> commandManager) : commandManager(commandManager) {
this->data = static_cast<uint8_t *>(malloc(BUF_SIZE));
this->temp_data = static_cast<uint8_t *>(malloc(256));
}
void SerialManager::setup()
{
@@ -18,9 +21,6 @@ void SerialManager::setup()
usb_serial_jtag_config.rx_buffer_size = BUF_SIZE;
usb_serial_jtag_config.tx_buffer_size = BUF_SIZE;
usb_serial_jtag_driver_install(&usb_serial_jtag_config);
// Configure a temporary buffer for the incoming data
this->data = (uint8_t *)malloc(BUF_SIZE);
this->temp_data = (uint8_t *)malloc(256);
}
void SerialManager::try_receive()
@@ -43,17 +43,17 @@ void SerialManager::try_receive()
data[current_position] = '\0';
current_position = 0;
auto result = this->commandManager->executeFromJson(std::string_view((const char *)this->data));
auto resultMessage = result.getResult();
const auto result = this->commandManager->executeFromJson(std::string_view(reinterpret_cast<const char *>(this->data)));
const auto resultMessage = result.getResult();
usb_serial_jtag_write_bytes(resultMessage.c_str(), resultMessage.length(), 1000 / 20);
}
}
void HandleSerialManagerTask(void *pvParameters)
{
auto serialManager = static_cast<SerialManager *>(pvParameters);
auto const serialManager = static_cast<SerialManager *>(pvParameters);
while (1)
while (true)
{
serialManager->try_receive();
}

4
components/SerialManager/SerialManager/SerialManager.hpp
View File

@@ -19,12 +19,12 @@
class SerialManager
{
public:
SerialManager(std::shared_ptr<CommandManager> commandManager);
explicit SerialManager(std::shared_ptr<CommandManager> commandManager);
void setup();
void try_receive();
private:
QueueHandle_t serialQueue;
// QueueHandle_t serialQueue;
std::shared_ptr<CommandManager> commandManager;
uint8_t *data;
uint8_t *temp_data;

18
components/StateManager/StateManager/StateManager.cpp
View File

@@ -5,7 +5,7 @@ StateManager::StateManager(QueueHandle_t eventQueue, QueueHandle_t ledStateQueue
void StateManager::HandleUpdateState()
{
SystemEvent eventBuffer;
auto ledStreamState = LEDStates_e::_LedStateNone;
auto ledStreamState = LEDStates_e::LedStateNone;
if (xQueueReceive(this->eventQueue, &eventBuffer, portMAX_DELAY))
{
@@ -18,17 +18,17 @@ void StateManager::HandleUpdateState()
if (this->wifi_state == WiFiState_e::WiFiState_Connecting)
{
ledStreamState = LEDStates_e::_WiFiState_Connecting;
ledStreamState = LEDStates_e::WiFiStateConnecting;
xQueueSend(this->ledStateQueue, &ledStreamState, 10);
}
if (this->wifi_state == WiFiState_e::WiFiState_Connected)
{
ledStreamState = LEDStates_e::_WiFiState_Connected;
ledStreamState = LEDStates_e::WiFiStateConnected;
xQueueSend(this->ledStateQueue, &ledStreamState, 10);
}
if (this->wifi_state == WiFiState_e::WiFiState_Error)
{
ledStreamState = LEDStates_e::_WiFiState_Error;
ledStreamState = LEDStates_e::WiFiStateError;
xQueueSend(this->ledStateQueue, &ledStreamState, 10);
}
@@ -47,7 +47,7 @@ void StateManager::HandleUpdateState()
if (this->camera_state == CameraState_e::Camera_Error)
{
ledStreamState = LEDStates_e::_Camera_Error;
ledStreamState = LEDStates_e::CameraError;
xQueueSend(this->ledStateQueue, &ledStreamState, 10);
}
@@ -60,12 +60,12 @@ void StateManager::HandleUpdateState()
if (this->stream_state == StreamState_e::Stream_ON)
{
ledStreamState = LEDStates_e::_LedStateStreaming;
ledStreamState = LEDStates_e::LedStateStreaming;
xQueueSend(this->ledStateQueue, &ledStreamState, 10);
}
if (this->stream_state == StreamState_e::Stream_ON)
{
ledStreamState = LEDStates_e::_LedStateStreaming;
ledStreamState = LEDStates_e::LedStateStreaming;
xQueueSend(this->ledStateQueue, &ledStreamState, 10);
}
break;
@@ -89,9 +89,9 @@ CameraState_e StateManager::GetCameraState()
void HandleStateManagerTask(void *pvParameters)
{
StateManager *stateManager = static_cast<StateManager *>(pvParameters);
auto *stateManager = static_cast<StateManager *>(pvParameters);
while (1)
while (true)
{
stateManager->HandleUpdateState();
}

26
components/StateManager/StateManager/StateManager.hpp
View File

@@ -6,22 +6,22 @@
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
enum LEDStates_e
enum class LEDStates_e
{
_LedStateNone,
_LedStateStreaming,
_LedStateStoppedStreaming,
_Camera_Error,
_WiFiState_Error,
_WiFiState_Connecting,
_WiFiState_Connected
LedStateNone,
LedStateStreaming,
LedStateStoppedStreaming,
CameraError,
WiFiStateError,
WiFiStateConnecting,
WiFiStateConnected
};
enum WiFiState_e
enum class WiFiState_e
{
WiFiState_NotInitialized,
WiFiState_Initialized,
WiFiState_ReadyToConect,
WiFiState_ReadyToConnect,
WiFiState_Connecting,
WiFiState_WaitingForIp,
WiFiState_Connected,
@@ -29,7 +29,7 @@ enum WiFiState_e
WiFiState_Error
};
enum MDNSState_e
enum class MDNSState_e
{
MDNSState_Stopped,
MDNSState_Starting,
@@ -40,14 +40,14 @@ enum MDNSState_e
MDNSState_QueryComplete
};
enum CameraState_e
enum class CameraState_e
{
Camera_Disconnected,
Camera_Success,
Camera_Error
};
enum StreamState_e
enum class StreamState_e
{
Stream_OFF,
Stream_ON,

20
components/UVCStream/UVCStream/UVCStream.cpp
View File

@@ -9,7 +9,6 @@ static esp_err_t UVCStreamHelpers::camera_start_cb(uvc_format_t format, int widt
ESP_LOGI(UVC_STREAM_TAG, "Camera Start");
ESP_LOGI(UVC_STREAM_TAG, "Format: %d, width: %d, height: %d, rate: %d", format, width, height, rate);
framesize_t frame_size = FRAMESIZE_QVGA;
int jpeg_quality = 10;
if (format != UVC_FORMAT_JPEG)
{
@@ -20,7 +19,6 @@ static esp_err_t UVCStreamHelpers::camera_start_cb(uvc_format_t format, int widt
if (width == 240 && height == 240)
{
frame_size = FRAMESIZE_240X240;
jpeg_quality = 10;
}
else
{
@@ -29,9 +27,9 @@ static esp_err_t UVCStreamHelpers::camera_start_cb(uvc_format_t format, int widt
}
cameraHandler->setCameraResolution(frame_size);
cameraHandler->resetCamera(0);
cameraHandler->resetCamera(false);
SystemEvent event = {EventSource::STREAM, StreamState_e::Stream_ON};
constexpr SystemEvent event = {EventSource::STREAM, StreamState_e::Stream_ON};
xQueueSend(eventQueue, &event, 10);
return ESP_OK;
@@ -46,7 +44,7 @@ static void UVCStreamHelpers::camera_stop_cb(void *cb_ctx)
s_fb.cam_fb_p = nullptr;
}
SystemEvent event = {EventSource::STREAM, StreamState_e::Stream_OFF};
constexpr SystemEvent event = {EventSource::STREAM, StreamState_e::Stream_OFF};
xQueueSend(eventQueue, &event, 10);
}
@@ -88,7 +86,7 @@ esp_err_t UVCStreamManager::setup()
{
ESP_LOGI(UVC_STREAM_TAG, "Setting up UVC Stream");
uvc_buffer = (uint8_t *)malloc(UVC_MAX_FRAMESIZE_SIZE);
uvc_buffer = static_cast<uint8_t *>(malloc(UVC_MAX_FRAMESIZE_SIZE));
if (uvc_buffer == nullptr)
{
ESP_LOGE(UVC_STREAM_TAG, "Allocating buffer for UVC Device failed");
@@ -110,10 +108,7 @@ esp_err_t UVCStreamManager::setup()
ESP_LOGE(UVC_STREAM_TAG, "Configuring UVC Device failed: %s", esp_err_to_name(ret));
return ret;
}
else
{
ESP_LOGI(UVC_STREAM_TAG, "Configured UVC Device");
}
ESP_LOGI(UVC_STREAM_TAG, "Configured UVC Device");
ESP_LOGI(UVC_STREAM_TAG, "Initializing UVC Device");
ret = uvc_device_init();
@@ -122,10 +117,7 @@ esp_err_t UVCStreamManager::setup()
ESP_LOGE(UVC_STREAM_TAG, "Initializing UVC Device failed: %s", esp_err_to_name(ret));
return ret;
}
else
{
ESP_LOGI(UVC_STREAM_TAG, "Initialized UVC Device");
}
ESP_LOGI(UVC_STREAM_TAG, "Initialized UVC Device");
return ESP_OK;
}

2
components/UVCStream/UVCStream/UVCStream.hpp
View File

@@ -19,7 +19,7 @@ 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
// TODO move the camera handling code to the camera manager and have the uvc manager initialize it in wired mode
typedef struct
{

10
components/WebSocketLogger/WebSocketLogger/WebSocketLogger.cpp
View File

@@ -14,13 +14,13 @@ void LoggerHelpers::ws_async_send(void *arg)
{
char *log_buffer = webSocketLogger.get_websocket_log_buffer();
struct async_resp_arg *resp_arg = (struct async_resp_arg *)arg;
httpd_handle_t hd = resp_arg->hd;
int fd = resp_arg->fd;
const auto *resp_arg = static_cast<struct async_resp_arg *>(arg);
const auto hd = resp_arg->hd;
const auto fd = resp_arg->fd;
httpd_ws_frame_t websocket_packet = httpd_ws_frame_t{};
auto websocket_packet = httpd_ws_frame_t{};
websocket_packet.payload = (uint8_t *)log_buffer;
websocket_packet.payload = reinterpret_cast<uint8_t *>(log_buffer);
websocket_packet.len = strlen(log_buffer);
websocket_packet.type = HTTPD_WS_TYPE_TEXT;

5
components/WebSocketLogger/WebSocketLogger/WebSocketLogger.hpp
View File

@@ -20,9 +20,8 @@ namespace LoggerHelpers
class WebSocketLogger
{
private:
async_resp_arg connected_socket_client;
char ws_log_buffer[WS_LOG_BUFFER_LEN];
async_resp_arg connected_socket_client{};
char ws_log_buffer[WS_LOG_BUFFER_LEN]{};
public:
WebSocketLogger();

61
components/wifiManager/wifiManager/wifiManager.cpp
View File

@@ -1,15 +1,16 @@
#include "wifiManager.hpp"
static auto WIFI_MANAGER_TAG = "[WIFI_MANAGER]";
void WiFiManagerHelpers::event_handler(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data)
{
ESP_LOGI(WIFI_MAMANGER_TAG, "Trying to connect, got event: %d", (int)event_id);
ESP_LOGI(WIFI_MANAGER_TAG, "Trying to connect, got event: %d", (int)event_id);
if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START)
{
esp_err_t err = esp_wifi_connect();
if (err != ESP_OK)
if (const auto err = esp_wifi_connect(); err != ESP_OK)
{
ESP_LOGI(WIFI_MAMANGER_TAG, "esp_wifi_connect() failed: %s", esp_err_to_name(err));
ESP_LOGI(WIFI_MANAGER_TAG, "esp_wifi_connect() failed: %s", esp_err_to_name(err));
}
}
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED)
@@ -18,19 +19,19 @@ void WiFiManagerHelpers::event_handler(void *arg, esp_event_base_t event_base,
{
esp_wifi_connect();
s_retry_num++;
ESP_LOGI(WIFI_MAMANGER_TAG, "retry to connect to the AP");
ESP_LOGI(WIFI_MANAGER_TAG, "retry to connect to the AP");
}
else
{
xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
}
ESP_LOGI(WIFI_MAMANGER_TAG, "connect to the AP fail");
ESP_LOGI(WIFI_MANAGER_TAG, "connect to the AP fail");
}
else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP)
{
ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
ESP_LOGI(WIFI_MAMANGER_TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
const auto *event = static_cast<ip_event_got_ip_t *>(event_data);
ESP_LOGI(WIFI_MANAGER_TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
s_retry_num = 0;
xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
}
@@ -47,7 +48,7 @@ void WiFiManager::SetCredentials(const char *ssid, const char *password)
void WiFiManager::ConnectWithHardcodedCredentials()
{
SystemEvent event = {EventSource::WIFI, WiFiState_e::WiFiState_ReadyToConect};
SystemEvent event = {EventSource::WIFI, WiFiState_e::WiFiState_ReadyToConnect};
this->SetCredentials(CONFIG_WIFI_SSID, CONFIG_WIFI_PASSWORD);
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &_wifi_cfg));
@@ -67,7 +68,7 @@ void WiFiManager::ConnectWithHardcodedCredentials()
* happened. */
if (bits & WIFI_CONNECTED_BIT)
{
ESP_LOGI(WIFI_MAMANGER_TAG, "connected to ap SSID:%s password:%s",
ESP_LOGI(WIFI_MANAGER_TAG, "connected to ap SSID:%p password:%p",
_wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
event.value = WiFiState_e::WiFiState_Connected;
@@ -76,7 +77,7 @@ void WiFiManager::ConnectWithHardcodedCredentials()
else if (bits & WIFI_FAIL_BIT)
{
ESP_LOGE(WIFI_MAMANGER_TAG, "Failed to connect to SSID:%s, password:%s",
ESP_LOGE(WIFI_MANAGER_TAG, "Failed to connect to SSID:%p, password:%p",
_wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
event.value = WiFiState_e::WiFiState_Error;
@@ -84,30 +85,30 @@ void WiFiManager::ConnectWithHardcodedCredentials()
}
else
{
ESP_LOGE(WIFI_MAMANGER_TAG, "UNEXPECTED EVENT");
ESP_LOGE(WIFI_MANAGER_TAG, "UNEXPECTED EVENT");
}
}
void WiFiManager::ConnectWithStoredCredentials()
{
SystemEvent event = {EventSource::WIFI, WiFiState_e::WiFiState_ReadyToConect};
SystemEvent event = {EventSource::WIFI, WiFiState_e::WiFiState_ReadyToConnect};
auto networks = this->deviceConfig->getWifiConfigs();
auto const networks = this->deviceConfig->getWifiConfigs();
if (networks.size() == 0)
if (networks.empty())
{
event.value = WiFiState_e::WiFiState_Disconnected;
xQueueSend(this->eventQueue, &event, 10);
ESP_LOGE(WIFI_MAMANGER_TAG, "No networks stored, cannot connect");
ESP_LOGE(WIFI_MANAGER_TAG, "No networks stored, cannot connect");
return;
}
for (auto network : networks)
for (const auto& network : networks)
{
xEventGroupClearBits(s_wifi_event_group, WIFI_FAIL_BIT);
this->SetCredentials(network.ssid.c_str(), network.password.c_str());
// we need to update the config after every credentials change
// we need to update the config after every credential change
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &_wifi_cfg));
xQueueSend(this->eventQueue, &event, 10);
@@ -123,7 +124,7 @@ void WiFiManager::ConnectWithStoredCredentials()
portMAX_DELAY);
if (bits & WIFI_CONNECTED_BIT)
{
ESP_LOGI(WIFI_MAMANGER_TAG, "connected to ap SSID:%s password:%s",
ESP_LOGI(WIFI_MANAGER_TAG, "connected to ap SSID:%p password:%p",
_wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
event.value = WiFiState_e::WiFiState_Connected;
@@ -131,18 +132,18 @@ void WiFiManager::ConnectWithStoredCredentials()
return;
}
ESP_LOGE(WIFI_MAMANGER_TAG, "Failed to connect to SSID:%s, password:%s, trying next stored network",
ESP_LOGE(WIFI_MANAGER_TAG, "Failed to connect to SSID:%p, password:%p, trying next stored network",
_wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
}
event.value = WiFiState_e::WiFiState_Error;
xQueueSend(this->eventQueue, &event, 10);
ESP_LOGE(WIFI_MAMANGER_TAG, "Failed to connect to all saved networks");
ESP_LOGE(WIFI_MANAGER_TAG, "Failed to connect to all saved networks");
}
void WiFiManager::SetupAccessPoint()
{
ESP_LOGI(WIFI_MAMANGER_TAG, "Connection to stored credentials failed, starting AP");
ESP_LOGI(WIFI_MANAGER_TAG, "Connection to stored credentials failed, starting AP");
esp_netif_create_default_wifi_ap();
wifi_init_config_t esp_wifi_ap_init_config = WIFI_INIT_CONFIG_DEFAULT();
@@ -161,7 +162,7 @@ void WiFiManager::SetupAccessPoint()
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
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.");
ESP_LOGI(WIFI_MANAGER_TAG, "AP started.");
}
void WiFiManager::Begin()
@@ -178,12 +179,12 @@ void WiFiManager::Begin()
ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
ESP_EVENT_ANY_ID,
&WiFiManagerHelpers::event_handler,
NULL,
nullptr,
&instance_any_id));
ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
IP_EVENT_STA_GOT_IP,
&WiFiManagerHelpers::event_handler,
NULL,
nullptr,
&instance_got_ip));
_wifi_cfg = {};
@@ -193,24 +194,24 @@ void WiFiManager::Begin()
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
ESP_LOGI(WIFI_MAMANGER_TAG, "Beginning setup");
bool hasHardcodedCredentials = strlen(CONFIG_WIFI_SSID) > 0;
ESP_LOGI(WIFI_MANAGER_TAG, "Beginning setup");
const auto hasHardcodedCredentials = strlen(CONFIG_WIFI_SSID) > 0;
if (hasHardcodedCredentials)
{
ESP_LOGI(WIFI_MAMANGER_TAG, "Detected hardcoded credentials, trying them out");
ESP_LOGI(WIFI_MANAGER_TAG, "Detected hardcoded credentials, trying them out");
this->ConnectWithHardcodedCredentials();
}
if (this->stateManager->GetWifiState() != WiFiState_e::WiFiState_Connected || !hasHardcodedCredentials)
{
ESP_LOGI(WIFI_MAMANGER_TAG, "Hardcoded credentials failed or missing, trying stored credentials");
ESP_LOGI(WIFI_MANAGER_TAG, "Hardcoded credentials failed or missing, trying stored credentials");
xEventGroupClearBits(s_wifi_event_group, WIFI_FAIL_BIT);
this->ConnectWithStoredCredentials();
}
if (this->stateManager->GetWifiState() != WiFiState_e::WiFiState_Connected)
{
ESP_LOGI(WIFI_MAMANGER_TAG, "Stored netoworks failed or hardcoded credentials missing, starting AP");
ESP_LOGI(WIFI_MANAGER_TAG, "Stored netoworks failed or hardcoded credentials missing, starting AP");
xEventGroupClearBits(s_wifi_event_group, WIFI_FAIL_BIT);
esp_netif_destroy(netif);
this->SetupAccessPoint();

1
components/wifiManager/wifiManager/wifiManager.hpp
View File

@@ -18,7 +18,6 @@
static int s_retry_num = 0;
static EventGroupHandle_t s_wifi_event_group;
static const char *WIFI_MAMANGER_TAG = "[WIFI_MANAGER]";
namespace WiFiManagerHelpers
{

31
main/openiris_main.cpp
View File

@@ -1,4 +1,4 @@
#include <stdio.h>
#include <cstdio>
#include <string>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
@@ -6,9 +6,7 @@
#include "driver/gpio.h"
#include "esp_log.h"
#include "sdkconfig.h"
#include "esp_camera.h"
#include "nvs_flash.h"
#include "esp_psram.h"
#include <openiris_logo.hpp>
#include <wifiManager.hpp>
@@ -23,8 +21,6 @@
#include <SerialManager.hpp>
#include <RestAPI.hpp>
#include <stdarg.h>
#ifdef CONFIG_WIRED_MODE
#include <UVCStream.hpp>
#endif
@@ -32,34 +28,31 @@
#define BLINK_GPIO (gpio_num_t) CONFIG_BLINK_GPIO
#define CONFIG_LED_C_PIN_GPIO (gpio_num_t) CONFIG_LED_C_PIN
static const char *TAG = "[MAIN]";
QueueHandle_t eventQueue = xQueueCreate(10, sizeof(SystemEvent));
QueueHandle_t ledStateQueue = xQueueCreate(10, sizeof(uint32_t));
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);
auto *stateManager = new StateManager(eventQueue, ledStateQueue);
auto dependencyRegistry = std::make_shared<DependencyRegistry>();
auto commandManager = std::make_shared<CommandManager>(dependencyRegistry);
WebSocketLogger webSocketLogger;
Preferences preferences;
std::shared_ptr<ProjectConfig> deviceConfig = std::make_shared<ProjectConfig>(&preferences);
auto deviceConfig = std::make_shared<ProjectConfig>(&preferences);
WiFiManager wifiManager(deviceConfig, eventQueue, stateManager);
MDNSManager mdnsManager(deviceConfig, eventQueue);
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);
auto *restAPI = new RestAPI("http://0.0.0.0:81", commandManager);
#ifdef CONFIG_WIRED_MODE
UVCStreamManager uvcStream;
#endif
LEDManager *ledManager = new LEDManager(BLINK_GPIO, CONFIG_LED_C_PIN_GPIO, ledStateQueue);
SerialManager *serialManager = new SerialManager(commandManager);
auto *ledManager = new LEDManager(BLINK_GPIO, CONFIG_LED_C_PIN_GPIO, ledStateQueue);
auto *serialManager = new SerialManager(commandManager);
static void initNVSStorage()
{
@@ -140,7 +133,7 @@ extern "C" void app_main(void)
1024 * 2,
stateManager,
3,
NULL // it's fine for us not get a handle back, we don't need it
nullptr // it's fine for us not get a handle back, we don't need it
);
xTaskCreate(
@@ -149,7 +142,7 @@ extern "C" void app_main(void)
1024 * 2,
ledManager,
3,
NULL);
nullptr);
deviceConfig->load();
serialManager->setup();
@@ -160,7 +153,7 @@ extern "C" void app_main(void)
1024 * 6,
serialManager,
1, // we only rely on the serial manager during provisioning, we can run it slower
NULL);
nullptr);
wifiManager.Begin();
mdnsManager.start();
@@ -175,7 +168,7 @@ extern "C" void app_main(void)
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);
nullptr);
#ifdef CONFIG_WIRED_MODE
uvcStream.setup();