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

Reformat project using clang-format

Browse Source
This commit is contained in:
Lorow
2026-01-06 22:51:24 +01:00
parent 567d3ebd75
commit 555e290d71
70 changed files with 3282 additions and 3428 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.clang-format
+12
View File
@@ -0,0 +1,12 @@
BasedOnStyle: Google
IndentWidth: 4
TabWidth: 4
UseTab: Never
BreakBeforeBraces: Allman
ColumnLimit: 160
IncludeBlocks: Preserve
IndentCaseLabels: false
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Empty
AllowShortBlocksOnASingleLine: Never
bootloader_components/boot_hooks.c
+3 -5
View File
@@ -1,4 +1,5 @@
// source: https://github.com/espressif/esp-iot-solution/blob/4730d91db70df7e6e0a3191d725ab1c5f98ff9ce/examples/usb/device/usb_webcam/bootloader_components/boot_hooks/boot_hooks.c
// source:
// https://github.com/espressif/esp-iot-solution/blob/4730d91db70df7e6e0a3191d725ab1c5f98ff9ce/examples/usb/device/usb_webcam/bootloader_components/boot_hooks/boot_hooks.c
#ifdef CONFIG_GENERAL_INCLUDE_UVC_MODE
#include "esp_log.h"
@@ -9,13 +10,10 @@
* with all its symbols.
*/
void bootloader_hooks_include(void)
{
}
void bootloader_hooks_include(void) {}
void bootloader_before_init(void)
{
// Disable D+ pullup, to prevent the USB host from retrieving USB-Serial-JTAG's descriptor.
SET_PERI_REG_MASK(USB_SERIAL_JTAG_CONF0_REG, USB_SERIAL_JTAG_PAD_PULL_OVERRIDE);
CLEAR_PERI_REG_MASK(USB_SERIAL_JTAG_CONF0_REG, USB_SERIAL_JTAG_DP_PULLUP);
components/CameraManager/CameraManager/CameraManager.cpp
+12 -20
View File
@@ -1,9 +1,8 @@
#include "CameraManager.hpp"
const char *CAMERA_MANAGER_TAG = "[CAMERA_MANAGER]";
const char* CAMERA_MANAGER_TAG = "[CAMERA_MANAGER]";
CameraManager::CameraManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue)
: projectConfig(projectConfig), eventQueue(eventQueue) {}
CameraManager::CameraManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue) : projectConfig(projectConfig), eventQueue(eventQueue) {}
void CameraManager::setupCameraPinout()
{
@@ -76,7 +75,8 @@ void CameraManager::setupCameraPinout()
.ledc_channel = LEDC_CHANNEL_0,
.pixel_format = PIXFORMAT_JPEG, // YUV422,GRAYSCALE,RGB565,JPEG
.frame_size = FRAMESIZE_240X240, // QQVGA-UXGA, For ESP32, do not use sizes above QVGA when not JPEG. The performance of the ESP32-S series has improved a lot, but JPEG mode always gives better frame rates.
.frame_size = FRAMESIZE_240X240, // QQVGA-UXGA, For ESP32, do not use sizes above QVGA when not JPEG. The performance of the ESP32-S series has
// improved a lot, but JPEG mode always gives better frame rates.
.jpeg_quality = 8, // 0-63, for OV series camera sensors, lower number means higher quality // Below 6 stability problems
.fb_count = 2, // When jpeg mode is used, if fb_count more than one, the driver will work in continuous mode.
@@ -92,8 +92,7 @@ void CameraManager::setupCameraSensor()
camera_sensor = esp_camera_sensor_get();
// fixes corrupted jpegs, https://github.com/espressif/esp32-camera/issues/203
// documentation https://www.uctronics.com/download/cam_module/OV2640DS.pdf
camera_sensor->set_reg(
camera_sensor, 0xff, 0xff,
camera_sensor->set_reg(camera_sensor, 0xff, 0xff,
0x00); // banksel, here we're directly writing to the registers.
// 0xFF==0x00 is the first bank, there's also 0xFF==0x01
camera_sensor->set_reg(camera_sensor, 0xd3, 0xff, 5); // clock
@@ -130,8 +129,7 @@ void CameraManager::setupCameraSensor()
camera_sensor->set_dcw(camera_sensor, 0); // 0 = disable , 1 = enable
// gamma correction
camera_sensor->set_raw_gma(
camera_sensor,
camera_sensor->set_raw_gma(camera_sensor,
1); // 0 = disable , 1 = enable (makes much lighter and noisy)
camera_sensor->set_lenc(camera_sensor, 0); // 0 = disable , 1 = enable // 0 =
@@ -139,8 +137,7 @@ void CameraManager::setupCameraSensor()
camera_sensor->set_colorbar(camera_sensor, 0); // 0 = disable , 1 = enable
camera_sensor->set_special_effect(
camera_sensor,
camera_sensor->set_special_effect(camera_sensor,
2); // 0 to 6 (0 - No Effect, 1 - Negative, 2 - Grayscale, 3 - Red Tint,
// 4 - Green Tint, 5 - Blue Tint, 6 - Sepia)
@@ -157,17 +154,16 @@ bool CameraManager::setupCamera()
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));
ESP_LOGI(CAMERA_MANAGER_TAG, "Camera initialized: %s \r\n", esp_err_to_name(hasCameraBeenInitialized));
constexpr auto event = SystemEvent{EventSource::CAMERA, CameraState_e::Camera_Success};
xQueueSend(this->eventQueue, &event, 10);
}
else
{
ESP_LOGE(CAMERA_MANAGER_TAG, "Camera initialization failed with error: %s \r\n",
esp_err_to_name(hasCameraBeenInitialized));
ESP_LOGE(CAMERA_MANAGER_TAG, "Camera most likely not seated properly in the socket. "
ESP_LOGE(CAMERA_MANAGER_TAG, "Camera initialization failed with error: %s \r\n", esp_err_to_name(hasCameraBeenInitialized));
ESP_LOGE(CAMERA_MANAGER_TAG,
"Camera most likely not seated properly in the socket. "
"Please "
"fix the "
"camera and reboot the device.\r\n");
@@ -226,12 +222,8 @@ int CameraManager::setHFlip(const int direction)
return camera_sensor->set_hmirror(camera_sensor, direction);
}
int CameraManager::setVieWindow(int offsetX,
int offsetY,
int outputX,
int outputY)
int CameraManager::setVieWindow(int offsetX, int offsetY, int outputX, int outputY)
{
// todo safariMonkey made a PoC, implement it here
return 0;
}
components/CameraManager/CameraManager/CameraManager.hpp
+7 -7
View File
@@ -2,29 +2,29 @@
#ifndef CAMERAMANAGER_HPP
#define CAMERAMANAGER_HPP
#include "esp_log.h"
#include "esp_camera.h"
#include "driver/gpio.h"
#include "esp_camera.h"
#include "esp_log.h"
#include "esp_psram.h"
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include <StateManager.hpp>
#include <ProjectConfig.hpp>
#include <StateManager.hpp>
#define OV5640_XCLK_FREQ_HZ CONFIG_CAMERA_WIFI_XCLK_FREQ
class CameraManager
{
private:
sensor_t *camera_sensor;
private:
sensor_t* camera_sensor;
std::shared_ptr<ProjectConfig> projectConfig;
QueueHandle_t eventQueue;
camera_config_t config;
public:
public:
CameraManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue);
int setCameraResolution(framesize_t frameSize);
bool setupCamera();
@@ -32,7 +32,7 @@ public:
int setHFlip(int direction);
int setVieWindow(int offsetX, int offsetY, int outputX, int outputY);
private:
private:
void loadConfigData();
void setupCameraPinout();
void setupCameraSensor();
components/CommandManager/CommandManager/CommandManager.cpp
+25 -48
View File
@@ -30,85 +30,62 @@ std::unordered_map<std::string, CommandType> commandTypeMap = {
{"get_who_am_i", CommandType::GET_WHO_AM_I},
};
std::function<CommandResult()> CommandManager::createCommand(const CommandType type, const nlohmann::json &json) const
std::function<CommandResult()> CommandManager::createCommand(const CommandType type, const nlohmann::json& json) const
{
switch (type)
{
case CommandType::PING:
return {PingCommand};
case CommandType::PAUSE:
return [json]
{ return PauseCommand(json); };
return [json] { return PauseCommand(json); };
case CommandType::UPDATE_OTA_CREDENTIALS:
return [this, json]
{ return updateOTACredentialsCommand(this->registry, json); };
return [this, json] { return updateOTACredentialsCommand(this->registry, json); };
case CommandType::SET_WIFI:
return [this, json]
{ return setWiFiCommand(this->registry, json); };
return [this, json] { return setWiFiCommand(this->registry, json); };
case CommandType::UPDATE_WIFI:
return [this, json]
{ return updateWiFiCommand(this->registry, json); };
return [this, json] { return updateWiFiCommand(this->registry, json); };
case CommandType::UPDATE_AP_WIFI:
return [this, json]
{ return updateAPWiFiCommand(this->registry, json); };
return [this, json] { return updateAPWiFiCommand(this->registry, json); };
case CommandType::DELETE_NETWORK:
return [this, json]
{ return deleteWiFiCommand(this->registry, json); };
return [this, json] { return deleteWiFiCommand(this->registry, json); };
case CommandType::SET_MDNS:
return [this, json]
{ return setMDNSCommand(this->registry, json); };
return [this, json] { return setMDNSCommand(this->registry, json); };
case CommandType::GET_MDNS_NAME:
return [this]
{ return getMDNSNameCommand(this->registry); };
return [this] { return getMDNSNameCommand(this->registry); };
case CommandType::UPDATE_CAMERA:
return [this, json]
{ return updateCameraCommand(this->registry, json); };
return [this, json] { return updateCameraCommand(this->registry, json); };
case CommandType::GET_CONFIG:
return [this]
{ return getConfigCommand(this->registry); };
return [this] { return getConfigCommand(this->registry); };
case CommandType::SAVE_CONFIG:
return [this]
{ return saveConfigCommand(this->registry); };
return [this] { return saveConfigCommand(this->registry); };
case CommandType::RESET_CONFIG:
return [this, json]
{ return resetConfigCommand(this->registry, json); };
return [this, json] { return resetConfigCommand(this->registry, json); };
case CommandType::RESTART_DEVICE:
return restartDeviceCommand;
case CommandType::SCAN_NETWORKS:
return [this, json]
{ return scanNetworksCommand(this->registry, json); };
return [this, json] { return scanNetworksCommand(this->registry, json); };
case CommandType::START_STREAMING:
return startStreamingCommand;
case CommandType::GET_WIFI_STATUS:
return [this]
{ return getWiFiStatusCommand(this->registry); };
return [this] { return getWiFiStatusCommand(this->registry); };
case CommandType::CONNECT_WIFI:
return [this]
{ return connectWiFiCommand(this->registry); };
return [this] { return connectWiFiCommand(this->registry); };
case CommandType::SWITCH_MODE:
return [this, json]
{ return switchModeCommand(this->registry, json); };
return [this, json] { return switchModeCommand(this->registry, json); };
case CommandType::GET_DEVICE_MODE:
return [this]
{ return getDeviceModeCommand(this->registry); };
return [this] { return getDeviceModeCommand(this->registry); };
case CommandType::SET_LED_DUTY_CYCLE:
return [this, json]
{ return updateLEDDutyCycleCommand(this->registry, json); };
return [this, json] { return updateLEDDutyCycleCommand(this->registry, json); };
case CommandType::GET_LED_DUTY_CYCLE:
return [this]
{ return getLEDDutyCycleCommand(this->registry); };
return [this] { return getLEDDutyCycleCommand(this->registry); };
case CommandType::GET_SERIAL:
return [this]
{ return getSerialNumberCommand(this->registry); };
return [this] { return getSerialNumberCommand(this->registry); };
case CommandType::GET_LED_CURRENT:
return [this]
{ return getLEDCurrentCommand(this->registry); };
return [this] { return getLEDCurrentCommand(this->registry); };
case CommandType::GET_BATTERY_STATUS:
return [this]
{ return getBatteryStatusCommand(this->registry); };
return [this] { return getBatteryStatusCommand(this->registry); };
case CommandType::GET_WHO_AM_I:
return [this]
{ return getInfoCommand(this->registry); };
return [this] { return getInfoCommand(this->registry); };
default:
return nullptr;
}
@@ -129,7 +106,7 @@ CommandManagerResponse CommandManager::executeFromJson(const std::string_view js
nlohmann::json results = nlohmann::json::array();
for (auto &commandObject : parsedJson["commands"].items())
for (auto& commandObject : parsedJson["commands"].items())
{
auto commandData = commandObject.value();
if (!commandData.contains("command"))
components/CommandManager/CommandManager/CommandManager.hpp
+12 -12
View File
@@ -1,24 +1,24 @@
#ifndef COMMANDMANAGER_HPP
#define COMMANDMANAGER_HPP
#include <ProjectConfig.hpp>
#include <CameraManager.hpp>
#include <memory>
#include <string>
#include <optional>
#include <unordered_map>
#include <ProjectConfig.hpp>
#include <functional>
#include <memory>
#include <nlohmann-json.hpp>
#include <optional>
#include <string>
#include <unordered_map>
#include "CommandResult.hpp"
#include "CommandSchema.hpp"
#include "DependencyRegistry.hpp"
#include "commands/simple_commands.hpp"
#include "commands/camera_commands.hpp"
#include "commands/config_commands.hpp"
#include "commands/mdns_commands.hpp"
#include "commands/wifi_commands.hpp"
#include "commands/device_commands.hpp"
#include "commands/mdns_commands.hpp"
#include "commands/scan_commands.hpp"
#include <nlohmann-json.hpp>
#include "commands/simple_commands.hpp"
#include "commands/wifi_commands.hpp"
enum class CommandType
{
@@ -55,9 +55,9 @@ class CommandManager
{
std::shared_ptr<DependencyRegistry> registry;
public:
explicit CommandManager(const std::shared_ptr<DependencyRegistry> &DependencyRegistry) : registry(DependencyRegistry) {};
std::function<CommandResult()> createCommand(const CommandType type, const nlohmann::json &json) const;
public:
explicit CommandManager(const std::shared_ptr<DependencyRegistry>& DependencyRegistry) : registry(DependencyRegistry) {};
std::function<CommandResult()> createCommand(const CommandType type, const nlohmann::json& json) const;
CommandManagerResponse executeFromJson(std::string_view json) const;
CommandManagerResponse executeFromType(CommandType type, std::string_view json) const;
components/CommandManager/CommandManager/CommandResult.cpp
+4 -4
View File
@@ -1,24 +1,24 @@
#include "CommandResult.hpp"
void to_json(nlohmann::json &j, const CommandResult &result)
void to_json(nlohmann::json& j, const CommandResult& result)
{
j = nlohmann::json{{"status", result.isSuccess() ? "success" : "error"}, {"data", result.getData()}};
}
// defined only for interface compatibility, should not be used directly
void from_json(const nlohmann::json &j, CommandResult &result)
void from_json(const nlohmann::json& j, CommandResult& result)
{
auto message = j.at("message");
j.at("status") == "success" ? result = CommandResult::getSuccessResult(message) : result = CommandResult::getErrorResult(message);
}
void to_json(nlohmann::json &j, const CommandManagerResponse &result)
void to_json(nlohmann::json& j, const CommandManagerResponse& result)
{
j = result.getData();
}
// defined only for interface compatibility, should not be used directly
void from_json(const nlohmann::json &j, CommandManagerResponse &result)
void from_json(const nlohmann::json& j, CommandManagerResponse& result)
{
result = CommandManagerResponse(j.at("result"));
}
components/CommandManager/CommandManager/CommandResult.hpp
+23 -14
View File
@@ -2,30 +2,33 @@
#ifndef COMMAND_RESULT
#define COMMAND_RESULT
#include <format>
#include <string>
#include <algorithm>
#include <format>
#include <nlohmann-json.hpp>
#include <string>
using json = nlohmann::json;
class CommandResult
{
public:
public:
enum class Status
{
SUCCESS,
FAILURE,
};
private:
private:
nlohmann::json data;
Status status;
public:
public:
CommandResult(nlohmann::json data, const Status status) : data(data), status(status) {}
bool isSuccess() const { return status == Status::SUCCESS; }
bool isSuccess() const
{
return status == Status::SUCCESS;
}
static CommandResult getSuccessResult(nlohmann::json message)
{
@@ -37,23 +40,29 @@ public:
return CommandResult(message, Status::FAILURE);
}
nlohmann::json getData() const { return this->data; }
nlohmann::json getData() const
{
return this->data;
}
};
void to_json(nlohmann::json &j, const CommandResult &result);
void from_json(const nlohmann::json &j, CommandResult &result);
void to_json(nlohmann::json& j, const CommandResult& result);
void from_json(const nlohmann::json& j, CommandResult& result);
class CommandManagerResponse
{
private:
private:
nlohmann::json data;
public:
public:
CommandManagerResponse(nlohmann::json data) : data(data) {}
nlohmann::json getData() const { return this->data; }
nlohmann::json getData() const
{
return this->data;
}
};
void to_json(nlohmann::json &j, const CommandManagerResponse &result);
void from_json(const nlohmann::json &j, CommandManagerResponse &result);
void to_json(nlohmann::json& j, const CommandManagerResponse& result);
void from_json(const nlohmann::json& j, CommandManagerResponse& result);
#endif
components/CommandManager/CommandManager/CommandSchema.cpp
+8 -7
View File
@@ -1,11 +1,11 @@
#include "CommandSchema.hpp"
void to_json(nlohmann::json &j, const UpdateWifiPayload &payload)
void to_json(nlohmann::json& j, const UpdateWifiPayload& payload)
{
j = nlohmann::json{{"name", payload.name}, {"ssid", payload.ssid}, {"password", payload.password}, {"channel", payload.channel}, {"power", payload.power}};
}
void from_json(const nlohmann::json &j, UpdateWifiPayload &payload)
void from_json(const nlohmann::json& j, UpdateWifiPayload& payload)
{
payload.name = j.at("name").get<std::string>();
if (j.contains("ssid"))
@@ -29,12 +29,12 @@ void from_json(const nlohmann::json &j, UpdateWifiPayload &payload)
}
}
void to_json(nlohmann::json &j, const UpdateAPWiFiPayload &payload)
void to_json(nlohmann::json& j, const UpdateAPWiFiPayload& payload)
{
j = nlohmann::json{{"ssid", payload.ssid}, {"password", payload.password}, {"channel", payload.channel}};
}
void from_json(const nlohmann::json &j, UpdateAPWiFiPayload &payload)
void from_json(const nlohmann::json& j, UpdateAPWiFiPayload& payload)
{
if (j.contains("ssid"))
{
@@ -51,12 +51,13 @@ void from_json(const nlohmann::json &j, UpdateAPWiFiPayload &payload)
}
}
void to_json(nlohmann::json &j, const UpdateCameraConfigPayload &payload)
void to_json(nlohmann::json& j, const UpdateCameraConfigPayload& payload)
{
j = nlohmann::json{{"vflip", payload.vflip}, {"href", payload.href}, {"framesize", payload.framesize}, {"quality", payload.quality}, {"brightness", payload.brightness}};
j = nlohmann::json{
{"vflip", payload.vflip}, {"href", payload.href}, {"framesize", payload.framesize}, {"quality", payload.quality}, {"brightness", payload.brightness}};
}
void from_json(const nlohmann::json &j, UpdateCameraConfigPayload &payload)
void from_json(const nlohmann::json& j, UpdateCameraConfigPayload& payload)
{
if (j.contains("vflip"))
{
components/CommandManager/CommandManager/CommandSchema.hpp
+6 -6
View File
@@ -26,8 +26,8 @@ struct UpdateWifiPayload : BasePayload
std::optional<uint8_t> power;
};
void to_json(nlohmann::json &j, const UpdateWifiPayload &payload);
void from_json(const nlohmann::json &j, UpdateWifiPayload &payload);
void to_json(nlohmann::json& j, const UpdateWifiPayload& payload);
void from_json(const nlohmann::json& j, UpdateWifiPayload& payload);
struct deleteNetworkPayload : BasePayload
{
std::string name;
@@ -42,8 +42,8 @@ struct UpdateAPWiFiPayload : BasePayload
std::optional<uint8_t> channel;
};
void to_json(nlohmann::json &j, const UpdateAPWiFiPayload &payload);
void from_json(const nlohmann::json &j, UpdateAPWiFiPayload &payload);
void to_json(nlohmann::json& j, const UpdateAPWiFiPayload& payload);
void from_json(const nlohmann::json& j, UpdateAPWiFiPayload& payload);
struct MDNSPayload : BasePayload
{
std::string hostname;
@@ -61,6 +61,6 @@ struct UpdateCameraConfigPayload : BasePayload
// TODO add more options here
};
void to_json(nlohmann::json &j, const UpdateCameraConfigPayload &payload);
void from_json(const nlohmann::json &j, UpdateCameraConfigPayload &payload);
void to_json(nlohmann::json& j, const UpdateCameraConfigPayload& payload);
void from_json(const nlohmann::json& j, UpdateCameraConfigPayload& payload);
#endif
components/CommandManager/CommandManager/DependencyRegistry.hpp
+1 -1
View File
@@ -17,7 +17,7 @@ class DependencyRegistry
{
std::unordered_map<DependencyType, std::shared_ptr<void>> services;
public:
public:
template <typename ServiceType>
void registerService(DependencyType dependencyType, std::shared_ptr<ServiceType> service)
{
components/CommandManager/CommandManager/commands/camera_commands.cpp
+3 -5
View File
@@ -1,16 +1,14 @@
#include "camera_commands.hpp"
CommandResult updateCameraCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult updateCameraCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
auto payload = json.get<UpdateCameraConfigPayload>();
std::shared_ptr<ProjectConfig> projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
auto oldConfig = projectConfig->getCameraConfig();
projectConfig->setCameraConfig(
payload.vflip.has_value() ? payload.vflip.value() : oldConfig.vflip,
payload.framesize.has_value() ? payload.framesize.value() : oldConfig.framesize,
payload.href.has_value() ? payload.href.value() : oldConfig.href,
payload.quality.has_value() ? payload.quality.value() : oldConfig.quality,
payload.vflip.has_value() ? payload.vflip.value() : oldConfig.vflip, payload.framesize.has_value() ? payload.framesize.value() : oldConfig.framesize,
payload.href.has_value() ? payload.href.value() : oldConfig.href, payload.quality.has_value() ? payload.quality.value() : oldConfig.quality,
payload.brightness.has_value() ? payload.brightness.value() : oldConfig.brightness);
return CommandResult::getSuccessResult("Config updated");
components/CommandManager/CommandManager/commands/camera_commands.hpp
+4 -4
View File
@@ -1,16 +1,16 @@
#ifndef CAMERA_COMMANDS_HPP
#define CAMERA_COMMANDS_HPP
#include <CameraManager.hpp>
#include <ProjectConfig.hpp>
#include <memory>
#include <string>
#include <nlohmann-json.hpp>
#include <optional>
#include <string>
#include "CommandResult.hpp"
#include "CommandSchema.hpp"
#include "DependencyRegistry.hpp"
#include <CameraManager.hpp>
#include <nlohmann-json.hpp>
CommandResult updateCameraCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult updateCameraCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
#endif
components/CommandManager/CommandManager/commands/config_commands.cpp
+1 -1
View File
@@ -16,7 +16,7 @@ CommandResult getConfigCommand(std::shared_ptr<DependencyRegistry> registry)
return CommandResult::getSuccessResult(configRepresentation);
}
CommandResult resetConfigCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult resetConfigCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
std::array<std::string, 4> supported_sections = {
"all",
components/CommandManager/CommandManager/commands/config_commands.hpp
+3 -3
View File
@@ -1,13 +1,13 @@
#include <ProjectConfig.hpp>
#include <memory>
#include <string>
#include <nlohmann-json.hpp>
#include <optional>
#include <string>
#include "CommandResult.hpp"
#include "CommandSchema.hpp"
#include "DependencyRegistry.hpp"
#include <nlohmann-json.hpp>
CommandResult saveConfigCommand(std::shared_ptr<DependencyRegistry> registry);
CommandResult getConfigCommand(std::shared_ptr<DependencyRegistry> registry);
CommandResult resetConfigCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult resetConfigCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
components/CommandManager/CommandManager/commands/device_commands.cpp
+11 -18
View File
@@ -1,10 +1,10 @@
#include "device_commands.hpp"
#include <cstdio>
#include "LEDManager.hpp"
#include "MonitoringManager.hpp"
#include "esp_mac.h"
#include <cstdio>
CommandResult setDeviceModeCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult setDeviceModeCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
if (!json.contains("mode") || !json["mode"].is_number_integer())
{
@@ -23,9 +23,8 @@ CommandResult setDeviceModeCommand(std::shared_ptr<DependencyRegistry> registry,
return CommandResult::getSuccessResult("Device mode set");
}
CommandResult updateOTACredentialsCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult updateOTACredentialsCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
const auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
const auto oldDeviceConfig = projectConfig->getDeviceConfig();
auto OTALogin = oldDeviceConfig.OTALogin;
@@ -57,7 +56,7 @@ CommandResult updateOTACredentialsCommand(std::shared_ptr<DependencyRegistry> re
return CommandResult::getSuccessResult("OTA Config set");
}
CommandResult updateLEDDutyCycleCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult updateLEDDutyCycleCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
if (!json.contains("dutyCycle") || !json["dutyCycle"].is_number_integer())
{
@@ -105,10 +104,7 @@ CommandResult startStreamingCommand()
// from *inside* the serial handler, we'd deadlock.
// we can just pass nullptr to the vtaskdelete(),
// but then we won't get any response, so we schedule a timer instead
esp_timer_create_args_t args{
.callback = activateStreaming,
.arg = nullptr,
.name = "activateStreaming"};
esp_timer_create_args_t args{.callback = activateStreaming, .arg = nullptr, .name = "activateStreaming"};
esp_timer_handle_t activateStreamingTimer;
esp_timer_create(&args, &activateStreamingTimer);
@@ -117,9 +113,8 @@ CommandResult startStreamingCommand()
return CommandResult::getSuccessResult("Streaming starting");
}
CommandResult switchModeCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult switchModeCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
if (!json.contains("mode") || !json["mode"].is_string())
{
return CommandResult::getErrorResult("Invalid payload - missing mode");
@@ -159,7 +154,7 @@ CommandResult getDeviceModeCommand(std::shared_ptr<DependencyRegistry> registry)
const auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
StreamingMode currentMode = projectConfig->getDeviceMode();
const char *modeStr = "unknown";
const char* modeStr = "unknown";
switch (currentMode)
{
case StreamingMode::UVC:
@@ -188,13 +183,11 @@ CommandResult getSerialNumberCommand(std::shared_ptr<DependencyRegistry> /*regis
char serial_no_sep[13];
// Serial without separators (12 hex chars)
std::snprintf(serial_no_sep, sizeof(serial_no_sep), "%02X%02X%02X%02X%02X%02X",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
std::snprintf(serial_no_sep, sizeof(serial_no_sep), "%02X%02X%02X%02X%02X%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
char mac_colon[18];
// MAC with colons
std::snprintf(mac_colon, sizeof(mac_colon), "%02X:%02X:%02X:%02X:%02X:%02X",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
std::snprintf(mac_colon, sizeof(mac_colon), "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
const auto json = nlohmann::json{
{"serial", serial_no_sep},
@@ -246,8 +239,8 @@ CommandResult getBatteryStatusCommand(std::shared_ptr<DependencyRegistry> regist
CommandResult getInfoCommand(std::shared_ptr<DependencyRegistry> /*registry*/)
{
const char *who = CONFIG_GENERAL_BOARD;
const char *ver = CONFIG_GENERAL_VERSION;
const char* who = CONFIG_GENERAL_BOARD;
const char* ver = CONFIG_GENERAL_VERSION;
// Ensure non-null strings
if (!who)
who = "";
components/CommandManager/CommandManager/commands/device_commands.hpp
+6 -6
View File
@@ -1,24 +1,24 @@
#include "CommandResult.hpp"
#include "ProjectConfig.hpp"
#include "OpenIrisTasks.hpp"
#include "DependencyRegistry.hpp"
#include "OpenIrisTasks.hpp"
#include "ProjectConfig.hpp"
#include "esp_timer.h"
#include "main_globals.hpp"
#include <format>
#include <string>
#include <nlohmann-json.hpp>
#include <string>
CommandResult updateOTACredentialsCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult updateOTACredentialsCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
CommandResult updateLEDDutyCycleCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult updateLEDDutyCycleCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
CommandResult getLEDDutyCycleCommand(std::shared_ptr<DependencyRegistry> registry);
CommandResult restartDeviceCommand();
CommandResult startStreamingCommand();
CommandResult switchModeCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult switchModeCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
CommandResult getDeviceModeCommand(std::shared_ptr<DependencyRegistry> registry);
components/CommandManager/CommandManager/commands/mdns_commands.cpp
+1 -1
View File
@@ -1,6 +1,6 @@
#include "mdns_commands.hpp"
CommandResult setMDNSCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult setMDNSCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
const auto payload = json.get<MDNSPayload>();
if (payload.hostname.empty())
components/CommandManager/CommandManager/commands/mdns_commands.hpp
+3 -3
View File
@@ -1,11 +1,11 @@
#include <ProjectConfig.hpp>
#include <memory>
#include <string>
#include <nlohmann-json.hpp>
#include <optional>
#include <string>
#include "CommandResult.hpp"
#include "CommandSchema.hpp"
#include "DependencyRegistry.hpp"
#include <nlohmann-json.hpp>
CommandResult setMDNSCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult setMDNSCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
CommandResult getMDNSNameCommand(std::shared_ptr<DependencyRegistry> registry);
components/CommandManager/CommandManager/commands/scan_commands.cpp
+3 -5
View File
@@ -1,7 +1,7 @@
#include "scan_commands.hpp"
#include "sdkconfig.h"
CommandResult scanNetworksCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult scanNetworksCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
#if !CONFIG_GENERAL_ENABLE_WIRELESS
return CommandResult::getErrorResult("Not supported by current firmware");
@@ -24,16 +24,14 @@ CommandResult scanNetworksCommand(std::shared_ptr<DependencyRegistry> registry,
nlohmann::json result;
std::vector<nlohmann::json> networksJson;
for (const auto &network : networks)
for (const auto& network : networks)
{
nlohmann::json networkItem;
networkItem["ssid"] = network.ssid;
networkItem["channel"] = network.channel;
networkItem["rssi"] = network.rssi;
char mac_str[18];
sprintf(mac_str, "%02x:%02x:%02x:%02x:%02x:%02x",
network.mac[0], network.mac[1], network.mac[2],
network.mac[3], network.mac[4], network.mac[5]);
sprintf(mac_str, "%02x:%02x:%02x:%02x:%02x:%02x", network.mac[0], network.mac[1], network.mac[2], network.mac[3], network.mac[4], network.mac[5]);
networkItem["mac_address"] = mac_str;
networkItem["auth_mode"] = network.auth_mode;
networksJson.push_back(networkItem);
components/CommandManager/CommandManager/commands/scan_commands.hpp
+4 -4
View File
@@ -1,13 +1,13 @@
#ifndef SCAN_COMMANDS_HPP
#define SCAN_COMMANDS_HPP
#include <nlohmann-json.hpp>
#include <string>
#include <wifiManager.hpp>
#include "CommandResult.hpp"
#include "DependencyRegistry.hpp"
#include "esp_log.h"
#include <wifiManager.hpp>
#include <string>
#include <nlohmann-json.hpp>
CommandResult scanNetworksCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult scanNetworksCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
#endif
components/CommandManager/CommandManager/commands/simple_commands.cpp
+2 -2
View File
@@ -1,13 +1,13 @@
#include "simple_commands.hpp"
static const char *TAG = "SimpleCommands";
static const char* TAG = "SimpleCommands";
CommandResult PingCommand()
{
return CommandResult::getSuccessResult("pong");
};
CommandResult PauseCommand(const nlohmann::json &json)
CommandResult PauseCommand(const nlohmann::json& json)
{
auto pause = true;
components/CommandManager/CommandManager/commands/simple_commands.hpp
+3 -3
View File
@@ -1,13 +1,13 @@
#ifndef SIMPLE_COMMANDS
#define SIMPLE_COMMANDS
#include <nlohmann-json.hpp>
#include <string>
#include "CommandResult.hpp"
#include "main_globals.hpp"
#include "esp_log.h"
#include <nlohmann-json.hpp>
#include "main_globals.hpp"
CommandResult PingCommand();
CommandResult PauseCommand(const nlohmann::json &json);
CommandResult PauseCommand(const nlohmann::json& json);
#endif
components/CommandManager/CommandManager/commands/wifi_commands.cpp
+9 -20
View File
@@ -2,7 +2,7 @@
#include "esp_netif.h"
#include "sdkconfig.h"
CommandResult setWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult setWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
#if !CONFIG_GENERAL_ENABLE_WIRELESS
return CommandResult::getErrorResult("Not supported by current firmware");
@@ -20,17 +20,12 @@ CommandResult setWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const
}
std::shared_ptr<ProjectConfig> projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
projectConfig->setWifiConfig(
payload.name,
payload.ssid,
payload.password,
payload.channel,
payload.power);
projectConfig->setWifiConfig(payload.name, payload.ssid, payload.password, payload.channel, payload.power);
return CommandResult::getSuccessResult("Config updated");
}
CommandResult deleteWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult deleteWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
#if !CONFIG_GENERAL_ENABLE_WIRELESS
return CommandResult::getErrorResult("Not supported by current firmware");
@@ -46,7 +41,7 @@ CommandResult deleteWiFiCommand(std::shared_ptr<DependencyRegistry> registry, co
return CommandResult::getSuccessResult("Config updated");
}
CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
#if !CONFIG_GENERAL_ENABLE_WIRELESS
return CommandResult::getErrorResult("Not supported by current firmware");
@@ -60,15 +55,10 @@ CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, co
auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
auto storedNetworks = projectConfig->getWifiConfigs();
if (const auto networkToUpdate = std::ranges::find_if(
storedNetworks,
[&](auto &network)
{ return network.name == payload.name; });
if (const auto networkToUpdate = std::ranges::find_if(storedNetworks, [&](auto& network) { return network.name == payload.name; });
networkToUpdate != storedNetworks.end())
{
projectConfig->setWifiConfig(
payload.name,
payload.ssid.has_value() ? payload.ssid.value() : networkToUpdate->ssid,
projectConfig->setWifiConfig(payload.name, payload.ssid.has_value() ? payload.ssid.value() : networkToUpdate->ssid,
payload.password.has_value() ? payload.password.value() : networkToUpdate->password,
payload.channel.has_value() ? payload.channel.value() : networkToUpdate->channel,
payload.power.has_value() ? payload.power.value() : networkToUpdate->power);
@@ -79,7 +69,7 @@ CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, co
return CommandResult::getErrorResult("Requested network does not exist");
}
CommandResult updateAPWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json)
CommandResult updateAPWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json)
{
#if !CONFIG_GENERAL_ENABLE_WIRELESS
return CommandResult::getErrorResult("Not supported by current firmware");
@@ -90,8 +80,7 @@ CommandResult updateAPWiFiCommand(std::shared_ptr<DependencyRegistry> registry,
auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
const auto previousAPConfig = projectConfig->getAPWifiConfig();
projectConfig->setAPWifiConfig(
payload.ssid.has_value() ? payload.ssid.value() : previousAPConfig.ssid,
projectConfig->setAPWifiConfig(payload.ssid.has_value() ? payload.ssid.value() : previousAPConfig.ssid,
payload.password.has_value() ? payload.password.value() : previousAPConfig.password,
payload.channel.has_value() ? payload.channel.value() : previousAPConfig.channel);
@@ -143,7 +132,7 @@ CommandResult getWiFiStatusCommand(std::shared_ptr<DependencyRegistry> registry)
{
// Get IP address from ESP32
esp_netif_ip_info_t ip_info;
esp_netif_t *netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
esp_netif_t* netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
if (netif && esp_netif_get_ip_info(netif, &ip_info) == ESP_OK)
{
char ip_str[16];
components/CommandManager/CommandManager/commands/wifi_commands.hpp
+7 -7
View File
@@ -1,21 +1,21 @@
#include <ProjectConfig.hpp>
#include <wifiManager.hpp>
#include <StateManager.hpp>
#include <memory>
#include <string>
#include <nlohmann-json.hpp>
#include <optional>
#include <string>
#include <wifiManager.hpp>
#include "CommandResult.hpp"
#include "CommandSchema.hpp"
#include "DependencyRegistry.hpp"
#include <nlohmann-json.hpp>
CommandResult setWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult setWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
CommandResult deleteWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult deleteWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
CommandResult updateAPWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json &json);
CommandResult updateAPWiFiCommand(std::shared_ptr<DependencyRegistry> registry, const nlohmann::json& json);
CommandResult getWiFiStatusCommand(std::shared_ptr<DependencyRegistry> registry);
CommandResult connectWiFiCommand(std::shared_ptr<DependencyRegistry> registry);
components/Helpers/Helpers/helpers.cpp
+3 -3
View File
@@ -1,6 +1,6 @@
#include "helpers.hpp"
char *Helpers::itoa(int value, char *result, int base)
char* Helpers::itoa(int value, char* result, int base)
{
// check that the base if valid
if (base < 2 || base > 36)
@@ -32,7 +32,7 @@ char *Helpers::itoa(int value, char *result, int base)
return result;
}
void split(const std::string &str, const std::string &splitBy, std::vector<std::string> &tokens)
void split(const std::string& str, const std::string& splitBy, std::vector<std::string>& tokens)
{
/* Store the original string in the array, so we can loop the rest
* of the algorithm. */
@@ -67,7 +67,7 @@ void split(const std::string &str, const std::string &splitBy, std::vector<std::
}
}
std::vector<std::string> Helpers::split(const std::string &s, char delimiter)
std::vector<std::string> Helpers::split(const std::string& s, char delimiter)
{
std::vector<std::string> parts;
std::string part;
components/Helpers/Helpers/helpers.hpp
+18 -18
View File
@@ -1,27 +1,27 @@
#pragma once
#ifndef HELPERS_HPP
#define HELPERS_HPP
#include "esp_timer.h"
#include <string>
#include <sstream>
#include <vector>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include "esp_timer.h"
namespace Helpers
{
char *itoa(int value, char *result, int base);
void split(std::string str, std::string splitBy, std::vector<std::string> &tokens);
std::vector<std::string> split(const std::string &s, char delimiter);
char* itoa(int value, char* result, int base);
void split(std::string str, std::string splitBy, std::vector<std::string>& tokens);
std::vector<std::string> split(const std::string& s, char delimiter);
/// @brief
/// @tparam ...Args
/// @param format
/// @param ...args
/// @return
template <typename... Args>
std::string format_string(const std::string &format, Args... args)
{
/// @brief
/// @tparam ...Args
/// @param format
/// @param ...args
/// @return
template <typename... Args>
std::string format_string(const std::string& format, Args... args)
{
int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1; // Extra space for '\0'
if (size_s <= 0)
{
@@ -32,9 +32,9 @@ namespace Helpers
std::unique_ptr<char[]> buf(new char[size]);
std::snprintf(buf.get(), size, format.c_str(), args...);
return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
}
int64_t getTimeInMillis();
}
int64_t getTimeInMillis();
} // namespace Helpers
#endif // HELPERS_HPP
components/Helpers/Helpers/main_globals.cpp
+9 -3
View File
@@ -28,12 +28,18 @@ void setStartupPaused(bool startupPaused)
}
// Function to manually activate streaming
void activateStreaming(void *arg)
void activateStreaming(void* arg)
{
force_activate_streaming();
}
// USB handover state
static bool s_usbHandoverDone = false;
bool getUsbHandoverDone() { return s_usbHandoverDone; }
void setUsbHandoverDone(bool done) { s_usbHandoverDone = done; }
bool getUsbHandoverDone()
{
return s_usbHandoverDone;
}
void setUsbHandoverDone(bool done)
{
s_usbHandoverDone = done;
}
components/Helpers/Helpers/main_globals.hpp
+1 -1
View File
@@ -9,7 +9,7 @@
// Function to manually activate streaming
// designed to be scheduled as a task
// so that the serial manager has time to return the response
void activateStreaming(void *arg);
void activateStreaming(void* arg);
bool getStartupCommandReceived();
void setStartupCommandReceived(bool startupCommandReceived);
components/LEDManager/LEDManager/LEDManager.cpp
+14 -19
View File
@@ -1,6 +1,6 @@
#include "LEDManager.hpp"
const char *LED_MANAGER_TAG = "[LED_MANAGER]";
const char* LED_MANAGER_TAG = "[LED_MANAGER]";
// Pattern design rules:
// - Error states: isError=true, repeat indefinitely, easily distinguishable (avoid overlap).
@@ -8,21 +8,21 @@ const char *LED_MANAGER_TAG = "[LED_MANAGER]";
// - Non-repeating notification (e.g. Connected) gives user a brief confirmation burst then turns off.
// Durations in ms.
ledStateMap_t LEDManager::ledStateMap = {
{ LEDStates_e::LedStateNone, { /*isError*/false, /*repeat*/false, {{LED_OFF, 1000}} } },
{ LEDStates_e::LedStateStreaming, { false, /*repeat steady*/true, {{LED_ON, 1000}} } },
{ LEDStates_e::LedStateStoppedStreaming, { false, true, {{LED_OFF, 1000}} } },
{LEDStates_e::LedStateNone, {/*isError*/ false, /*repeat*/ false, {{LED_OFF, 1000}}}},
{LEDStates_e::LedStateStreaming, {false, /*repeat steady*/ true, {{LED_ON, 1000}}}},
{LEDStates_e::LedStateStoppedStreaming, {false, true, {{LED_OFF, 1000}}}},
// CameraError: double blink pattern repeating
{ LEDStates_e::CameraError, { true, true, {{ {LED_ON,300}, {LED_OFF,300}, {LED_ON,300}, {LED_OFF,700} }} } },
{LEDStates_e::CameraError, {true, true, {{{LED_ON, 300}, {LED_OFF, 300}, {LED_ON, 300}, {LED_OFF, 700}}}}},
// WiFiStateConnecting: balanced slow blink 400/400
{ LEDStates_e::WiFiStateConnecting, { false, true, {{ {LED_ON,400}, {LED_OFF,400} }} } },
{LEDStates_e::WiFiStateConnecting, {false, true, {{{LED_ON, 400}, {LED_OFF, 400}}}}},
// WiFiStateConnected: short 3 quick flashes then done (was long noisy burst before)
{ LEDStates_e::WiFiStateConnected, { false, false, {{ {LED_ON,150}, {LED_OFF,150}, {LED_ON,150}, {LED_OFF,150}, {LED_ON,150}, {LED_OFF,600} }} } },
{LEDStates_e::WiFiStateConnected, {false, false, {{{LED_ON, 150}, {LED_OFF, 150}, {LED_ON, 150}, {LED_OFF, 150}, {LED_ON, 150}, {LED_OFF, 600}}}}},
// WiFiStateError: asymmetric attention pattern (fast, pause, long, pause, fast)
{ LEDStates_e::WiFiStateError, { true, true, {{ {LED_ON,200}, {LED_OFF,100}, {LED_ON,500}, {LED_OFF,300} }} } },
{LEDStates_e::WiFiStateError, {true, true, {{{LED_ON, 200}, {LED_OFF, 100}, {LED_ON, 500}, {LED_OFF, 300}}}}},
};
LEDManager::LEDManager(gpio_num_t pin, gpio_num_t illumninator_led_pin,
QueueHandle_t ledStateQueue, std::shared_ptr<ProjectConfig> deviceConfig) : blink_led_pin(pin),
LEDManager::LEDManager(gpio_num_t pin, gpio_num_t illumninator_led_pin, QueueHandle_t ledStateQueue, std::shared_ptr<ProjectConfig> deviceConfig)
: blink_led_pin(pin),
illumninator_led_pin(illumninator_led_pin),
ledStateQueue(ledStateQueue),
currentState(LEDStates_e::LedStateNone),
@@ -52,16 +52,11 @@ void LEDManager::setup()
ESP_LOGI(LED_MANAGER_TAG, "Setting dutyCycle to: %lu ", dutyCycle);
ledc_timer_config_t ledc_timer = {
.speed_mode = LEDC_LOW_SPEED_MODE,
.duty_resolution = resolution,
.timer_num = LEDC_TIMER_0,
.freq_hz = freq,
.clk_cfg = LEDC_AUTO_CLK};
.speed_mode = LEDC_LOW_SPEED_MODE, .duty_resolution = resolution, .timer_num = LEDC_TIMER_0, .freq_hz = freq, .clk_cfg = LEDC_AUTO_CLK};
ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer));
ledc_channel_config_t ledc_channel = {
.gpio_num = this->illumninator_led_pin,
ledc_channel_config_t ledc_channel = {.gpio_num = this->illumninator_led_pin,
.speed_mode = LEDC_LOW_SPEED_MODE,
.channel = LEDC_CHANNEL_0,
.intr_type = LEDC_INTR_DISABLE,
@@ -195,9 +190,9 @@ void LEDManager::setExternalLEDDutyCycle(uint8_t dutyPercent)
#endif
}
void HandleLEDDisplayTask(void *pvParameter)
void HandleLEDDisplayTask(void* pvParameter)
{
auto *ledManager = static_cast<LEDManager *>(pvParameter);
auto* ledManager = static_cast<LEDManager*>(pvParameter);
TickType_t lastWakeTime = xTaskGetTickCount();
while (true)
components/LEDManager/LEDManager/LEDManager.hpp
+15 -10
View File
@@ -11,13 +11,13 @@
#endif
#include <esp_log.h>
#include <ProjectConfig.hpp>
#include <StateManager.hpp>
#include <algorithm>
#include <cstdint>
#include <helpers.hpp>
#include <unordered_map>
#include <vector>
#include <StateManager.hpp>
#include <ProjectConfig.hpp>
#include <helpers.hpp>
// it kinda looks like different boards have these states swapped
#define LED_OFF 1
@@ -36,23 +36,28 @@ struct LEDStage
std::vector<BlinkPatterns_t> patterns;
};
typedef std::unordered_map<LEDStates_e, LEDStage>
ledStateMap_t;
typedef std::unordered_map<LEDStates_e, LEDStage> ledStateMap_t;
class LEDManager
{
public:
public:
LEDManager(gpio_num_t blink_led_pin, gpio_num_t illumninator_led_pin, QueueHandle_t ledStateQueue, std::shared_ptr<ProjectConfig> deviceConfig);
void setup();
void handleLED();
size_t getTimeToDelayFor() const { return timeToDelayFor; }
size_t getTimeToDelayFor() const
{
return timeToDelayFor;
}
// Apply new external LED PWM duty cycle immediately (0-100)
void setExternalLEDDutyCycle(uint8_t dutyPercent);
uint8_t getExternalLEDDutyCycle() const { return deviceConfig ? deviceConfig->getDeviceConfig().led_external_pwm_duty_cycle : 0; }
uint8_t getExternalLEDDutyCycle() const
{
return deviceConfig ? deviceConfig->getDeviceConfig().led_external_pwm_duty_cycle : 0;
}
private:
private:
void toggleLED(bool state) const;
void displayCurrentPattern();
void updateState(LEDStates_e newState);
@@ -77,5 +82,5 @@ private:
#endif
};
void HandleLEDDisplayTask(void *pvParameter);
void HandleLEDDisplayTask(void* pvParameter);
#endif
components/MDNSManager/MDNSManager/MDNSManager.cpp
+2 -2
View File
@@ -1,12 +1,12 @@
#include "MDNSManager.hpp"
static const char *MDNS_MANAGER_TAG = "[MDNS MANAGER]";
static const char* MDNS_MANAGER_TAG = "[MDNS MANAGER]";
MDNSManager::MDNSManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue) : projectConfig(projectConfig), eventQueue(eventQueue) {}
esp_err_t MDNSManager::start()
{
const std::string &mdnsName = "_openiristracker";
const std::string& mdnsName = "_openiristracker";
{
SystemEvent event = {EventSource::MDNS, MDNSState_e::MDNSState_Starting};
components/MDNSManager/MDNSManager/MDNSManager.hpp
+3 -3
View File
@@ -1,9 +1,9 @@
#pragma once
#ifndef MDNSMANAGER_HPP
#define MDNSMANAGER_HPP
#include <string>
#include <ProjectConfig.hpp>
#include <StateManager.hpp>
#include <string>
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
@@ -11,11 +11,11 @@
class MDNSManager
{
private:
private:
std::shared_ptr<ProjectConfig> projectConfig;
QueueHandle_t eventQueue;
public:
public:
MDNSManager(std::shared_ptr<ProjectConfig> projectConfig, QueueHandle_t eventQueue);
esp_err_t start();
};
components/Monitoring/Monitoring/AdcSampler.cpp
+8 -9
View File
@@ -13,7 +13,7 @@
#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32)
#include <esp_log.h>
static const char *TAG = "[AdcSampler]";
static const char* TAG = "[AdcSampler]";
// Static member initialization
adc_oneshot_unit_handle_t AdcSampler::shared_unit_ = nullptr;
@@ -22,11 +22,11 @@ AdcSampler::~AdcSampler()
{
if (cali_handle_)
{
#if defined(CONFIG_IDF_TARGET_ESP32S3)
#if defined(CONFIG_IDF_TARGET_ESP32S3)
adc_cali_delete_scheme_curve_fitting(cali_handle_);
#elif defined(CONFIG_IDF_TARGET_ESP32)
#elif defined(CONFIG_IDF_TARGET_ESP32)
adc_cali_delete_scheme_line_fitting(cali_handle_);
#endif
#endif
cali_handle_ = nullptr;
}
}
@@ -69,7 +69,7 @@ bool AdcSampler::init(int gpio, adc_atten_t atten, adc_bitwidth_t bitwidth, size
// ESP32-S3 uses curve-fitting, ESP32 uses line-fitting
esp_err_t cal_err = ESP_FAIL;
#if defined(CONFIG_IDF_TARGET_ESP32S3)
#if defined(CONFIG_IDF_TARGET_ESP32S3)
// ESP32-S3 curve fitting calibration
adc_cali_curve_fitting_config_t cal_cfg = {
.unit_id = unit_,
@@ -78,7 +78,7 @@ bool AdcSampler::init(int gpio, adc_atten_t atten, adc_bitwidth_t bitwidth, size
.bitwidth = bitwidth_,
};
cal_err = adc_cali_create_scheme_curve_fitting(&cal_cfg, &cali_handle_);
#elif defined(CONFIG_IDF_TARGET_ESP32)
#elif defined(CONFIG_IDF_TARGET_ESP32)
// ESP32 line-fitting calibration is per-unit, not per-channel
adc_cali_line_fitting_config_t cal_cfg = {
.unit_id = unit_,
@@ -86,7 +86,7 @@ bool AdcSampler::init(int gpio, adc_atten_t atten, adc_bitwidth_t bitwidth, size
.bitwidth = bitwidth_,
};
cal_err = adc_cali_create_scheme_line_fitting(&cal_cfg, &cali_handle_);
#endif
#endif
if (cal_err == ESP_OK)
{
@@ -187,8 +187,7 @@ bool AdcSampler::configure_channel(int gpio, adc_atten_t atten, adc_bitwidth_t b
esp_err_t err = adc_oneshot_config_channel(shared_unit_, channel_, &chan_cfg);
if (err != ESP_OK)
{
ESP_LOGE(TAG, "adc_oneshot_config_channel failed (GPIO %d, CH %d): %s",
gpio, static_cast<int>(channel_), esp_err_to_name(err));
ESP_LOGE(TAG, "adc_oneshot_config_channel failed (GPIO %d, CH %d): %s", gpio, static_cast<int>(channel_), esp_err_to_name(err));
return false;
}
return true;
components/Monitoring/Monitoring/AdcSampler.hpp
+35 -20
View File
@@ -21,10 +21,10 @@
#include "sdkconfig.h"
#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32)
#include "esp_adc/adc_oneshot.h"
#include <vector>
#include "esp_adc/adc_cali.h"
#include "esp_adc/adc_cali_scheme.h"
#include <vector>
#include "esp_adc/adc_oneshot.h"
/**
* @class AdcSampler
@@ -35,15 +35,15 @@
*/
class AdcSampler
{
public:
public:
AdcSampler() = default;
~AdcSampler();
// Non-copyable, non-movable (owns hardware resources)
AdcSampler(const AdcSampler &) = delete;
AdcSampler &operator=(const AdcSampler &) = delete;
AdcSampler(AdcSampler &&) = delete;
AdcSampler &operator=(AdcSampler &&) = delete;
AdcSampler(const AdcSampler&) = delete;
AdcSampler& operator=(const AdcSampler&) = delete;
AdcSampler(AdcSampler&&) = delete;
AdcSampler& operator=(AdcSampler&&) = delete;
/**
* @brief Initialize the ADC channel on the shared ADC1 oneshot unit
@@ -53,10 +53,7 @@ public:
* @param window_size Moving average window size (>=1)
* @return true on success, false on failure
*/
bool init(int gpio,
adc_atten_t atten = ADC_ATTEN_DB_12,
adc_bitwidth_t bitwidth = ADC_BITWIDTH_DEFAULT,
size_t window_size = 1);
bool init(int gpio, adc_atten_t atten = ADC_ATTEN_DB_12, adc_bitwidth_t bitwidth = ADC_BITWIDTH_DEFAULT, size_t window_size = 1);
/**
* @brief Perform one ADC conversion and update filtered value
@@ -68,15 +65,21 @@ public:
* @brief Get the filtered ADC reading in millivolts
* @return Filtered voltage in mV
*/
int getFilteredMilliVolts() const { return filtered_mv_; }
int getFilteredMilliVolts() const
{
return filtered_mv_;
}
/**
* @brief Check if ADC sampling is supported on current platform
* @return true if supported
*/
static constexpr bool isSupported() { return true; }
static constexpr bool isSupported()
{
return true;
}
private:
private:
// Hardware initialization helpers
bool ensure_unit();
bool configure_channel(int gpio, adc_atten_t atten, adc_bitwidth_t bitwidth);
@@ -85,7 +88,7 @@ private:
* @brief Platform-specific GPIO to ADC channel mapping
* @note Implemented separately in AdcSampler_esp32.cpp and AdcSampler_esp32s3.cpp
*/
static bool map_gpio_to_channel(int gpio, adc_unit_t &unit, adc_channel_t &channel);
static bool map_gpio_to_channel(int gpio, adc_unit_t& unit, adc_channel_t& channel);
// Shared ADC1 oneshot handle (single instance for all AdcSampler objects)
static adc_oneshot_unit_handle_t shared_unit_;
@@ -110,10 +113,22 @@ private:
// Stub for unsupported targets to keep interfaces consistent
class AdcSampler
{
public:
bool init(int /*gpio*/, int /*atten*/ = 0, int /*bitwidth*/ = 0, size_t /*window_size*/ = 1) { return false; }
bool sampleOnce() { return false; }
int getFilteredMilliVolts() const { return 0; }
static constexpr bool isSupported() { return false; }
public:
bool init(int /*gpio*/, int /*atten*/ = 0, int /*bitwidth*/ = 0, size_t /*window_size*/ = 1)
{
return false;
}
bool sampleOnce()
{
return false;
}
int getFilteredMilliVolts() const
{
return 0;
}
static constexpr bool isSupported()
{
return false;
}
};
#endif
components/Monitoring/Monitoring/AdcSampler_esp32.cpp
+1 -1
View File
@@ -19,7 +19,7 @@
#if defined(CONFIG_IDF_TARGET_ESP32)
bool AdcSampler::map_gpio_to_channel(int gpio, adc_unit_t &unit, adc_channel_t &channel)
bool AdcSampler::map_gpio_to_channel(int gpio, adc_unit_t& unit, adc_channel_t& channel)
{
unit = ADC_UNIT_1; // Only use ADC1 to avoid Wi-Fi conflict
components/Monitoring/Monitoring/AdcSampler_esp32s3.cpp
+1 -1
View File
@@ -21,7 +21,7 @@
#if defined(CONFIG_IDF_TARGET_ESP32S3)
bool AdcSampler::map_gpio_to_channel(int gpio, adc_unit_t &unit, adc_channel_t &channel)
bool AdcSampler::map_gpio_to_channel(int gpio, adc_unit_t& unit, adc_channel_t& channel)
{
unit = ADC_UNIT_1; // Only use ADC1 to avoid Wi-Fi conflict
components/Monitoring/Monitoring/BatteryMonitor.cpp
+3 -3
View File
@@ -9,7 +9,7 @@
#include "BatteryMonitor.hpp"
#include <esp_log.h>
static const char *TAG = "[BatteryMonitor]";
static const char* TAG = "[BatteryMonitor]";
bool BatteryMonitor::setup()
{
@@ -86,8 +86,8 @@ float BatteryMonitor::voltageToPercentage(int voltage_mv)
// Linear interpolation between lookup table points
for (size_t i = 0; i < soc_lookup_.size() - 1; ++i)
{
const auto &high = soc_lookup_[i];
const auto &low = soc_lookup_[i + 1];
const auto& high = soc_lookup_[i];
const auto& low = soc_lookup_[i + 1];
if (volts <= high.voltage_mv && volts >= low.voltage_mv)
{
components/Monitoring/Monitoring/BatteryMonitor.hpp
+2 -3
View File
@@ -20,7 +20,6 @@
#include "AdcSampler.hpp"
#include "sdkconfig.h"
/**
* @struct BatteryStatus
* @brief Battery status information
@@ -48,7 +47,7 @@ struct BatteryStatus
*/
class BatteryMonitor
{
public:
public:
BatteryMonitor() = default;
~BatteryMonitor() = default;
@@ -87,7 +86,7 @@ public:
#endif
}
private:
private:
/**
* @brief Li-ion/Li-Po voltage to SOC lookup table entry
*/
components/Monitoring/Monitoring/CurrentMonitor.cpp
+1 -1
View File
@@ -9,7 +9,7 @@
#include "CurrentMonitor.hpp"
#include <esp_log.h>
static const char *TAG = "[CurrentMonitor]";
static const char* TAG = "[CurrentMonitor]";
void CurrentMonitor::setup()
{
components/Monitoring/Monitoring/CurrentMonitor.hpp
+3 -3
View File
@@ -17,8 +17,8 @@
*/
#include <cstdint>
#include "sdkconfig.h"
#include "AdcSampler.hpp"
#include "sdkconfig.h"
/**
* @class CurrentMonitor
@@ -34,7 +34,7 @@
*/
class CurrentMonitor
{
public:
public:
CurrentMonitor() = default;
~CurrentMonitor() = default;
@@ -54,7 +54,7 @@ public:
#endif
}
private:
private:
mutable AdcSampler adc_; // ADC sampler instance (BSP layer)
};
components/Monitoring/Monitoring/MonitoringManager.cpp
+7 -13
View File
@@ -10,7 +10,7 @@
#include <esp_log.h>
#include "sdkconfig.h"
static const char *TAG = "[MonitoringManager]";
static const char* TAG = "[MonitoringManager]";
void MonitoringManager::setup()
{
@@ -18,11 +18,8 @@ void MonitoringManager::setup()
if (CurrentMonitor::isEnabled())
{
cm_.setup();
ESP_LOGI(TAG, "LED current monitoring enabled. Interval=%dms, Samples=%d, Gain=%d, R=%dmΩ",
CONFIG_MONITORING_LED_INTERVAL_MS,
CONFIG_MONITORING_LED_SAMPLES,
CONFIG_MONITORING_LED_GAIN,
CONFIG_MONITORING_LED_SHUNT_MILLIOHM);
ESP_LOGI(TAG, "LED current monitoring enabled. Interval=%dms, Samples=%d, Gain=%d, R=%dmΩ", CONFIG_MONITORING_LED_INTERVAL_MS,
CONFIG_MONITORING_LED_SAMPLES, CONFIG_MONITORING_LED_GAIN, CONFIG_MONITORING_LED_SHUNT_MILLIOHM);
}
else
{
@@ -36,11 +33,8 @@ void MonitoringManager::setup()
if (BatteryMonitor::isEnabled())
{
bm_.setup();
ESP_LOGI(TAG, "Battery monitoring enabled. Interval=%dms, Samples=%d, R-Top=%dΩ, R-Bottom=%dΩ",
CONFIG_MONITORING_BATTERY_INTERVAL_MS,
CONFIG_MONITORING_BATTERY_SAMPLES,
CONFIG_MONITORING_BATTERY_DIVIDER_R_TOP_OHM,
CONFIG_MONITORING_BATTERY_DIVIDER_R_BOTTOM_OHM);
ESP_LOGI(TAG, "Battery monitoring enabled. Interval=%dms, Samples=%d, R-Top=%dΩ, R-Bottom=%dΩ", CONFIG_MONITORING_BATTERY_INTERVAL_MS,
CONFIG_MONITORING_BATTERY_SAMPLES, CONFIG_MONITORING_BATTERY_DIVIDER_R_TOP_OHM, CONFIG_MONITORING_BATTERY_DIVIDER_R_BOTTOM_OHM);
}
else
{
@@ -77,9 +71,9 @@ void MonitoringManager::stop()
}
}
void MonitoringManager::taskEntry(void *arg)
void MonitoringManager::taskEntry(void* arg)
{
static_cast<MonitoringManager *>(arg)->run();
static_cast<MonitoringManager*>(arg)->run();
}
void MonitoringManager::run()
components/Monitoring/Monitoring/MonitoringManager.hpp
+3 -3
View File
@@ -35,7 +35,7 @@
*/
class MonitoringManager
{
public:
public:
MonitoringManager() = default;
~MonitoringManager() = default;
@@ -57,8 +57,8 @@ public:
return CurrentMonitor::isEnabled() || BatteryMonitor::isEnabled();
}
private:
static void taskEntry(void *arg);
private:
static void taskEntry(void* arg);
void run();
TaskHandle_t task_{nullptr};
components/OpenIrisTasks/OpenIrisTasks/OpenIrisTasks.cpp
+3 -5
View File
@@ -1,16 +1,14 @@
#include "OpenIrisTasks.hpp"
void restart_the_board(void *arg) {
void restart_the_board(void* arg)
{
esp_restart();
}
void OpenIrisTasks::ScheduleRestart(const int milliseconds)
{
esp_timer_handle_t timerHandle;
constexpr esp_timer_create_args_t args = {
.callback = &restart_the_board,
.arg = nullptr,
.name = "restartBoard"};
constexpr esp_timer_create_args_t args = {.callback = &restart_the_board, .arg = nullptr, .name = "restartBoard"};
if (const auto result = esp_timer_create(&args, &timerHandle); result == ESP_OK)
{
components/OpenIrisTasks/OpenIrisTasks/OpenIrisTasks.hpp
+3 -3
View File
@@ -2,14 +2,14 @@
#ifndef OPENIRISTASKS_HPP
#define OPENIRISTASKS_HPP
#include "helpers.hpp"
#include "esp_system.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "helpers.hpp"
namespace OpenIrisTasks
{
void ScheduleRestart(int milliseconds);
void ScheduleRestart(int milliseconds);
};
#endif
components/Preferences/Preferences/Preferences.cpp
+44 -44
View File
@@ -3,13 +3,13 @@
#include "Preferences.hpp"
const char *PREFERENCES_TAG = "[PREFERENCES]";
const char *nvs_errors[] = {"OTHER", "NOT_INITIALIZED", "NOT_FOUND", "TYPE_MISMATCH", "READ_ONLY", "NOT_ENOUGH_SPACE", "INVALID_NAME",
const char* PREFERENCES_TAG = "[PREFERENCES]";
const char* nvs_errors[] = {"OTHER", "NOT_INITIALIZED", "NOT_FOUND", "TYPE_MISMATCH", "READ_ONLY", "NOT_ENOUGH_SPACE", "INVALID_NAME",
"INVALID_HANDLE", "REMOVE_FAILED", "KEY_TOO_LONG", "PAGE_FULL", "INVALID_STATE", "INVALID_LENGTH"};
#define nvs_error(e) (((e) > ESP_ERR_NVS_BASE) ? nvs_errors[(e) & ~(ESP_ERR_NVS_BASE)] : nvs_errors[0])
Preferences::Preferences() : _handle(0), _started(false), _readOnly(false) {}
bool Preferences::begin(const char *name, bool readOnly, const char *partition_label)
bool Preferences::begin(const char* name, bool readOnly, const char* partition_label)
{
if (_started)
{
@@ -84,7 +84,7 @@ bool Preferences::clear()
* Remove a key
* */
bool Preferences::remove(const char *key)
bool Preferences::remove(const char* key)
{
if (!_started || !key || _readOnly)
{
@@ -110,7 +110,7 @@ bool Preferences::remove(const char *key)
* Put a key value
* */
size_t Preferences::putChar(const char *key, int8_t value)
size_t Preferences::putChar(const char* key, int8_t value)
{
if (!_started || !key || _readOnly)
{
@@ -131,7 +131,7 @@ size_t Preferences::putChar(const char *key, int8_t value)
return 1;
}
size_t Preferences::putUChar(const char *key, uint8_t value)
size_t Preferences::putUChar(const char* key, uint8_t value)
{
if (!_started || !key || _readOnly)
{
@@ -152,7 +152,7 @@ size_t Preferences::putUChar(const char *key, uint8_t value)
return 1;
}
size_t Preferences::putShort(const char *key, int16_t value)
size_t Preferences::putShort(const char* key, int16_t value)
{
if (!_started || !key || _readOnly)
{
@@ -173,7 +173,7 @@ size_t Preferences::putShort(const char *key, int16_t value)
return 2;
}
size_t Preferences::putUShort(const char *key, uint16_t value)
size_t Preferences::putUShort(const char* key, uint16_t value)
{
if (!_started || !key || _readOnly)
{
@@ -194,7 +194,7 @@ size_t Preferences::putUShort(const char *key, uint16_t value)
return 2;
}
size_t Preferences::putInt(const char *key, int32_t value)
size_t Preferences::putInt(const char* key, int32_t value)
{
if (!_started || !key || _readOnly)
{
@@ -215,7 +215,7 @@ size_t Preferences::putInt(const char *key, int32_t value)
return 4;
}
size_t Preferences::putUInt(const char *key, uint32_t value)
size_t Preferences::putUInt(const char* key, uint32_t value)
{
if (!_started || !key || _readOnly)
{
@@ -236,17 +236,17 @@ size_t Preferences::putUInt(const char *key, uint32_t value)
return 4;
}
size_t Preferences::putLong(const char *key, int32_t value)
size_t Preferences::putLong(const char* key, int32_t value)
{
return putInt(key, value);
}
size_t Preferences::putULong(const char *key, uint32_t value)
size_t Preferences::putULong(const char* key, uint32_t value)
{
return putUInt(key, value);
}
size_t Preferences::putLong64(const char *key, int64_t value)
size_t Preferences::putLong64(const char* key, int64_t value)
{
if (!_started || !key || _readOnly)
{
@@ -267,7 +267,7 @@ size_t Preferences::putLong64(const char *key, int64_t value)
return 8;
}
size_t Preferences::putULong64(const char *key, uint64_t value)
size_t Preferences::putULong64(const char* key, uint64_t value)
{
if (!_started || !key || _readOnly)
{
@@ -288,22 +288,22 @@ size_t Preferences::putULong64(const char *key, uint64_t value)
return 8;
}
size_t Preferences::putFloat(const char *key, const float_t value)
size_t Preferences::putFloat(const char* key, const float_t value)
{
return putBytes(key, (void *)&value, sizeof(float_t));
return putBytes(key, (void*)&value, sizeof(float_t));
}
size_t Preferences::putDouble(const char *key, const double_t value)
size_t Preferences::putDouble(const char* key, const double_t value)
{
return putBytes(key, (void *)&value, sizeof(double_t));
return putBytes(key, (void*)&value, sizeof(double_t));
}
size_t Preferences::putBool(const char *key, const bool value)
size_t Preferences::putBool(const char* key, const bool value)
{
return putUChar(key, (uint8_t)(value ? 1 : 0));
}
size_t Preferences::putString(const char *key, const char *value)
size_t Preferences::putString(const char* key, const char* value)
{
if (!_started || !key || !value || _readOnly)
{
@@ -324,12 +324,12 @@ size_t Preferences::putString(const char *key, const char *value)
return strlen(value);
}
size_t Preferences::putString(const char *key, const std::string value)
size_t Preferences::putString(const char* key, const std::string value)
{
return putString(key, value.c_str());
}
size_t Preferences::putBytes(const char *key, const void *value, size_t len)
size_t Preferences::putBytes(const char* key, const void* value, size_t len)
{
if (!_started || !key || !value || !len || _readOnly)
{
@@ -350,7 +350,7 @@ size_t Preferences::putBytes(const char *key, const void *value, size_t len)
return len;
}
PreferenceType Preferences::getType(const char *key)
PreferenceType Preferences::getType(const char* key)
{
if (!_started || !key || strlen(key) > 15)
{
@@ -408,7 +408,7 @@ PreferenceType Preferences::getType(const char *key)
return PT_INVALID;
}
bool Preferences::isKey(const char *key)
bool Preferences::isKey(const char* key)
{
return getType(key) != PT_INVALID;
}
@@ -417,7 +417,7 @@ bool Preferences::isKey(const char *key)
* Get a key value
* */
int8_t Preferences::getChar(const char *key, const int8_t defaultValue)
int8_t Preferences::getChar(const char* key, const int8_t defaultValue)
{
int8_t value = defaultValue;
if (!_started || !key)
@@ -432,7 +432,7 @@ int8_t Preferences::getChar(const char *key, const int8_t defaultValue)
return value;
}
uint8_t Preferences::getUChar(const char *key, const uint8_t defaultValue)
uint8_t Preferences::getUChar(const char* key, const uint8_t defaultValue)
{
uint8_t value = defaultValue;
if (!_started || !key)
@@ -447,7 +447,7 @@ uint8_t Preferences::getUChar(const char *key, const uint8_t defaultValue)
return value;
}
int16_t Preferences::getShort(const char *key, const int16_t defaultValue)
int16_t Preferences::getShort(const char* key, const int16_t defaultValue)
{
int16_t value = defaultValue;
if (!_started || !key)
@@ -462,7 +462,7 @@ int16_t Preferences::getShort(const char *key, const int16_t defaultValue)
return value;
}
uint16_t Preferences::getUShort(const char *key, const uint16_t defaultValue)
uint16_t Preferences::getUShort(const char* key, const uint16_t defaultValue)
{
uint16_t value = defaultValue;
if (!_started || !key)
@@ -477,7 +477,7 @@ uint16_t Preferences::getUShort(const char *key, const uint16_t defaultValue)
return value;
}
int32_t Preferences::getInt(const char *key, const int32_t defaultValue)
int32_t Preferences::getInt(const char* key, const int32_t defaultValue)
{
int32_t value = defaultValue;
if (!_started || !key)
@@ -492,7 +492,7 @@ int32_t Preferences::getInt(const char *key, const int32_t defaultValue)
return value;
}
uint32_t Preferences::getUInt(const char *key, const uint32_t defaultValue)
uint32_t Preferences::getUInt(const char* key, const uint32_t defaultValue)
{
uint32_t value = defaultValue;
if (!_started || !key)
@@ -507,17 +507,17 @@ uint32_t Preferences::getUInt(const char *key, const uint32_t defaultValue)
return value;
}
int32_t Preferences::getLong(const char *key, const int32_t defaultValue)
int32_t Preferences::getLong(const char* key, const int32_t defaultValue)
{
return getInt(key, defaultValue);
}
uint32_t Preferences::getULong(const char *key, const uint32_t defaultValue)
uint32_t Preferences::getULong(const char* key, const uint32_t defaultValue)
{
return getUInt(key, defaultValue);
}
int64_t Preferences::getLong64(const char *key, const int64_t defaultValue)
int64_t Preferences::getLong64(const char* key, const int64_t defaultValue)
{
int64_t value = defaultValue;
if (!_started || !key)
@@ -532,7 +532,7 @@ int64_t Preferences::getLong64(const char *key, const int64_t defaultValue)
return value;
}
uint64_t Preferences::getULong64(const char *key, const uint64_t defaultValue)
uint64_t Preferences::getULong64(const char* key, const uint64_t defaultValue)
{
uint64_t value = defaultValue;
if (!_started || !key)
@@ -547,26 +547,26 @@ uint64_t Preferences::getULong64(const char *key, const uint64_t defaultValue)
return value;
}
float_t Preferences::getFloat(const char *key, const float_t defaultValue)
float_t Preferences::getFloat(const char* key, const float_t defaultValue)
{
float_t value = defaultValue;
getBytes(key, (void *)&value, sizeof(float_t));
getBytes(key, (void*)&value, sizeof(float_t));
return value;
}
double_t Preferences::getDouble(const char *key, const double_t defaultValue)
double_t Preferences::getDouble(const char* key, const double_t defaultValue)
{
double_t value = defaultValue;
getBytes(key, (void *)&value, sizeof(double_t));
getBytes(key, (void*)&value, sizeof(double_t));
return value;
}
bool Preferences::getBool(const char *key, const bool defaultValue)
bool Preferences::getBool(const char* key, const bool defaultValue)
{
return getUChar(key, defaultValue ? 1 : 0) == 1;
}
size_t Preferences::getString(const char *key, char *value, const size_t maxLen)
size_t Preferences::getString(const char* key, char* value, const size_t maxLen)
{
size_t len = 0;
if (!_started || !key || !value || !maxLen)
@@ -593,9 +593,9 @@ size_t Preferences::getString(const char *key, char *value, const size_t maxLen)
return len;
}
std::string Preferences::getString(const char *key, const std::string defaultValue)
std::string Preferences::getString(const char* key, const std::string defaultValue)
{
char *value = NULL;
char* value = NULL;
size_t len = 0;
if (!_started || !key)
{
@@ -618,7 +618,7 @@ std::string Preferences::getString(const char *key, const std::string defaultVal
return std::string(buf);
}
size_t Preferences::getBytesLength(const char *key)
size_t Preferences::getBytesLength(const char* key)
{
size_t len = 0;
if (!_started || !key)
@@ -634,7 +634,7 @@ size_t Preferences::getBytesLength(const char *key)
return len;
}
size_t Preferences::getBytes(const char *key, void *buf, size_t maxLen)
size_t Preferences::getBytes(const char* key, void* buf, size_t maxLen)
{
size_t len = getBytesLength(key);
if (!len || !buf || !maxLen)
components/Preferences/Preferences/Preferences.hpp
+43 -43
View File
@@ -5,13 +5,13 @@
#ifndef PREFERENCES_HPP
#define PREFERENCES_HPP
#include <cstdint>
#include <string>
#include <cstring>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <string>
#include "esp_log.h"
#include "nvs_flash.h"
#include "nvs.h"
#include "nvs_flash.h"
typedef enum
{
@@ -30,57 +30,57 @@ typedef enum
class Preferences
{
protected:
protected:
uint32_t _handle;
bool _started;
bool _readOnly;
public:
public:
Preferences();
~Preferences();
bool begin(const char *name, bool readOnly = false, const char *partition_label = nullptr);
bool begin(const char* name, bool readOnly = false, const char* partition_label = nullptr);
void end();
bool clear();
bool remove(const char *key);
bool remove(const char* key);
size_t putChar(const char *key, int8_t value);
size_t putUChar(const char *key, uint8_t value);
size_t putShort(const char *key, int16_t value);
size_t putUShort(const char *key, uint16_t value);
size_t putInt(const char *key, int32_t value);
size_t putUInt(const char *key, uint32_t value);
size_t putLong(const char *key, int32_t value);
size_t putULong(const char *key, uint32_t value);
size_t putLong64(const char *key, int64_t value);
size_t putULong64(const char *key, uint64_t value);
size_t putFloat(const char *key, float_t value);
size_t putDouble(const char *key, double_t value);
size_t putBool(const char *key, bool value);
size_t putString(const char *key, const char *value);
size_t putString(const char *key, std::string value);
size_t putBytes(const char *key, const void *value, size_t len);
size_t putChar(const char* key, int8_t value);
size_t putUChar(const char* key, uint8_t value);
size_t putShort(const char* key, int16_t value);
size_t putUShort(const char* key, uint16_t value);
size_t putInt(const char* key, int32_t value);
size_t putUInt(const char* key, uint32_t value);
size_t putLong(const char* key, int32_t value);
size_t putULong(const char* key, uint32_t value);
size_t putLong64(const char* key, int64_t value);
size_t putULong64(const char* key, uint64_t value);
size_t putFloat(const char* key, float_t value);
size_t putDouble(const char* key, double_t value);
size_t putBool(const char* key, bool value);
size_t putString(const char* key, const char* value);
size_t putString(const char* key, std::string value);
size_t putBytes(const char* key, const void* value, size_t len);
bool isKey(const char *key);
PreferenceType getType(const char *key);
int8_t getChar(const char *key, int8_t defaultValue = 0);
uint8_t getUChar(const char *key, uint8_t defaultValue = 0);
int16_t getShort(const char *key, int16_t defaultValue = 0);
uint16_t getUShort(const char *key, uint16_t defaultValue = 0);
int32_t getInt(const char *key, int32_t defaultValue = 0);
uint32_t getUInt(const char *key, uint32_t defaultValue = 0);
int32_t getLong(const char *key, int32_t defaultValue = 0);
uint32_t getULong(const char *key, uint32_t defaultValue = 0);
int64_t getLong64(const char *key, int64_t defaultValue = 0);
uint64_t getULong64(const char *key, uint64_t defaultValue = 0);
float_t getFloat(const char *key, float_t defaultValue = NAN);
double_t getDouble(const char *key, double_t defaultValue = NAN);
bool getBool(const char *key, bool defaultValue = false);
size_t getString(const char *key, char *value, size_t maxLen);
std::string getString(const char *key, std::string defaultValue = std::string());
size_t getBytesLength(const char *key);
size_t getBytes(const char *key, void *buf, size_t maxLen);
bool isKey(const char* key);
PreferenceType getType(const char* key);
int8_t getChar(const char* key, int8_t defaultValue = 0);
uint8_t getUChar(const char* key, uint8_t defaultValue = 0);
int16_t getShort(const char* key, int16_t defaultValue = 0);
uint16_t getUShort(const char* key, uint16_t defaultValue = 0);
int32_t getInt(const char* key, int32_t defaultValue = 0);
uint32_t getUInt(const char* key, uint32_t defaultValue = 0);
int32_t getLong(const char* key, int32_t defaultValue = 0);
uint32_t getULong(const char* key, uint32_t defaultValue = 0);
int64_t getLong64(const char* key, int64_t defaultValue = 0);
uint64_t getULong64(const char* key, uint64_t defaultValue = 0);
float_t getFloat(const char* key, float_t defaultValue = NAN);
double_t getDouble(const char* key, double_t defaultValue = NAN);
bool getBool(const char* key, bool defaultValue = false);
size_t getString(const char* key, char* value, size_t maxLen);
std::string getString(const char* key, std::string defaultValue = std::string());
size_t getBytesLength(const char* key);
size_t getBytes(const char* key, void* buf, size_t maxLen);
size_t freeEntries();
};
components/ProjectConfig/ProjectConfig/Models.hpp
+32 -58
View File
@@ -2,23 +2,23 @@
#ifndef PROJECT_CONFIG_MODELS_HPP
#define PROJECT_CONFIG_MODELS_HPP
#include <Preferences.hpp>
#include <helpers.hpp>
#include <string>
#include <utility>
#include <vector>
#include <helpers.hpp>
#include "sdkconfig.h"
#include <Preferences.hpp>
#include "esp_log.h"
#include "sdkconfig.h"
struct BaseConfigModel
{
BaseConfigModel(Preferences *pref) : pref(pref) {}
BaseConfigModel(Preferences* pref) : pref(pref) {}
void load();
void save();
std::string toRepresentation();
Preferences *pref;
Preferences* pref;
};
enum class StreamingMode
@@ -31,7 +31,7 @@ enum class StreamingMode
struct DeviceMode_t : BaseConfigModel
{
StreamingMode mode;
explicit DeviceMode_t(Preferences *pref) : BaseConfigModel(pref), mode(StreamingMode::SETUP) {}
explicit DeviceMode_t(Preferences* pref) : BaseConfigModel(pref), mode(StreamingMode::SETUP) {}
void load()
{
@@ -59,7 +59,7 @@ struct DeviceMode_t : BaseConfigModel
struct DeviceConfig_t : BaseConfigModel
{
DeviceConfig_t(Preferences *pref) : BaseConfigModel(pref) {}
DeviceConfig_t(Preferences* pref) : BaseConfigModel(pref) {}
std::string OTALogin;
std::string OTAPassword;
@@ -97,7 +97,7 @@ struct DeviceConfig_t : BaseConfigModel
struct MDNSConfig_t : BaseConfigModel
{
MDNSConfig_t(Preferences *pref) : BaseConfigModel(pref) {}
MDNSConfig_t(Preferences* pref) : BaseConfigModel(pref) {}
std::string hostname;
@@ -120,15 +120,13 @@ struct MDNSConfig_t : BaseConfigModel
std::string toRepresentation()
{
return Helpers::format_string(
"\"mdns_config\": {\"hostname\": \"%s\"}",
this->hostname.c_str());
return Helpers::format_string("\"mdns_config\": {\"hostname\": \"%s\"}", this->hostname.c_str());
};
};
struct CameraConfig_t : BaseConfigModel
{
CameraConfig_t(Preferences *pref) : BaseConfigModel(pref) {}
CameraConfig_t(Preferences* pref) : BaseConfigModel(pref) {}
uint8_t vflip;
uint8_t href;
@@ -159,8 +157,7 @@ struct CameraConfig_t : BaseConfigModel
return Helpers::format_string(
"\"camera_config\": {\"vflip\": %d,\"framesize\": %d,\"href\": "
"%d,\"quality\": %d,\"brightness\": %d}",
this->vflip, this->framesize, this->href, this->quality,
this->brightness);
this->vflip, this->framesize, this->href, this->quality, this->brightness);
};
};
@@ -171,23 +168,12 @@ struct CameraConfig_t : BaseConfigModel
struct WiFiConfig_t : BaseConfigModel
{
// default constructor used for loading
WiFiConfig_t(Preferences *pref) : BaseConfigModel(pref) {}
WiFiConfig_t(Preferences* pref) : BaseConfigModel(pref) {}
WiFiConfig_t(
Preferences *pref,
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)),
ssid(std::move(ssid)),
password(std::move(password)),
channel(channel),
power(power) {}
WiFiConfig_t(Preferences* pref, 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)), ssid(std::move(ssid)), password(std::move(password)), channel(channel), power(power)
{
}
uint8_t index;
std::string name;
@@ -208,8 +194,7 @@ struct WiFiConfig_t : BaseConfigModel
this->channel = this->pref->getUInt(("channel" + iter_str).c_str());
this->power = this->pref->getUInt(("power" + iter_str).c_str());
ESP_LOGI("WiFiConfig", "Loaded network %d: name=%s, ssid=%s, channel=%d",
index, this->name.c_str(), this->ssid.c_str(), this->channel);
ESP_LOGI("WiFiConfig", "Loaded network %d: name=%s, ssid=%s, channel=%d", index, this->name.c_str(), this->ssid.c_str(), this->channel);
};
void save() const
@@ -223,22 +208,19 @@ struct WiFiConfig_t : BaseConfigModel
this->pref->putUInt(("channel" + iter_str).c_str(), this->channel);
this->pref->putUInt(("power" + iter_str).c_str(), this->power);
ESP_LOGI("WiFiConfig", "Saved network %d: name=%s, ssid=%s, channel=%d",
this->index, this->name.c_str(), this->ssid.c_str(), this->channel);
ESP_LOGI("WiFiConfig", "Saved network %d: name=%s, ssid=%s, channel=%d", this->index, this->name.c_str(), this->ssid.c_str(), this->channel);
};
std::string toRepresentation()
{
return Helpers::format_string(
"{\"name\": \"%s\", \"ssid\": \"%s\", \"password\": \"%s\", \"channel\": %u, \"power\": %u}",
this->name.c_str(), this->ssid.c_str(), this->password.c_str(),
this->channel, this->power);
return Helpers::format_string("{\"name\": \"%s\", \"ssid\": \"%s\", \"password\": \"%s\", \"channel\": %u, \"power\": %u}", this->name.c_str(),
this->ssid.c_str(), this->password.c_str(), this->channel, this->power);
};
};
struct AP_WiFiConfig_t : BaseConfigModel
{
AP_WiFiConfig_t(Preferences *pref) : BaseConfigModel(pref) {}
AP_WiFiConfig_t(Preferences* pref) : BaseConfigModel(pref) {}
std::string ssid;
std::string password;
@@ -268,7 +250,7 @@ struct AP_WiFiConfig_t : BaseConfigModel
struct WiFiTxPower_t : BaseConfigModel
{
WiFiTxPower_t(Preferences *pref) : BaseConfigModel(pref) {}
WiFiTxPower_t(Preferences* pref) : BaseConfigModel(pref) {}
uint8_t power;
@@ -290,7 +272,7 @@ struct WiFiTxPower_t : BaseConfigModel
class TrackerConfig_t
{
public:
public:
DeviceConfig_t device;
DeviceMode_t device_mode;
CameraConfig_t camera;
@@ -299,20 +281,17 @@ public:
MDNSConfig_t mdns;
WiFiTxPower_t txpower;
TrackerConfig_t(
DeviceConfig_t device,
DeviceMode_t device_mode,
CameraConfig_t camera,
std::vector<WiFiConfig_t> networks,
AP_WiFiConfig_t ap_network,
MDNSConfig_t mdns,
WiFiTxPower_t txpower) : device(std::move(device)),
TrackerConfig_t(DeviceConfig_t device, DeviceMode_t device_mode, CameraConfig_t camera, std::vector<WiFiConfig_t> networks, AP_WiFiConfig_t ap_network,
MDNSConfig_t mdns, WiFiTxPower_t txpower)
: device(std::move(device)),
device_mode(std::move(device_mode)),
camera(std::move(camera)),
networks(std::move(networks)),
ap_network(std::move(ap_network)),
mdns(std::move(mdns)),
txpower(std::move(txpower)) {}
txpower(std::move(txpower))
{
}
std::string toRepresentation()
{
@@ -332,14 +311,9 @@ public:
WifiConfigRepresentation += Helpers::format_string("%s", this->networks[networks.size() - 1].toRepresentation().c_str());
}
return Helpers::format_string(
"{%s, %s, %s, \"networks\": [%s], %s, %s}",
this->device.toRepresentation().c_str(),
this->mdns.toRepresentation().c_str(),
this->camera.toRepresentation().c_str(),
WifiConfigRepresentation.c_str(),
this->ap_network.toRepresentation().c_str(),
this->txpower.toRepresentation().c_str());
return Helpers::format_string("{%s, %s, %s, \"networks\": [%s], %s, %s}", this->device.toRepresentation().c_str(),
this->mdns.toRepresentation().c_str(), this->camera.toRepresentation().c_str(), WifiConfigRepresentation.c_str(),
this->ap_network.toRepresentation().c_str(), this->txpower.toRepresentation().c_str());
}
};
components/ProjectConfig/ProjectConfig/ProjectConfig.cpp
+27 -49
View File
@@ -2,25 +2,23 @@
static auto CONFIGURATION_TAG = "[CONFIGURATION]";
int getNetworkCount(Preferences *pref)
int getNetworkCount(Preferences* pref)
{
return pref->getInt("networkcount", 0);
}
void saveNetworkCount(Preferences *pref, const int count)
void saveNetworkCount(Preferences* pref, const int count)
{
pref->putInt("networkcount", count);
}
ProjectConfig::ProjectConfig(Preferences *pref) : pref(pref),
ProjectConfig::ProjectConfig(Preferences* pref)
: pref(pref),
_already_loaded(false),
config(DeviceConfig_t(pref),
DeviceMode_t(pref),
CameraConfig_t(pref),
std::vector<WiFiConfig_t>{},
AP_WiFiConfig_t(pref),
MDNSConfig_t(pref),
WiFiTxPower_t(pref)) {}
config(DeviceConfig_t(pref), DeviceMode_t(pref), CameraConfig_t(pref), std::vector<WiFiConfig_t>{}, AP_WiFiConfig_t(pref), MDNSConfig_t(pref),
WiFiTxPower_t(pref))
{
}
ProjectConfig::~ProjectConfig() = default;
@@ -93,9 +91,7 @@ bool ProjectConfig::reset()
//! DeviceConfig
//*
//**********************************************************************************************************************
void ProjectConfig::setOTAConfig(const std::string &OTALogin,
const std::string &OTAPassword,
const int OTAPort)
void ProjectConfig::setOTAConfig(const std::string& OTALogin, const std::string& OTAPassword, const int OTAPort)
{
ESP_LOGD(CONFIGURATION_TAG, "Updating device config");
this->config.device.OTALogin.assign(OTALogin);
@@ -111,18 +107,14 @@ void ProjectConfig::setLEDDUtyCycleConfig(int led_external_pwm_duty_cycle)
this->config.device.save();
}
void ProjectConfig::setMDNSConfig(const std::string &hostname)
void ProjectConfig::setMDNSConfig(const std::string& hostname)
{
ESP_LOGD(CONFIGURATION_TAG, "Updating MDNS config");
this->config.mdns.hostname.assign(hostname);
this->config.mdns.save();
}
void ProjectConfig::setCameraConfig(const uint8_t vflip,
const uint8_t framesize,
const uint8_t href,
const uint8_t quality,
const 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;
@@ -135,23 +127,15 @@ void ProjectConfig::setCameraConfig(const uint8_t vflip,
ESP_LOGD(CONFIGURATION_TAG, "Updating Camera config");
}
void ProjectConfig::setWifiConfig(const std::string &networkName,
const std::string &ssid,
const std::string &password,
uint8_t channel,
uint8_t power)
void ProjectConfig::setWifiConfig(const std::string& networkName, const std::string& ssid, const std::string& password, uint8_t channel, uint8_t power)
{
const auto size = this->config.networks.size();
const auto it = std::ranges::find_if(this->config.networks,
[&](const 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())
{
ESP_LOGI(CONFIGURATION_TAG, "Found network %s, updating it ...",
it->name.c_str());
ESP_LOGI(CONFIGURATION_TAG, "Found network %s, updating it ...", it->name.c_str());
it->name = networkName;
it->ssid = ssid;
@@ -166,8 +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, static_cast<uint8_t>(0), networkName, ssid, password, channel,
power);
this->config.networks.emplace_back(this->pref, static_cast<uint8_t>(0), networkName, ssid, password, channel, power);
// Save the new network immediately
this->config.networks.back().save();
saveNetworkCount(this->pref, 1);
@@ -182,8 +165,7 @@ void ProjectConfig::setWifiConfig(const std::string &networkName,
// space we're using emplace_back as push_back will create a copy of it,
// we want to avoid that
uint8_t last_index = getNetworkCount(this->pref);
this->config.networks.emplace_back(this->pref, last_index, networkName, ssid, password, channel,
power);
this->config.networks.emplace_back(this->pref, last_index, networkName, ssid, password, channel, power);
// Save the new network immediately
this->config.networks.back().save();
saveNetworkCount(this->pref, static_cast<int>(this->config.networks.size()));
@@ -194,16 +176,14 @@ void ProjectConfig::setWifiConfig(const std::string &networkName,
}
}
void ProjectConfig::deleteWifiConfig(const std::string &networkName)
void ProjectConfig::deleteWifiConfig(const std::string& networkName)
{
if (const auto size = this->config.networks.size(); size == 0)
{
ESP_LOGI(CONFIGURATION_TAG, "No networks, nothing to delete");
}
const auto it = std::ranges::find_if(this->config.networks,
[&](const 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())
{
@@ -220,9 +200,7 @@ void ProjectConfig::setWiFiTxPower(uint8_t power)
ESP_LOGD(CONFIGURATION_TAG, "Updating wifi tx power");
}
void ProjectConfig::setAPWifiConfig(const std::string &ssid,
const std::string &password,
const uint8_t channel)
void ProjectConfig::setAPWifiConfig(const std::string& ssid, const std::string& password, const uint8_t channel)
{
this->config.ap_network.ssid.assign(ssid);
this->config.ap_network.password.assign(password);
@@ -243,36 +221,36 @@ void ProjectConfig::setDeviceMode(const StreamingMode deviceMode)
//*
//**********************************************************************************************************************
DeviceConfig_t &ProjectConfig::getDeviceConfig()
DeviceConfig_t& ProjectConfig::getDeviceConfig()
{
return this->config.device;
}
CameraConfig_t &ProjectConfig::getCameraConfig()
CameraConfig_t& ProjectConfig::getCameraConfig()
{
return this->config.camera;
}
std::vector<WiFiConfig_t> &ProjectConfig::getWifiConfigs()
std::vector<WiFiConfig_t>& ProjectConfig::getWifiConfigs()
{
return this->config.networks;
}
AP_WiFiConfig_t &ProjectConfig::getAPWifiConfig()
AP_WiFiConfig_t& ProjectConfig::getAPWifiConfig()
{
return this->config.ap_network;
}
MDNSConfig_t &ProjectConfig::getMDNSConfig()
MDNSConfig_t& ProjectConfig::getMDNSConfig()
{
return this->config.mdns;
}
WiFiTxPower_t &ProjectConfig::getWiFiTxPowerConfig()
WiFiTxPower_t& ProjectConfig::getWiFiTxPowerConfig()
{
return this->config.txpower;
}
TrackerConfig_t &ProjectConfig::getTrackerConfig()
TrackerConfig_t& ProjectConfig::getTrackerConfig()
{
return this->config;
}
DeviceMode_t &ProjectConfig::getDeviceModeConfig()
DeviceMode_t& ProjectConfig::getDeviceModeConfig()
{
return this->config.device_mode;
}
components/ProjectConfig/ProjectConfig/ProjectConfig.hpp
+26 -38
View File
@@ -1,22 +1,22 @@
#pragma once
#ifndef PROJECT_CONFIG_HPP
#define PROJECT_CONFIG_HPP
#include "esp_log.h"
#include <algorithm>
#include <vector>
#include <string>
#include <helpers.hpp>
#include "Models.hpp"
#include <Preferences.hpp>
#include <algorithm>
#include <helpers.hpp>
#include <string>
#include <vector>
#include "Models.hpp"
#include "esp_log.h"
int getNetworkCount(Preferences *pref);
int getNetworkCount(Preferences* pref);
void saveNetworkCount(Preferences *pref, int count);
void saveNetworkCount(Preferences* pref, int count);
class ProjectConfig
{
public:
explicit ProjectConfig(Preferences *pref);
public:
explicit ProjectConfig(Preferences* pref);
virtual ~ProjectConfig();
void load();
@@ -24,42 +24,30 @@ public:
bool reset();
DeviceConfig_t &getDeviceConfig();
DeviceMode_t &getDeviceModeConfig();
CameraConfig_t &getCameraConfig();
std::vector<WiFiConfig_t> &getWifiConfigs();
AP_WiFiConfig_t &getAPWifiConfig();
MDNSConfig_t &getMDNSConfig();
WiFiTxPower_t &getWiFiTxPowerConfig();
TrackerConfig_t &getTrackerConfig();
DeviceConfig_t& getDeviceConfig();
DeviceMode_t& getDeviceModeConfig();
CameraConfig_t& getCameraConfig();
std::vector<WiFiConfig_t>& getWifiConfigs();
AP_WiFiConfig_t& getAPWifiConfig();
MDNSConfig_t& getMDNSConfig();
WiFiTxPower_t& getWiFiTxPowerConfig();
TrackerConfig_t& getTrackerConfig();
void setOTAConfig(const std::string &OTALogin,
const std::string &OTAPassword,
int OTAPort);
void setOTAConfig(const std::string& OTALogin, const std::string& OTAPassword, int OTAPort);
void setLEDDUtyCycleConfig(int led_external_pwm_duty_cycle);
void setMDNSConfig(const std::string &hostname);
void setCameraConfig(uint8_t vflip,
uint8_t framesize,
uint8_t href,
uint8_t quality,
uint8_t brightness);
void setWifiConfig(const std::string &networkName,
const std::string &ssid,
const std::string &password,
uint8_t channel,
uint8_t power);
void setMDNSConfig(const std::string& hostname);
void setCameraConfig(uint8_t vflip, uint8_t framesize, uint8_t href, uint8_t quality, uint8_t brightness);
void setWifiConfig(const std::string& networkName, const std::string& ssid, const std::string& password, uint8_t channel, uint8_t power);
void deleteWifiConfig(const std::string &networkName);
void deleteWifiConfig(const std::string& networkName);
void setAPWifiConfig(const std::string &ssid,
const std::string &password,
uint8_t channel);
void setAPWifiConfig(const std::string& ssid, const std::string& password, uint8_t channel);
void setWiFiTxPower(uint8_t power);
void setDeviceMode(StreamingMode deviceMode);
StreamingMode getDeviceMode();
private:
Preferences *pref;
private:
Preferences* pref;
bool _already_loaded;
TrackerConfig_t config;
};
components/RestAPI/RestAPI/RestAPI.cpp
+10 -14
View File
@@ -7,7 +7,7 @@
#define GET_METHOD "GET"
#define DELETE_METHOD "DELETE"
bool getIsSuccess(const nlohmann::json &response)
bool getIsSuccess(const nlohmann::json& response)
{
// since the commandManager will be returning CommandManagerResponse to simplify parsing on the clients end
// we can slightly its json representation, and extract the status from there
@@ -82,11 +82,11 @@ void RestAPI::begin()
mg_http_listen(&mgr, this->url.c_str(), (mg_event_handler_t)RestAPIHelpers::event_handler, this);
}
void RestAPI::handle_request(struct mg_connection *connection, int event, void *event_data)
void RestAPI::handle_request(struct mg_connection* connection, int event, void* event_data)
{
if (event == MG_EV_HTTP_MSG)
{
auto const *message = static_cast<struct mg_http_message *>(event_data);
auto const* message = static_cast<struct mg_http_message*>(event_data);
auto const uri = std::string(message->uri.buf, message->uri.len);
if (this->routes.find(uri) == this->routes.end())
@@ -97,22 +97,19 @@ void RestAPI::handle_request(struct mg_connection *connection, int event, void *
auto const base_request_params = this->routes.at(uri);
auto *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),
};
this->handle_endpoint_command(context,
base_request_params.allowed_method,
base_request_params.command_type,
base_request_params.success_code,
this->handle_endpoint_command(context, base_request_params.allowed_method, base_request_params.command_type, base_request_params.success_code,
base_request_params.error_code);
}
}
void RestAPIHelpers::event_handler(struct mg_connection *connection, int event, void *event_data)
void RestAPIHelpers::event_handler(struct mg_connection* connection, int event, void* event_data)
{
auto *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);
}
@@ -121,9 +118,9 @@ void RestAPI::poll()
mg_mgr_poll(&mgr, 100);
}
void HandleRestAPIPollTask(void *pvParameter)
void HandleRestAPIPollTask(void* pvParameter)
{
auto *rest_api_handler = static_cast<RestAPI *>(pvParameter);
auto* rest_api_handler = static_cast<RestAPI*>(pvParameter);
while (true)
{
rest_api_handler->poll();
@@ -131,9 +128,8 @@ void HandleRestAPIPollTask(void *pvParameter)
}
}
void RestAPI::handle_endpoint_command(RequestContext *context, std::string allowed_method, CommandType command_type, int success_code, int error_code)
void RestAPI::handle_endpoint_command(RequestContext* context, std::string allowed_method, CommandType command_type, int success_code, int error_code)
{
if (context->method != allowed_method)
{
mg_http_reply(context->connection, 401, JSON_RESPONSE, "{%m:%m}", MG_ESC("error"), "Method not allowed");
components/RestAPI/RestAPI/RestAPI.hpp
+12 -11
View File
@@ -1,11 +1,11 @@
#pragma once
#ifndef RESTAPI_HPP
#define RESTAPI_HPP
#include <string>
#include <memory>
#include <unordered_map>
#include <mongoose.h>
#include <CommandManager.hpp>
#include <memory>
#include <string>
#include <unordered_map>
#include "esp_log.h"
@@ -13,7 +13,7 @@
struct RequestContext
{
mg_connection *connection;
mg_connection* connection;
std::string method;
std::string body;
};
@@ -24,7 +24,8 @@ struct RequestBaseData
CommandType command_type;
int success_code;
int error_code;
RequestBaseData(std::string allowed_method, CommandType command_type, int success_code, int error_code) : allowed_method(allowed_method), command_type(command_type), success_code(success_code), error_code(error_code) {};
RequestBaseData(std::string allowed_method, CommandType command_type, int success_code, int error_code)
: allowed_method(allowed_method), command_type(command_type), success_code(success_code), error_code(error_code) {};
};
class RestAPI
@@ -36,22 +37,22 @@ class RestAPI
mg_mgr mgr;
std::shared_ptr<CommandManager> command_manager;
private:
void handle_endpoint_command(RequestContext *context, std::string allowed_method, CommandType command_type, int success_code, int error_code);
private:
void handle_endpoint_command(RequestContext* context, std::string allowed_method, CommandType command_type, int success_code, int error_code);
public:
public:
// this will also need command manager
RestAPI(std::string url, std::shared_ptr<CommandManager> command_manager);
void begin();
void handle_request(struct mg_connection *connection, int event, void *event_data);
void handle_request(struct mg_connection* connection, int event, void* event_data);
void poll();
};
namespace RestAPIHelpers
{
void event_handler(struct mg_connection *connection, int event, void *event_data);
void event_handler(struct mg_connection* connection, int event, void* event_data);
};
void HandleRestAPIPollTask(void *pvParameter);
void HandleRestAPIPollTask(void* pvParameter);
#endif
components/SerialManager/SerialManager/SerialManager.cpp
+5 -5
View File
@@ -2,11 +2,11 @@
#include "esp_log.h"
#include "main_globals.hpp"
SerialManager::SerialManager(std::shared_ptr<CommandManager> commandManager, esp_timer_handle_t *timerHandle)
SerialManager::SerialManager(std::shared_ptr<CommandManager> commandManager, esp_timer_handle_t* timerHandle)
: commandManager(commandManager), timerHandle(timerHandle)
{
this->data = static_cast<uint8_t *>(malloc(BUF_SIZE));
this->temp_data = static_cast<uint8_t *>(malloc(256));
this->data = static_cast<uint8_t*>(malloc(BUF_SIZE));
this->temp_data = static_cast<uint8_t*>(malloc(256));
}
// Function to notify that a command was received during startup
@@ -25,9 +25,9 @@ void SerialManager::notify_startup_command_received()
}
// we can cancel this task once we're in cdc
void HandleSerialManagerTask(void *pvParameters)
void HandleSerialManagerTask(void* pvParameters)
{
auto const serialManager = static_cast<SerialManager *>(pvParameters);
auto const serialManager = static_cast<SerialManager*>(pvParameters);
while (true)
{
serialManager->try_receive();
components/SerialManager/SerialManager/SerialManager.hpp
+16 -16
View File
@@ -3,18 +3,18 @@
#define SERIALMANAGER_HPP
#include <stdio.h>
#include <string>
#include <memory>
#include <CommandManager.hpp>
#include <ProjectConfig.hpp>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "sdkconfig.h"
#include "esp_log.h"
#include <memory>
#include <string>
#include "driver/gpio.h"
#include "esp_vfs_dev.h"
#include "esp_log.h"
#include "esp_mac.h"
#include "esp_vfs_dev.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"
#include "sdkconfig.h"
#ifndef BUF_SIZE
#define BUF_SIZE (1024)
@@ -33,20 +33,20 @@ struct cdc_command_packet_t
class SerialManager
{
public:
explicit SerialManager(std::shared_ptr<CommandManager> commandManager, esp_timer_handle_t *timerHandle);
public:
explicit SerialManager(std::shared_ptr<CommandManager> commandManager, esp_timer_handle_t* timerHandle);
void setup();
void try_receive();
void notify_startup_command_received();
void shutdown();
private:
private:
std::shared_ptr<CommandManager> commandManager;
esp_timer_handle_t *timerHandle;
uint8_t *data;
uint8_t *temp_data;
esp_timer_handle_t* timerHandle;
uint8_t* data;
uint8_t* temp_data;
};
void HandleSerialManagerTask(void *pvParameters);
void HandleCDCSerialManagerTask(void *pvParameters);
void HandleSerialManagerTask(void* pvParameters);
void HandleCDCSerialManagerTask(void* pvParameters);
#endif
components/SerialManager/SerialManager/SerialManager_esp32.cpp
+4 -8
View File
@@ -1,7 +1,7 @@
#include "SerialManager.hpp"
#include "driver/uart.h"
#include "esp_log.h"
#include "main_globals.hpp"
#include "driver/uart.h"
void SerialManager::setup()
{
@@ -18,11 +18,7 @@ void SerialManager::setup()
uart_driver_install(uart_num, BUF_SIZE, BUF_SIZE, 0, NULL, 0);
uart_param_config(uart_num, &uart_config);
uart_set_pin(uart_num,
CONFIG_UART_TX_PIN,
CONFIG_UART_RX_PIN,
UART_PIN_NO_CHANGE,
UART_PIN_NO_CHANGE);
uart_set_pin(uart_num, CONFIG_UART_TX_PIN, CONFIG_UART_RX_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
gpio_set_pull_mode(static_cast<gpio_num_t>(CONFIG_UART_RX_PIN), GPIO_PULLDOWN_ONLY);
@@ -36,7 +32,7 @@ void SerialManager::setup()
}
}
void uart_write_bytes_chunked(uart_port_t uart_num, const void *src, size_t size)
void uart_write_bytes_chunked(uart_port_t uart_num, const void* src, size_t size)
{
while (size > 0)
{
@@ -77,7 +73,7 @@ void SerialManager::try_receive()
data[current_position] = '\0';
current_position = 0;
const nlohmann::json result = this->commandManager->executeFromJson(std::string_view(reinterpret_cast<const char *>(this->data)));
const nlohmann::json result = this->commandManager->executeFromJson(std::string_view(reinterpret_cast<const char*>(this->data)));
const auto resultMessage = result.dump();
// todo check if this works
// uart_write_bytes_chunked(uart_num, resultMessage.c_str(), resultMessage.length())s
components/SerialManager/SerialManager/SerialManager_esp32s3.cpp
+9 -10
View File
@@ -1,8 +1,8 @@
#include "SerialManager.hpp"
#include "esp_log.h"
#include "main_globals.hpp"
#include "driver/usb_serial_jtag.h"
#include "esp_log.h"
#include "esp_vfs_usb_serial_jtag.h"
#include "main_globals.hpp"
#include "tusb.h"
@@ -16,7 +16,7 @@ void SerialManager::setup()
#endif
}
void usb_serial_jtag_write_bytes_chunked(const char *data, size_t len, size_t timeout)
void usb_serial_jtag_write_bytes_chunked(const char* data, size_t len, size_t timeout)
{
#ifndef CONFIG_USE_UART_FOR_COMMUNICATION
while (len > 0)
@@ -59,7 +59,7 @@ void SerialManager::try_receive()
data[current_position] = '\0';
current_position = 0;
const nlohmann::json result = this->commandManager->executeFromJson(std::string_view(reinterpret_cast<const char *>(this->data)));
const nlohmann::json result = this->commandManager->executeFromJson(std::string_view(reinterpret_cast<const char*>(this->data)));
const auto resultMessage = result.dump();
usb_serial_jtag_write_bytes_chunked(resultMessage.c_str(), resultMessage.length(), 1000 / 20);
}
@@ -80,10 +80,10 @@ void SerialManager::shutdown()
}
}
void HandleCDCSerialManagerTask(void *pvParameters)
void HandleCDCSerialManagerTask(void* pvParameters)
{
#ifndef CONFIG_USE_UART_FOR_COMMUNICATION
auto const commandManager = static_cast<CommandManager *>(pvParameters);
auto const commandManager = static_cast<CommandManager*>(pvParameters);
static char buffer[BUF_SIZE];
auto idx = 0;
@@ -100,7 +100,7 @@ void HandleCDCSerialManagerTask(void *pvParameters)
if (idx >= BUF_SIZE || buffer[idx - 1] == '\n' || buffer[idx - 1] == '\r')
{
buffer[idx - 1] = '\0';
const nlohmann::json result = commandManager->executeFromJson(std::string_view(reinterpret_cast<const char *>(buffer)));
const nlohmann::json result = commandManager->executeFromJson(std::string_view(reinterpret_cast<const char*>(buffer)));
const auto resultMessage = result.dump();
tud_cdc_write(resultMessage.c_str(), resultMessage.length());
tud_cdc_write_flush();
@@ -143,10 +143,9 @@ extern "C" void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
ESP_LOGI("[SERIAL]", "CDC line state changed: DTR=%d, RTS=%d", dtr, rts);
}
void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const *p_line_coding)
void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_line_coding)
{
(void)itf;
ESP_LOGI("[SERIAL]", "CDC line coding: %" PRIu32 " bps, %d stop bits, %d parity, %d data bits",
p_line_coding->bit_rate, p_line_coding->stop_bits,
ESP_LOGI("[SERIAL]", "CDC line coding: %" PRIu32 " bps, %d stop bits, %d parity, %d data bits", p_line_coding->bit_rate, p_line_coding->stop_bits,
p_line_coding->parity, p_line_coding->data_bits);
}
components/StateManager/StateManager/StateManager.cpp
+2 -3
View File
@@ -11,7 +11,6 @@ void StateManager::HandleUpdateState()
{
switch (eventBuffer.source)
{
case EventSource::WIFI:
{
this->wifi_state = std::get<WiFiState_e>(eventBuffer.value);
@@ -92,9 +91,9 @@ QueueHandle_t StateManager::GetEventQueue() const
return this->eventQueue;
}
void HandleStateManagerTask(void *pvParameters)
void HandleStateManagerTask(void* pvParameters)
{
auto *stateManager = static_cast<StateManager *>(pvParameters);
auto* stateManager = static_cast<StateManager*>(pvParameters);
while (true)
{
components/StateManager/StateManager/StateManager.hpp
+8 -8
View File
@@ -11,11 +11,11 @@
enum class LEDStates_e
{
LedStateNone, // Idle / no indication (LED off)
LedStateStreaming, // Active streaming (UVC or WiFi) – steady ON
LedStateStoppedStreaming, // Streaming stopped intentionally – steady OFF (could differentiate later)
CameraError, // Camera init / runtime failure – double blink pattern
WiFiStateError, // WiFi connection error – distinctive blink sequence
WiFiStateConnecting, // WiFi association / DHCP pending – slow blink
LedStateStreaming, // Active streaming (UVC or WiFi) - steady ON
LedStateStoppedStreaming, // Streaming stopped intentionally - steady OFF (could differentiate later)
CameraError, // Camera init / runtime failure - double blink pattern
WiFiStateError, // WiFi connection error - distinctive blink sequence
WiFiStateConnecting, // WiFi association / DHCP pending - slow blink
WiFiStateConnected // WiFi connected (momentary confirmation burst)
};
@@ -71,14 +71,14 @@ struct SystemEvent
class StateManager
{
public:
public:
StateManager(QueueHandle_t eventQueue, QueueHandle_t ledStateQueue);
void HandleUpdateState();
WiFiState_e GetWifiState();
CameraState_e GetCameraState();
QueueHandle_t GetEventQueue() const;
private:
private:
QueueHandle_t eventQueue;
QueueHandle_t ledStateQueue;
@@ -97,6 +97,6 @@ static inline bool SendStreamEvent(QueueHandle_t queue, StreamState_e state)
return xQueueSend(queue, &evt, 0) == pdTRUE;
}
void HandleStateManagerTask(void *pvParameters);
void HandleStateManagerTask(void* pvParameters);
#endif // STATEMANAGER_HPP
components/StreamServer/StreamServer/StreamServer.cpp
+16 -18
View File
@@ -1,32 +1,30 @@
#include "StreamServer.hpp"
constexpr static const char *STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
constexpr static const char *STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
constexpr static const char *STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\nX-Timestamp: %lli.%06li\r\n\r\n";
constexpr static const char* STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
constexpr static const char* STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
constexpr static const char* STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\nX-Timestamp: %lli.%06li\r\n\r\n";
static const char *STREAM_SERVER_TAG = "[STREAM_SERVER]";
static const char* STREAM_SERVER_TAG = "[STREAM_SERVER]";
StreamServer::StreamServer(const int STREAM_PORT, StateManager *stateManager) : STREAM_SERVER_PORT(STREAM_PORT), stateManager(stateManager)
StreamServer::StreamServer(const int STREAM_PORT, StateManager* stateManager) : STREAM_SERVER_PORT(STREAM_PORT), stateManager(stateManager) {}
esp_err_t StreamHelpers::stream(httpd_req_t* req)
{
}
esp_err_t StreamHelpers::stream(httpd_req_t *req)
{
camera_fb_t *fb = nullptr;
camera_fb_t* fb = nullptr;
struct timeval _timestamp;
esp_err_t response = ESP_OK;
size_t _jpg_buf_len = 0;
uint8_t *_jpg_buf = nullptr;
uint8_t* _jpg_buf = nullptr;
// Buffer for multipart header; was mistakenly declared as array of pointers
// Buffer for multipart header
char part_buf[256];
static int64_t last_frame = 0;
if (!last_frame)
last_frame = esp_timer_get_time();
// Pull event queue from user_ctx to send STREAM on/off notifications
auto *stateManager = static_cast<StateManager *>(req->user_ctx);
auto* stateManager = static_cast<StateManager*>(req->user_ctx);
QueueHandle_t eventQueue = stateManager ? stateManager->GetEventQueue() : nullptr;
bool stream_on_sent = false;
@@ -63,11 +61,11 @@ esp_err_t StreamHelpers::stream(httpd_req_t *req)
response = httpd_resp_send_chunk(req, STREAM_BOUNDARY, strlen(STREAM_BOUNDARY));
if (response == ESP_OK)
{
size_t hlen = snprintf((char *)part_buf, sizeof(part_buf), STREAM_PART, _jpg_buf_len, _timestamp.tv_sec, _timestamp.tv_usec);
response = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
size_t hlen = snprintf((char*)part_buf, sizeof(part_buf), STREAM_PART, _jpg_buf_len, _timestamp.tv_sec, _timestamp.tv_usec);
response = httpd_resp_send_chunk(req, (const char*)part_buf, hlen);
}
if (response == ESP_OK)
response = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
response = httpd_resp_send_chunk(req, (const char*)_jpg_buf, _jpg_buf_len);
if (fb)
{
esp_camera_fb_return(fb);
@@ -103,7 +101,7 @@ esp_err_t StreamHelpers::stream(httpd_req_t *req)
{
fps = (frame_window * 1000) / window_ms;
}
ESP_LOGI(STREAM_SERVER_TAG, "%i Frames Size: %uKB, Time: %lims (%lifps)",frame_window, _jpg_buf_len / 1024, window_ms, fps);
ESP_LOGI(STREAM_SERVER_TAG, "%i Frames Size: %uKB, Time: %lims (%lifps)", frame_window, _jpg_buf_len / 1024, window_ms, fps);
}
}
}
@@ -115,7 +113,7 @@ esp_err_t StreamHelpers::stream(httpd_req_t *req)
return response;
}
esp_err_t StreamHelpers::ws_logs_handle(httpd_req_t *req)
esp_err_t StreamHelpers::ws_logs_handle(httpd_req_t* req)
{
auto ret = webSocketLogger.register_socket_client(req);
return ret;
components/StreamServer/StreamServer/StreamServer.hpp
+13 -13
View File
@@ -4,35 +4,35 @@
#define PART_BOUNDARY "123456789000000000000987654321"
#include "esp_log.h"
#include "esp_camera.h"
#include "esp_http_server.h"
#include "esp_timer.h"
#include <StateManager.hpp>
#include <WebSocketLogger.hpp>
#include <helpers.hpp>
#include "esp_camera.h"
#include "esp_http_server.h"
#include "esp_log.h"
#include "esp_timer.h"
extern WebSocketLogger webSocketLogger;
namespace StreamHelpers
{
esp_err_t stream(httpd_req_t *req);
esp_err_t ws_logs_handle(httpd_req_t *req);
}
esp_err_t stream(httpd_req_t* req);
esp_err_t ws_logs_handle(httpd_req_t* req);
} // namespace StreamHelpers
class StreamServer
{
private:
private:
int STREAM_SERVER_PORT;
StateManager *stateManager;
StateManager* stateManager;
httpd_handle_t camera_stream = nullptr;
public:
StreamServer(const int STREAM_PORT, StateManager *StateManager);
public:
StreamServer(const int STREAM_PORT, StateManager* StateManager);
esp_err_t startStreamServer();
esp_err_t stream(httpd_req_t *req);
esp_err_t ws_logs_handle(httpd_req_t *req);
esp_err_t stream(httpd_req_t* req);
esp_err_t ws_logs_handle(httpd_req_t* req);
};
#endif
components/UVCStream/UVCStream/UVCStream.cpp
+12 -12
View File
@@ -5,7 +5,7 @@
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
static const char *UVC_STREAM_TAG = "[UVC DEVICE]";
static const char* UVC_STREAM_TAG = "[UVC DEVICE]";
// Tracks whether a frame has been handed to TinyUSB and not yet returned.
// File scope so both get_cb and return_cb can access it safely.
@@ -15,12 +15,12 @@ extern "C"
{
static char serial_number_str[13];
const char *get_uvc_device_name()
const char* get_uvc_device_name()
{
return deviceConfig->getMDNSConfig().hostname.c_str();
}
const char *get_serial_number(void)
const char* get_serial_number(void)
{
if (serial_number_str[0] == '\0')
{
@@ -33,8 +33,8 @@ extern "C"
}
// 12 hex chars without separators
snprintf(serial_number_str, sizeof(serial_number_str), "%02X%02X%02X%02X%02X%02X",
mac_address[0], mac_address[1], mac_address[2], mac_address[3], mac_address[4], mac_address[5]);
snprintf(serial_number_str, sizeof(serial_number_str), "%02X%02X%02X%02X%02X%02X", mac_address[0], mac_address[1], mac_address[2], mac_address[3],
mac_address[4], mac_address[5]);
}
return serial_number_str;
}
@@ -43,7 +43,7 @@ extern "C"
// single definition of shared framebuffer storage
UVCStreamHelpers::fb_t UVCStreamHelpers::s_fb = {};
static esp_err_t UVCStreamHelpers::camera_start_cb(uvc_format_t format, int width, int height, int rate, void *cb_ctx)
static esp_err_t UVCStreamHelpers::camera_start_cb(uvc_format_t format, int width, int height, int rate, void* cb_ctx)
{
ESP_LOGI(UVC_STREAM_TAG, "Camera Start");
ESP_LOGI(UVC_STREAM_TAG, "Format: %d, width: %d, height: %d, rate: %d", format, width, height, rate);
@@ -72,7 +72,7 @@ static esp_err_t UVCStreamHelpers::camera_start_cb(uvc_format_t format, int widt
return ESP_OK;
}
static void UVCStreamHelpers::camera_stop_cb(void *cb_ctx)
static void UVCStreamHelpers::camera_stop_cb(void* cb_ctx)
{
(void)cb_ctx;
if (s_fb.cam_fb_p)
@@ -84,9 +84,9 @@ static void UVCStreamHelpers::camera_stop_cb(void *cb_ctx)
SendStreamEvent(eventQueue, StreamState_e::Stream_OFF);
}
static uvc_fb_t *UVCStreamHelpers::camera_fb_get_cb(void *cb_ctx)
static uvc_fb_t* UVCStreamHelpers::camera_fb_get_cb(void* cb_ctx)
{
auto *mgr = static_cast<UVCStreamManager *>(cb_ctx);
auto* mgr = static_cast<UVCStreamManager*>(cb_ctx);
// Guard against requesting a new frame while previous is still in flight.
// This was causing intermittent corruption/glitches because the pointer
@@ -114,7 +114,7 @@ static uvc_fb_t *UVCStreamHelpers::camera_fb_get_cb(void *cb_ctx)
}
// Acquire a fresh frame only when allowed and no frame in flight
camera_fb_t *cam_fb = esp_camera_fb_get();
camera_fb_t* cam_fb = esp_camera_fb_get();
if (!cam_fb)
{
return nullptr;
@@ -152,7 +152,7 @@ static uvc_fb_t *UVCStreamHelpers::camera_fb_get_cb(void *cb_ctx)
return &s_fb.uvc_fb;
}
static void UVCStreamHelpers::camera_fb_return_cb(uvc_fb_t *fb, void *cb_ctx)
static void UVCStreamHelpers::camera_fb_return_cb(uvc_fb_t* fb, void* cb_ctx)
{
(void)cb_ctx;
assert(fb == &s_fb.uvc_fb);
@@ -169,7 +169,7 @@ esp_err_t UVCStreamManager::setup()
ESP_LOGI(UVC_STREAM_TAG, "Setting up UVC Stream");
// Allocate a fixed-size transfer buffer (compile-time constant)
uvc_buffer_size = UVCStreamManager::UVC_MAX_FRAMESIZE_SIZE;
uvc_buffer = static_cast<uint8_t *>(malloc(uvc_buffer_size));
uvc_buffer = static_cast<uint8_t*>(malloc(uvc_buffer_size));
if (uvc_buffer == nullptr)
{
ESP_LOGE(UVC_STREAM_TAG, "Allocating buffer for UVC Device failed");
components/UVCStream/UVCStream/UVCStream.hpp
+23 -20
View File
@@ -5,15 +5,15 @@
#include "sdkconfig.h"
#ifdef CONFIG_GENERAL_INCLUDE_UVC_MODE
#include "esp_timer.h"
#include "esp_mac.h"
#include "esp_camera.h"
#include <CameraManager.hpp>
#include <StateManager.hpp>
#include "esp_camera.h"
#include "esp_log.h"
#include "usb_device_uvc.h"
#include "esp_mac.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "usb_device_uvc.h"
// we need access to the camera manager
// in order to update the frame settings
@@ -25,8 +25,8 @@ extern "C"
{
#endif
const char *get_uvc_device_name();
const char *get_serial_number(void);
const char* get_uvc_device_name();
const char* get_serial_number(void);
#ifdef __cplusplus
}
@@ -37,32 +37,35 @@ extern QueueHandle_t eventQueue;
namespace UVCStreamHelpers
{
typedef struct
{
camera_fb_t *cam_fb_p;
typedef struct
{
camera_fb_t* cam_fb_p;
uvc_fb_t uvc_fb;
} fb_t;
} fb_t;
// single storage is defined in UVCStream.cpp
extern fb_t s_fb;
// single storage is defined in UVCStream.cpp
extern fb_t s_fb;
static esp_err_t camera_start_cb(uvc_format_t format, int width, int height, int rate, void *cb_ctx);
static void camera_stop_cb(void *cb_ctx);
static uvc_fb_t *camera_fb_get_cb(void *cb_ctx);
static void camera_fb_return_cb(uvc_fb_t *fb, void *cb_ctx);
}
static esp_err_t camera_start_cb(uvc_format_t format, int width, int height, int rate, void* cb_ctx);
static void camera_stop_cb(void* cb_ctx);
static uvc_fb_t* camera_fb_get_cb(void* cb_ctx);
static void camera_fb_return_cb(uvc_fb_t* fb, void* cb_ctx);
} // namespace UVCStreamHelpers
class UVCStreamManager
{
uint8_t *uvc_buffer = nullptr;
uint8_t* uvc_buffer = nullptr;
uint32_t uvc_buffer_size = 0;
public:
public:
// Compile-time buffer size; keep conservative headroom for MJPEG QVGA
static constexpr uint32_t UVC_MAX_FRAMESIZE_SIZE = 75 * 1024;
esp_err_t setup();
esp_err_t start();
uint32_t getUvcBufferSize() const { return uvc_buffer_size; }
uint32_t getUvcBufferSize() const
{
return uvc_buffer_size;
}
};
#endif // UVCSTREAM_HPP
components/WebSocketLogger/WebSocketLogger/WebSocketLogger.cpp
+7 -7
View File
@@ -10,24 +10,24 @@ WebSocketLogger::WebSocketLogger()
this->ws_log_buffer[0] = '\0';
}
void LoggerHelpers::ws_async_send(void *arg)
void LoggerHelpers::ws_async_send(void* arg)
{
char *log_buffer = webSocketLogger.get_websocket_log_buffer();
char* log_buffer = webSocketLogger.get_websocket_log_buffer();
const auto *resp_arg = static_cast<struct async_resp_arg *>(arg);
const auto* resp_arg = static_cast<struct async_resp_arg*>(arg);
const auto hd = resp_arg->hd;
const auto fd = resp_arg->fd;
auto websocket_packet = httpd_ws_frame_t{};
websocket_packet.payload = reinterpret_cast<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;
httpd_ws_send_frame_async(hd, fd, &websocket_packet);
}
esp_err_t WebSocketLogger::log_message(const char *format, va_list args)
esp_err_t WebSocketLogger::log_message(const char* format, va_list args)
{
vsnprintf(this->ws_log_buffer, 100, format, args);
@@ -46,7 +46,7 @@ esp_err_t WebSocketLogger::log_message(const char *format, va_list args)
return ret;
}
esp_err_t WebSocketLogger::register_socket_client(httpd_req_t *req)
esp_err_t WebSocketLogger::register_socket_client(httpd_req_t* req)
{
if (connected_socket_client.fd != -1 && connected_socket_client.hd != nullptr)
{
@@ -65,7 +65,7 @@ void WebSocketLogger::unregister_socket_client()
connected_socket_client.hd = nullptr;
}
char *WebSocketLogger::get_websocket_log_buffer()
char* WebSocketLogger::get_websocket_log_buffer()
{
return this->ws_log_buffer;
}
components/WebSocketLogger/WebSocketLogger/WebSocketLogger.hpp
+5 -5
View File
@@ -15,7 +15,7 @@ struct async_resp_arg
namespace LoggerHelpers
{
void ws_async_send(void *arg);
void ws_async_send(void* arg);
}
class WebSocketLogger
@@ -23,14 +23,14 @@ class WebSocketLogger
async_resp_arg connected_socket_client{};
char ws_log_buffer[WS_LOG_BUFFER_LEN]{};
public:
public:
WebSocketLogger();
esp_err_t log_message(const char *format, va_list args);
esp_err_t register_socket_client(httpd_req_t *req);
esp_err_t log_message(const char* format, va_list args);
esp_err_t register_socket_client(httpd_req_t* req);
void unregister_socket_client();
bool is_client_connected();
char *get_websocket_log_buffer();
char* get_websocket_log_buffer();
};
extern WebSocketLogger webSocketLogger;
components/openiris_logo/openiris_logo/openiris_logo.hpp
+5 -5
View File
@@ -6,10 +6,10 @@
namespace Logo
{
static const char *LOGO_TAG = "[LOGO]";
static const char* LOGO_TAG = "[LOGO]";
inline static void printASCII()
{
inline static void printASCII()
{
ESP_LOGI(LOGO_TAG, " : === WELCOME === TO === : ");
ESP_LOGI(LOGO_TAG, " <===========================================================================================================================> ");
ESP_LOGI(LOGO_TAG, " ██████╗ ██████╗ ███████╗███╗ ██╗██╗██████╗ ██╗███████╗ ");
@@ -70,7 +70,7 @@ namespace Logo
ESP_LOGI(LOGO_TAG, " ████████ ");
ESP_LOGI(LOGO_TAG, " ");
ESP_LOGI(LOGO_TAG, " <============================================================================================================================> ");
}
};
}
}; // namespace Logo
#endif
components/wifiManager/wifiManager/WiFiScanner.cpp
+14 -20
View File
@@ -2,14 +2,13 @@
#include <cstring>
#include "esp_timer.h"
static const char *TAG = "WiFiScanner";
static const char* TAG = "WiFiScanner";
WiFiScanner::WiFiScanner() {}
void WiFiScanner::scanResultCallback(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data)
void WiFiScanner::scanResultCallback(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
{
auto *scanner = static_cast<WiFiScanner *>(arg);
auto* scanner = static_cast<WiFiScanner*>(arg);
if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_SCAN_DONE)
{
uint16_t ap_count = 0;
@@ -21,14 +20,14 @@ void WiFiScanner::scanResultCallback(void *arg, esp_event_base_t event_base,
return;
}
wifi_ap_record_t *ap_records = new wifi_ap_record_t[ap_count];
wifi_ap_record_t* ap_records = new wifi_ap_record_t[ap_count];
ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&ap_count, ap_records));
scanner->networks.clear();
for (uint16_t i = 0; i < ap_count; i++)
{
WiFiNetwork network;
network.ssid = std::string(reinterpret_cast<char *>(ap_records[i].ssid));
network.ssid = std::string(reinterpret_cast<char*>(ap_records[i].ssid));
network.channel = ap_records[i].primary;
network.rssi = ap_records[i].rssi;
memcpy(network.mac, ap_records[i].bssid, 6);
@@ -74,8 +73,8 @@ std::vector<WiFiNetwork> WiFiScanner::scanNetworks(int timeout_ms)
.channel = 0, // 0 means scan all channels
.show_hidden = true,
.scan_type = WIFI_SCAN_TYPE_ACTIVE, // Active scan
.scan_time = {
.active = {
.scan_time = {.active =
{
.min = 120, // Min per channel
.max = 300 // Max per channel
},
@@ -109,17 +108,12 @@ std::vector<WiFiNetwork> WiFiScanner::scanNetworks(int timeout_ms)
break;
}
wifi_scan_config_t scan_config = {
.ssid = nullptr,
wifi_scan_config_t scan_config = {.ssid = nullptr,
.bssid = nullptr,
.channel = ch,
.show_hidden = true,
.scan_type = WIFI_SCAN_TYPE_ACTIVE,
.scan_time = {
.active = {
.min = 100,
.max = 200},
.passive = 300},
.scan_time = {.active = {.min = 100, .max = 200}, .passive = 300},
.home_chan_dwell_time = 0,
.channel_bitmap = 0};
@@ -130,7 +124,7 @@ std::vector<WiFiNetwork> WiFiScanner::scanNetworks(int timeout_ms)
esp_wifi_scan_get_ap_num(&ch_count);
if (ch_count > 0)
{
wifi_ap_record_t *ch_records = new wifi_ap_record_t[ch_count];
wifi_ap_record_t* ch_records = new wifi_ap_record_t[ch_count];
if (esp_wifi_scan_get_ap_records(&ch_count, ch_records) == ESP_OK)
{
for (uint16_t i = 0; i < ch_count; i++)
@@ -145,10 +139,10 @@ std::vector<WiFiNetwork> WiFiScanner::scanNetworks(int timeout_ms)
}
// Process all collected records
for (const auto &record : all_records)
for (const auto& record : all_records)
{
WiFiNetwork network;
network.ssid = std::string(reinterpret_cast<const char *>(record.ssid));
network.ssid = std::string(reinterpret_cast<const char*>(record.ssid));
network.channel = record.primary;
network.rssi = record.rssi;
memcpy(network.mac, record.bssid, 6);
@@ -206,7 +200,7 @@ std::vector<WiFiNetwork> WiFiScanner::scanNetworks(int timeout_ms)
return scan_results;
}
wifi_ap_record_t *ap_records = new wifi_ap_record_t[ap_count];
wifi_ap_record_t* ap_records = new wifi_ap_record_t[ap_count];
err = esp_wifi_scan_get_ap_records(&ap_count, ap_records);
if (err != ESP_OK)
{
@@ -221,7 +215,7 @@ std::vector<WiFiNetwork> WiFiScanner::scanNetworks(int timeout_ms)
for (uint16_t i = 0; i < ap_count; i++)
{
WiFiNetwork network;
network.ssid = std::string(reinterpret_cast<char *>(ap_records[i].ssid));
network.ssid = std::string(reinterpret_cast<char*>(ap_records[i].ssid));
network.channel = ap_records[i].primary;
network.rssi = ap_records[i].rssi;
memcpy(network.mac, ap_records[i].bssid, 6);
components/wifiManager/wifiManager/WiFiScanner.hpp
+5 -5
View File
@@ -2,10 +2,10 @@
#ifndef WIFI_SCANNER_HPP
#define WIFI_SCANNER_HPP
#include <vector>
#include <string>
#include "esp_wifi.h"
#include <vector>
#include "esp_log.h"
#include "esp_wifi.h"
struct WiFiNetwork
{
@@ -18,12 +18,12 @@ struct WiFiNetwork
class WiFiScanner
{
public:
public:
WiFiScanner();
std::vector<WiFiNetwork> scanNetworks(int timeout_ms = 15000);
static void scanResultCallback(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data);
static void scanResultCallback(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data);
private:
private:
std::vector<WiFiNetwork> networks;
};
components/wifiManager/wifiManager/wifiManager.cpp
+24 -41
View File
@@ -5,8 +5,7 @@ static auto WIFI_MANAGER_TAG = "[WIFI_MANAGER]";
int s_retry_num = 0;
EventGroupHandle_t s_wifi_event_group;
void WiFiManagerHelpers::event_handler(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data)
void WiFiManagerHelpers::event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
{
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)
@@ -18,7 +17,7 @@ void WiFiManagerHelpers::event_handler(void *arg, esp_event_base_t event_base,
}
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED)
{
const auto *disconnected = static_cast<wifi_event_sta_disconnected_t *>(event_data);
const auto* disconnected = static_cast<wifi_event_sta_disconnected_t*>(event_data);
ESP_LOGI(WIFI_MANAGER_TAG, "Disconnect reason: %d", disconnected->reason);
if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY)
@@ -36,17 +35,19 @@ void WiFiManagerHelpers::event_handler(void *arg, esp_event_base_t event_base,
else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP)
{
const auto *event = static_cast<ip_event_got_ip_t *>(event_data);
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);
}
}
WiFiManager::WiFiManager(std::shared_ptr<ProjectConfig> deviceConfig, QueueHandle_t eventQueue, StateManager *stateManager)
: deviceConfig(deviceConfig), eventQueue(eventQueue), stateManager(stateManager), wifiScanner(std::make_unique<WiFiScanner>()) {}
WiFiManager::WiFiManager(std::shared_ptr<ProjectConfig> deviceConfig, QueueHandle_t eventQueue, StateManager* stateManager)
: deviceConfig(deviceConfig), eventQueue(eventQueue), stateManager(stateManager), wifiScanner(std::make_unique<WiFiScanner>())
{
}
void WiFiManager::SetCredentials(const char *ssid, const char *password)
void WiFiManager::SetCredentials(const char* ssid, const char* password)
{
// Clear the config first
memset(&_wifi_cfg, 0, sizeof(_wifi_cfg));
@@ -94,8 +95,7 @@ void WiFiManager::SetCredentials(const char *ssid, const char *password)
// Log what we're trying to connect to with detailed debugging
ESP_LOGI(WIFI_MANAGER_TAG, "Setting credentials for SSID: '%s' (length: %d)", ssid, (int)strlen(ssid));
ESP_LOGI(WIFI_MANAGER_TAG, "Password: '%s' (length: %d)", password, (int)strlen(password));
ESP_LOGI(WIFI_MANAGER_TAG, "Auth mode: %d, PMF capable: %d",
_wifi_cfg.sta.threshold.authmode, _wifi_cfg.sta.pmf_cfg.capable);
ESP_LOGI(WIFI_MANAGER_TAG, "Auth mode: %d, PMF capable: %d", _wifi_cfg.sta.threshold.authmode, _wifi_cfg.sta.pmf_cfg.capable);
}
void WiFiManager::ConnectWithHardcodedCredentials()
@@ -104,7 +104,8 @@ void WiFiManager::ConnectWithHardcodedCredentials()
this->SetCredentials(CONFIG_WIFI_SSID, CONFIG_WIFI_PASSWORD);
wifi_mode_t mode;
if (esp_wifi_get_mode(&mode) == ESP_OK) {
if (esp_wifi_get_mode(&mode) == ESP_OK)
{
esp_wifi_stop();
}
@@ -118,18 +119,13 @@ void WiFiManager::ConnectWithHardcodedCredentials()
xQueueSend(this->eventQueue, &event, 10);
// Use shorter timeout for faster startup - 8 seconds should be enough for most networks
EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
pdFALSE,
pdFALSE,
pdMS_TO_TICKS(8000));
EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE, pdMS_TO_TICKS(8000));
/* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually
* happened. */
if (bits & WIFI_CONNECTED_BIT)
{
ESP_LOGI(WIFI_MANAGER_TAG, "connected to ap SSID:%p password:%p",
_wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
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;
xQueueSend(this->eventQueue, &event, 10);
@@ -137,8 +133,7 @@ void WiFiManager::ConnectWithHardcodedCredentials()
else if (bits & WIFI_FAIL_BIT)
{
ESP_LOGE(WIFI_MANAGER_TAG, "Failed to connect to SSID:%p, password:%p",
_wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
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;
xQueueSend(this->eventQueue, &event, 10);
@@ -170,7 +165,7 @@ void WiFiManager::ConnectWithStoredCredentials()
// Ensure we're in STA mode
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
for (const auto &network : networks)
for (const auto& network : networks)
{
// Reset retry counter for each network attempt
s_retry_num = 0;
@@ -194,23 +189,18 @@ void WiFiManager::ConnectWithStoredCredentials()
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,
pdFALSE,
EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE,
pdMS_TO_TICKS(10000)); // 10 second timeout for faster failover
if (bits & WIFI_CONNECTED_BIT)
{
ESP_LOGI(WIFI_MANAGER_TAG, "connected to ap SSID:%s",
network.ssid.c_str());
ESP_LOGI(WIFI_MANAGER_TAG, "connected to ap SSID:%s", network.ssid.c_str());
event.value = WiFiState_e::WiFiState_Connected;
xQueueSend(this->eventQueue, &event, 10);
return;
}
ESP_LOGE(WIFI_MANAGER_TAG, "Failed to connect to SSID:%s, trying next stored network",
network.ssid.c_str());
ESP_LOGE(WIFI_MANAGER_TAG, "Failed to connect to SSID:%s, trying next stored network", network.ssid.c_str());
// Disconnect before trying next network
esp_wifi_disconnect();
@@ -232,7 +222,8 @@ void WiFiManager::SetupAccessPoint()
ESP_ERROR_CHECK(esp_wifi_init(&esp_wifi_ap_init_config));
wifi_config_t ap_wifi_config = {
.ap = {
.ap =
{
.ssid = CONFIG_WIFI_AP_SSID,
.password = CONFIG_WIFI_AP_PASSWORD,
.max_connection = 1,
@@ -263,7 +254,7 @@ std::vector<WiFiNetwork> WiFiManager::ScanNetworks(int timeout_ms)
ESP_LOGI(WIFI_MANAGER_TAG, "AP mode detected, checking for STA interface");
// Check if STA netif already exists
esp_netif_t *sta_netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
esp_netif_t* sta_netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
bool sta_netif_exists = (sta_netif != nullptr);
if (!sta_netif_exists)
@@ -341,7 +332,7 @@ void WiFiManager::TryConnectToStoredNetworks()
vTaskDelay(pdMS_TO_TICKS(100));
// Check if STA interface exists, create if needed
esp_netif_t *sta_netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
esp_netif_t* sta_netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
if (sta_netif == nullptr)
{
ESP_LOGI(WIFI_MANAGER_TAG, "Creating STA interface");
@@ -370,16 +361,8 @@ void WiFiManager::Begin()
wifi_init_config_t esp_wifi_init_config = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&esp_wifi_init_config));
ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
ESP_EVENT_ANY_ID,
&WiFiManagerHelpers::event_handler,
nullptr,
&instance_any_id));
ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
IP_EVENT_STA_GOT_IP,
&WiFiManagerHelpers::event_handler,
nullptr,
&instance_got_ip));
ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &WiFiManagerHelpers::event_handler, nullptr, &instance_any_id));
ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &WiFiManagerHelpers::event_handler, nullptr, &instance_got_ip));
_wifi_cfg = {};
_wifi_cfg.sta.threshold.authmode = WIFI_AUTH_OPEN; // Start with open, will be set properly by SetCredentials
components/wifiManager/wifiManager/wifiManager.hpp
+11 -12
View File
@@ -2,16 +2,16 @@
#ifndef WIFIHANDLER_HPP
#define WIFIHANDLER_HPP
#include <string>
#include <cstring>
#include <algorithm>
#include <StateManager.hpp>
#include <ProjectConfig.hpp>
#include <StateManager.hpp>
#include <algorithm>
#include <cstring>
#include <string>
#include "WiFiScanner.hpp"
#include "esp_event.h"
#include "esp_wifi.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
@@ -21,17 +21,16 @@
namespace WiFiManagerHelpers
{
void event_handler(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data);
void event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data);
}
class WiFiManager
{
private:
private:
uint8_t channel;
std::shared_ptr<ProjectConfig> deviceConfig;
QueueHandle_t eventQueue;
StateManager *stateManager;
StateManager* stateManager;
wifi_init_config_t _wifi_init_cfg = WIFI_INIT_CONFIG_DEFAULT();
wifi_config_t _wifi_cfg = {};
std::unique_ptr<WiFiScanner> wifiScanner;
@@ -41,13 +40,13 @@ private:
int8_t power;
void SetCredentials(const char *ssid, const char *password);
void SetCredentials(const char* ssid, const char* password);
void ConnectWithHardcodedCredentials();
void ConnectWithStoredCredentials();
void SetupAccessPoint();
public:
WiFiManager(std::shared_ptr<ProjectConfig> deviceConfig, QueueHandle_t eventQueue, StateManager *stateManager);
public:
WiFiManager(std::shared_ptr<ProjectConfig> deviceConfig, QueueHandle_t eventQueue, StateManager* stateManager);
void Begin();
std::vector<WiFiNetwork> ScanNetworks(int timeout_ms = 15000);
WiFiState_e GetCurrentWiFiState();
main/openiris_main.cpp
+24 -56
View File
@@ -1,27 +1,27 @@
#include <cstdio>
#include <string>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"
#include "nvs_flash.h"
#include "sdkconfig.h"
#include <openiris_logo.hpp>
#include <wifiManager.hpp>
#include <ProjectConfig.hpp>
#include <StateManager.hpp>
#include <CameraManager.hpp>
#include <CommandManager.hpp>
#include <LEDManager.hpp>
#include <MDNSManager.hpp>
#include <CameraManager.hpp>
#include <WebSocketLogger.hpp>
#include <StreamServer.hpp>
#include <CommandManager.hpp>
#include <SerialManager.hpp>
#include <ProjectConfig.hpp>
#include <RestAPI.hpp>
#include <SerialManager.hpp>
#include <StateManager.hpp>
#include <StreamServer.hpp>
#include <WebSocketLogger.hpp>
#include <main_globals.hpp>
#include <openiris_logo.hpp>
#include <wifiManager.hpp>
#if CONFIG_MONITORING_LED_CURRENT || CONFIG_MONITORING_BATTERY_ENABLE
#include <MonitoringManager.hpp>
@@ -50,7 +50,7 @@ QueueHandle_t eventQueue = xQueueCreate(10, sizeof(SystemEvent));
QueueHandle_t ledStateQueue = xQueueCreate(10, sizeof(uint32_t));
QueueHandle_t cdcMessageQueue = xQueueCreate(3, sizeof(cdc_command_packet_t));
auto *stateManager = new StateManager(eventQueue, ledStateQueue);
auto* stateManager = new StateManager(eventQueue, ledStateQueue);
auto dependencyRegistry = std::make_shared<DependencyRegistry>();
auto commandManager = std::make_shared<CommandManager>(dependencyRegistry);
@@ -76,7 +76,7 @@ auto ledManager = std::make_shared<LEDManager>(BLINK_GPIO, CONFIG_LED_C_PIN_GPIO
std::shared_ptr<MonitoringManager> monitoringManager = std::make_shared<MonitoringManager>();
#endif
auto *serialManager = new SerialManager(commandManager, &timerHandle);
auto* serialManager = new SerialManager(commandManager, &timerHandle);
void startWiFiMode();
void startWiredMode(bool shouldCloseSerialManager);
@@ -92,7 +92,7 @@ static void initNVSStorage()
ESP_ERROR_CHECK(ret);
}
int websocket_logger(const char *format, va_list args)
int websocket_logger(const char* format, va_list args)
{
webSocketLogger.log_message(format, args);
return vprintf(format, args);
@@ -129,10 +129,9 @@ void launch_streaming()
}
// Callback for automatic startup after delay
void startup_timer_callback(void *arg)
void startup_timer_callback(void* arg)
{
ESP_LOGI("[MAIN]", "Startup timer fired, startupCommandReceived=%s, startupPaused=%s",
getStartupCommandReceived() ? "true" : "false",
ESP_LOGI("[MAIN]", "Startup timer fired, startupCommandReceived=%s, startupPaused=%s", getStartupCommandReceived() ? "true" : "false",
getStartupPaused() ? "true" : "false");
if (!getStartupCommandReceived() && !getStartupPaused())
@@ -199,13 +198,7 @@ void startWiredMode(bool shouldCloseSerialManager)
}
ESP_LOGI("[MAIN]", "Starting CDC Serial Manager Task");
xTaskCreate(
HandleCDCSerialManagerTask,
"HandleCDCSerialManagerTask",
1024 * 6,
commandManager.get(),
1,
nullptr);
xTaskCreate(HandleCDCSerialManagerTask, "HandleCDCSerialManagerTask", 1024 * 6, commandManager.get(), 1, nullptr);
ESP_LOGI("[MAIN]", "Starting UVC streaming");
@@ -227,11 +220,7 @@ void startWiFiMode()
{
streamServer.startStreamServer();
}
xTaskCreate(
HandleRestAPIPollTask,
"HandleRestAPIPollTask",
2024 * 2,
restAPI.get(),
xTaskCreate(HandleRestAPIPollTask, "HandleRestAPIPollTask", 2024 * 2, restAPI.get(),
1, // it's the rest API, we only serve commands over it so we don't really need a higher priority
nullptr);
#else
@@ -251,11 +240,7 @@ void startSetupMode()
// Create a one-shot timer for 20 seconds
const esp_timer_create_args_t startup_timer_args = {
.callback = &startup_timer_callback,
.arg = nullptr,
.dispatch_method = ESP_TIMER_TASK,
.name = "startup_timer",
.skip_unhandled_events = false};
.callback = &startup_timer_callback, .arg = nullptr, .dispatch_method = ESP_TIMER_TASK, .name = "startup_timer", .skip_unhandled_events = false};
ESP_ERROR_CHECK(esp_timer_create(&startup_timer_args, &timerHandle));
ESP_ERROR_CHECK(esp_timer_start_once(timerHandle, startup_delay_s * 1000000));
@@ -290,35 +275,18 @@ extern "C" void app_main(void)
monitoringManager->start();
#endif
xTaskCreate(
HandleStateManagerTask,
"HandleStateManagerTask",
1024 * 2,
stateManager,
3,
xTaskCreate(HandleStateManagerTask, "HandleStateManagerTask", 1024 * 2, stateManager, 3,
nullptr // it's fine for us not get a handle back, we don't need it
);
xTaskCreate(
HandleLEDDisplayTask,
"HandleLEDDisplayTask",
1024 * 2,
ledManager.get(),
3,
nullptr);
xTaskCreate(HandleLEDDisplayTask, "HandleLEDDisplayTask", 1024 * 2, ledManager.get(), 3, nullptr);
cameraHandler->setupCamera();
// let's keep the serial manager running for the duration of the setup
// we'll clean it up later if need be
serialManager->setup();
xTaskCreate(
HandleSerialManagerTask,
"HandleSerialManagerTask",
1024 * 6,
serialManager,
1,
&serialManagerHandle);
xTaskCreate(HandleSerialManagerTask, "HandleSerialManagerTask", 1024 * 6, serialManager, 1, &serialManagerHandle);
StreamingMode mode = deviceConfig->getDeviceMode();
if (mode == StreamingMode::UVC)