✨ Adds callback based event bus

.vscode/settings.json

@@ -13,7 +13,7 @@
     },
     "editor.tabSize": 4,
     "editor.detectIndentation": false,
-    "cmake.sourceDirectory": "C:/data/repos/Hardware/Spot Micro - Leika/.pio/libdeps/esp32cam/esp32-camera",
+    "cmake.sourceDirectory": "C:/data/repos/Hardware/Spot_Micro_Leika",
     "cSpell.words": [
       "Adafruit",
       "IRAM",

app/src/lib/filesystem/chunkedTransfer.ts

@@ -15,7 +15,7 @@ import type {
 } from '$lib/platform_shared/filesystem'
 import type { Result, DataResult, ListResult, ProgressCallback } from '$lib/types/models'
 
-const MAX_CHUNK_SIZE = 1024 * 64 // 64KB - must match ESP32 FS_MAX_CHUNK_SIZE
+const MAX_CHUNK_SIZE = 2 ** 14
 
 type TimeoutId = ReturnType<typeof setTimeout>
 type CleanupFn = (() => void) | null
@@ -51,7 +51,7 @@ export class FileSystemClient {
 	private downloadListenerCleanup: CleanupFn = null
 	private completeListenerCleanup: CleanupFn = null
 	private uploadCompleteListenerCleanup: CleanupFn = null
-	private transferTimeout = 300000
+	private transferTimeout = 60000
 
 	constructor() {
 		this.setupListeners()

app/src/lib/stores/socket.ts

@@ -153,8 +153,6 @@ function createWebSocket() {
             }
 
             const { tag, msg } = decodeMessage(frame.data)
-            const key: keyof Message = (MESSAGE_TAG_TO_KEY.get(tag) ?? "") as keyof Message;
-            console.log(key + ": ", msg[key])
             if (msg.correlationResponse) {
                 const pending = pending_requests.get(msg.correlationResponse.correlationId)
                 if (pending) {

app/vite.config.ts

@@ -21,7 +21,7 @@ export default defineConfig({
     server: {
         proxy: {
             '/api': {
-                target: 'http://192.168.50.141/',
+                target: 'http://spot-micro.local/',
                 changeOrigin: true,
                 ws: true
             }

boards/esp32p4_dev.json

@@ -0,0 +1,33 @@
+{
+  "build": {
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM"
+    ],
+    "f_cpu": "360000000L",
+    "f_flash": "80000000L",
+    "f_psram": "200000000L",
+    "flash_mode": "qio",
+    "mcu": "esp32p4",
+    "variant": "esp32p4"
+  },
+  "connectivity": [
+    "wifi"
+  ],
+  "debug": {
+    "openocd_target": "esp32p4.cfg"
+  },
+  "frameworks": [
+    "espidf"
+  ],
+  "name": "ESP32-P4 Dev Board (32MB PSRAM + 32MB Flash, C6 coprocessor)",
+  "upload": {
+    "flash_size": "32MB",
+    "maximum_ram_size": 786432,
+    "maximum_size": 33554432,
+    "require_upload_port": true,
+    "speed": 1500000
+  },
+  "url": "https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32p4/",
+  "vendor": "Espressif"
+}

esp32/include/ap_service.h

@@ -1,8 +1,7 @@
 #pragma once
 
-#include <template/stateful_service.h>
-#include <template/stateful_proto_endpoint.h>
-#include <template/stateful_persistence_pb.h>
+#include <esp_http_server.h>
+#include <eventbus.hpp>
 #include <settings/ap_settings.h>
 #include <utils/timing.h>
 #include <wifi/wifi_idf.h>
@@ -10,7 +9,9 @@
 #include <esp_timer.h>
 #include <string>
 
-class APService : public StatefulService<APSettings> {
+class WebServer;
+
+class APService {
   public:
     APService();
     ~APService();
@@ -23,10 +24,11 @@ class APService : public StatefulService<APSettings> {
     void statusProto(api_APStatus &proto);
     APNetworkStatus getAPNetworkStatus();
 
-    StatefulProtoEndpoint<APSettings, api_APSettings> protoEndpoint;
+    void registerRoutes(WebServer &server);
 
   private:
-    FSPersistencePB<APSettings> _persistence;
+    APSettings _settings {};
+    SubscriptionHandle _settingsHandle;
     DNSServer *_dnsServer;
 
     volatile unsigned long _lastManaged;

esp32/include/communication/comm_base.hpp

@@ -8,7 +8,7 @@
 #include <map>
 #include <type_traits>
 #include <communication/proto_helpers.h>
-#include <utils/timing.h>
+#include <eventbus.hpp>
 
 class CommAdapterBase {
   public:
@@ -36,6 +36,11 @@ class CommAdapterBase {
         decoder_.on<T>(handler);
     }
 
+    template <typename T>
+    void forward() {
+        decoder_.on<T>([](const T& data, int) { EventBus::instance().publish(data); });
+    }
+
     template <typename T>
     void emit(const T& data, int clientId = -1) {
         constexpr pb_size_t tag = MessageTraits<T>::tag;
@@ -48,15 +53,13 @@ class CommAdapterBase {
         size_t out_size;
         pb_get_encoded_size(&out_size, socket_message_Message_fields, &msg_);
         uint8_t* buffer = pb_heap_enc_buf;
-        if (out_size > sizeof(pb_heap_enc_buf)) { // If the encoded size exceeds our buffer size, we needs to malloc a
-                                                  // buffer of a proper size
+        if (out_size > sizeof(pb_heap_enc_buf)) {
             buffer = (uint8_t*)malloc(out_size);
         }
 
         pb_ostream_t stream = pb_ostream_from_buffer(buffer, out_size);
         if (!pb_encode(&stream, socket_message_Message_fields, &msg_)) {
-            ESP_LOGE("ProtoComm", "Failed to encode message (tag %d): %s (calc=%u, written=%u)",
-                     (int)tag, PB_GET_ERROR(&stream), out_size, stream.bytes_written);
+            ESP_LOGE("ProtoComm", "Failed to encode message (tag %d), buffer too small?", (int)tag);
             return;
         }
 
@@ -97,11 +100,9 @@ class CommAdapterBase {
     }
 
     void handleIncoming(const uint8_t* data, size_t len, int cid) {
-        TIME_IT(
         if (!decoder_.decode(data, len, cid)) {
             ESP_LOGE("ProtoComm", "Failed to decode incoming message from client %d", cid);
         }
-        , INCOMING_DECODE)
     }
 
     void sendPong(int cid) {

esp32/include/communication/proto_helpers.h

@@ -3,7 +3,6 @@
 #include <pb_encode.h>
 #include <pb_decode.h>
 #include <platform_shared/message.pb.h>
-#include <esp_log.h>
 #include <functional>
 #include <map>
 
@@ -72,48 +71,32 @@ class ProtoDecoder {
     bool decode(const uint8_t* data, size_t len, int clientId) {
         pb_istream_t stream = pb_istream_from_buffer(data, len);
 
-        // Reset message before decoding (nanopb will malloc FT_POINTER fields)
-        msg_ = socket_message_Message_init_zero;
-
-        bool success = pb_decode(&stream, socket_message_Message_fields, &msg_);
-
-        if (!success) {
-            ESP_LOGE("ProtoHelpers", "Decode failed: %s (len=%u)", PB_GET_ERROR(&stream), len);
-            pb_release(socket_message_Message_fields, &msg_);
+        if (!pb_decode(&stream, socket_message_Message_fields, &msg_)) {
             return false;
         }
 
-        bool handled = false;
         switch (msg_.which_message) {
             case socket_message_Message_sub_notif_tag:
                 if (subscribeHandler_) subscribeHandler_(msg_.message.sub_notif.tag, clientId);
-                handled = true;
-                break;
+                return true;
 
             case socket_message_Message_unsub_notif_tag:
                 if (unsubscribeHandler_) unsubscribeHandler_(msg_.message.unsub_notif.tag, clientId);
-                handled = true;
-                break;
+                return true;
 
             case socket_message_Message_pingmsg_tag:
                 if (pingHandler_) pingHandler_(clientId);
-                handled = true;
-                break;
+                return true;
 
             default: {
                 auto it = handlers_.find(msg_.which_message);
                 if (it != handlers_.end()) {
                     it->second(clientId);
-                    handled = true;
+                    return true;
                 }
-                break;
+                return false;
             }
         }
-
-        // Free any malloc'd FT_POINTER fields
-        pb_release(socket_message_Message_fields, &msg_);
-
-        return handled;
     }
 
   private:

esp32/include/communication/webserver.h

@@ -15,7 +15,7 @@
 #include <pb_encode.h>
 #include <pb_decode.h>
 #include <platform_shared/api.pb.h>
-#include <freertos/semphr.h>
+#include <eventbus.hpp>
 
 using HttpGetHandler = std::function<esp_err_t(httpd_req_t*)>;
 using HttpPostHandler = std::function<esp_err_t(httpd_req_t*, api_Request*)>;
@@ -23,16 +23,21 @@ using WsFrameHandler = std::function<esp_err_t(httpd_req_t*, httpd_ws_frame_t*)>
 using WsOpenHandler = std::function<void(httpd_req_t*)>;
 using WsCloseHandler = std::function<void(int)>;
 
-// Macro to register a proto endpoint that extracts a specific payload type
-// Usage: STAITC_PROTO_POST_ENDPOINT(server, "/api/files/delete", file_delete_request, FileSystem::handleDelete)
-// Handler signature: esp_err_t handleDelete(httpd_req_t* req, const api_FileDeleteRequest& payload)
-#define STAITC_PROTO_POST_ENDPOINT(server_ref, uri, payload_type, handler) \
-    (server_ref).on(uri, HTTP_POST, [&](httpd_req_t *request, api_Request *protoReq) { \
-        if (protoReq->which_payload != api_Request_##payload_type##_tag) { \
-            return WebServer::sendError(request, 400, "Invalid request payload"); \
-        } \
-        return handler(request, protoReq->payload.payload_type); \
-    })
+#define PROTO_ROUTE(server_ref, uri, field_name, proto_type)               \
+    (server_ref)                                                           \
+        .protoRoute<proto_type>(                                           \
+            uri,                                                           \
+            [](const api_Request& req, proto_type& out) -> bool {          \
+                if (req.which_payload == api_Request_##field_name##_tag) { \
+                    out = req.payload.field_name;                          \
+                    return true;                                           \
+                }                                                          \
+                return false;                                              \
+            },                                                             \
+            [](api_Response& res, const proto_type& data) {                \
+                res.which_payload = api_Response_##field_name##_tag;       \
+                res.payload.field_name = data;                             \
+            })
 
 struct HttpRoute {
     std::string uri;
@@ -54,6 +59,36 @@ class WebServer {
     void on(const char* uri, httpd_method_t method, HttpGetHandler handler);
     void on(const char* uri, httpd_method_t method, HttpPostHandler handler);
 
+    template <typename ProtoT>
+    void protoRoute(const char* uri, std::function<bool(const api_Request&, ProtoT&)> extractor,
+                    std::function<void(api_Response&, const ProtoT&)> assigner) {
+        on(uri, HTTP_GET, [assigner](httpd_req_t* req) {
+            auto* res = new api_Response();
+            *res = api_Response_init_zero;
+            res->status_code = 200;
+            ProtoT current = EventBus::instance().peek<ProtoT>();
+            assigner(*res, current);
+            esp_err_t ret = WebServer::send(req, 200, *res, api_Response_fields);
+            delete res;
+            return ret;
+        });
+        on(uri, HTTP_POST, [extractor, assigner](httpd_req_t* req, api_Request* protoReq) {
+            ProtoT msg = {};
+            if (!extractor(*protoReq, msg)) {
+                return sendError(req, 400, "Invalid request type");
+            }
+            EventBus::instance().publish(msg);
+            auto* res = new api_Response();
+            *res = api_Response_init_zero;
+            res->status_code = 200;
+            ProtoT current = EventBus::instance().peek<ProtoT>();
+            assigner(*res, current);
+            esp_err_t ret = WebServer::send(req, 200, *res, api_Response_fields);
+            delete res;
+            return ret;
+        });
+    }
+
     void onWsFrame(WsFrameHandler handler);
     void onWsOpen(WsOpenHandler handler);
     void onWsClose(WsCloseHandler handler);

esp32/include/event_storage_manager.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <proto_event_storage.hpp>
+#include <platform_shared/api.pb.h>
+#include <peripherals/servo_controller.h>
+#include <settings/wifi_settings.h>
+#include <settings/ap_settings.h>
+#include <settings/mdns_settings.h>
+#include <settings/peripherals_settings.h>
+#include <settings/camera_settings.h>
+#include <features.h>
+
+class EventStorageManager {
+  public:
+    void initialize() {
+        _servoStorage.begin();
+        _wifiStorage.begin();
+        _apStorage.begin();
+        _peripheralStorage.begin();
+#if FT_ENABLED(USE_MDNS)
+        _mdnsStorage.begin();
+#endif
+#if FT_ENABLED(USE_CAMERA) && USE_DVP_CAMERA
+        _cameraStorage.begin();
+#endif
+    }
+
+  private:
+    ProtoEventStorage<api_ServoSettings, ServoSettings_defaults> _servoStorage {
+        SERVO_SETTINGS_FILE, api_ServoSettings_fields, api_ServoSettings_size, 1000};
+
+    ProtoEventStorage<api_WifiSettings, WiFiSettings_defaults> _wifiStorage {
+        WIFI_SETTINGS_FILE, api_WifiSettings_fields, api_WifiSettings_size, 1000};
+
+    ProtoEventStorage<api_APSettings, APSettings_defaults> _apStorage {AP_SETTINGS_FILE, api_APSettings_fields,
+                                                                       api_APSettings_size, 1000};
+
+    ProtoEventStorage<api_PeripheralSettings, PeripheralsConfiguration_defaults> _peripheralStorage {
+        PERIPHERAL_SETTINGS_FILE, api_PeripheralSettings_fields, api_PeripheralSettings_size, 500};
+
+#if FT_ENABLED(USE_MDNS)
+    ProtoEventStorage<api_MDNSSettings, MDNSSettings_defaults> _mdnsStorage {
+        MDNS_SETTINGS_FILE, api_MDNSSettings_fields, api_MDNSSettings_size, 1000};
+#endif
+
+#if FT_ENABLED(USE_CAMERA) && USE_DVP_CAMERA
+    ProtoEventStorage<api_CameraSettings, CameraSettings_defaults> _cameraStorage {
+        CAMERA_SETTINGS_FILE, api_CameraSettings_fields, api_CameraSettings_size, 1000};
+#endif
+};

esp32/include/event_types.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <cstdint>
+
+struct SystemReadyEvent {};

esp32/include/eventbus.hpp

@@ -0,0 +1,166 @@
+#pragma once
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <functional>
+#include <list>
+#include <map>
+#include <cstdint>
+
+class EventBus;
+
+class SubscriptionHandle {
+  public:
+    SubscriptionHandle() = default;
+
+    ~SubscriptionHandle() { unsubscribe(); }
+
+    SubscriptionHandle(SubscriptionHandle&& other) noexcept
+        : typeId_(other.typeId_), handlerId_(other.handlerId_), bus_(other.bus_) {
+        other.bus_ = nullptr;
+    }
+
+    SubscriptionHandle& operator=(SubscriptionHandle&& other) noexcept {
+        if (this != &other) {
+            unsubscribe();
+            typeId_ = other.typeId_;
+            handlerId_ = other.handlerId_;
+            bus_ = other.bus_;
+            other.bus_ = nullptr;
+        }
+        return *this;
+    }
+
+    SubscriptionHandle(const SubscriptionHandle&) = delete;
+    SubscriptionHandle& operator=(const SubscriptionHandle&) = delete;
+
+    void unsubscribe();
+
+  private:
+    friend class EventBus;
+    using TypeId = const void*;
+
+    SubscriptionHandle(TypeId typeId, uint32_t handlerId, EventBus* bus)
+        : typeId_(typeId), handlerId_(handlerId), bus_(bus) {}
+
+    TypeId typeId_ = nullptr;
+    uint32_t handlerId_ = 0;
+    EventBus* bus_ = nullptr;
+};
+
+class EventBus {
+  public:
+    using TypeId = const void*;
+
+    template <typename T>
+    static TypeId typeId() {
+        static const char id = 0;
+        return &id;
+    }
+
+    static EventBus& instance() {
+        static EventBus bus;
+        return bus;
+    }
+
+    template <typename T>
+    SubscriptionHandle subscribe(std::function<void(const T&)> callback) {
+        xSemaphoreTake(mutex_, portMAX_DELAY);
+        auto id = typeId<T>();
+        uint32_t hid = nextHandlerId_++;
+        handlers_[id].push_back(
+            {hid, [cb = std::move(callback)](const void* data) { cb(*static_cast<const T*>(data)); }});
+        xSemaphoreGive(mutex_);
+        return SubscriptionHandle(id, hid, this);
+    }
+
+    template <typename T>
+    void publish(const T& event) {
+        xSemaphoreTake(mutex_, portMAX_DELAY);
+
+        auto id = typeId<T>();
+        auto& entry = cache_[id];
+        if (entry.data) {
+            *static_cast<T*>(entry.data) = event;
+        } else {
+            entry.data = new T(event);
+            entry.deleter = [](void* p) { delete static_cast<T*>(p); };
+        }
+
+        auto it = handlers_.find(id);
+        if (it == handlers_.end()) {
+            xSemaphoreGive(mutex_);
+            return;
+        }
+        auto snapshot = it->second;
+        xSemaphoreGive(mutex_);
+
+        for (auto& handler : snapshot) {
+            handler.callback(&event);
+        }
+    }
+
+    template <typename T>
+    bool has() {
+        xSemaphoreTake(mutex_, portMAX_DELAY);
+        auto it = cache_.find(typeId<T>());
+        bool result = it != cache_.end() && it->second.data != nullptr;
+        xSemaphoreGive(mutex_);
+        return result;
+    }
+
+    template <typename T>
+    T peek() {
+        xSemaphoreTake(mutex_, portMAX_DELAY);
+        auto it = cache_.find(typeId<T>());
+        T result = (it != cache_.end() && it->second.data) ? *static_cast<const T*>(it->second.data) : T {};
+        xSemaphoreGive(mutex_);
+        return result;
+    }
+
+  private:
+    friend class SubscriptionHandle;
+
+    EventBus() { mutex_ = xSemaphoreCreateMutex(); }
+
+    ~EventBus() {
+        for (auto& [id, entry] : cache_) {
+            if (entry.deleter) entry.deleter(entry.data);
+        }
+        vSemaphoreDelete(mutex_);
+    }
+
+    EventBus(const EventBus&) = delete;
+    EventBus& operator=(const EventBus&) = delete;
+
+    void removeHandler(TypeId typeId, uint32_t handlerId) {
+        xSemaphoreTake(mutex_, portMAX_DELAY);
+        auto it = handlers_.find(typeId);
+        if (it != handlers_.end()) {
+            it->second.remove_if([handlerId](const Handler& h) { return h.id == handlerId; });
+        }
+        xSemaphoreGive(mutex_);
+    }
+
+    struct Handler {
+        uint32_t id;
+        std::function<void(const void*)> callback;
+    };
+
+    struct CacheEntry {
+        void* data = nullptr;
+        void (*deleter)(void*) = nullptr;
+    };
+
+    SemaphoreHandle_t mutex_;
+    uint32_t nextHandlerId_ = 1;
+    std::map<TypeId, std::list<Handler>> handlers_;
+    std::map<TypeId, CacheEntry> cache_;
+};
+
+inline void SubscriptionHandle::unsubscribe() {
+    if (bus_) {
+        bus_->removeHandler(typeId_, handlerId_);
+        bus_ = nullptr;
+    }
+}

esp32/include/features.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <sdkconfig.h>
 #include <wifi/wifi_idf.h>
 #include <esp_http_server.h>
 #include "platform_shared/message.pb.h"

esp32/include/filesystem.h

@@ -9,18 +9,18 @@
 #include <cstdio>
 #include <platform_shared/api.pb.h>
 
-#define MOUNT_POINT "/"
-#define LITTLEFS_MOUNT_POINT "/littlefs"
-#define SD_MOUNT_POINT "/sdcard"
+class WebServer;
 
-#define FS_CONFIG_DIRECTORY LITTLEFS_MOUNT_POINT "/config"
-#define DEVICE_CONFIG_FILE LITTLEFS_MOUNT_POINT "/config/peripheral.pb"
-#define CAMERA_SETTINGS_FILE LITTLEFS_MOUNT_POINT "/config/cameraSettings.pb"
-#define AP_SETTINGS_FILE LITTLEFS_MOUNT_POINT "/config/apSettings.pb"
-#define MDNS_SETTINGS_FILE LITTLEFS_MOUNT_POINT "/config/mdnsSettings.pb"
-#define WIFI_SETTINGS_FILE LITTLEFS_MOUNT_POINT "/config/wifiSettings.pb"
-#define PERIPHERAL_SETTINGS_FILE LITTLEFS_MOUNT_POINT "/config/peripheralSettings.pb"
-#define SERVO_SETTINGS_FILE LITTLEFS_MOUNT_POINT "/config/servoSettings.pb"
+#define MOUNT_POINT "/littlefs"
+
+#define FS_CONFIG_DIRECTORY MOUNT_POINT "/config"
+#define DEVICE_CONFIG_FILE MOUNT_POINT "/config/peripheral.pb"
+#define CAMERA_SETTINGS_FILE MOUNT_POINT "/config/cameraSettings.pb"
+#define AP_SETTINGS_FILE MOUNT_POINT "/config/apSettings.pb"
+#define MDNS_SETTINGS_FILE MOUNT_POINT "/config/mdnsSettings.pb"
+#define WIFI_SETTINGS_FILE MOUNT_POINT "/config/wifiSettings.pb"
+#define PERIPHERAL_SETTINGS_FILE MOUNT_POINT "/config/peripheralSettings.pb"
+#define SERVO_SETTINGS_FILE MOUNT_POINT "/config/servoSettings.pb"
 
 namespace FileSystem {
 
@@ -37,6 +37,8 @@ bool writeFile(const char *filename, const char *content);
 bool writeFile(const char *filename, const uint8_t *content, size_t size);
 bool mkdirRecursive(const char *path);
 
+void registerRoutes(WebServer &server);
+
 esp_err_t getFilesProto(httpd_req_t *request);
 esp_err_t getFiles(httpd_req_t *request);
 esp_err_t getConfigFile(httpd_req_t *request);

esp32/include/filesystem_ws.h

@@ -1,21 +1,15 @@
 #pragma once
 
 #include <platform_shared/message.pb.h>
+#include <eventbus.hpp>
 #include <filesystem.h>
 #include <map>
 #include <string>
 #include <functional>
 #include <cstdio>
-#include <freertos/FreeRTOS.h>
-#include <freertos/queue.h>
-#include <freertos/task.h>
-#include <freertos/semphr.h>
 
-#define FS_MAX_CHUNK_SIZE (1024 * 64)
+#define FS_MAX_CHUNK_SIZE 16384
 #define FS_TRANSFER_TIMEOUT_MS 30000
-#define FS_WRITE_QUEUE_SIZE 4
-#define FS_WRITER_TASK_STACK_SIZE 4096
-#define FS_WRITER_TASK_PRIORITY 5
 
 namespace FileSystemWS {
 
@@ -36,7 +30,6 @@ struct UploadState {
     uint32_t fileSize;
     uint32_t totalChunks;
     uint32_t chunksReceived;
-    uint32_t chunksWritten;
     uint32_t bytesReceived;
     uint32_t lastActivityTime;
     int clientId;
@@ -44,14 +37,6 @@ struct UploadState {
     std::string errorMessage;
 };
 
-struct WriteRequest {
-    uint32_t transferId;
-    uint8_t* data;
-    size_t size;
-    uint32_t chunkIndex;
-    bool isLastChunk;
-};
-
 using SendMetadataCallback = std::function<void(const socket_message_FSDownloadMetadata&, int clientId)>;
 using SendCallback = std::function<void(const socket_message_FSDownloadData&, int clientId)>;
 using SendCompleteCallback = std::function<void(const socket_message_FSDownloadComplete&, int clientId)>;
@@ -60,11 +45,8 @@ using SendUploadCompleteCallback = std::function<void(const socket_message_FSUpl
 class FileSystemHandler {
   public:
     FileSystemHandler();
-    ~FileSystemHandler();
-
-    void startWriterTask();
-    void stopWriterTask();
 
+    void begin();
     void setSendCallbacks(SendMetadataCallback sendMetadata, SendCallback sendData, SendCompleteCallback sendComplete,
                           SendUploadCompleteCallback sendUploadComplete);
 
@@ -83,12 +65,6 @@ class FileSystemHandler {
     std::map<uint32_t, UploadState> uploads_;
     uint32_t transferIdCounter_;
 
-    // Async writer task
-    QueueHandle_t writeQueue_;
-    TaskHandle_t writerTaskHandle_;
-    SemaphoreHandle_t uploadsMutex_;
-    volatile bool writerTaskRunning_;
-
     inline uint32_t generateTransferId() { return ++transferIdCounter_; }
 
     SendMetadataCallback sendMetadataCallback_;
@@ -100,8 +76,8 @@ class FileSystemHandler {
     bool deleteRecursive(const std::string& path);
     bool sendNextDownloadChunk(uint32_t transferId);
     void finalizeUpload(uint32_t transferId, bool success, const std::string& error = "");
-    void processWriteRequest(const WriteRequest& req);
-    static void writerTaskFunc(void* param);
+
+    SubscriptionHandle uploadHandle_;
 };
 
 extern FileSystemHandler fsHandler;

esp32/include/global.h

@@ -23,29 +23,39 @@
 #ifndef ESP_PLATFORM_NAME
 #define ESP_PLATFORM_NAME "ESP32-S3"
 #endif
+#elif CONFIG_IDF_TARGET_ESP32C6
+#include "esp32c6/rom/rtc.h"
+#ifndef ESP_PLATFORM_NAME
+#define ESP_PLATFORM_NAME "ESP32-C6"
+#endif
+#elif CONFIG_IDF_TARGET_ESP32P4
+#include "esp32p4/rom/rtc.h"
+#ifndef ESP_PLATFORM_NAME
+#define ESP_PLATFORM_NAME "ESP32-P4"
+#endif
+#define ESP32P4_USES_C6_COPROCESSOR 1
 #else
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
 
+/*
+ * I2C software connection
+ */
+#if CONFIG_IDF_TARGET_ESP32P4
+#ifndef SDA_PIN
+#define SDA_PIN 7
+#endif
+#ifndef SCL_PIN
+#define SCL_PIN 8
+#endif
+#else
 #ifndef SDA_PIN
 #define SDA_PIN 21
 #endif
 #ifndef SCL_PIN
 #define SCL_PIN 22
 #endif
+#endif
 #ifndef I2C_FREQUENCY
-#define I2C_FREQUENCY 100000UL
+#define I2C_FREQUENCY 1000000UL
 #endif
-
-// Optional SD card mounting via SDMMC (1-bit mode for ESP32-S3-CAM)
-// Pin definitions - override in build flags if needed
-#ifndef SD_CMD_PIN
-#define SD_CMD_PIN GPIO_NUM_38
-#endif
-#ifndef SD_CLK_PIN
-#define SD_CLK_PIN GPIO_NUM_39
-#endif
-#ifndef SD_DATA_PIN
-#define SD_DATA_PIN GPIO_NUM_40
-#endif
-

esp32/include/mdns_service.h

@@ -2,13 +2,13 @@
 
 #include <esp_http_server.h>
 #include <mdns.h>
-#include <template/stateful_service.h>
-#include <template/stateful_proto_endpoint.h>
-#include <template/stateful_persistence_pb.h>
+#include <eventbus.hpp>
 #include <settings/mdns_settings.h>
 #include <utils/timing.h>
 
-class MDNSService : public StatefulService<MDNSSettings> {
+class WebServer;
+
+class MDNSService {
   public:
     MDNSService();
     ~MDNSService();
@@ -18,10 +18,11 @@ class MDNSService : public StatefulService<MDNSSettings> {
     esp_err_t getStatus(httpd_req_t *request);
     esp_err_t queryServices(httpd_req_t *request, api_Request *protoReq);
 
-    StatefulProtoEndpoint<MDNSSettings, api_MDNSSettings> protoEndpoint;
+    void registerRoutes(WebServer &server);
 
   private:
-    FSPersistencePB<MDNSSettings> _persistence;
+    MDNSSettings _settings {};
+    SubscriptionHandle _settingsHandle;
     bool _started {false};
 
     void reconfigureMDNS();

esp32/include/motion.h

@@ -14,6 +14,7 @@
 #include <motion_states/stand_state.h>
 #include <motion_states/rest_state.h>
 #include <message_types.h>
+#include <eventbus.hpp>
 
 enum class MOTION_STATE { DEACTIVATED, IDLE, CALIBRATION, REST, STAND, WALK };
 
@@ -62,6 +63,10 @@ class MotionService {
     float dir[12] = {1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1};
 
     int64_t lastUpdate = esp_timer_get_time();
+
+    SubscriptionHandle controllerHandle_;
+    SubscriptionHandle walkGaitHandle_;
+    SubscriptionHandle anglesHandle_;
 };
 
 #endif

esp32/include/motion_states/walk_state.h

@@ -2,6 +2,7 @@
 
 #include <motion_states/state.h>
 #include <utils/math_utils.h>
+#include <algorithm>
 #include <array>
 #include <functional>
 

esp32/include/peripherals/camera_service.h

@@ -3,27 +3,29 @@
 #include <esp_http_server.h>
 
 #include <features.h>
-#include <template/stateful_service.h>
-#include <template/stateful_proto_endpoint.h>
-#include <template/stateful_persistence_pb.h>
+#include <eventbus.hpp>
 
 #include <settings/camera_settings.h>
 
+class WebServer;
+
 namespace Camera {
 
+#define USE_DVP_CAMERA (USE_CAMERA && !CONFIG_IDF_TARGET_ESP32P4)
+#define USE_CSI_CAMERA (USE_CAMERA && CONFIG_IDF_TARGET_ESP32P4)
+
+#if USE_DVP_CAMERA
 #include <esp_camera.h>
-
-#if USE_CAMERA
 #include <peripherals/camera_pins.h>
-#endif
-
-#define PART_BOUNDARY "frame"
 
 camera_fb_t *safe_camera_fb_get();
 sensor_t *safe_sensor_get();
 void safe_sensor_return();
+#endif
 
-class CameraService : public StatefulService<CameraSettings> {
+#define PART_BOUNDARY "frame"
+
+class CameraService {
   public:
     CameraService();
 
@@ -32,10 +34,13 @@ class CameraService : public StatefulService<CameraSettings> {
     esp_err_t cameraStill(httpd_req_t *request);
     esp_err_t cameraStream(httpd_req_t *request);
 
-    StatefulProtoEndpoint<CameraSettings, api_CameraSettings> protoEndpoint;
+    void registerRoutes(WebServer &server);
 
+#if USE_DVP_CAMERA
   private:
-    FSPersistencePB<CameraSettings> _persistence;
+    CameraSettings _settings {};
+    SubscriptionHandle _settingsHandle;
     void updateCamera();
+#endif
 };
 } // namespace Camera

esp32/include/peripherals/i2c_bus.h

@@ -1,11 +1,12 @@
 #pragma once
 
-#include <driver/i2c.h>
+#include <driver/i2c_master.h>
 #include <esp_log.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 #include <functional>
 #include <vector>
+#include <cstring>
 
 class I2CBus {
   public:
@@ -24,30 +25,17 @@ class I2CBus {
         _scl = scl;
         _freq = freq;
 
-        i2c_config_t conf = {};
-        conf.mode = I2C_MODE_MASTER;
-        conf.sda_io_num = sda;
-        conf.scl_io_num = scl;
-        conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
-        conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
-        conf.master.clk_speed = freq;
+        i2c_master_bus_config_t bus_cfg = {};
+        bus_cfg.i2c_port = port;
+        bus_cfg.sda_io_num = sda;
+        bus_cfg.scl_io_num = scl;
+        bus_cfg.clk_source = I2C_CLK_SRC_DEFAULT;
+        bus_cfg.glitch_ignore_cnt = 7;
+        bus_cfg.flags.enable_internal_pullup = true;
 
-        esp_err_t err = i2c_param_config(_port, &conf);
+        esp_err_t err = i2c_new_master_bus(&bus_cfg, &_bus);
         if (err != ESP_OK) {
-            ESP_LOGE(TAG, "i2c_param_config failed: %s", esp_err_to_name(err));
-            return err;
-        }
-
-        err = i2c_driver_install(_port, I2C_MODE_MASTER, 0, 0, 0);
-        if (err == ESP_ERR_INVALID_STATE) {
-            ESP_LOGW(TAG, "I2C driver already installed for port %d, reconfiguring", _port);
-            i2c_driver_delete(_port);
-            err = i2c_param_config(_port, &conf);
-            if (err != ESP_OK) return err;
-            err = i2c_driver_install(_port, I2C_MODE_MASTER, 0, 0, 0);
-        }
-        if (err != ESP_OK) {
-            ESP_LOGE(TAG, "i2c_driver_install failed: %s", esp_err_to_name(err));
+            ESP_LOGE(TAG, "i2c_new_master_bus failed: %s", esp_err_to_name(err));
             return err;
         }
 
@@ -57,73 +45,51 @@ class I2CBus {
 
     void end() {
         if (_initialized) {
-            i2c_driver_delete(_port);
+            if (_dev) {
+                i2c_master_bus_rm_device(_dev);
+                _dev = NULL;
+                _dev_addr = 0xFF;
+            }
+            i2c_del_master_bus(_bus);
+            _bus = NULL;
             _initialized = false;
         }
     }
 
     bool isInitialized() const { return _initialized; }
 
+    i2c_master_bus_handle_t busHandle() const { return _bus; }
+
     esp_err_t writeBytes(uint8_t addr, const uint8_t* data, size_t len) {
         if (!_initialized) return ESP_ERR_INVALID_STATE;
-
-        i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-        i2c_master_start(cmd);
-        i2c_master_write_byte(cmd, (addr << 1) | I2C_MASTER_WRITE, true);
-        if (len > 0 && data != nullptr) {
-            i2c_master_write(cmd, data, len, true);
-        }
-        i2c_master_stop(cmd);
-        esp_err_t ret = i2c_master_cmd_begin(_port, cmd, pdMS_TO_TICKS(100));
-        i2c_cmd_link_delete(cmd);
-        return ret;
+        esp_err_t err = ensureDevice(addr);
+        if (err != ESP_OK) return err;
+        return i2c_master_transmit(_dev, data, len, pdMS_TO_TICKS(100));
     }
 
     esp_err_t writeReg(uint8_t addr, uint8_t reg, const uint8_t* data, size_t len) {
         if (!_initialized) return ESP_ERR_INVALID_STATE;
+        esp_err_t err = ensureDevice(addr);
+        if (err != ESP_OK) return err;
 
-        i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-        i2c_master_start(cmd);
-        i2c_master_write_byte(cmd, (addr << 1) | I2C_MASTER_WRITE, true);
-        i2c_master_write_byte(cmd, reg, true);
+        uint8_t buf[len + 1];
+        buf[0] = reg;
         if (len > 0 && data != nullptr) {
-            i2c_master_write(cmd, data, len, true);
+            memcpy(buf + 1, data, len);
         }
-        i2c_master_stop(cmd);
-        esp_err_t ret = i2c_master_cmd_begin(_port, cmd, pdMS_TO_TICKS(100));
-        i2c_cmd_link_delete(cmd);
-        return ret;
+        return i2c_master_transmit(_dev, buf, len + 1, pdMS_TO_TICKS(100));
     }
 
     esp_err_t readReg(uint8_t addr, uint8_t reg, uint8_t* data, size_t len) {
         if (!_initialized) return ESP_ERR_INVALID_STATE;
-
-        i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-        i2c_master_start(cmd);
-        i2c_master_write_byte(cmd, (addr << 1) | I2C_MASTER_WRITE, true);
-        i2c_master_write_byte(cmd, reg, true);
-        i2c_master_start(cmd);
-        i2c_master_write_byte(cmd, (addr << 1) | I2C_MASTER_READ, true);
-        if (len > 1) {
-            i2c_master_read(cmd, data, len - 1, I2C_MASTER_ACK);
-        }
-        i2c_master_read_byte(cmd, data + len - 1, I2C_MASTER_NACK);
-        i2c_master_stop(cmd);
-        esp_err_t ret = i2c_master_cmd_begin(_port, cmd, pdMS_TO_TICKS(100));
-        i2c_cmd_link_delete(cmd);
-        return ret;
+        esp_err_t err = ensureDevice(addr);
+        if (err != ESP_OK) return err;
+        return i2c_master_transmit_receive(_dev, &reg, 1, data, len, pdMS_TO_TICKS(100));
     }
 
     bool probe(uint8_t addr) {
         if (!_initialized) return false;
-
-        i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-        i2c_master_start(cmd);
-        i2c_master_write_byte(cmd, (addr << 1) | I2C_MASTER_WRITE, true);
-        i2c_master_stop(cmd);
-        esp_err_t ret = i2c_master_cmd_begin(_port, cmd, pdMS_TO_TICKS(50));
-        i2c_cmd_link_delete(cmd);
-        return ret == ESP_OK;
+        return i2c_master_probe(_bus, addr, pdMS_TO_TICKS(50)) == ESP_OK;
     }
 
     std::vector<uint8_t> scan(uint8_t lower = 1, uint8_t upper = 127) {
@@ -157,4 +123,23 @@ class I2CBus {
     gpio_num_t _scl = GPIO_NUM_NC;
     uint32_t _freq = 100000;
     bool _initialized = false;
+
+    i2c_master_bus_handle_t _bus = NULL;
+    i2c_master_dev_handle_t _dev = NULL;
+    uint8_t _dev_addr = 0xFF;
+
+    esp_err_t ensureDevice(uint8_t addr) {
+        if (_dev && _dev_addr == addr) return ESP_OK;
+        if (_dev) {
+            i2c_master_bus_rm_device(_dev);
+            _dev = NULL;
+        }
+        i2c_device_config_t dev_cfg = {};
+        dev_cfg.dev_addr_length = I2C_ADDR_BIT_LEN_7;
+        dev_cfg.device_address = addr;
+        dev_cfg.scl_speed_hz = _freq;
+        esp_err_t err = i2c_master_bus_add_device(_bus, &dev_cfg, &_dev);
+        if (err == ESP_OK) _dev_addr = addr;
+        return err;
+    }
 };

esp32/include/peripherals/led_service.h

@@ -1,6 +1,7 @@
 #ifndef LEDService_h
 #define LEDService_h
 
+#include <sdkconfig.h>
 #include <driver/rmt_tx.h>
 #include <led_strip.h>
 #include <led_strip_rmt.h>
@@ -9,8 +10,12 @@
 #include <esp_log.h>
 
 #ifndef WS2812_PIN
+#if CONFIG_IDF_TARGET_ESP32P4
+#define WS2812_PIN 27
+#else
 #define WS2812_PIN 12
 #endif
+#endif
 
 #ifndef WS2812_NUM_LEDS
 #define WS2812_NUM_LEDS 13

esp32/include/peripherals/peripherals.h

@@ -1,8 +1,6 @@
 #pragma once
 
-#include <template/stateful_persistence_pb.h>
-#include <template/stateful_service.h>
-#include <template/stateful_proto_endpoint.h>
+#include <eventbus.hpp>
 #include <utils/math_utils.h>
 #include <utils/timing.h>
 #include <filesystem.h>
@@ -21,12 +19,9 @@
 #include <peripherals/barometer.h>
 #include <peripherals/gesture.h>
 
-/*
- * Ultrasonic Sensor Settings
- */
 #define MAX_DISTANCE 200
 
-class Peripherals : public StatefulService<PeripheralsConfiguration> {
+class Peripherals {
   public:
     Peripherals();
 
@@ -42,21 +37,14 @@ class Peripherals : public StatefulService<PeripheralsConfiguration> {
     void getIMUProto(socket_message_IMUData &data);
     void getSettingsProto(socket_message_PeripheralSettingsData &data);
 
-    /* IMU FUNCTIONS */
     bool readImu();
-
     bool readMag();
-
     bool readBMP();
-
     bool readGesture();
-
     void readSonar();
 
     float angleX();
-
     float angleY();
-
     float angleZ();
 
     gesture_t takeGesture();
@@ -66,14 +54,12 @@ class Peripherals : public StatefulService<PeripheralsConfiguration> {
 
     bool calibrateIMU();
 
-    StatefulProtoEndpoint<PeripheralsConfiguration, api_PeripheralSettings> protoEndpoint;
-
   private:
-    FSPersistencePB<PeripheralsConfiguration> _persistence;
+    PeripheralsConfiguration _settings {};
+    SubscriptionHandle _settingsHandle;
 
     SemaphoreHandle_t _accessMutex;
     inline void beginTransaction() { xSemaphoreTakeRecursive(_accessMutex, portMAX_DELAY); }
-
     inline void endTransaction() { xSemaphoreGiveRecursive(_accessMutex); }
 
 #if FT_ENABLED(USE_MPU6050 || USE_BNO055)
@@ -97,4 +83,4 @@ class Peripherals : public StatefulService<PeripheralsConfiguration> {
 
     std::list<uint8_t> addressList;
     bool i2c_active = false;
-};
+};

esp32/include/peripherals/servo_controller.h

@@ -2,11 +2,10 @@
 #define ServoController_h
 
 #include <peripherals/drivers/pca9685.h>
-#include <template/stateful_persistence_pb.h>
-#include <template/stateful_proto_endpoint.h>
-#include <template/stateful_service.h>
+#include <eventbus.hpp>
 #include <utils/math_utils.h>
 #include <platform_shared/api.pb.h>
+#include <platform_shared/message.pb.h>
 
 #ifndef FACTORY_SERVO_PWM_FREQUENCY
 #define FACTORY_SERVO_PWM_FREQUENCY 50
@@ -24,41 +23,28 @@ inline ServoSettings ServoSettings_defaults() {
     ServoSettings settings = {};
     settings.servos_count = 12;
     const api_Servo defaults[12] = {
-        {306, -1, 0, 2.0f, "Servo1"},   {306, 1, -45, 2.0f, "Servo2"},
-        {306, 1, 90, 2.0f, "Servo3"}, {306, -1, 0, 2.0f, "Servo4"},
-        {306, -1, 45, 2.0f, "Servo5"}, {306, -1, -90, 2.0f, "Servo6"},
-        {306, 1, 0, 2.0f, "Servo7"},   {306, 1, -45, 2.0f, "Servo8"},
-        {306, 1, 90, 2.0f, "Servo9"}, {306, 1, 0, 2.0f, "Servo10"},
-        {306, -1, 45, 2.0f, "Servo11"}, {306, -1, -90, 2.0f, "Servo12"}
-    };
+        {306, -1, 0, 2.0f, "Servo1"}, {306, 1, -45, 2.0f, "Servo2"},  {306, 1, 90, 2.0f, "Servo3"},
+        {306, -1, 0, 2.0f, "Servo4"}, {306, -1, 45, 2.0f, "Servo5"},  {306, -1, -90, 2.0f, "Servo6"},
+        {306, 1, 0, 2.0f, "Servo7"},  {306, 1, -45, 2.0f, "Servo8"},  {306, 1, 90, 2.0f, "Servo9"},
+        {306, 1, 0, 2.0f, "Servo10"}, {306, -1, 45, 2.0f, "Servo11"}, {306, -1, -90, 2.0f, "Servo12"}};
     for (int i = 0; i < 12; i++) {
         settings.servos[i] = defaults[i];
     }
     return settings;
 }
 
-inline void ServoSettings_read(const ServoSettings &settings, ServoSettings &proto) {
-    proto = settings;
-}
-
-inline StateUpdateResult ServoSettings_update(const ServoSettings &proto, ServoSettings &settings) {
-    settings = proto;
-    return StateUpdateResult::CHANGED;
-}
-
-class ServoController : public StatefulService<ServoSettings> {
+class ServoController {
   public:
-    ServoController()
-        : protoEndpoint(ServoSettings_read, ServoSettings_update, this,
-                        API_REQUEST_EXTRACTOR(servo_settings, ServoSettings),
-                        API_RESPONSE_ASSIGNER(servo_settings, ServoSettings)),
-          _persistence(ServoSettings_read, ServoSettings_update, this,
-                       SERVO_SETTINGS_FILE, api_ServoSettings_fields, api_ServoSettings_size,
-                       ServoSettings_defaults()) {}
-
     void begin() {
-        _persistence.readFromFS();
+        _settings = EventBus::instance().peek<ServoSettings>();
         initializePCA();
+
+        _settingsHandle =
+            EventBus::instance().subscribe<ServoSettings>([this](const ServoSettings& s) { _settings = s; });
+        servoPwmHandle_ = EventBus::instance().subscribe<socket_message_ServoPWMData>(
+            [this](const socket_message_ServoPWMData& data) { setServoPWM(data.servo_id, data.servo_pwm); });
+        servoStateHandle_ = EventBus::instance().subscribe<socket_message_ServoStateData>(
+            [this](const socket_message_ServoStateData& data) { data.active ? activate() : deactivate(); });
     }
 
     void pcaWrite(int index, int value) {
@@ -109,7 +95,7 @@ class ServoController : public StatefulService<ServoSettings> {
         uint16_t pwms[12];
         for (int i = 0; i < 12; i++) {
             angles[i] = lerp(angles[i], target_angles[i], 0.1);
-            auto &servo = state().servos[i];
+            auto& servo = _settings.servos[i];
             float angle = servo.direction * angles[i] + servo.center_angle;
             uint16_t pwm = angle * servo.conversion + servo.center_pwm;
             pwms[i] = pwm = std::clamp<uint16_t>(pwm, 125, 600);
@@ -121,8 +107,6 @@ class ServoController : public StatefulService<ServoSettings> {
         if (control_state == SERVO_CONTROL_STATE::ANGLE) calculatePWM();
     }
 
-    StatefulProtoEndpoint<ServoSettings, ServoSettings> protoEndpoint;
-
   private:
     void initializePCA() {
         _pca.begin();
@@ -130,8 +114,8 @@ class ServoController : public StatefulService<ServoSettings> {
         _pca.setPWMFreq(FACTORY_SERVO_PWM_FREQUENCY);
         _pca.sleep();
     }
-    FSPersistencePB<ServoSettings> _persistence;
 
+    ServoSettings _settings {};
     PCA9685Driver _pca;
 
     SERVO_CONTROL_STATE control_state = SERVO_CONTROL_STATE::DEACTIVATED;
@@ -139,6 +123,10 @@ class ServoController : public StatefulService<ServoSettings> {
     bool is_active {false};
     float angles[12] = {0, 90, -145, 0, 90, -145, 0, 90, -145, 0, 90, -145};
     float target_angles[12] = {0, 90, -145, 0, 90, -145, 0, 90, -145, 0, 90, -145};
+
+    SubscriptionHandle _settingsHandle;
+    SubscriptionHandle servoPwmHandle_;
+    SubscriptionHandle servoStateHandle_;
 };
 
 #endif

esp32/include/proto_event_storage.hpp

@@ -0,0 +1,113 @@
+#pragma once
+
+#include <eventbus.hpp>
+#include <pb_encode.h>
+#include <pb_decode.h>
+#include <esp_timer.h>
+#include <esp_log.h>
+#include <cstdio>
+#include <memory>
+
+template <typename ProtoMsg, ProtoMsg (*DefaultsFn)()>
+class ProtoEventStorage {
+  public:
+    ProtoEventStorage(const char* filename, const pb_msgdesc_t* descriptor, size_t maxSize, uint32_t debounceMs = 1000)
+        : _filename(filename), _descriptor(descriptor), _maxSize(maxSize), _debounceMs(debounceMs) {}
+
+    void begin() {
+        ProtoMsg loaded {};
+        loadOrDefault(loaded);
+        EventBus::instance().publish(loaded);
+
+        esp_timer_create_args_t timerArgs {};
+        timerArgs.callback = timerCallback;
+        timerArgs.arg = this;
+        timerArgs.dispatch_method = ESP_TIMER_TASK;
+        timerArgs.name = _filename;
+        esp_timer_create(&timerArgs, &_timer);
+
+        _handle = EventBus::instance().subscribe<ProtoMsg>([this](const ProtoMsg& msg) {
+            _pending = msg;
+            esp_timer_stop(_timer);
+            esp_timer_start_once(_timer, static_cast<uint64_t>(_debounceMs) * 1000);
+        });
+    }
+
+  private:
+    const char* _filename;
+    const pb_msgdesc_t* _descriptor;
+    size_t _maxSize;
+    uint32_t _debounceMs;
+    SubscriptionHandle _handle;
+    ProtoMsg _pending {};
+    esp_timer_handle_t _timer = nullptr;
+
+    static void timerCallback(void* arg) {
+        auto* self = static_cast<ProtoEventStorage*>(arg);
+        self->save(self->_pending);
+    }
+
+    void loadOrDefault(ProtoMsg& outMsg) {
+        FILE* file = fopen(_filename, "rb");
+        if (!file) {
+            ESP_LOGI("ProtoStorage", "No file %s, using defaults", _filename);
+            outMsg = DefaultsFn();
+            return;
+        }
+
+        fseek(file, 0, SEEK_END);
+        long tellResult = ftell(file);
+        fseek(file, 0, SEEK_SET);
+        if (tellResult < 0) {
+            ESP_LOGE("ProtoStorage", "ftell failed for %s", _filename);
+            fclose(file);
+            outMsg = DefaultsFn();
+            return;
+        }
+        size_t size = static_cast<size_t>(tellResult);
+
+        if (size == 0 || size > _maxSize) {
+            ESP_LOGW("ProtoStorage", "Invalid size %zu for %s (max %zu)", size, _filename, _maxSize);
+            fclose(file);
+            outMsg = DefaultsFn();
+            return;
+        }
+
+        auto buffer = std::make_unique<uint8_t[]>(size);
+        size_t read = fread(buffer.get(), 1, size, file);
+        fclose(file);
+        if (read != size) {
+            ESP_LOGE("ProtoStorage", "Read %zu/%zu from %s", read, size, _filename);
+            outMsg = DefaultsFn();
+            return;
+        }
+
+        pb_istream_t stream = pb_istream_from_buffer(buffer.get(), size);
+        if (!pb_decode(&stream, _descriptor, &outMsg)) {
+            ESP_LOGE("ProtoStorage", "Decode failed for %s", _filename);
+            outMsg = DefaultsFn();
+        }
+    }
+
+    void save(const ProtoMsg& msg) {
+        auto buffer = std::make_unique<uint8_t[]>(_maxSize);
+        pb_ostream_t stream = pb_ostream_from_buffer(buffer.get(), _maxSize);
+
+        if (!pb_encode(&stream, _descriptor, &msg)) {
+            ESP_LOGE("ProtoStorage", "Encode failed for %s", _filename);
+            return;
+        }
+
+        FILE* file = fopen(_filename, "wb");
+        if (!file) {
+            ESP_LOGE("ProtoStorage", "Open write failed for %s", _filename);
+            return;
+        }
+
+        size_t written = fwrite(buffer.get(), 1, stream.bytes_written, file);
+        fclose(file);
+        if (written != stream.bytes_written) {
+            ESP_LOGE("ProtoStorage", "Write failed for %s (%zu/%zu)", _filename, written, stream.bytes_written);
+        }
+    }
+};

esp32/include/settings/ap_settings.h

@@ -2,7 +2,6 @@
 
 #include <wifi/wifi_idf.h>
 #include <wifi/dns_server.h>
-#include <template/state_result.h>
 #include <platform_shared/api.pb.h>
 #include <cstring>
 
@@ -75,10 +74,3 @@ inline APSettings APSettings_defaults() {
     settings.subnet_mask = parseIPv4(FACTORY_AP_SUBNET_MASK);
     return settings;
 }
-
-inline void APSettings_read(const APSettings &settings, APSettings &proto) { proto = settings; }
-
-inline StateUpdateResult APSettings_update(const APSettings &proto, APSettings &settings) {
-    settings = proto;
-    return StateUpdateResult::CHANGED;
-}

esp32/include/settings/camera_settings.h

@@ -1,15 +1,20 @@
 #pragma once
 
-#include <template/state_result.h>
+#include <sdkconfig.h>
 #include <platform_shared/api.pb.h>
+
+#if !CONFIG_IDF_TARGET_ESP32P4
 #include <esp_camera.h>
+#else
+#define PIXFORMAT_JPEG 0
+#define FRAMESIZE_VGA 0
+#define GAINCEILING_2X 0
+#endif
 
 namespace Camera {
 
-// Use proto type directly as settings type
 using CameraSettings = api_CameraSettings;
 
-// Default factory settings
 inline CameraSettings CameraSettings_defaults() {
     CameraSettings settings = api_CameraSettings_init_zero;
     settings.pixformat = PIXFORMAT_JPEG;
@@ -45,14 +50,4 @@ inline CameraSettings CameraSettings_defaults() {
     return settings;
 }
 
-// Proto read/update are identity functions since type is the same
-inline void CameraSettings_read(const CameraSettings& settings, CameraSettings& proto) {
-    proto = settings;
-}
-
-inline StateUpdateResult CameraSettings_update(const CameraSettings& proto, CameraSettings& settings) {
-    settings = proto;
-    return StateUpdateResult::CHANGED;
-}
-
 } // namespace Camera

esp32/include/settings/mdns_settings.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <template/state_result.h>
 #include <platform_shared/api.pb.h>
 #include <string>
 #include <cstring>
@@ -13,45 +12,30 @@
 #define FACTORY_MDNS_INSTANCE "ESP32 Device"
 #endif
 
-// Use proto types directly
 using MDNSTxtRecord = api_MDNSTxtRecord;
 using MDNSServiceDef = api_MDNSServiceDef;
 using MDNSSettings = api_MDNSSettings;
 using MDNSStatus = api_MDNSStatus;
 
-// Default factory settings
 inline MDNSSettings MDNSSettings_defaults() {
     MDNSSettings settings = api_MDNSSettings_init_zero;
     strncpy(settings.hostname, FACTORY_MDNS_HOSTNAME, sizeof(settings.hostname) - 1);
     strncpy(settings.instance, FACTORY_MDNS_INSTANCE, sizeof(settings.instance) - 1);
 
-    // Default HTTP service
     settings.services_count = 2;
     strncpy(settings.services[0].service, "http", sizeof(settings.services[0].service) - 1);
     strncpy(settings.services[0].protocol, "tcp", sizeof(settings.services[0].protocol) - 1);
     settings.services[0].port = 80;
     settings.services[0].txt_records_count = 0;
 
-    // Default WS service
     strncpy(settings.services[1].service, "ws", sizeof(settings.services[1].service) - 1);
     strncpy(settings.services[1].protocol, "tcp", sizeof(settings.services[1].protocol) - 1);
     settings.services[1].port = 80;
     settings.services[1].txt_records_count = 0;
 
-    // Default global txt record
     settings.global_txt_records_count = 1;
     strncpy(settings.global_txt_records[0].key, "Firmware Version", sizeof(settings.global_txt_records[0].key) - 1);
     strncpy(settings.global_txt_records[0].value, APP_VERSION, sizeof(settings.global_txt_records[0].value) - 1);
 
     return settings;
 }
-
-// Proto read/update are identity functions since type is the same
-inline void MDNSSettings_read(const MDNSSettings& settings, MDNSSettings& proto) {
-    proto = settings;
-}
-
-inline StateUpdateResult MDNSSettings_update(const MDNSSettings& proto, MDNSSettings& settings) {
-    settings = proto;
-    return StateUpdateResult::CHANGED;
-}

esp32/include/settings/ntp_settings.h

@@ -1,4 +1,3 @@
-#include <template/state_result.h>
 #include <ArduinoJson.h>
 #include <string>
 
@@ -32,11 +31,10 @@ class NTPSettings {
         root["tz_format"] = settings.tzFormat.c_str();
     }
 
-    static StateUpdateResult update(JsonVariant &root, NTPSettings &settings) {
+    static void update(JsonVariant &root, NTPSettings &settings) {
         settings.enabled = root["enabled"] | FACTORY_NTP_ENABLED;
         settings.server = root["server"] | FACTORY_NTP_SERVER;
         settings.tzLabel = root["tz_label"] | FACTORY_NTP_TIME_ZONE_LABEL;
         settings.tzFormat = root["tz_format"] | FACTORY_NTP_TIME_ZONE_FORMAT;
-        return StateUpdateResult::CHANGED;
     }
 };

esp32/include/settings/peripherals_settings.h

@@ -1,26 +1,12 @@
 #pragma once
 
-#include <template/state_result.h>
+#include <sdkconfig.h>
 #include <platform_shared/api.pb.h>
+#include <global.h>
 
-/*
- * I2C software connection
- */
-#ifndef SDA_PIN
-#define SDA_PIN 21
-#endif
-#ifndef SCL_PIN
-#define SCL_PIN 22
-#endif
-#ifndef I2C_FREQUENCY
-#define I2C_FREQUENCY 1000000UL
-#endif
-
-// Use proto types directly
 using PinConfig = api_PinConfig;
 using PeripheralsConfiguration = api_PeripheralSettings;
 
-// Default factory settings
 inline PeripheralsConfiguration PeripheralsConfiguration_defaults() {
     PeripheralsConfiguration settings = api_PeripheralSettings_init_zero;
     settings.sda = SDA_PIN;
@@ -29,14 +15,3 @@ inline PeripheralsConfiguration PeripheralsConfiguration_defaults() {
     settings.pins_count = 0;
     return settings;
 }
-
-// Proto read/update are identity functions since type is the same
-inline void PeripheralsConfiguration_read(const PeripheralsConfiguration& settings, PeripheralsConfiguration& proto) {
-    proto = settings;
-}
-
-inline StateUpdateResult PeripheralsConfiguration_update(const PeripheralsConfiguration& proto,
-                                                         PeripheralsConfiguration& settings) {
-    settings = proto;
-    return StateUpdateResult::CHANGED;
-}

esp32/include/settings/wifi_settings.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <wifi/wifi_idf.h>
-#include <template/state_result.h>
 #include <platform_shared/api.pb.h>
 #include <cstring>
 
@@ -49,10 +48,3 @@ inline WiFiSettings WiFiSettings_defaults() {
     }
     return settings;
 }
-
-inline void WiFiSettings_read(const WiFiSettings &settings, WiFiSettings &proto) { proto = settings; }
-
-inline StateUpdateResult WiFiSettings_update(const WiFiSettings &proto, WiFiSettings &settings) {
-    settings = proto;
-    return StateUpdateResult::CHANGED;
-}

esp32/include/system_service.h

@@ -12,11 +12,15 @@
 
 #include "platform_shared/message.pb.h"
 
+class WebServer;
+
 namespace system_service {
 esp_err_t handleReset(httpd_req_t *request);
 esp_err_t handleRestart(httpd_req_t *request);
 esp_err_t handleSleep(httpd_req_t *request);
 
+void registerRoutes(WebServer &server);
+
 void reset();
 void restart();
 void sleep();

esp32/include/template/state_result.h

@@ -1,7 +0,0 @@
-#pragma once
-
-enum class StateUpdateResult {
-    CHANGED = 0, // The update changed the state and propagation should take place if required
-    UNCHANGED,   // The state was unchanged, propagation should not take place
-    ERROR        // There was a problem updating the state, propagation should not take place
-};

esp32/include/template/stateful_endpoint.h

@@ -1,47 +0,0 @@
-#pragma once
-
-#include <esp_http_server.h>
-#include <ArduinoJson.h>
-#include <template/stateful_service.h>
-#include <communication/webserver.h>
-
-#include <functional>
-
-#define HTTP_ENDPOINT_ORIGIN_ID "http"
-#define HTTPS_ENDPOINT_ORIGIN_ID "https"
-
-template <class T>
-class StatefulHttpEndpoint {
-  protected:
-    JsonStateReader<T> _stateReader;
-    JsonStateUpdater<T> _stateUpdater;
-    StatefulService<T> *_statefulService;
-
-  public:
-    StatefulHttpEndpoint(JsonStateReader<T> stateReader, JsonStateUpdater<T> stateUpdater,
-                         StatefulService<T> *statefulService)
-        : _stateReader(stateReader), _stateUpdater(stateUpdater), _statefulService(statefulService) {}
-
-    esp_err_t handleStateUpdate(httpd_req_t *request, JsonVariant &json) {
-        JsonVariant jsonObject = json.as<JsonVariant>();
-        StateUpdateResult outcome = _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
-
-        if (outcome == StateUpdateResult::ERROR) {
-            return WebServer::sendError(request, 400, "Invalid state");
-        } else if ((outcome == StateUpdateResult::CHANGED)) {
-            _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID);
-        }
-
-        JsonDocument doc;
-        JsonVariant root = doc.to<JsonVariant>();
-        _statefulService->read(root, _stateReader);
-        return WebServer::sendJson(request, 200, doc);
-    }
-
-    esp_err_t getState(httpd_req_t *request) {
-        JsonDocument doc;
-        JsonVariant root = doc.to<JsonVariant>();
-        _statefulService->read(root, _stateReader);
-        return WebServer::sendJson(request, 200, doc);
-    }
-};

esp32/include/template/stateful_persistence.h

@@ -1,94 +0,0 @@
-#ifndef FSPersistence_h
-#define FSPersistence_h
-
-#include <template/stateful_service.h>
-#include <filesystem.h>
-#include <ArduinoJson.h>
-#include <cstdio>
-#include <sys/stat.h>
-
-template <class T>
-class FSPersistence {
-  public:
-    FSPersistence(JsonStateReader<T> stateReader, JsonStateUpdater<T> stateUpdater, StatefulService<T> *statefulService,
-                  const char *filePath)
-        : _stateReader(stateReader),
-          _stateUpdater(stateUpdater),
-          _statefulService(statefulService),
-          _filePath(filePath),
-          _updateHandlerId(0) {
-        enableUpdateHandler();
-    }
-
-    void readFromFS() {
-        std::string content = FileSystem::readFile(_filePath);
-
-        if (!content.empty()) {
-            JsonDocument jsonDocument;
-            DeserializationError error = deserializeJson(jsonDocument, content);
-            if (error == DeserializationError::Ok) {
-                JsonVariant jsonObject = jsonDocument.as<JsonVariant>();
-                _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
-                return;
-            }
-        }
-
-        applyDefaults();
-        writeToFS();
-    }
-
-    bool writeToFS() {
-        JsonDocument jsonDocument;
-        JsonVariant jsonObject = jsonDocument.to<JsonVariant>();
-        _statefulService->read(jsonObject, _stateReader);
-
-        mkdirs();
-
-        std::string content;
-        serializeJson(jsonDocument, content);
-
-        return FileSystem::writeFile(_filePath, content.c_str());
-    }
-
-    void disableUpdateHandler() {
-        if (_updateHandlerId) {
-            _statefulService->removeUpdateHandler(_updateHandlerId);
-            _updateHandlerId = 0;
-        }
-    }
-
-    void enableUpdateHandler() {
-        if (!_updateHandlerId) {
-            _updateHandlerId = _statefulService->addUpdateHandler([&](const std::string &originId) { writeToFS(); });
-        }
-    }
-
-  private:
-    JsonStateReader<T> _stateReader;
-    JsonStateUpdater<T> _stateUpdater;
-    StatefulService<T> *_statefulService;
-    const char *_filePath;
-    size_t _bufferSize;
-    HandlerId _updateHandlerId;
-
-    void mkdirs() {
-        std::string path(_filePath);
-        size_t index = 0;
-        while ((index = path.find('/', index + 1)) != std::string::npos) {
-            std::string segment = path.substr(0, index);
-            struct stat st;
-            if (stat(segment.c_str(), &st) != 0) {
-                FileSystem::mkdirRecursive(segment.c_str());
-            }
-        }
-    }
-
-  protected:
-    virtual void applyDefaults() {
-        JsonDocument jsonDocument;
-        JsonVariant jsonObject = jsonDocument.as<JsonVariant>();
-        _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
-    }
-};
-
-#endif

esp32/include/template/stateful_persistence_pb.h

@@ -1,141 +0,0 @@
-#pragma once
-
-#include <template/stateful_service.h>
-#include <template/state_result.h>
-#include <filesystem.h>
-#include <pb_encode.h>
-#include <pb_decode.h>
-#include <cstdio>
-#include <sys/stat.h>
-#include <esp_log.h>
-
-static const char *TAG_PERSISTENCE = "FSPersistencePB";
-
-template <class T>
-class FSPersistencePB {
-  public:
-    using ProtoStateReader = std::function<void(const T &, T &)>;
-    using ProtoStateUpdater = std::function<StateUpdateResult(const T &, T &)>;
-
-    FSPersistencePB(ProtoStateReader stateReader, ProtoStateUpdater stateUpdater, StatefulService<T> *statefulService,
-                    const char *filePath, const pb_msgdesc_t *msgDescriptor, size_t maxSize, const T &defaultState)
-        : _stateReader(stateReader),
-          _stateUpdater(stateUpdater),
-          _statefulService(statefulService),
-          _filePath(filePath),
-          _msgDescriptor(msgDescriptor),
-          _maxSize(maxSize),
-          _defaultState(defaultState),
-          _updateHandlerId(0) {
-        enableUpdateHandler();
-    }
-
-    void readFromFS() {
-        FILE *file = fopen(_filePath, "rb");
-
-        if (file) {
-            fseek(file, 0, SEEK_END);
-            size_t fileSize = ftell(file);
-            fseek(file, 0, SEEK_SET);
-
-            if (fileSize > 0 && fileSize <= _maxSize) {
-                uint8_t *buffer = new uint8_t[fileSize];
-                size_t bytesRead = fread(buffer, 1, fileSize, file);
-                fclose(file);
-
-                if (bytesRead == fileSize) {
-                    T *protoMsg = new T();
-                    *protoMsg = {};
-                    pb_istream_t stream = pb_istream_from_buffer(buffer, bytesRead);
-
-                    if (pb_decode(&stream, _msgDescriptor, protoMsg)) {
-                        _statefulService->updateWithoutPropagation(
-                            [this, protoMsg](T &state) { return _stateUpdater(*protoMsg, state); });
-                        delete protoMsg;
-                        delete[] buffer;
-                        return;
-                    }
-                    delete protoMsg;
-                }
-                delete[] buffer;
-            } else {
-                fclose(file);
-            }
-        }
-
-        applyDefaults();
-        writeToFS();
-    }
-
-    bool writeToFS() {
-        uint8_t *buffer = new uint8_t[_maxSize];
-        pb_ostream_t stream = pb_ostream_from_buffer(buffer, _maxSize);
-
-        T *protoMsg = new T();
-        *protoMsg = {};
-        _statefulService->read([this, protoMsg](const T &state) { _stateReader(state, *protoMsg); });
-
-        bool encodeSuccess = pb_encode(&stream, _msgDescriptor, protoMsg);
-        delete protoMsg;
-
-        if (!encodeSuccess) {
-            delete[] buffer;
-            return false;
-        }
-
-        mkdirs();
-
-        FILE *file = fopen(_filePath, "wb");
-        if (!file) {
-            ESP_LOGE(TAG_PERSISTENCE, "Failed to open file for writing: %s", _filePath);
-            delete[] buffer;
-            return false;
-        }
-
-        size_t written = fwrite(buffer, 1, stream.bytes_written, file);
-        fclose(file);
-        delete[] buffer;
-
-        return written == stream.bytes_written;
-    }
-
-    void disableUpdateHandler() {
-        if (_updateHandlerId) {
-            _statefulService->removeUpdateHandler(_updateHandlerId);
-            _updateHandlerId = 0;
-        }
-    }
-
-    void enableUpdateHandler() {
-        if (!_updateHandlerId) {
-            _updateHandlerId = _statefulService->addUpdateHandler([&](const std::string &originId) { writeToFS(); });
-        }
-    }
-
-  private:
-    ProtoStateReader _stateReader;
-    ProtoStateUpdater _stateUpdater;
-    StatefulService<T> *_statefulService;
-    const char *_filePath;
-    const pb_msgdesc_t *_msgDescriptor;
-    size_t _maxSize;
-    T _defaultState;
-    HandlerId _updateHandlerId;
-
-    void mkdirs() {
-        std::string path(_filePath);
-        size_t index = 0;
-        while ((index = path.find('/', index + 1)) != std::string::npos) {
-            std::string segment = path.substr(0, index);
-            struct stat st;
-            if (stat(segment.c_str(), &st) != 0) {
-                FileSystem::mkdirRecursive(segment.c_str());
-            }
-        }
-    }
-
-  protected:
-    void applyDefaults() {
-        _statefulService->updateWithoutPropagation([this](T &state) { return _stateUpdater(_defaultState, state); });
-    }
-};

esp32/include/template/stateful_proto_endpoint.h

@@ -1,135 +0,0 @@
-#pragma once
-
-#include <esp_http_server.h>
-#include <template/stateful_service.h>
-#include <communication/webserver.h>
-#include <platform_shared/api.pb.h>
-#include <pb_encode.h>
-#include <pb_decode.h>
-
-#include <functional>
-
-#define PROTO_ENDPOINT_ORIGIN_ID "proto"
-
-/**
- * A stateful HTTP endpoint that uses protobuf encoding with api::Request/Response wrappers.
- *
- * @tparam T The internal state type (e.g., APSettings C++ class)
- * @tparam ProtoT The protobuf message type within the oneof (e.g., api_APSettings)
- *
- * The endpoint receives api::Request, extracts the specific payload from the oneof,
- * and returns api::Response with the updated state.
- */
-template <class T, class ProtoT>
-class StatefulProtoEndpoint {
-  public:
-    /** Converts internal state to protobuf message for responses */
-    // Formats are passed as referenced const (local variable) we want to read from, and a reference (proto) we write to
-    using ProtoStateReader = std::function<void(const T&, ProtoT&)>;
-    /** Converts incoming protobuf message to internal state */
-    // Formats are passed as referenced const (new object) we read from, and a reference to the local variable we  write to
-    using ProtoStateUpdater = std::function<StateUpdateResult(const ProtoT&, T&)>;
-    /** Extracts the specific proto type from Request oneof */
-    using RequestExtractor = std::function<bool(const api_Request&, ProtoT&)>;
-    /** Assigns the specific proto type to Response oneof */
-    using ResponseAssigner = std::function<void(api_Response&, const ProtoT&)>;
-
-  protected:
-    ProtoStateReader _stateReader;
-    ProtoStateUpdater _stateUpdater;
-    StatefulService<T>* _statefulService;
-    RequestExtractor _requestExtractor;
-    ResponseAssigner _responseAssigner;
-
-  public:
-    /**
-     * Constructor for wrapped proto endpoint
-     * @param stateReader Converts internal state to proto
-     * @param stateUpdater Converts proto to internal state
-     * @param statefulService The stateful service to manage
-     * @param requestExtractor Extracts specific type from Request oneof
-     * @param responseAssigner Assigns specific type to Response oneof
-     */
-    StatefulProtoEndpoint(ProtoStateReader stateReader, ProtoStateUpdater stateUpdater,
-                          StatefulService<T>* statefulService,
-                          RequestExtractor requestExtractor, ResponseAssigner responseAssigner)
-        : _stateReader(stateReader),
-          _stateUpdater(stateUpdater),
-          _statefulService(statefulService),
-          _requestExtractor(requestExtractor),
-          _responseAssigner(responseAssigner) {}
-
-    /**
-     * Handles POST requests: extracts payload from pre-decoded Request, updates state, returns Response
-     */
-    esp_err_t handleStateUpdate(httpd_req_t* httpReq, api_Request* protoReq) {
-        ProtoT protoMsg = {};
-        if (!_requestExtractor(*protoReq, protoMsg)) {
-            return sendErrorResponse(httpReq, 400, "Invalid request type");
-        }
-
-        StateUpdateResult outcome = _statefulService->update(
-            [this, &protoMsg](T& settings) { return _stateUpdater(protoMsg, settings); }, PROTO_ENDPOINT_ORIGIN_ID);
-
-        if (outcome == StateUpdateResult::ERROR) {
-            return sendErrorResponse(httpReq, 400, "Invalid state");
-        }
-
-        return sendStateResponse(httpReq, 200);
-    }
-
-    /**
-     * Handles GET requests: reads current state and returns it as Response
-     */
-    esp_err_t getState(httpd_req_t* request) {
-        return sendStateResponse(request, 200);
-    }
-
-  private:
-    /** Sends current state wrapped in Response */
-    esp_err_t sendStateResponse(httpd_req_t* request, uint32_t statusCode) {
-        api_Response res = api_Response_init_zero;
-        res.status_code = statusCode;
-
-        ProtoT protoState = {};
-        _statefulService->read([this, &protoState](const T& settings) { _stateReader(settings, protoState); });
-        _responseAssigner(res, protoState);
-
-        return WebServer::send(request, 200, res, api_Response_fields);
-    }
-
-    /** Sends error wrapped in Response */
-    esp_err_t sendErrorResponse(httpd_req_t* request, uint32_t statusCode, const char* message) {
-        api_Response res = api_Response_init_zero;
-        res.status_code = statusCode;
-        res.error_message = (char*)message;
-        return WebServer::send(request, statusCode == 200 ? 200 : 400, res, api_Response_fields);
-    }
-};
-
-// =============================================================================
-// Helper macros for defining request extractors and response assigners
-// =============================================================================
-
-/**
- * Creates a request extractor lambda for a specific payload type
- * Usage: API_REQUEST_EXTRACTOR(ap_settings, api_APSettings)
- */
-#define API_REQUEST_EXTRACTOR(field_name, proto_type)                              \
-    [](const api_Request& req, proto_type& out) -> bool {                          \
-        if (req.which_payload == api_Request_##field_name##_tag) {                 \
-            out = req.payload.field_name;                                          \
-            return true;                                                           \
-        }                                                                          \
-        return false;                                                              \
-    }
-
-/**
- * Creates a response assigner lambda for a specific payload type
- * Usage: API_RESPONSE_ASSIGNER(ap_settings, api_APSettings)
- */
-#define API_RESPONSE_ASSIGNER(field_name, proto_type)                              \
-    [](api_Response& res, const proto_type& data) {                                \
-        res.which_payload = api_Response_##field_name##_tag;                       \
-        res.payload.field_name = data;                                             \
-    }

esp32/include/template/stateful_service.h

@@ -1,135 +0,0 @@
-#pragma once
-
-#include <list>
-#include <functional>
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-#include <string>
-
-#include <template/state_result.h>
-
-using HandlerId = size_t;
-using StateUpdateCallback = std::function<void(const std::string &originId)>;
-using StateHookCallback = std::function<void(const std::string &originId, StateUpdateResult &result)>;
-
-class HandlerBase {
-  protected:
-    static inline HandlerId nextId_ = 1;
-    HandlerId id_;
-    bool allowRemove_;
-
-    HandlerBase(bool allowRemove) : id_(nextId_++), allowRemove_(allowRemove) {}
-
-  public:
-    HandlerId getId() const { return id_; }
-    bool isRemovable() const { return allowRemove_; }
-};
-
-class UpdateHandler : public HandlerBase {
-    StateUpdateCallback callback_;
-
-  public:
-    UpdateHandler(StateUpdateCallback callback, bool allowRemove)
-        : HandlerBase(allowRemove), callback_(std::move(callback)) {}
-
-    void invoke(const std::string &originId) const { callback_(originId); }
-};
-
-class HookHandler : public HandlerBase {
-    StateHookCallback callback_;
-
-  public:
-    HookHandler(StateHookCallback callback, bool allowRemove)
-        : HandlerBase(allowRemove), callback_(std::move(callback)) {}
-
-    void invoke(const std::string &originId, StateUpdateResult &result) const { callback_(originId, result); }
-};
-
-template <class T>
-class StatefulService {
-  public:
-    template <typename... Args>
-    StatefulService(Args &&...args) : state_(std::forward<Args>(args)...), mutex_(xSemaphoreCreateRecursiveMutex()) {}
-
-    HandlerId addUpdateHandler(StateUpdateCallback callback, bool allowRemove = true) {
-        if (!callback) return 0;
-
-        updateHandlers_.emplace_back(std::move(callback), allowRemove);
-        return updateHandlers_.back().getId();
-    }
-
-    void removeUpdateHandler(HandlerId id) {
-        updateHandlers_.remove_if(
-            [id](const UpdateHandler &handler) { return handler.isRemovable() && handler.getId() == id; });
-    }
-
-    HandlerId addHookHandler(StateHookCallback callback, bool allowRemove = true) {
-        if (!callback) return 0;
-
-        hookHandlers_.emplace_back(std::move(callback), allowRemove);
-        return hookHandlers_.back().getId();
-    }
-
-    void removeHookHandler(HandlerId id) {
-        hookHandlers_.remove_if(
-            [id](const HookHandler &handler) { return handler.isRemovable() && handler.getId() == id; });
-    }
-
-    StateUpdateResult update(std::function<StateUpdateResult(T &)> stateUpdater, const std::string &originId) {
-        lock();
-        StateUpdateResult result = stateUpdater(state_);
-        unlock();
-        notifyStateChange(originId, result);
-        return result;
-    }
-
-    StateUpdateResult updateWithoutPropagation(std::function<StateUpdateResult(T &)> stateUpdater) {
-        lock();
-        StateUpdateResult result = stateUpdater(state_);
-        unlock();
-        return result;
-    }
-
-    void read(std::function<void(T &)> stateReader) {
-        lock();
-        stateReader(state_);
-        unlock();
-    }
-
-    void read(std::function<void(const T &)> stateReader) const {
-        const_cast<StatefulService *>(this)->lock();
-        stateReader(state_);
-        const_cast<StatefulService *>(this)->unlock();
-    }
-
-    void callUpdateHandlers(const std::string &originId) {
-        for (const UpdateHandler &updateHandler : updateHandlers_) {
-            updateHandler.invoke(originId);
-        }
-    }
-
-    void callHookHandlers(const std::string &originId, StateUpdateResult &result) {
-        for (const HookHandler &hookHandler : hookHandlers_) {
-            hookHandler.invoke(originId, result);
-        }
-    }
-
-    T &state() { return state_; }
-
-  private:
-    T state_;
-
-    inline void lock() { xSemaphoreTakeRecursive(mutex_, portMAX_DELAY); }
-    inline void unlock() { xSemaphoreGiveRecursive(mutex_); }
-
-    void notifyStateChange(const std::string &originId, StateUpdateResult &result) {
-        callHookHandlers(originId, result);
-        if (result == StateUpdateResult::CHANGED) {
-            callUpdateHandlers(originId);
-        }
-    }
-
-    SemaphoreHandle_t mutex_;
-    std::list<UpdateHandler> updateHandlers_;
-    std::list<HookHandler> hookHandlers_;
-};

esp32/include/utils/timing.h

@@ -16,18 +16,17 @@
         }                                                                                         \
     } while (0)
 
-    // Note: name must be a valid variable name too
-#define TIME_IT(code, name)                                                                       \
+#define TIME_IT(code)                                                                       \
     {                                                                                       \
-        uint64_t time_it_start##name = esp_timer_get_time();                                      \
+        uint64_t time_it_start = esp_timer_get_time();                                      \
         code;                                                                               \
-        uint64_t time_it_elapsed##name = esp_timer_get_time() - time_it_start##name;                    \
-        if (time_it_elapsed##name < 1000) {                                                       \
-            ESP_LOGI("Time It - " #name, "Time elapsed: %llu microseconds", time_it_elapsed##name);        \
-        } else if (time_it_elapsed##name < 1000000) {                                             \
-            ESP_LOGI("Time It - " #name, "Time elapsed: %llu milliseconds", time_it_elapsed##name / 1000); \
+        uint64_t time_it_elapsed = esp_timer_get_time() - time_it_start;                    \
+        if (time_it_elapsed < 1000) {                                                       \
+            ESP_LOGI("Time It", "Time elapsed: %llu microseconds", time_it_elapsed);        \
+        } else if (time_it_elapsed < 1000000) {                                             \
+            ESP_LOGI("Time It", "Time elapsed: %llu milliseconds", time_it_elapsed / 1000); \
         } else {                                                                            \
-            ESP_LOGI("Time It - " #name, "Time elapsed: %.2f seconds", time_it_elapsed##name / 1000000.0); \
+            ESP_LOGI("Time It", "Time elapsed: %.2f seconds", time_it_elapsed / 1000000.0); \
         }                                                                                   \
     }
 

esp32/include/wifi_service.h

@@ -7,16 +7,16 @@
 
 #include <filesystem.h>
 #include <utils/timing.h>
-#include <template/stateful_service.h>
-#include <template/stateful_persistence_pb.h>
-#include <template/stateful_proto_endpoint.h>
+#include <eventbus.hpp>
 #include <settings/wifi_settings.h>
 
+class WebServer;
+
 #define WIFI_EVENT_STA_DISCONNECTED_IDF WIFI_EVENT_STA_DISCONNECTED
 #define WIFI_EVENT_STA_STOP_IDF WIFI_EVENT_STA_STOP
 #define IP_EVENT_STA_GOT_IP_IDF 1000
 
-class WiFiService : public StatefulService<WiFiSettings> {
+class WiFiService {
   public:
     WiFiService();
     ~WiFiService();
@@ -27,20 +27,21 @@ class WiFiService : public StatefulService<WiFiSettings> {
     void setupMDNS(const char *hostname);
     void selectNetwork(uint32_t index);
 
-    const char *getHostname() { return state().hostname; }
+    const char *getHostname() { return _settings.hostname; }
 
     static esp_err_t handleScan(httpd_req_t *request);
     static esp_err_t getNetworks(httpd_req_t *request);
     static esp_err_t getNetworkStatus(httpd_req_t *request);
 
-    StatefulProtoEndpoint<WiFiSettings, api_WifiSettings> protoEndpoint;
+    void registerRoutes(WebServer &server);
 
   private:
     void onStationModeDisconnected(int32_t event, void *event_data);
     void onStationModeStop(int32_t event, void *event_data);
     static void onStationModeGotIP(int32_t event, void *event_data);
 
-    FSPersistencePB<WiFiSettings> _persistence;
+    WiFiSettings _settings {};
+    SubscriptionHandle _settingsHandle;
 
     void reconfigureWiFiConnection();
     void manageSTA();

esp32/partition_table/default_32MB.csv

@@ -0,0 +1,8 @@
+# Name,   Type, SubType, Offset,   Size, Flags
+# 32MB Flash partition table for ESP32-P4
+nvs,      data, nvs,     0x9000,   0x5000,
+otadata,  data, ota,     0xe000,   0x2000,
+app0,     app,  ota_0,   0x10000,  0xC80000,
+app1,     app,  ota_1,   0xC90000, 0xC80000,
+spiffs,   data, spiffs,  0x1910000,0x6E0000,
+coredump, data, coredump,0x1FF0000,0x10000,

esp32/src/CMakeLists.txt

@@ -1,3 +1,25 @@
+set(COMPONENT_REQUIRES
+    driver
+    esp_driver_i2c
+    esp_http_server
+    nvs_flash
+    esp_wifi
+    esp_event
+    esp_netif
+    mdns
+    esp_timer
+    esp_psram
+    spi_flash
+    littlefs
+    esp-dsp
+)
+
+if(IDF_TARGET STREQUAL "esp32p4")
+    list(APPEND COMPONENT_REQUIRES esp_wifi_remote esp_hosted esp_driver_cam esp_driver_isp esp_driver_jpeg espressif__esp_sccb_intf espressif__esp_cam_sensor)
+else()
+    list(APPEND COMPONENT_REQUIRES esp32-camera)
+endif()
+
 idf_component_register(
     SRC_DIRS 
         "."
@@ -10,17 +32,5 @@ idf_component_register(
         "../include"
         "../../submodules/nanopb"
     REQUIRES
-        driver
-        esp_http_server
-        nvs_flash
-        esp_wifi
-        esp_event
-        esp_netif
-        mdns
-        esp_timer
-        esp_psram
-        spi_flash
-        littlefs
-        esp32-camera
-        esp-dsp
+        ${COMPONENT_REQUIRES}
 )

esp32/src/ap_service.cpp

@@ -3,17 +3,7 @@
 
 static const char *TAG = "APService";
 
-APService::APService()
-    : protoEndpoint(APSettings_read, APSettings_update, this, API_REQUEST_EXTRACTOR(ap_settings, api_APSettings),
-                    API_RESPONSE_ASSIGNER(ap_settings, api_APSettings)),
-      _persistence(APSettings_read, APSettings_update, this, AP_SETTINGS_FILE, api_APSettings_fields,
-                   api_APSettings_size, APSettings_defaults()),
-      _dnsServer(nullptr),
-      _lastManaged(0),
-      _reconfigureAp(false),
-      _recoveryMode(false) {
-    addUpdateHandler([&](const std::string &originId) { reconfigureAP(); }, false);
-}
+APService::APService() : _dnsServer(nullptr), _lastManaged(0), _reconfigureAp(false), _recoveryMode(false) {}
 
 APService::~APService() {
     if (_dnsServer) {
@@ -22,7 +12,17 @@ APService::~APService() {
     }
 }
 
-void APService::begin() { _persistence.readFromFS(); }
+void APService::begin() {
+    _settings = EventBus::instance().peek<APSettings>();
+    _settingsHandle = EventBus::instance().subscribe<APSettings>([this](const APSettings &s) {
+        _settings = s;
+        reconfigureAP();
+    });
+}
+
+void APService::registerRoutes(WebServer &s) {
+    s.on("/api/ap/status", HTTP_GET, [this](httpd_req_t *request) { return getStatusProto(request); });
+}
 
 esp_err_t APService::getStatusProto(httpd_req_t *request) {
     api_Response res = api_Response_init_zero;
@@ -44,7 +44,7 @@ void APService::statusProto(api_APStatus &proto) {
 APNetworkStatus APService::getAPNetworkStatus() {
     wifi_mode_t currentWiFiMode = WiFi.getMode();
     bool apActive = currentWiFiMode == WIFI_MODE_AP || currentWiFiMode == WIFI_MODE_APSTA;
-    if (apActive && state().provision_mode != AP_MODE_ALWAYS && WiFi.status() == WL_CONNECTED) {
+    if (apActive && _settings.provision_mode != AP_MODE_ALWAYS && WiFi.status() == WL_CONNECTED) {
         return LINGERING;
     }
     return apActive ? ACTIVE : INACTIVE;
@@ -70,8 +70,8 @@ void APService::loop() {
 
 void APService::manageAP() {
     wifi_mode_t currentWiFiMode = WiFi.getMode();
-    if (state().provision_mode == AP_MODE_ALWAYS ||
-        (state().provision_mode == AP_MODE_DISCONNECTED && WiFi.status() != WL_CONNECTED) || _recoveryMode) {
+    if (_settings.provision_mode == AP_MODE_ALWAYS ||
+        (_settings.provision_mode == AP_MODE_DISCONNECTED && WiFi.status() != WL_CONNECTED) || _recoveryMode) {
         if (_reconfigureAp || currentWiFiMode == WIFI_MODE_NULL || currentWiFiMode == WIFI_MODE_STA) {
             startAP();
         }
@@ -83,9 +83,9 @@ void APService::manageAP() {
 }
 
 void APService::startAP() {
-    ESP_LOGI(TAG, "Starting software access point: %s", state().ssid);
-    WiFi.softAPConfig(IPAddress(state().local_ip), IPAddress(state().gateway_ip), IPAddress(state().subnet_mask));
-    WiFi.softAP(state().ssid, state().password, state().channel, state().ssid_hidden, state().max_clients);
+    ESP_LOGI(TAG, "Starting software access point: %s", _settings.ssid);
+    WiFi.softAPConfig(IPAddress(_settings.local_ip), IPAddress(_settings.gateway_ip), IPAddress(_settings.subnet_mask));
+    WiFi.softAP(_settings.ssid, _settings.password, _settings.channel, _settings.ssid_hidden, _settings.max_clients);
 #if CONFIG_IDF_TARGET_ESP32C3
     WiFi.setTxPower(8);
 #endif

esp32/src/communication/webserver.cpp

@@ -2,7 +2,6 @@
 #include <esp_log.h>
 #include <cstring>
 #include <algorithm>
-#include <utils/timing.h>
 
 static const char* TAG = "WebServer";
 
@@ -122,10 +121,6 @@ esp_err_t WebServer::httpHandler(httpd_req_t* req) {
 }
 
 esp_err_t WebServer::wsHandler(httpd_req_t* req) {
-    esp_err_t result;
-    httpd_ws_frame_t frame;
-    esp_err_t ret;
-    TIME_IT(
     WebServer* self = static_cast<WebServer*>(req->user_ctx);
 
     if (req->method == HTTP_GET) {
@@ -138,21 +133,17 @@ esp_err_t WebServer::wsHandler(httpd_req_t* req) {
         return ESP_OK;
     }
 
-    
+    httpd_ws_frame_t frame;
     memset(&frame, 0, sizeof(httpd_ws_frame_t));
     frame.type = HTTPD_WS_TYPE_BINARY;
 
-    
-    TIME_IT(
-    ret = httpd_ws_recv_frame(req, &frame, 0);
+    esp_err_t ret = httpd_ws_recv_frame(req, &frame, 0);
     if (ret != ESP_OK) {
         ESP_LOGE(TAG, "Failed to get frame len: %s", esp_err_to_name(ret));
         return ret;
     }
-    , FRAME_LEN)
 
     if (frame.len > 0) {
-        TIME_IT(
         frame.payload = (uint8_t*)malloc(frame.len);
         if (!frame.payload) {
             ESP_LOGE(TAG, "Failed to allocate frame payload");
@@ -165,7 +156,6 @@ esp_err_t WebServer::wsHandler(httpd_req_t* req) {
             free(frame.payload);
             return ret;
         }
-        , FRAME_RECEIVE)
     }
 
     if (frame.type == HTTPD_WS_TYPE_CLOSE) {
@@ -179,18 +169,15 @@ esp_err_t WebServer::wsHandler(httpd_req_t* req) {
         return ESP_OK;
     }
 
-    result = ESP_OK;
+    esp_err_t result = ESP_OK;
     if (self->wsFrameHandler_) {
-        TIME_IT(
         result = self->wsFrameHandler_(req, &frame);
-        , FRAME_HANDLER)
     }
 
     if (frame.payload) {
         free(frame.payload);
     }
 
-    , WS_HANDLER)
     return result;
 }
 
@@ -278,19 +265,7 @@ esp_err_t WebServer::wsSend(int sockfd, const uint8_t* data, size_t len) {
                               .type = HTTPD_WS_TYPE_BINARY,
                               .payload = const_cast<uint8_t*>(data),
                               .len = len};
-    xSemaphoreTake(wsMutex_, portMAX_DELAY);
-    esp_err_t ret = httpd_ws_send_frame_async(server_, sockfd, &frame);
-    xSemaphoreGive(wsMutex_);
-
-    if (ret != ESP_OK) {
-        if (httpd_ws_get_fd_info(server_, sockfd) != HTTPD_WS_CLIENT_WEBSOCKET) {
-        ESP_LOGW(TAG, "Removing disconnected client %d", sockfd);
-        removeWsClient(sockfd);
-            return ESP_ERR_INVALID_STATE;
-        } 
-    }
-
-    return ret;
+    return httpd_ws_send_frame_async(server_, sockfd, &frame);
 }
 
 esp_err_t WebServer::wsSendAll(const uint8_t* data, size_t len) {

esp32/src/communication/websocket.cpp

@@ -24,26 +24,8 @@ void Websocket::onWsClose(int sockfd) {
 }
 
 esp_err_t Websocket::onFrame(httpd_req_t* req, httpd_ws_frame_t* frame) {
-    // Handle PING - respond with PONG
-    if (frame->type == HTTPD_WS_TYPE_PING) {
-        httpd_ws_frame_t pong = {
-            .final = true,
-            .fragmented = false,
-            .type = HTTPD_WS_TYPE_PONG,
-            .payload = frame->payload,
-            .len = frame->len
-        };
-        return httpd_ws_send_frame(req, &pong);
-    }
-
-    // Ignore PONG frames
-    if (frame->type == HTTPD_WS_TYPE_PONG) {
-        return ESP_OK;
-    }
-
-    // Ignore other non-binary frames
     if (frame->type != HTTPD_WS_TYPE_BINARY) {
-        ESP_LOGD(TAG, "Ignoring frame type %d", frame->type);
+        ESP_LOGW(TAG, "Expected binary frame, got type %d", frame->type);
         return ESP_OK;
     }
 

esp32/src/filesystem.cpp

@@ -6,14 +6,34 @@
 #include <esp_log.h>
 #include <pb_encode.h>
 #include <pb_decode.h>
-#include "esp_vfs_fat.h"
-#include <sdmmc_cmd.h>
-#include <driver/sdmmc_host.h>
 
 static const char *TAG = "FileSystem";
 
 namespace FileSystem {
 
+void registerRoutes(WebServer &s) {
+    s.on("/api/config/*", HTTP_GET, [](httpd_req_t *request) { return getConfigFile(request); });
+    s.on("/api/files", HTTP_GET, [](httpd_req_t *request) { return getFilesProto(request); });
+    s.on("/api/files/delete", HTTP_POST, [](httpd_req_t *request, api_Request *protoReq) {
+        if (protoReq->which_payload != api_Request_file_delete_request_tag) {
+            return WebServer::sendError(request, 400, "Invalid request payload");
+        }
+        return handleDelete(request, protoReq->payload.file_delete_request);
+    });
+    s.on("/api/files/edit", HTTP_POST, [](httpd_req_t *request, api_Request *protoReq) {
+        if (protoReq->which_payload != api_Request_file_edit_request_tag) {
+            return WebServer::sendError(request, 400, "Invalid request payload");
+        }
+        return handleEdit(request, protoReq->payload.file_edit_request);
+    });
+    s.on("/api/files/mkdir", HTTP_POST, [](httpd_req_t *request, api_Request *protoReq) {
+        if (protoReq->which_payload != api_Request_file_mkdir_request_tag) {
+            return WebServer::sendError(request, 400, "Invalid request payload");
+        }
+        return mkdir(request, protoReq->payload.file_mkdir_request);
+    });
+}
+
 static std::vector<api_FileEntry *> allocatedEntries;
 
 static void freeAllocatedEntries() {
@@ -82,7 +102,7 @@ void listFilesProto(const std::string &directory, api_FileEntry *entry) {
     if (path.empty() || path[0] != '/') {
         path = "/" + directory;
     }
-    std::string fullPath = path;
+    std::string fullPath = std::string(MOUNT_POINT) + path;
     listFilesProtoRecursive(fullPath, entry);
 }
 
@@ -111,7 +131,7 @@ esp_err_t getFilesProto(httpd_req_t *request) {
 
 bool init() {
     esp_vfs_littlefs_conf_t conf = {
-        .base_path = LITTLEFS_MOUNT_POINT,
+        .base_path = MOUNT_POINT,
         .partition_label = "spiffs",
         .format_if_mount_failed = true,
         .dont_mount = false,
@@ -137,38 +157,6 @@ bool init() {
 
     mkdirRecursive(FS_CONFIG_DIRECTORY);
 
-    esp_vfs_fat_sdmmc_mount_config_t sd_mount_config = {
-        .format_if_mount_failed = false,
-        .max_files = 4,
-        .allocation_unit_size = 16 * 1024,
-    };
-
-    sdmmc_host_t host = SDMMC_HOST_DEFAULT();
-    host.flags = SDMMC_HOST_FLAG_1BIT;  // Use 1-bit mode
-    host.max_freq_khz = SDMMC_FREQ_DEFAULT;
-
-    sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
-    slot_config.width = 1;  // 1-bit mode
-    slot_config.clk = SD_CLK_PIN;
-    slot_config.cmd = SD_CMD_PIN;
-    slot_config.d0 = SD_DATA_PIN;
-    slot_config.flags |= SDMMC_SLOT_FLAG_INTERNAL_PULLUP;
-
-    sdmmc_card_t *card = nullptr;
-    esp_err_t err = esp_vfs_fat_sdmmc_mount(SD_MOUNT_POINT, &host, &slot_config, &sd_mount_config, &card);
-    if (err != ESP_OK) {
-        if (err == ESP_FAIL) {
-            ESP_LOGW(TAG, "Failed to mount SD card filesystem");
-        } else {
-            ESP_LOGW(TAG, "SD card not present or failed to initialize (%s)", esp_err_to_name(err));
-        }
-        // Don't fail - SD card is optional
-    } else {
-        ESP_LOGI(TAG, "SD card mounted at %s", SD_MOUNT_POINT);
-        ESP_LOGI(TAG, "SD card: %s, %lluMB", card->cid.name,
-                 ((uint64_t)card->csd.capacity) * card->csd.sector_size / (1024 * 1024));
-    }
-
     return true;
 }
 
@@ -266,7 +254,7 @@ esp_err_t getFiles(httpd_req_t *request) {
 
 esp_err_t getConfigFile(httpd_req_t *request) {
     const char *uri = request->uri;
-    std::string path = std::string(LITTLEFS_MOUNT_POINT) + "/config" + std::string(uri).substr(11);
+    std::string path = std::string(MOUNT_POINT) + "/config" + std::string(uri).substr(11);
 
     if (!fileExists(path.c_str())) {
         return WebServer::sendError(request, 404, "File not found");
@@ -288,7 +276,7 @@ esp_err_t getConfigFile(httpd_req_t *request) {
 }
 
 esp_err_t handleDelete(httpd_req_t *request, const api_FileDeleteRequest &req) {
-    std::string fullPath = req.path;
+    std::string fullPath = std::string(MOUNT_POINT) + req.path;
     ESP_LOGI(TAG, "Deleting file: %s", fullPath.c_str());
 
     api_Response res = api_Response_init_zero;
@@ -302,7 +290,7 @@ esp_err_t handleDelete(httpd_req_t *request, const api_FileDeleteRequest &req) {
 }
 
 esp_err_t handleEdit(httpd_req_t *request, const api_FileEditRequest &req) {
-    std::string fullPath = req.path;
+    std::string fullPath = std::string(MOUNT_POINT) + req.path;
     ESP_LOGI(TAG, "Editing file: %s", fullPath.c_str());
 
     api_Response res = api_Response_init_zero;
@@ -361,7 +349,7 @@ bool editFile(const char *filename, const uint8_t *content, size_t size) { retur
 bool editFile(const char *filename, const char *content) { return writeFile(filename, content); }
 
 esp_err_t mkdir(httpd_req_t *request, const api_FileMkdirRequest &req) {
-    std::string fullPath = req.path;
+    std::string fullPath = std::string(MOUNT_POINT) + req.path;
     ESP_LOGI(TAG, "Creating directory: %s", fullPath.c_str());
 
     api_Response res = api_Response_init_zero;

esp32/src/filesystem_ws.cpp

@@ -7,8 +7,6 @@
 #include <dirent.h>
 #include <sys/stat.h>
 #include <cstring>
-#include <cerrno>
-#include <utils/timing.h>
 
 static const char* TAG = "FileSystemWS";
 
@@ -16,136 +14,11 @@ namespace FileSystemWS {
 
 FileSystemHandler fsHandler;
 
-FileSystemHandler::FileSystemHandler()
-    : transferIdCounter_(0), writeQueue_(nullptr), writerTaskHandle_(nullptr), uploadsMutex_(nullptr),
-      writerTaskRunning_(false) {
-    uploadsMutex_ = xSemaphoreCreateMutex();
-}
+FileSystemHandler::FileSystemHandler() : transferIdCounter_(0) {}
 
-FileSystemHandler::~FileSystemHandler() {
-    stopWriterTask();
-    if (uploadsMutex_) {
-        vSemaphoreDelete(uploadsMutex_);
-    }
-}
-
-void FileSystemHandler::startWriterTask() {
-    if (writerTaskHandle_ != nullptr) {
-        return;
-    }
-
-    writeQueue_ = xQueueCreate(FS_WRITE_QUEUE_SIZE, sizeof(WriteRequest));
-    if (!writeQueue_) {
-        ESP_LOGE(TAG, "Failed to create write queue");
-        return;
-    }
-
-    writerTaskRunning_ = true;
-    BaseType_t result =
-        xTaskCreate(writerTaskFunc, "fs_writer", FS_WRITER_TASK_STACK_SIZE, this, FS_WRITER_TASK_PRIORITY, &writerTaskHandle_);
-
-    if (result != pdPASS) {
-        ESP_LOGE(TAG, "Failed to create writer task");
-        vQueueDelete(writeQueue_);
-        writeQueue_ = nullptr;
-        writerTaskRunning_ = false;
-    } else {
-        ESP_LOGI(TAG, "Writer task started");
-    }
-}
-
-void FileSystemHandler::stopWriterTask() {
-    if (!writerTaskRunning_) {
-        return;
-    }
-
-    writerTaskRunning_ = false;
-
-    // Send a poison pill to wake up the task
-    WriteRequest poison = {0, nullptr, 0, 0, false};
-    if (writeQueue_) {
-        xQueueSend(writeQueue_, &poison, portMAX_DELAY);
-    }
-
-    // Wait for task to finish
-    if (writerTaskHandle_) {
-        vTaskDelay(pdMS_TO_TICKS(100));
-        writerTaskHandle_ = nullptr;
-    }
-
-    if (writeQueue_) {
-        // Drain any remaining requests and free their data
-        WriteRequest req;
-        while (xQueueReceive(writeQueue_, &req, 0) == pdTRUE) {
-            if (req.data) {
-                free(req.data);
-            }
-        }
-        vQueueDelete(writeQueue_);
-        writeQueue_ = nullptr;
-    }
-
-    ESP_LOGI(TAG, "Writer task stopped");
-}
-
-void FileSystemHandler::writerTaskFunc(void* param) {
-    FileSystemHandler* self = static_cast<FileSystemHandler*>(param);
-    WriteRequest req;
-
-    while (self->writerTaskRunning_) {
-        if (xQueueReceive(self->writeQueue_, &req, pdMS_TO_TICKS(10)) == pdTRUE) {
-            if (req.data == nullptr) {
-                // Poison pill - exit
-                break;
-            }
-            self->processWriteRequest(req);
-            free(req.data);
-        }
-    }
-
-    vTaskDelete(nullptr);
-}
-
-void FileSystemHandler::processWriteRequest(const WriteRequest& req) {
-    xSemaphoreTake(uploadsMutex_, portMAX_DELAY);
-
-    auto it = uploads_.find(req.transferId);
-    if (it == uploads_.end()) {
-        xSemaphoreGive(uploadsMutex_);
-        return;
-    }
-
-    UploadState& state = it->second;
-
-    if (state.hasError) {
-        xSemaphoreGive(uploadsMutex_);
-        return;
-    }
-
-    size_t bytesWritten = fwrite(req.data, 1, req.size, state.file);
-
-    if (bytesWritten != req.size) {
-        state.hasError = true;
-        state.errorMessage = "Failed to write chunk";
-        xSemaphoreGive(uploadsMutex_);
-        finalizeUpload(req.transferId, false, state.errorMessage);
-        return;
-    }
-
-    state.chunksWritten++;
-    ESP_LOGD(TAG, "Async write chunk %u/%u: %u bytes", state.chunksWritten, state.totalChunks, bytesWritten);
-
-    // Periodic flush
-    if (state.chunksWritten > 0 && state.chunksWritten % 64 == 0) {
-        fflush(state.file);
-    }
-
-    bool shouldFinalize = req.isLastChunk;
-    xSemaphoreGive(uploadsMutex_);
-
-    if (shouldFinalize) {
-        finalizeUpload(req.transferId, true);
-    }
+void FileSystemHandler::begin() {
+    uploadHandle_ = EventBus::instance().subscribe<socket_message_FSUploadData>(
+        [this](const socket_message_FSUploadData& data) { handleUploadData(data); });
 }
 
 void FileSystemHandler::setSendCallbacks(SendMetadataCallback sendMetadata, SendCallback sendData,
@@ -184,46 +57,35 @@ void FileSystemHandler::cleanupExpiredTransfers() {
         }
     }
 
-    xSemaphoreTake(uploadsMutex_, portMAX_DELAY);
     auto ulIt = uploads_.begin();
     while (ulIt != uploads_.end()) {
         if (now - ulIt->second.lastActivityTime > FS_TRANSFER_TIMEOUT_MS) {
             if (ulIt->second.file) {
                 fclose(ulIt->second.file);
-                ulIt->second.file = nullptr;
             }
-            std::string path = ulIt->second.path;
-            uint32_t chunksReceived = ulIt->second.chunksReceived;
-            int clientId = ulIt->second.clientId;
-            uint32_t transferId = ulIt->first;
-
-            ulIt = uploads_.erase(ulIt);
-            xSemaphoreGive(uploadsMutex_);
-
-            remove(path.c_str());
-            ESP_LOGW(TAG, "Upload %u timed out, deleted partial file", transferId);
+            remove(ulIt->second.path.c_str());
+            ESP_LOGW(TAG, "Upload %u timed out, deleted partial file", ulIt->first);
 
             if (sendUploadCompleteCallback_) {
                 socket_message_FSUploadComplete complete = socket_message_FSUploadComplete_init_zero;
-                complete.transfer_id = transferId;
+                complete.transfer_id = ulIt->first;
                 complete.success = false;
                 strncpy(complete.error, "Transfer timed out", sizeof(complete.error) - 1);
-                complete.chunks_received = chunksReceived;
-                sendUploadCompleteCallback_(complete, clientId);
+                complete.chunks_received = ulIt->second.chunksReceived;
+                sendUploadCompleteCallback_(complete, ulIt->second.clientId);
             }
 
-            xSemaphoreTake(uploadsMutex_, portMAX_DELAY);
+            ulIt = uploads_.erase(ulIt);
         } else {
             ++ulIt;
         }
     }
-    xSemaphoreGive(uploadsMutex_);
 }
 
 socket_message_FSDeleteResponse FileSystemHandler::handleDelete(const socket_message_FSDeleteRequest& req) {
     socket_message_FSDeleteResponse response = socket_message_FSDeleteResponse_init_zero;
 
-    std::string path = req.path;
+    std::string path = std::string(MOUNT_POINT) + req.path;
     ESP_LOGI(TAG, "Delete request: %s", path.c_str());
 
     struct stat st;
@@ -272,7 +134,7 @@ bool FileSystemHandler::deleteRecursive(const std::string& path) {
 socket_message_FSMkdirResponse FileSystemHandler::handleMkdir(const socket_message_FSMkdirRequest& req) {
     socket_message_FSMkdirResponse response = socket_message_FSMkdirResponse_init_zero;
 
-    std::string path = req.path;
+    std::string path = std::string(MOUNT_POINT) + req.path;
     ESP_LOGI(TAG, "Mkdir request: %s", path.c_str());
 
     struct stat st;
@@ -293,15 +155,6 @@ socket_message_FSMkdirResponse FileSystemHandler::handleMkdir(const socket_messa
 }
 
 void FileSystemHandler::listDirectory(const std::string& path, socket_message_FSListResponse& response) {
-
-    // Root "/" is virtual - list mount points instead
-    if (strcmp(path.c_str(), "/") == 0) {
-        strncpy(response.directories[0].name, LITTLEFS_MOUNT_POINT + 1, sizeof(response.directories[0].name) - 1);
-        strncpy(response.directories[1].name, SD_MOUNT_POINT + 1, sizeof(response.directories[1].name) - 1);
-        response.directories_count = 2;
-        return;
-    }
-
     DIR* dir = opendir(path.c_str());
     if (!dir) {
         return;
@@ -343,13 +196,15 @@ void FileSystemHandler::listDirectory(const std::string& path, socket_message_FS
 socket_message_FSListResponse FileSystemHandler::handleList(const socket_message_FSListRequest& req) {
     socket_message_FSListResponse response = socket_message_FSListResponse_init_zero;
 
-    std::string path = req.path;
+    std::string path = std::string(MOUNT_POINT);
+    if (strlen(req.path) > 0 && req.path[0] != '\0') {
+        path += req.path;
+    }
 
     ESP_LOGI(TAG, "List request: %s", path.c_str());
 
     struct stat st;
-    // Make sure that path exists, or that it is a root listing
-    if (strcmp(path.c_str(), "/") != 0 && stat(path.c_str(), &st) != 0) {
+    if (stat(path.c_str(), &st) != 0) {
         response.success = false;
         strncpy(response.error, "Path not found", sizeof(response.error) - 1);
         return response;
@@ -362,7 +217,7 @@ socket_message_FSListResponse FileSystemHandler::handleList(const socket_message
 }
 
 void FileSystemHandler::handleDownloadRequest(const socket_message_FSDownloadRequest& req, int clientId) {
-    std::string path = req.path;
+    std::string path = std::string(MOUNT_POINT) + req.path;
     ESP_LOGI(TAG, "Download request: %s", path.c_str());
 
     struct stat st;
@@ -458,28 +313,8 @@ bool FileSystemHandler::sendNextDownloadChunk(uint32_t transferId) {
         bytesToRead = state.fileSize - position;
     }
 
-    // Allocate buffer for FT_POINTER data field
-    data->data = (pb_bytes_array_t*)malloc(PB_BYTES_ARRAY_T_ALLOCSIZE(bytesToRead));
-    if (!data->data) {
-        delete data;
-        if (sendCompleteCallback_) {
-            socket_message_FSDownloadComplete complete = socket_message_FSDownloadComplete_init_zero;
-            complete.transfer_id = transferId;
-            complete.success = false;
-            strncpy(complete.error, "Memory allocation failed", sizeof(complete.error) - 1);
-            complete.total_chunks = state.chunksSent;
-            complete.file_size = state.fileSize;
-            sendCompleteCallback_(complete, state.clientId);
-        }
-        fclose(state.file);
-        downloads_.erase(it);
-        ESP_LOGE(TAG, "Download failed - memory allocation: %u", transferId);
-        return false;
-    }
-
-    size_t bytesRead = fread(data->data->bytes, 1, bytesToRead, state.file);
+    size_t bytesRead = fread(data->data.bytes, 1, bytesToRead, state.file);
     if (bytesRead == 0 && bytesToRead > 0) {
-        free(data->data);
         delete data;
         if (sendCompleteCallback_) {
             socket_message_FSDownloadComplete complete = socket_message_FSDownloadComplete_init_zero;
@@ -496,13 +331,12 @@ bool FileSystemHandler::sendNextDownloadChunk(uint32_t transferId) {
         ESP_LOGE(TAG, "Download failed - read error: %u", transferId);
         return false;
     }
-    data->data->size = bytesRead;
+    data->data.size = bytesRead;
 
     if (sendDataCallback_) {
         sendDataCallback_(*data, state.clientId);
     }
 
-    free(data->data);
     delete data;
     state.chunksSent++;
     ESP_LOGD(TAG, "Download chunk %u/%u sent: %u bytes", state.chunksSent, state.totalChunks, bytesRead);
@@ -514,22 +348,17 @@ socket_message_FSUploadStartResponse FileSystemHandler::handleUploadStart(const
                                                                           int clientId) {
     socket_message_FSUploadStartResponse response = socket_message_FSUploadStartResponse_init_zero;
 
-    std::string path = req.path;
+    std::string path = std::string(MOUNT_POINT) + req.path;
     ESP_LOGI(TAG, "Upload start request: %s, size=%u, chunks=%u", path.c_str(), req.file_size, req.total_chunks);
 
-    // Check available space on the target filesystem
-    if (path.find(SD_MOUNT_POINT) != 0) {
-        // LittleFS path
-        size_t fs_total = 0, fs_used = 0;
-        esp_littlefs_info("spiffs", &fs_total, &fs_used);
-        size_t freeSpace = fs_total - fs_used;
-        if (freeSpace < req.file_size + 4096) {
-            response.success = false;
-            strncpy(response.error, "Insufficient storage space", sizeof(response.error) - 1);
-            return response;
-        }
+    size_t fs_total = 0, fs_used = 0;
+    esp_littlefs_info("spiffs", &fs_total, &fs_used);
+    size_t freeSpace = fs_total - fs_used;
+    if (freeSpace < req.file_size + 4096) {
+        response.success = false;
+        strncpy(response.error, "Insufficient storage space", sizeof(response.error) - 1);
+        return response;
     }
-    // TODO: SD card space check skipped - FAT doesn't have a simple API for this
 
     size_t lastSlash = path.find_last_of('/');
     if (lastSlash != std::string::npos && lastSlash > 0) {
@@ -544,15 +373,11 @@ socket_message_FSUploadStartResponse FileSystemHandler::handleUploadStart(const
 
     FILE* file = fopen(path.c_str(), "wb");
     if (!file) {
-        ESP_LOGE(TAG, "fopen failed for '%s': %s (errno=%d)", path.c_str(), strerror(errno), errno);
         response.success = false;
-        snprintf(response.error, sizeof(response.error) - 1, "Cannot open file: %s", strerror(errno));
+        strncpy(response.error, "Cannot open file for writing", sizeof(response.error) - 1);
         return response;
     }
 
-    // Set larger buffer for better write performance
-    setvbuf(file, nullptr, _IOFBF, 32 * 1024);
-
     uint32_t transferId = generateTransferId();
 
     UploadState state;
@@ -561,15 +386,12 @@ socket_message_FSUploadStartResponse FileSystemHandler::handleUploadStart(const
     state.fileSize = req.file_size;
     state.totalChunks = req.total_chunks;
     state.chunksReceived = 0;
-    state.chunksWritten = 0;
     state.bytesReceived = 0;
     state.lastActivityTime = esp_timer_get_time() / 1000;
     state.clientId = clientId;
     state.hasError = false;
 
-    xSemaphoreTake(uploadsMutex_, portMAX_DELAY);
     uploads_[transferId] = state;
-    xSemaphoreGive(uploadsMutex_);
 
     response.success = true;
     response.transfer_id = transferId;
@@ -582,16 +404,8 @@ socket_message_FSUploadStartResponse FileSystemHandler::handleUploadStart(const
 void FileSystemHandler::handleUploadData(const socket_message_FSUploadData& req) {
     uint32_t transferId = req.transfer_id;
 
-    // Auto-start writer task if not running
-    if (!writerTaskRunning_) {
-        startWriterTask();
-    }
-
-    xSemaphoreTake(uploadsMutex_, portMAX_DELAY);
-
     auto it = uploads_.find(transferId);
     if (it == uploads_.end()) {
-        xSemaphoreGive(uploadsMutex_);
         ESP_LOGW(TAG, "Upload data for unknown transfer: %u", transferId);
         return;
     }
@@ -600,7 +414,6 @@ void FileSystemHandler::handleUploadData(const socket_message_FSUploadData& req)
     state.lastActivityTime = esp_timer_get_time() / 1000;
 
     if (state.hasError) {
-        xSemaphoreGive(uploadsMutex_);
         return;
     }
 
@@ -608,61 +421,32 @@ void FileSystemHandler::handleUploadData(const socket_message_FSUploadData& req)
         ESP_LOGW(TAG, "Upload chunk out of order: expected %u, got %u", state.chunksReceived, req.chunk_index);
     }
 
-    if (!req.data || req.data->size == 0) {
+    size_t bytesWritten = fwrite(req.data.bytes, 1, req.data.size, state.file);
+    if (bytesWritten != req.data.size) {
         state.hasError = true;
-        state.errorMessage = "Empty or invalid data chunk";
-        xSemaphoreGive(uploadsMutex_);
+        state.errorMessage = "Failed to write chunk";
         finalizeUpload(transferId, false, state.errorMessage);
         return;
     }
 
-    // Copy data for async write
-    WriteRequest writeReq;
-    writeReq.transferId = transferId;
-    writeReq.size = req.data->size;
-    writeReq.chunkIndex = req.chunk_index;
-    writeReq.data = static_cast<uint8_t*>(malloc(req.data->size));
-
-    if (!writeReq.data) {
-        state.hasError = true;
-        state.errorMessage = "Memory allocation failed";
-        xSemaphoreGive(uploadsMutex_);
-        finalizeUpload(transferId, false, state.errorMessage);
-        return;
-    }
-
-    memcpy(writeReq.data, req.data->bytes, req.data->size);
-
     state.chunksReceived++;
-    state.bytesReceived += req.data->size;
-    writeReq.isLastChunk = (state.chunksReceived >= state.totalChunks);
+    state.bytesReceived += bytesWritten;
 
-    ESP_LOGD(TAG, "Queuing chunk %u/%u: %u bytes", state.chunksReceived, state.totalChunks, req.data->size);
-
-    xSemaphoreGive(uploadsMutex_);
-
-    // Check queue is valid
-    if (!writeQueue_) {
-        ESP_LOGE(TAG, "Write queue not initialized");
-        free(writeReq.data);
-        finalizeUpload(transferId, false, "Write queue not initialized");
-        return;
+    if (state.chunksReceived > 0 && state.chunksReceived % 64 == 0) {
+        ESP_LOGD(TAG, "Flushing file at chunk %u", state.chunksReceived);
+        fflush(state.file);
     }
 
-    // Try to queue (non-blocking) - if full, do sync write to avoid blocking HTTP server
-    if (xQueueSend(writeQueue_, &writeReq, 0) != pdTRUE) {
-        ESP_LOGD(TAG, "Queue full, doing sync write for chunk %u", writeReq.chunkIndex);
-        processWriteRequest(writeReq);
-        free(writeReq.data);
+    ESP_LOGD(TAG, "Upload chunk %u/%u: %u bytes", state.chunksReceived, state.totalChunks, bytesWritten);
+
+    if (state.chunksReceived >= state.totalChunks) {
+        finalizeUpload(transferId, true);
     }
 }
 
 void FileSystemHandler::finalizeUpload(uint32_t transferId, bool success, const std::string& error) {
-    xSemaphoreTake(uploadsMutex_, portMAX_DELAY);
-
     auto it = uploads_.find(transferId);
     if (it == uploads_.end()) {
-        xSemaphoreGive(uploadsMutex_);
         return;
     }
 
@@ -670,22 +454,13 @@ void FileSystemHandler::finalizeUpload(uint32_t transferId, bool success, const
 
     if (state.file) {
         fclose(state.file);
-        state.file = nullptr;
     }
 
-    std::string path = state.path;
-    uint32_t bytesReceived = state.bytesReceived;
-    uint32_t chunksReceived = state.chunksReceived;
-    int clientId = state.clientId;
-
-    uploads_.erase(it);
-    xSemaphoreGive(uploadsMutex_);
-
     if (!success) {
-        remove(path.c_str());
-        ESP_LOGW(TAG, "Upload failed, deleted partial file: %s", path.c_str());
+        remove(state.path.c_str());
+        ESP_LOGW(TAG, "Upload failed, deleted partial file: %s", state.path.c_str());
     } else {
-        ESP_LOGI(TAG, "Upload completed: %s (%u bytes)", path.c_str(), bytesReceived);
+        ESP_LOGI(TAG, "Upload completed: %s (%u bytes)", state.path.c_str(), state.bytesReceived);
     }
 
     if (sendUploadCompleteCallback_) {
@@ -695,9 +470,11 @@ void FileSystemHandler::finalizeUpload(uint32_t transferId, bool success, const
         if (!error.empty()) {
             strncpy(complete.error, error.c_str(), sizeof(complete.error) - 1);
         }
-        complete.chunks_received = chunksReceived;
-        sendUploadCompleteCallback_(complete, clientId);
+        complete.chunks_received = state.chunksReceived;
+        sendUploadCompleteCallback_(complete, state.clientId);
     }
+
+    uploads_.erase(it);
 }
 
 socket_message_FSCancelTransferResponse FileSystemHandler::handleCancelTransfer(
@@ -717,22 +494,17 @@ socket_message_FSCancelTransferResponse FileSystemHandler::handleCancelTransfer(
         return response;
     }
 
-    xSemaphoreTake(uploadsMutex_, portMAX_DELAY);
     auto ulIt = uploads_.find(transferId);
     if (ulIt != uploads_.end()) {
         if (ulIt->second.file) {
             fclose(ulIt->second.file);
-            ulIt->second.file = nullptr;
         }
-        std::string path = ulIt->second.path;
+        remove(ulIt->second.path.c_str());
         uploads_.erase(ulIt);
-        xSemaphoreGive(uploadsMutex_);
-        remove(path.c_str());
         response.success = true;
         ESP_LOGI(TAG, "Upload cancelled: %u", transferId);
         return response;
     }
-    xSemaphoreGive(uploadsMutex_);
 
     response.success = false;
     return response;

esp32/src/idf_component.yml

@@ -16,3 +16,21 @@ dependencies:
     
   espressif/esp32-camera:
     version: "^2.0.0"
+    rules:
+      - if: "idf_version >=5.0.0"
+      - if: "target not in [esp32p4]"
+      
+  espressif/esp_wifi_remote:
+    version: ">=0.3.0"
+    rules:
+      - if: "target in [esp32p4]"
+      
+  espressif/esp_hosted:
+    version: ">=0.0.6"
+    rules:
+      - if: "target in [esp32p4]"
+
+  espressif/esp_cam_sensor:
+    version: ">=0.5.0"
+    rules:
+      - if: "target in [esp32p4]"

esp32/src/main.cpp

@@ -1,7 +1,6 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 #include <esp_log.h>
-#include <esp_heap_caps.h>
 #include <nvs_flash.h>
 #include <wifi/wifi_idf.h>
 #include <mdns.h>
@@ -21,6 +20,14 @@
 #include <ap_service.h>
 #include <mdns_service.h>
 #include <system_service.h>
+#include <eventbus.hpp>
+#include <event_storage_manager.hpp>
+#include <event_types.h>
+#include <settings/camera_settings.h>
+
+#if CONFIG_IDF_TARGET_ESP32P4
+#include <esp_hosted.h>
+#endif
 
 #include <www_mount.hpp>
 
@@ -41,75 +48,36 @@ MDNSService mdnsService;
 
 WiFiService wifiService;
 APService apService;
+EventStorageManager storageManager;
+
+static SubscriptionHandle modeHandle;
 
 void setupServer() {
-    ESP_LOGI("Main", "Free heap before server: %lu, largest block: %lu",
-             esp_get_free_heap_size(), heap_caps_get_largest_free_block(MALLOC_CAP_8BIT));
     server.config(50 + WWW_ASSETS_COUNT, 16384);
     server.listen(80);
 
-    server.on("/api/system/reset", HTTP_POST,
-              [&](httpd_req_t *request, api_Request *protoReq) { return system_service::handleReset(request); });
-    server.on("/api/system/restart", HTTP_POST,
-              [&](httpd_req_t *request, api_Request *protoReq) { return system_service::handleRestart(request); });
-    server.on("/api/system/sleep", HTTP_POST,
-              [&](httpd_req_t *request, api_Request *protoReq) { return system_service::handleSleep(request); });
-#if USE_CAMERA
-    server.on("/api/camera/still", HTTP_GET, [&](httpd_req_t *request) { return cameraService.cameraStill(request); });
-    server.on("/api/camera/stream", HTTP_GET,
-              [&](httpd_req_t *request) { return cameraService.cameraStream(request); });
-    server.on("/api/camera/settings", HTTP_GET,
-              [&](httpd_req_t *request) { return cameraService.protoEndpoint.getState(request); });
-    server.on("/api/camera/settings", HTTP_POST, [&](httpd_req_t *request, api_Request *protoReq) {
-        return cameraService.protoEndpoint.handleStateUpdate(request, protoReq);
-    });
-#endif
-    server.on("/api/servo/config", HTTP_GET,
-              [&](httpd_req_t *request) { return servoController.protoEndpoint.getState(request); });
-    server.on("/api/servo/config", HTTP_POST, [&](httpd_req_t *request, api_Request *protoReq) {
-        return servoController.protoEndpoint.handleStateUpdate(request, protoReq);
-    });
-
-    server.on("/api/wifi/sta/settings", HTTP_GET,
-              [&](httpd_req_t *request) { return wifiService.protoEndpoint.getState(request); });
-    server.on("/api/wifi/sta/settings", HTTP_POST, [&](httpd_req_t *request, api_Request *protoReq) {
-        return wifiService.protoEndpoint.handleStateUpdate(request, protoReq);
-    });
-    server.on("/api/wifi/scan", HTTP_GET, [&](httpd_req_t *request) { return wifiService.handleScan(request); });
-    server.on("/api/wifi/networks", HTTP_GET, [&](httpd_req_t *request) { return wifiService.getNetworks(request); });
-    server.on("/api/wifi/sta/status", HTTP_GET,
-              [&](httpd_req_t *request) { return wifiService.getNetworkStatus(request); });
-
-    server.on("/api/ap/status", HTTP_GET, [&](httpd_req_t *request) { return apService.getStatusProto(request); });
-    server.on("/api/ap/settings", HTTP_GET,
-              [&](httpd_req_t *request) { return apService.protoEndpoint.getState(request); });
-    server.on("/api/ap/settings", HTTP_POST, [&](httpd_req_t *request, api_Request *protoReq) {
-        return apService.protoEndpoint.handleStateUpdate(request, protoReq);
-    });
-
-    server.on("/api/peripherals/settings", HTTP_GET,
-              [&](httpd_req_t *request) { return peripherals.protoEndpoint.getState(request); });
-    server.on("/api/peripherals/settings", HTTP_POST, [&](httpd_req_t *request, api_Request *protoReq) {
-        return peripherals.protoEndpoint.handleStateUpdate(request, protoReq);
-    });
-
+    PROTO_ROUTE(server, "/api/servo/config", servo_settings, ServoSettings);
+    PROTO_ROUTE(server, "/api/wifi/sta/settings", wifi_settings, WiFiSettings);
+    PROTO_ROUTE(server, "/api/ap/settings", ap_settings, APSettings);
+    PROTO_ROUTE(server, "/api/peripherals/settings", peripheral_settings, PeripheralsConfiguration);
 #if FT_ENABLED(USE_MDNS)
-    server.on("/api/mdns/settings", HTTP_GET,
-              [&](httpd_req_t *request) { return mdnsService.protoEndpoint.getState(request); });
-    server.on("/api/mdns/settings", HTTP_POST, [&](httpd_req_t *request, api_Request *protoReq) {
-        return mdnsService.protoEndpoint.handleStateUpdate(request, protoReq);
-    });
-    server.on("/api/mdns/status", HTTP_GET, [&](httpd_req_t *request) { return mdnsService.getStatus(request); });
-    server.on("/api/mdns/query", HTTP_POST, [&](httpd_req_t *request, api_Request *protoReq) {
-        return mdnsService.queryServices(request, protoReq);
-    });
+    PROTO_ROUTE(server, "/api/mdns/settings", mdns_settings, MDNSSettings);
+#endif
+#if FT_ENABLED(USE_CAMERA) && USE_DVP_CAMERA
+    PROTO_ROUTE(server, "/api/camera/settings", camera_settings, Camera::CameraSettings);
 #endif
 
-    server.on("/api/config/*", HTTP_GET, [](httpd_req_t *request) { return FileSystem::getConfigFile(request); });
-    server.on("/api/files", HTTP_GET, [&](httpd_req_t *request) { return FileSystem::getFilesProto(request); });
-    STAITC_PROTO_POST_ENDPOINT(server, "/api/files/delete", file_delete_request, FileSystem::handleDelete);
-    STAITC_PROTO_POST_ENDPOINT(server, "/api/files/edit", file_edit_request, FileSystem::handleEdit);
-    STAITC_PROTO_POST_ENDPOINT(server, "/api/files/mkdir", file_mkdir_request, FileSystem::mkdir);
+    system_service::registerRoutes(server);
+    wifiService.registerRoutes(server);
+    apService.registerRoutes(server);
+#if FT_ENABLED(USE_MDNS)
+    mdnsService.registerRoutes(server);
+#endif
+#if FT_ENABLED(USE_CAMERA)
+    cameraService.registerRoutes(server);
+#endif
+    FileSystem::registerRoutes(server);
+
     wsSocket.begin();
 #if EMBED_WEBAPP
     mountStaticAssets(server);
@@ -133,31 +101,21 @@ void setupEventSocket() {
         [](const socket_message_FSDownloadComplete &complete, int clientId) { wsSocket.emit(complete, clientId); },
         [](const socket_message_FSUploadComplete &complete, int clientId) { wsSocket.emit(complete, clientId); });
 
-    wsSocket.on<socket_message_ControllerData>(
-        [&](const socket_message_ControllerData &data, int clientId) { motionService.handleInput(data); });
+    wsSocket.forward<socket_message_ControllerData>();
+    wsSocket.forward<socket_message_ModeData>();
+    wsSocket.forward<socket_message_WalkGaitData>();
+    wsSocket.forward<socket_message_AnglesData>();
+    wsSocket.forward<socket_message_ServoPWMData>();
+    wsSocket.forward<socket_message_ServoStateData>();
+    wsSocket.forward<socket_message_FSUploadData>();
 
-    wsSocket.on<socket_message_ModeData>([&](const socket_message_ModeData &data, int clientId) {
+    modeHandle = EventBus::instance().subscribe<socket_message_ModeData>([&](const socket_message_ModeData &data) {
         servoController.setMode(SERVO_CONTROL_STATE::ANGLE);
         motionService.handleMode(data);
         motionService.isActive() ? servoController.activate() : servoController.deactivate();
     });
 
-    wsSocket.on<socket_message_WalkGaitData>(
-        [&](const socket_message_WalkGaitData &data, int clientId) { motionService.handleWalkGait(data); });
-
-    wsSocket.on<socket_message_AnglesData>(
-        [&](const socket_message_AnglesData &data, int clientId) { motionService.handleAngles(data); });
-
-    wsSocket.on<socket_message_ServoPWMData>([&](const socket_message_ServoPWMData &data, int clientId) {
-        servoController.setServoPWM(data.servo_id, data.servo_pwm);
-    });
-
-    wsSocket.on<socket_message_ServoStateData>([&](const socket_message_ServoStateData &data, int clientId) {
-        data.active ? servoController.activate() : servoController.deactivate();
-    });
-
-    wsSocket.on<socket_message_FSUploadData>(
-        [&](const socket_message_FSUploadData &data, int clientId) { TIME_IT(FileSystemWS::fsHandler.handleUploadData(data), handle_upload) });
+    FileSystemWS::fsHandler.begin();
 
     using CorrelationHandler =
         std::function<void(const socket_message_CorrelationRequest &, socket_message_CorrelationResponse &, int)>;
@@ -278,6 +236,21 @@ void IRAM_ATTR SpotControlLoopEntry(void *) {
 
 void IRAM_ATTR serviceLoopEntry(void *) {
     ESP_LOGI("main", "Service task starting");
+#if CONFIG_IDF_TARGET_ESP32P4
+    ESP_LOGI("main", "Initializing ESP-Hosted for C6 coprocessor WiFi...");
+    int ret = esp_hosted_init();
+    if (ret != 0) {
+        ESP_LOGE("main", "ESP-Hosted init failed: %d", ret);
+    } else {
+        ESP_LOGI("main", "ESP-Hosted initialized, connecting to C6...");
+        ret = esp_hosted_connect_to_slave();
+        if (ret != 0) {
+            ESP_LOGW("main", "ESP-Hosted connect failed: %d - WiFi may not work", ret);
+        } else {
+            ESP_LOGI("main", "ESP-Hosted link established with C6");
+        }
+    }
+#endif
 
     WiFi.init();
     wifiService.begin();
@@ -294,6 +267,7 @@ void IRAM_ATTR serviceLoopEntry(void *) {
     setupEventSocket();
 
     ESP_LOGI("main", "Service task started");
+
     for (;;) {
         wifiService.loop();
         apService.loop();
@@ -334,6 +308,7 @@ extern "C" void app_main(void) {
     ESP_ERROR_CHECK(ret);
 
     FileSystem::init();
+    storageManager.initialize();
 
     ESP_LOGI("main", "Booting robot");
 
@@ -343,5 +318,7 @@ extern "C" void app_main(void) {
 
     xTaskCreatePinnedToCore(SpotControlLoopEntry, "Control task", 8192, nullptr, 5, nullptr, 1);
 
+    EventBus::instance().publish(SystemReadyEvent {});
+
     ESP_LOGI("main", "Finished booting");
 }

esp32/src/mdns_service.cpp

@@ -4,14 +4,7 @@
 
 static const char *TAG = "MDNSService";
 
-MDNSService::MDNSService()
-    : protoEndpoint(MDNSSettings_read, MDNSSettings_update, this,
-                    API_REQUEST_EXTRACTOR(mdns_settings, api_MDNSSettings),
-                    API_RESPONSE_ASSIGNER(mdns_settings, api_MDNSSettings)),
-      _persistence(MDNSSettings_read, MDNSSettings_update, this, MDNS_SETTINGS_FILE, api_MDNSSettings_fields,
-                   api_MDNSSettings_size, MDNSSettings_defaults()) {
-    addUpdateHandler([&](const std::string &originId) { reconfigureMDNS(); }, false);
-}
+MDNSService::MDNSService() {}
 
 MDNSService::~MDNSService() {
     if (_started) {
@@ -19,8 +12,18 @@ MDNSService::~MDNSService() {
     }
 }
 
+void MDNSService::registerRoutes(WebServer &s) {
+    s.on("/api/mdns/status", HTTP_GET, [this](httpd_req_t *request) { return getStatus(request); });
+    s.on("/api/mdns/query", HTTP_POST,
+         [this](httpd_req_t *request, api_Request *protoReq) { return queryServices(request, protoReq); });
+}
+
 void MDNSService::begin() {
-    _persistence.readFromFS();
+    _settings = EventBus::instance().peek<MDNSSettings>();
+    _settingsHandle = EventBus::instance().subscribe<MDNSSettings>([this](const MDNSSettings &s) {
+        _settings = s;
+        reconfigureMDNS();
+    });
     startMDNS();
 }
 
@@ -32,7 +35,7 @@ void MDNSService::reconfigureMDNS() {
 }
 
 void MDNSService::startMDNS() {
-    ESP_LOGV(TAG, "Starting MDNS with hostname: %s", state().hostname);
+    ESP_LOGV(TAG, "Starting MDNS with hostname: %s", _settings.hostname);
 
     esp_err_t err = mdns_init();
     if (err != ESP_OK) {
@@ -41,7 +44,7 @@ void MDNSService::startMDNS() {
         return;
     }
 
-    err = mdns_hostname_set(state().hostname);
+    err = mdns_hostname_set(_settings.hostname);
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "Failed to set MDNS hostname: %s", esp_err_to_name(err));
         mdns_free();
@@ -49,7 +52,7 @@ void MDNSService::startMDNS() {
         return;
     }
 
-    err = mdns_instance_name_set(state().instance);
+    err = mdns_instance_name_set(_settings.instance);
     if (err != ESP_OK) {
         ESP_LOGW(TAG, "Failed to set MDNS instance name: %s", esp_err_to_name(err));
     }
@@ -57,7 +60,7 @@ void MDNSService::startMDNS() {
     _started = true;
     addServices();
 
-    ESP_LOGI(TAG, "MDNS started successfully with hostname: %s", state().hostname);
+    ESP_LOGI(TAG, "MDNS started successfully with hostname: %s", _settings.hostname);
 }
 
 void MDNSService::stopMDNS() {
@@ -67,8 +70,8 @@ void MDNSService::stopMDNS() {
 }
 
 void MDNSService::addServices() {
-    for (size_t i = 0; i < state().services_count; i++) {
-        const auto &service = state().services[i];
+    for (size_t i = 0; i < _settings.services_count; i++) {
+        const auto &service = _settings.services[i];
         esp_err_t err = mdns_service_add(nullptr, service.service, service.protocol, service.port, nullptr, 0);
         if (err != ESP_OK) {
             ESP_LOGW(TAG, "Failed to add service %s: %s", service.service, esp_err_to_name(err));
@@ -81,10 +84,10 @@ void MDNSService::addServices() {
         }
     }
 
-    for (size_t i = 0; i < state().global_txt_records_count; i++) {
-        const auto &txt = state().global_txt_records[i];
-        for (size_t j = 0; j < state().services_count; j++) {
-            const auto &service = state().services[j];
+    for (size_t i = 0; i < _settings.global_txt_records_count; i++) {
+        const auto &txt = _settings.global_txt_records[i];
+        for (size_t j = 0; j < _settings.services_count; j++) {
+            const auto &service = _settings.services[j];
             mdns_service_txt_item_set(service.service, service.protocol, txt.key, txt.value);
         }
     }
@@ -96,17 +99,17 @@ esp_err_t MDNSService::getStatus(httpd_req_t *request) {
 
     MDNSStatus &status = response.payload.mdns_status;
     status.started = _started;
-    strncpy(status.hostname, state().hostname, sizeof(status.hostname) - 1);
-    strncpy(status.instance, state().instance, sizeof(status.instance) - 1);
+    strncpy(status.hostname, _settings.hostname, sizeof(status.hostname) - 1);
+    strncpy(status.instance, _settings.instance, sizeof(status.instance) - 1);
 
-    status.services_count = state().services_count;
-    for (size_t i = 0; i < state().services_count; i++) {
-        status.services[i] = state().services[i];
+    status.services_count = _settings.services_count;
+    for (size_t i = 0; i < _settings.services_count; i++) {
+        status.services[i] = _settings.services[i];
     }
 
-    status.global_txt_records_count = state().global_txt_records_count;
-    for (size_t i = 0; i < state().global_txt_records_count; i++) {
-        status.global_txt_records[i] = state().global_txt_records[i];
+    status.global_txt_records_count = _settings.global_txt_records_count;
+    for (size_t i = 0; i < _settings.global_txt_records_count; i++) {
+        status.global_txt_records[i] = _settings.global_txt_records[i];
     }
 
     return WebServer::send(request, 200, response, api_Response_fields);

esp32/src/motion.cpp

@@ -1,6 +1,15 @@
 #include <motion.h>
 
-void MotionService::begin() { body_state.updateFeet(KinConfig::default_feet_positions); }
+void MotionService::begin() {
+    body_state.updateFeet(KinConfig::default_feet_positions);
+
+    controllerHandle_ = EventBus::instance().subscribe<socket_message_ControllerData>(
+        [this](const socket_message_ControllerData& data) { handleInput(data); });
+    walkGaitHandle_ = EventBus::instance().subscribe<socket_message_WalkGaitData>(
+        [this](const socket_message_WalkGaitData& data) { handleWalkGait(data); });
+    anglesHandle_ = EventBus::instance().subscribe<socket_message_AnglesData>(
+        [this](const socket_message_AnglesData& data) { handleAngles(data); });
+}
 
 void MotionService::handleAngles(const socket_message_AnglesData& data) {
     for (int i = 0; i < 12 && i < data.angles_count; i++) {

esp32/src/peripherals/camera_service.cpp

@@ -6,9 +6,13 @@ namespace Camera {
 
 static const char *const TAG = "CameraService";
 
+#if USE_DVP_CAMERA || USE_CSI_CAMERA
 static constexpr const char *_STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
 static constexpr const char *_STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
 static constexpr const char *_STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";
+#endif
+
+#if USE_DVP_CAMERA
 
 SemaphoreHandle_t cameraMutex = xSemaphoreCreateMutex();
 
@@ -31,22 +35,17 @@ sensor_t *safe_sensor_get() {
 
 void safe_sensor_return() { xSemaphoreGiveRecursive(cameraMutex); }
 
-CameraService::CameraService()
-    : protoEndpoint(CameraSettings_read, CameraSettings_update, this,
-                    API_REQUEST_EXTRACTOR(camera_settings, api_CameraSettings),
-                    API_RESPONSE_ASSIGNER(camera_settings, api_CameraSettings)),
-      _persistence(CameraSettings_read, CameraSettings_update, this,
-                   CAMERA_SETTINGS_FILE, api_CameraSettings_fields, api_CameraSettings_size,
-                   CameraSettings_defaults()) {
-    addUpdateHandler([&](const std::string &originId) { updateCamera(); }, false);
-}
+CameraService::CameraService() {}
 
 esp_err_t CameraService::begin() {
-    _persistence.readFromFS();
+    _settings = EventBus::instance().peek<CameraSettings>();
+    _settingsHandle = EventBus::instance().subscribe<CameraSettings>([this](const CameraSettings &s) {
+        _settings = s;
+        updateCamera();
+    });
     camera_config_t camera_config;
     camera_config.ledc_channel = LEDC_CHANNEL_0;
     camera_config.ledc_timer = LEDC_TIMER_0;
-#if FT_ENABLED(USE_CAMERA)
     camera_config.pin_d0 = Y2_GPIO_NUM;
     camera_config.pin_d1 = Y3_GPIO_NUM;
     camera_config.pin_d2 = Y4_GPIO_NUM;
@@ -63,7 +62,6 @@ esp_err_t CameraService::begin() {
     camera_config.pin_sccb_scl = SIOC_GPIO_NUM;
     camera_config.pin_pwdn = PWDN_GPIO_NUM;
     camera_config.pin_reset = RESET_GPIO_NUM;
-#endif
     camera_config.xclk_freq_hz = 20000000;
     camera_config.pixel_format = PIXFORMAT_JPEG;
 
@@ -154,31 +152,500 @@ void CameraService::updateCamera() {
         safe_sensor_return();
         return;
     }
-    s->set_pixformat(s, static_cast<pixformat_t>(state().pixformat));
-    s->set_framesize(s, static_cast<framesize_t>(state().framesize));
-    s->set_brightness(s, state().brightness);
-    s->set_contrast(s, state().contrast);
-    s->set_saturation(s, state().saturation);
-    s->set_sharpness(s, state().sharpness);
-    s->set_denoise(s, state().denoise);
-    s->set_gainceiling(s, static_cast<gainceiling_t>(state().gainceiling));
-    s->set_quality(s, state().quality);
-    s->set_colorbar(s, state().colorbar);
-    s->set_awb_gain(s, state().awb_gain);
-    s->set_wb_mode(s, state().wb_mode);
-    s->set_aec2(s, state().aec2);
-    s->set_ae_level(s, state().ae_level);
-    s->set_aec_value(s, state().aec_value);
-    s->set_agc_gain(s, state().agc_gain);
-    s->set_bpc(s, state().bpc);
-    s->set_wpc(s, state().wpc);
-    s->set_special_effect(s, state().special_effect);
-    s->set_raw_gma(s, state().raw_gma);
-    s->set_lenc(s, state().lenc);
-    s->set_hmirror(s, state().hmirror);
-    s->set_vflip(s, state().vflip);
-    s->set_dcw(s, state().dcw);
+    s->set_pixformat(s, static_cast<pixformat_t>(_settings.pixformat));
+    s->set_framesize(s, static_cast<framesize_t>(_settings.framesize));
+    s->set_brightness(s, _settings.brightness);
+    s->set_contrast(s, _settings.contrast);
+    s->set_saturation(s, _settings.saturation);
+    s->set_sharpness(s, _settings.sharpness);
+    s->set_denoise(s, _settings.denoise);
+    s->set_gainceiling(s, static_cast<gainceiling_t>(_settings.gainceiling));
+    s->set_quality(s, _settings.quality);
+    s->set_colorbar(s, _settings.colorbar);
+    s->set_awb_gain(s, _settings.awb_gain);
+    s->set_wb_mode(s, _settings.wb_mode);
+    s->set_aec2(s, _settings.aec2);
+    s->set_ae_level(s, _settings.ae_level);
+    s->set_aec_value(s, _settings.aec_value);
+    s->set_agc_gain(s, _settings.agc_gain);
+    s->set_bpc(s, _settings.bpc);
+    s->set_wpc(s, _settings.wpc);
+    s->set_special_effect(s, _settings.special_effect);
+    s->set_raw_gma(s, _settings.raw_gma);
+    s->set_lenc(s, _settings.lenc);
+    s->set_hmirror(s, _settings.hmirror);
+    s->set_vflip(s, _settings.vflip);
+    s->set_dcw(s, _settings.dcw);
     safe_sensor_return();
 }
 
+#elif USE_CSI_CAMERA
+}
+
+extern "C" {
+#include "esp_cam_ctlr.h"
+#include "esp_cam_ctlr_csi.h"
+#include "esp_cam_ctlr_types.h"
+#include "driver/isp.h"
+#include "driver/jpeg_encode.h"
+#include "esp_sccb_intf.h"
+#include "esp_sccb_i2c.h"
+#include "esp_cam_sensor.h"
+#include "ov5647.h"
+#include "esp_ldo_regulator.h"
+#include "driver/isp_demosaic.h"
+#include "driver/isp_bf.h"
+#include "driver/isp_sharpen.h"
+}
+
+#include <peripherals/i2c_bus.h>
+
+namespace Camera {
+
+#ifndef MIPI_CSI_HRES
+#define MIPI_CSI_HRES 640
+#endif
+#ifndef MIPI_CSI_VRES
+#define MIPI_CSI_VRES 480
+#endif
+#ifndef MIPI_CSI_LANE_BITRATE_MBPS
+#define MIPI_CSI_LANE_BITRATE_MBPS 200
+#endif
+#ifndef MIPI_CSI_DATA_LANES
+#define MIPI_CSI_DATA_LANES 2
+#endif
+#ifndef CAM_SCCB_FREQ_HZ
+#define CAM_SCCB_FREQ_HZ 100000
+#endif
+#ifndef CAM_SENSOR_ADDR
+#define CAM_SENSOR_ADDR 0x36
+#endif
+#ifndef CAM_XCLK_PIN
+#define CAM_XCLK_PIN -1
+#endif
+#ifndef CAM_XCLK_FREQ_HZ
+#define CAM_XCLK_FREQ_HZ 25000000
+#endif
+#ifndef CAM_RESET_PIN
+#define CAM_RESET_PIN -1
+#endif
+#ifndef CAM_PWDN_PIN
+#define CAM_PWDN_PIN -1
+#endif
+#ifndef CSI_JPEG_QUALITY
+#define CSI_JPEG_QUALITY 80
+#endif
+
+#define NUM_FRAME_BUFS 2
+static constexpr size_t CACHE_LINE_SIZE = 64;
+#define ALIGN_UP(n, a) (((n) + ((a) - 1)) & ~((a) - 1))
+
+static esp_cam_ctlr_handle_t s_cam_handle = NULL;
+static isp_proc_handle_t s_isp_proc = NULL;
+static jpeg_encoder_handle_t s_jpeg_enc = NULL;
+
+static uint8_t *s_frame_bufs[NUM_FRAME_BUFS] = {};
+static size_t s_frame_buf_size = 0;
+static uint8_t *s_jpeg_bufs[NUM_FRAME_BUFS] = {};
+static size_t s_jpeg_buf_alloc = 0;
+
+static bool s_cam_initialized = false;
+static uint16_t s_frame_hres = MIPI_CSI_HRES;
+static uint16_t s_frame_vres = MIPI_CSI_VRES;
+
+static SemaphoreHandle_t s_frame_done = NULL;
+static SemaphoreHandle_t s_jpeg_lock = NULL;
+static SemaphoreHandle_t s_jpeg_ready = NULL;
+static TaskHandle_t s_capture_task = NULL;
+static volatile bool s_capture_running = false;
+
+static int s_write_idx = 0;
+static int s_ready_idx = -1;
+static size_t s_ready_jpeg_len = 0;
+
+static uint8_t *s_send_buf = NULL;
+static size_t s_send_buf_size = 0;
+
+static bool on_trans_finished(esp_cam_ctlr_handle_t handle, esp_cam_ctlr_trans_t *trans, void *user_data) {
+    BaseType_t woken = pdFALSE;
+    xSemaphoreGiveFromISR(s_frame_done, &woken);
+    return (woken == pdTRUE);
+}
+
+static void capture_task_fn(void *arg) {
+    while (s_capture_running) {
+        int idx = s_write_idx;
+
+        esp_cam_ctlr_trans_t trans = {};
+        trans.buffer = s_frame_bufs[idx];
+        trans.buflen = s_frame_buf_size;
+
+        if (esp_cam_ctlr_receive(s_cam_handle, &trans, 2000) != ESP_OK) {
+            vTaskDelay(pdMS_TO_TICKS(5));
+            continue;
+        }
+
+        if (xSemaphoreTake(s_frame_done, pdMS_TO_TICKS(2000)) != pdTRUE) {
+            continue;
+        }
+
+        jpeg_encode_cfg_t enc_cfg = {};
+        enc_cfg.src_type = JPEG_ENCODE_IN_FORMAT_RGB565;
+        enc_cfg.sub_sample = JPEG_DOWN_SAMPLING_YUV420;
+        enc_cfg.image_quality = CSI_JPEG_QUALITY;
+        enc_cfg.width = s_frame_hres;
+        enc_cfg.height = s_frame_vres;
+
+        uint32_t out_size = 0;
+        esp_err_t err = jpeg_encoder_process(s_jpeg_enc, &enc_cfg, s_frame_bufs[idx], trans.received_size,
+                                             s_jpeg_bufs[idx], s_jpeg_buf_alloc, &out_size);
+        if (err != ESP_OK) {
+            continue;
+        }
+
+        xSemaphoreTake(s_jpeg_lock, portMAX_DELAY);
+        s_ready_idx = idx;
+        s_ready_jpeg_len = out_size;
+        xSemaphoreGive(s_jpeg_lock);
+
+        s_write_idx = (idx + 1) % NUM_FRAME_BUFS;
+
+        xSemaphoreGive(s_jpeg_ready);
+    }
+    vTaskDelete(NULL);
+}
+
+CameraService::CameraService() {
+    s_frame_done = xSemaphoreCreateBinary();
+    s_jpeg_lock = xSemaphoreCreateMutex();
+    s_jpeg_ready = xSemaphoreCreateBinary();
+}
+
+esp_err_t CameraService::begin() {
+    ESP_LOGI(TAG, "Initializing MIPI-CSI camera for ESP32-P4");
+
+    esp_ldo_channel_handle_t ldo_mipi_phy = NULL;
+    esp_ldo_channel_config_t ldo_cfg = {};
+    ldo_cfg.chan_id = 3;
+    ldo_cfg.voltage_mv = 2500;
+    esp_err_t ldo_err = esp_ldo_acquire_channel(&ldo_cfg, &ldo_mipi_phy);
+    if (ldo_err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to acquire MIPI PHY LDO: %s", esp_err_to_name(ldo_err));
+        return ldo_err;
+    }
+
+    i2c_master_bus_handle_t i2c_bus = I2CBus::instance().busHandle();
+    if (!i2c_bus) {
+        ESP_LOGE(TAG, "I2C bus not initialized, cannot init camera SCCB");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_sccb_io_handle_t sccb_io = NULL;
+    sccb_i2c_config_t sccb_cfg = {};
+    sccb_cfg.scl_speed_hz = CAM_SCCB_FREQ_HZ;
+    sccb_cfg.device_address = CAM_SENSOR_ADDR;
+    sccb_cfg.dev_addr_length = I2C_ADDR_BIT_LEN_7;
+
+    esp_err_t err = sccb_new_i2c_io(i2c_bus, &sccb_cfg, &sccb_io);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to create SCCB I/O handle: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    esp_cam_sensor_config_t cam_sensor_cfg = {};
+    cam_sensor_cfg.sccb_handle = sccb_io;
+    cam_sensor_cfg.reset_pin = static_cast<gpio_num_t>(CAM_RESET_PIN);
+    cam_sensor_cfg.pwdn_pin = static_cast<gpio_num_t>(CAM_PWDN_PIN);
+    cam_sensor_cfg.xclk_pin = static_cast<gpio_num_t>(CAM_XCLK_PIN);
+    cam_sensor_cfg.xclk_freq_hz = CAM_XCLK_FREQ_HZ;
+    cam_sensor_cfg.sensor_port = ESP_CAM_SENSOR_MIPI_CSI;
+
+    esp_cam_sensor_device_t *cam_sensor = ov5647_detect(&cam_sensor_cfg);
+    if (!cam_sensor) {
+        ESP_LOGE(TAG, "OV5647 detection failed");
+        return ESP_FAIL;
+    }
+    ESP_LOGI(TAG, "OV5647 camera sensor detected");
+
+    esp_cam_sensor_format_array_t fmt_array = {};
+    err = esp_cam_sensor_query_format(cam_sensor, &fmt_array);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to query sensor formats: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    const esp_cam_sensor_format_t *selected_format = NULL;
+    uint32_t best_area = 0;
+    for (uint32_t i = 0; i < fmt_array.count; i++) {
+        const auto &f = fmt_array.format_array[i];
+        ESP_LOGI(TAG, "Sensor format[%u]: %dx%d mipi_clk=%uHz lanes=%d", (unsigned)i, f.width, f.height,
+                 (unsigned)f.mipi_info.mipi_clk, f.mipi_info.lane_num);
+    }
+    for (uint32_t i = 0; i < fmt_array.count; i++) {
+        const uint16_t w = fmt_array.format_array[i].width;
+        const uint16_t h = fmt_array.format_array[i].height;
+        if (w <= MIPI_CSI_HRES && h <= MIPI_CSI_VRES) {
+            const uint32_t area = (uint32_t)w * (uint32_t)h;
+            if (!selected_format || area > best_area) {
+                selected_format = &fmt_array.format_array[i];
+                best_area = area;
+            }
+        }
+    }
+    if (!selected_format && fmt_array.count > 0) {
+        uint32_t min_area = UINT32_MAX;
+        for (uint32_t i = 0; i < fmt_array.count; i++) {
+            const uint32_t area =
+                (uint32_t)fmt_array.format_array[i].width * (uint32_t)fmt_array.format_array[i].height;
+            if (area < min_area) {
+                selected_format = &fmt_array.format_array[i];
+                min_area = area;
+            }
+        }
+    }
+    if (!selected_format) {
+        ESP_LOGE(TAG, "No sensor formats available");
+        return ESP_FAIL;
+    }
+
+    err = esp_cam_sensor_set_format(cam_sensor, selected_format);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set sensor format: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    s_frame_hres = selected_format->width;
+    s_frame_vres = selected_format->height;
+    ESP_LOGI(TAG, "Sensor format set: %dx%d", s_frame_hres, s_frame_vres);
+
+    esp_cam_sensor_format_t cur_fmt = {};
+    if (esp_cam_sensor_get_format(cam_sensor, &cur_fmt) == ESP_OK) {
+        ESP_LOGI(TAG, "Active format: %dx%d, mipi_clk=%uHz, lanes=%d", cur_fmt.width, cur_fmt.height,
+                 (unsigned)cur_fmt.mipi_info.mipi_clk, cur_fmt.mipi_info.lane_num);
+    }
+
+    int stream_on = 1;
+    err = esp_cam_sensor_ioctl(cam_sensor, ESP_CAM_SENSOR_IOC_S_STREAM, &stream_on);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to start sensor stream: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    esp_isp_processor_cfg_t isp_cfg = {};
+    isp_cfg.clk_src = static_cast<isp_clk_src_t>(0);
+    isp_cfg.clk_hz = 80 * 1000 * 1000;
+    isp_cfg.input_data_source = ISP_INPUT_DATA_SOURCE_CSI;
+    isp_cfg.input_data_color_type = ISP_COLOR_RAW8;
+    isp_cfg.output_data_color_type = ISP_COLOR_RGB565;
+    isp_cfg.has_line_start_packet = false;
+    isp_cfg.has_line_end_packet = false;
+    isp_cfg.h_res = s_frame_hres;
+    isp_cfg.v_res = s_frame_vres;
+    isp_cfg.bayer_order = COLOR_RAW_ELEMENT_ORDER_GBRG;
+
+    err = esp_isp_new_processor(&isp_cfg, &s_isp_proc);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "ISP processor init failed: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    err = esp_isp_enable(s_isp_proc);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "ISP enable failed: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    esp_isp_demosaic_config_t demosaic_cfg = {};
+    demosaic_cfg.grad_ratio.val = 16;
+    demosaic_cfg.padding_mode = ISP_DEMOSAIC_EDGE_PADDING_MODE_SRND_DATA;
+    esp_isp_demosaic_configure(s_isp_proc, &demosaic_cfg);
+    esp_isp_demosaic_enable(s_isp_proc);
+
+    esp_isp_bf_config_t bf_cfg = {};
+    bf_cfg.denoising_level = 10;
+    bf_cfg.padding_mode = ISP_BF_EDGE_PADDING_MODE_SRND_DATA;
+    uint8_t bf_tpl[ISP_BF_TEMPLATE_X_NUMS][ISP_BF_TEMPLATE_Y_NUMS] = {{1, 2, 1}, {2, 4, 2}, {1, 2, 1}};
+    memcpy(bf_cfg.bf_template, bf_tpl, sizeof(bf_tpl));
+    esp_isp_bf_configure(s_isp_proc, &bf_cfg);
+    esp_isp_bf_enable(s_isp_proc);
+
+    esp_isp_sharpen_config_t sharp_cfg = {};
+    sharp_cfg.h_thresh = 255;
+    sharp_cfg.l_thresh = 20;
+    sharp_cfg.padding_mode = ISP_SHARPEN_EDGE_PADDING_MODE_SRND_DATA;
+    uint8_t sharp_m[ISP_SHARPEN_TEMPLATE_X_NUMS][ISP_SHARPEN_TEMPLATE_Y_NUMS] = {{1, 2, 1}, {2, 4, 2}, {1, 2, 1}};
+    memcpy(sharp_cfg.sharpen_template, sharp_m, sizeof(sharp_m));
+    sharp_cfg.h_freq_coeff.integer = 1;
+    sharp_cfg.h_freq_coeff.decimal = 0;
+    sharp_cfg.m_freq_coeff.integer = 1;
+    sharp_cfg.m_freq_coeff.decimal = 0;
+    esp_isp_sharpen_configure(s_isp_proc, &sharp_cfg);
+    esp_isp_sharpen_enable(s_isp_proc);
+
+    esp_cam_ctlr_csi_config_t csi_cfg = {};
+    csi_cfg.ctlr_id = 0;
+    csi_cfg.h_res = s_frame_hres;
+    csi_cfg.v_res = s_frame_vres;
+    csi_cfg.lane_bit_rate_mbps = MIPI_CSI_LANE_BITRATE_MBPS;
+    csi_cfg.input_data_color_type = CAM_CTLR_COLOR_RAW8;
+    csi_cfg.output_data_color_type = CAM_CTLR_COLOR_RGB565;
+    csi_cfg.data_lane_num = MIPI_CSI_DATA_LANES;
+    csi_cfg.byte_swap_en = false;
+    csi_cfg.queue_items = NUM_FRAME_BUFS;
+
+    err = esp_cam_new_csi_ctlr(&csi_cfg, &s_cam_handle);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "CSI controller init failed: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    esp_cam_ctlr_evt_cbs_t cbs = {};
+    cbs.on_trans_finished = on_trans_finished;
+    err = esp_cam_ctlr_register_event_callbacks(s_cam_handle, &cbs, NULL);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "CSI register callbacks failed: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    s_frame_buf_size = ALIGN_UP((size_t)s_frame_hres * s_frame_vres * 2, CACHE_LINE_SIZE);
+    for (int i = 0; i < NUM_FRAME_BUFS; i++) {
+        s_frame_bufs[i] = (uint8_t *)heap_caps_aligned_alloc(CACHE_LINE_SIZE, s_frame_buf_size, MALLOC_CAP_SPIRAM);
+        if (!s_frame_bufs[i]) {
+            ESP_LOGE(TAG, "Failed to allocate frame buffer %d (%d bytes)", i, (int)s_frame_buf_size);
+            return ESP_ERR_NO_MEM;
+        }
+    }
+
+    jpeg_encode_memory_alloc_cfg_t jpeg_mem_cfg = {};
+    jpeg_mem_cfg.buffer_direction = JPEG_ENC_ALLOC_OUTPUT_BUFFER;
+    for (int i = 0; i < NUM_FRAME_BUFS; i++) {
+        size_t alloc_sz = 0;
+        s_jpeg_bufs[i] = (uint8_t *)jpeg_alloc_encoder_mem(s_frame_hres * s_frame_vres, &jpeg_mem_cfg, &alloc_sz);
+        if (!s_jpeg_bufs[i]) {
+            ESP_LOGE(TAG, "Failed to allocate JPEG buffer %d", i);
+            return ESP_ERR_NO_MEM;
+        }
+        if (i == 0) s_jpeg_buf_alloc = alloc_sz;
+    }
+
+    s_send_buf_size = s_jpeg_buf_alloc;
+    s_send_buf = (uint8_t *)heap_caps_aligned_alloc(CACHE_LINE_SIZE, s_send_buf_size, MALLOC_CAP_SPIRAM);
+    if (!s_send_buf) {
+        ESP_LOGE(TAG, "Failed to allocate send buffer");
+        return ESP_ERR_NO_MEM;
+    }
+
+    jpeg_encode_engine_cfg_t enc_eng_cfg = {};
+    enc_eng_cfg.timeout_ms = 500;
+    err = jpeg_new_encoder_engine(&enc_eng_cfg, &s_jpeg_enc);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "JPEG encoder init failed: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    err = esp_cam_ctlr_enable(s_cam_handle);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "CSI controller enable failed: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    err = esp_cam_ctlr_start(s_cam_handle);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "CSI controller start failed: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    s_cam_initialized = true;
+
+    s_capture_running = true;
+    xTaskCreatePinnedToCore(capture_task_fn, "csi_cap", 4096, NULL, 6, &s_capture_task, 1);
+
+    ESP_LOGI(TAG, "MIPI-CSI camera initialized (%dx%d, %d-lane, %d Mbps)", s_frame_hres, s_frame_vres,
+             MIPI_CSI_DATA_LANES, MIPI_CSI_LANE_BITRATE_MBPS);
+    return ESP_OK;
+}
+
+esp_err_t CameraService::cameraStill(httpd_req_t *request) {
+    if (!s_cam_initialized) {
+        return WebServer::sendError(request, 503, "Camera not initialized");
+    }
+
+    if (xSemaphoreTake(s_jpeg_ready, pdMS_TO_TICKS(3000)) != pdTRUE) {
+        return WebServer::sendError(request, 500, "Camera capture timed out");
+    }
+
+    xSemaphoreTake(s_jpeg_lock, portMAX_DELAY);
+    size_t len = s_ready_jpeg_len;
+    if (s_ready_idx >= 0 && len > 0) {
+        memcpy(s_send_buf, s_jpeg_bufs[s_ready_idx], len);
+    }
+    xSemaphoreGive(s_jpeg_lock);
+
+    if (len == 0) {
+        return WebServer::sendError(request, 500, "No frame available");
+    }
+
+    httpd_resp_set_type(request, "image/jpeg");
+    httpd_resp_set_hdr(request, "Content-Disposition", "inline; filename=capture.jpg");
+    return httpd_resp_send(request, (const char *)s_send_buf, len);
+}
+
+esp_err_t CameraService::cameraStream(httpd_req_t *request) {
+    if (!s_cam_initialized) {
+        return WebServer::sendError(request, 503, "Camera not initialized");
+    }
+
+    httpd_resp_set_type(request, _STREAM_CONTENT_TYPE);
+
+    char part_buf[64];
+    esp_err_t res = ESP_OK;
+
+    while (res == ESP_OK) {
+        if (xSemaphoreTake(s_jpeg_ready, pdMS_TO_TICKS(3000)) != pdTRUE) {
+            break;
+        }
+
+        xSemaphoreTake(s_jpeg_lock, portMAX_DELAY);
+        size_t jpeg_len = s_ready_jpeg_len;
+        if (s_ready_idx >= 0 && jpeg_len > 0) {
+            memcpy(s_send_buf, s_jpeg_bufs[s_ready_idx], jpeg_len);
+        }
+        xSemaphoreGive(s_jpeg_lock);
+
+        if (jpeg_len == 0) continue;
+
+        size_t hlen = snprintf(part_buf, 64, _STREAM_PART, (unsigned int)jpeg_len);
+        res = httpd_resp_send_chunk(request, part_buf, hlen);
+        if (res == ESP_OK) res = httpd_resp_send_chunk(request, (const char *)s_send_buf, jpeg_len);
+        if (res == ESP_OK) res = httpd_resp_send_chunk(request, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
+    }
+
+    ESP_LOGI(TAG, "Stream ended");
+    httpd_resp_send_chunk(request, NULL, 0);
+    return ESP_OK;
+}
+
+void CameraService::registerRoutes(WebServer &s) {
+    s.on("/api/camera/still", HTTP_GET, [this](httpd_req_t *request) { return cameraStill(request); });
+    s.on("/api/camera/stream", HTTP_GET, [this](httpd_req_t *request) { return cameraStream(request); });
+}
+
+#else
+
+CameraService::CameraService() {}
+esp_err_t CameraService::begin() { return ESP_ERR_NOT_SUPPORTED; }
+esp_err_t CameraService::cameraStill(httpd_req_t *request) {
+    return WebServer::sendError(request, 501, "Camera not supported on this platform");
+}
+esp_err_t CameraService::cameraStream(httpd_req_t *request) {
+    return WebServer::sendError(request, 501, "Camera not supported on this platform");
+}
+
+void CameraService::registerRoutes(WebServer &s) {
+    s.on("/api/camera/still", HTTP_GET, [this](httpd_req_t *request) { return cameraStill(request); });
+    s.on("/api/camera/stream", HTTP_GET, [this](httpd_req_t *request) { return cameraStream(request); });
+}
+
+#endif
+
 } // namespace Camera

esp32/src/peripherals/peripherals.cpp

@@ -1,18 +1,14 @@
 #include <peripherals/peripherals.h>
 
-Peripherals::Peripherals()
-    : protoEndpoint(PeripheralsConfiguration_read, PeripheralsConfiguration_update, this,
-                    API_REQUEST_EXTRACTOR(peripheral_settings, api_PeripheralSettings),
-                    API_RESPONSE_ASSIGNER(peripheral_settings, api_PeripheralSettings)),
-      _persistence(PeripheralsConfiguration_read, PeripheralsConfiguration_update, this,
-                   PERIPHERAL_SETTINGS_FILE, api_PeripheralSettings_fields, api_PeripheralSettings_size,
-                   PeripheralsConfiguration_defaults()) {
-    _accessMutex = xSemaphoreCreateMutex();
-    addUpdateHandler([&](const std::string &originId) { updatePins(); }, false);
-}
+Peripherals::Peripherals() { _accessMutex = xSemaphoreCreateMutex(); }
 
 void Peripherals::begin() {
-    _persistence.readFromFS();
+    _settings = EventBus::instance().peek<PeripheralsConfiguration>();
+    _settingsHandle =
+        EventBus::instance().subscribe<PeripheralsConfiguration>([this](const PeripheralsConfiguration &s) {
+            _settings = s;
+            updatePins();
+        });
 
     updatePins();
 
@@ -47,9 +43,9 @@ void Peripherals::updatePins() {
         I2CBus::instance().end();
     }
 
-    if (state().sda != -1 && state().scl != -1) {
-        esp_err_t err = I2CBus::instance().begin(static_cast<gpio_num_t>(state().sda),
-                                                 static_cast<gpio_num_t>(state().scl), state().frequency);
+    if (_settings.sda != -1 && _settings.scl != -1) {
+        esp_err_t err = I2CBus::instance().begin(static_cast<gpio_num_t>(_settings.sda),
+                                                 static_cast<gpio_num_t>(_settings.scl), _settings.frequency);
         i2c_active = (err == ESP_OK);
     }
 }
@@ -92,13 +88,12 @@ void Peripherals::getIMUProto(socket_message_IMUData &data) {
 }
 
 void Peripherals::getSettingsProto(socket_message_PeripheralSettingsData &data) {
-    data.sda = state().sda;
-    data.scl = state().scl;
-    data.frequency = state().frequency;
+    data.sda = _settings.sda;
+    data.scl = _settings.scl;
+    data.frequency = _settings.frequency;
     data.pins_count = 0;
 }
 
-/* IMU FUNCTIONS */
 bool Peripherals::readImu() {
     bool updated = false;
 #if FT_ENABLED(USE_MPU6050 || USE_BNO055)
@@ -195,4 +190,4 @@ bool Peripherals::calibrateIMU() {
 #else
     return false;
 #endif
-}
+}

esp32/src/system_service.cpp

@@ -8,7 +8,8 @@
 #include <esp_sleep.h>
 #include <soc/soc.h>
 
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6
+#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C3 || \
+    CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32P4
 #include <driver/temperature_sensor.h>
 
 static float temperatureRead() {
@@ -58,6 +59,15 @@ esp_err_t handleSleep(httpd_req_t *request) {
     return WebServer::sendOk(request);
 }
 
+void registerRoutes(WebServer &s) {
+    s.on("/api/system/reset", HTTP_POST,
+         [](httpd_req_t *request, api_Request *protoReq) { return handleReset(request); });
+    s.on("/api/system/restart", HTTP_POST,
+         [](httpd_req_t *request, api_Request *protoReq) { return handleRestart(request); });
+    s.on("/api/system/sleep", HTTP_POST,
+         [](httpd_req_t *request, api_Request *protoReq) { return handleSleep(request); });
+}
+
 void reset() {
     ESP_LOGI(TAG, "Resetting device");
     DIR *dir = opendir(FS_CONFIG_DIRECTORY);
@@ -100,7 +110,7 @@ void sleep() {
 
                 uint64_t bitmask = (uint64_t)1 << (WAKEUP_PIN_NUMBER);
 
-#ifdef CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32P4
                 esp_deep_sleep_enable_gpio_wakeup(bitmask, (esp_deepsleep_gpio_wake_up_mode_t)WAKEUP_SIGNAL);
 #else
                 esp_sleep_enable_ext1_wakeup(bitmask, (esp_sleep_ext1_wakeup_mode_t)WAKEUP_SIGNAL);
@@ -124,6 +134,7 @@ static const char *getChipModel() {
         case CHIP_ESP32C2: return "ESP32-C2";
         case CHIP_ESP32C6: return "ESP32-C6";
         case CHIP_ESP32H2: return "ESP32-H2";
+        case CHIP_ESP32P4: return "ESP32-P4";
         default: return "Unknown";
     }
 }

esp32/src/wifi_service.cpp

@@ -3,17 +3,14 @@
 
 static const char *TAG = "WiFiService";
 
-WiFiService::WiFiService()
-    : protoEndpoint(WiFiSettings_read, WiFiSettings_update, this,
-                    API_REQUEST_EXTRACTOR(wifi_settings, api_WifiSettings),
-                    API_RESPONSE_ASSIGNER(wifi_settings, api_WifiSettings)),
-      _persistence(WiFiSettings_read, WiFiSettings_update, this, WIFI_SETTINGS_FILE, api_WifiSettings_fields,
-                   api_WifiSettings_size, WiFiSettings_defaults()),
-      _lastConnectionAttempt(0),
-      _stopping(false) {
-    addUpdateHandler([&](const std::string &originId) { reconfigureWiFiConnection(); }, false);
+void WiFiService::registerRoutes(WebServer &s) {
+    s.on("/api/wifi/scan", HTTP_GET, [](httpd_req_t *request) { return handleScan(request); });
+    s.on("/api/wifi/networks", HTTP_GET, [](httpd_req_t *request) { return getNetworks(request); });
+    s.on("/api/wifi/sta/status", HTTP_GET, [](httpd_req_t *request) { return getNetworkStatus(request); });
 }
 
+WiFiService::WiFiService() : _lastConnectionAttempt(0), _stopping(false) {}
+
 WiFiService::~WiFiService() {}
 
 void WiFiService::begin() {
@@ -25,15 +22,19 @@ void WiFiService::begin() {
     WiFi.onEvent([this](int32_t event, void *data) { this->onStationModeStop(event, data); }, WIFI_EVENT_STA_STOP);
     WiFi.onEvent(onStationModeGotIP, IP_EVENT_STA_GOT_IP_IDF);
 
-    _persistence.readFromFS();
+    _settings = EventBus::instance().peek<WiFiSettings>();
+    _settingsHandle = EventBus::instance().subscribe<WiFiSettings>([this](const WiFiSettings &s) {
+        _settings = s;
+        reconfigureWiFiConnection();
+    });
     _lastConnectionAttempt = 0;
 
-    if (state().wifi_networks_count >= 1) {
+    if (_settings.wifi_networks_count >= 1) {
         WiFi.mode(WIFI_MODE_STA);
         vTaskDelay(100 / portTICK_PERIOD_MS);
-        uint32_t idx = state().selected_network;
-        if (idx >= state().wifi_networks_count) idx = 0;
-        configureNetwork(state().wifi_networks[idx]);
+        uint32_t idx = _settings.selected_network;
+        if (idx >= _settings.wifi_networks_count) idx = 0;
+        configureNetwork(_settings.wifi_networks[idx]);
     }
 }
 
@@ -43,13 +44,9 @@ void WiFiService::reconfigureWiFiConnection() {
 }
 
 void WiFiService::selectNetwork(uint32_t index) {
-    if (index >= state().wifi_networks_count) return;
-    updateWithoutPropagation([&](WiFiSettings &settings) {
-        settings.selected_network = index;
-        return StateUpdateResult::CHANGED;
-    });
-    _persistence.writeToFS();
-    reconfigureWiFiConnection();
+    if (index >= _settings.wifi_networks_count) return;
+    _settings.selected_network = index;
+    EventBus::instance().publish(_settings);
 }
 
 void WiFiService::loop() { EXECUTE_EVERY_N_MS(reconnectDelay, manageSTA()); }
@@ -99,7 +96,7 @@ esp_err_t WiFiService::getNetworks(httpd_req_t *request) {
 
 void WiFiService::setupMDNS(const char *hostname) {
     mdns_init();
-    mdns_hostname_set(state().hostname);
+    mdns_hostname_set(_settings.hostname);
     mdns_instance_name_set(hostname);
     mdns_service_add(nullptr, "_http", "_tcp", 80, nullptr, 0);
     mdns_service_add(nullptr, "_ws", "_tcp", 80, nullptr, 0);
@@ -138,7 +135,7 @@ esp_err_t WiFiService::getNetworkStatus(httpd_req_t *request) {
 }
 
 void WiFiService::manageSTA() {
-    if (WiFi.isConnected() || state().wifi_networks_count == 0) return;
+    if (WiFi.isConnected() || _settings.wifi_networks_count == 0) return;
     wifi_mode_t mode = WiFi.getMode();
     if (mode == WIFI_MODE_NULL || mode == WIFI_MODE_AP) return;
 
@@ -153,12 +150,12 @@ void WiFiService::manageSTA() {
     uint32_t now = esp_timer_get_time() / 1000;
     if (now - startTime < 3000) return;
 
-    if (!attempted && state().wifi_networks_count > 0) {
+    if (!attempted && _settings.wifi_networks_count > 0) {
         attempted = true;
-        uint32_t idx = state().selected_network;
-        if (idx >= state().wifi_networks_count) idx = 0;
-        ESP_LOGI(TAG, "Connecting to: %s", state().wifi_networks[idx].ssid);
-        configureNetwork(state().wifi_networks[idx]);
+        uint32_t idx = _settings.selected_network;
+        if (idx >= _settings.wifi_networks_count) idx = 0;
+        ESP_LOGI(TAG, "Connecting to: %s", _settings.wifi_networks[idx].ssid);
+        configureNetwork(_settings.wifi_networks[idx]);
     }
 }
 
@@ -169,7 +166,7 @@ void WiFiService::configureNetwork(WiFiNetwork &network) {
     } else {
         WiFi.config(IPAddress(0, 0, 0, 0), IPAddress(0, 0, 0, 0), IPAddress(0, 0, 0, 0));
     }
-    WiFi.setHostname(state().hostname);
+    WiFi.setHostname(_settings.hostname);
     WiFi.begin(network.ssid, network.password);
 
 #if CONFIG_IDF_TARGET_ESP32C3

platform_shared/filesystem.options

@@ -16,11 +16,11 @@ socket_message.FSListResponse.directories max_count:20
 # Streaming download messages
 socket_message.FSDownloadRequest.path max_size:256
 socket_message.FSDownloadMetadata.error max_size:128
-socket_message.FSDownloadData.data type:FT_POINTER
+socket_message.FSDownloadData.data max_size:16384
 socket_message.FSDownloadComplete.error max_size:128
 
 # Streaming upload messages
 socket_message.FSUploadStart.path max_size:256
 socket_message.FSUploadStartResponse.error max_size:128
-socket_message.FSUploadData.data type:FT_POINTER
+socket_message.FSUploadData.data max_size:16384
 socket_message.FSUploadComplete.error max_size:128

platformio.ini

@@ -15,6 +15,7 @@ src_dir = esp32/src
 include_dir = esp32/include
 lib_dir = esp32/lib
 test_dir = esp32/test
+boards_dir = boards
 extra_configs = 
 	esp32/factory_settings.ini
 	esp32/features.ini
@@ -54,12 +55,6 @@ build_flags =
 	-D USS_RIGHT_PIN=14
 	-D SDA_PIN=47
 	-D SCL_PIN=21
-    -D SD_CMD_PIN=GPIO_NUM_38
-    -D SD_CLK_PIN=GPIO_NUM_39
-    -D SD_DATA_PIN=GPIO_NUM_40
-
-
-    
 
 [env:seeed-xiao-esp32s3]
 platform = espressif32
@@ -79,6 +74,45 @@ board_build.partitions = esp32/partition_table/min_spiffs.csv
 build_flags =
     ${env.build_flags}
 
+[env:esp32-p4]
+platform = https://github.com/pioarduino/platform-espressif32.git
+framework = espidf
+board = esp32p4_dev
+board_build.mcu = esp32p4
+board_build.f_cpu = 360000000L
+board_build.f_flash = 80000000L
+board_build.f_psram = 200000000L
+board_build.flash_mode = qio
+board_upload.flash_size = 32MB
+board_build.partitions = esp32/partition_table/default_32MB.csv
+board_build.filesystem = littlefs
+board_build.sdkconfig_defaults =
+    esp32/sdkconfig.defaults
+    esp32/sdkconfig.defaults.esp32p4
+upload_speed = 921600
+monitor_speed = 115200
+monitor_filters =
+    direct
+    esp32_exception_decoder
+extra_scripts =
+    pre:esp32/scripts/pre_build.py
+    pre:esp32/scripts/build_app.py
+build_flags =
+    ${env.build_flags}
+    -D USE_CAMERA=1
+    -D CAM_XCLK_PIN=-1
+    -D CAM_RESET_PIN=-1
+    -D CAM_PWDN_PIN=-1
+    -D MIPI_CSI_HRES=800
+    -D MIPI_CSI_VRES=640
+    -D MIPI_CSI_LANE_BITRATE_MBPS=400
+    -D MIPI_CSI_DATA_LANES=2
+    -D CSI_JPEG_QUALITY=65
+    -D BOARD_HAS_PSRAM
+    -D SDA_PIN=7
+    -D SCL_PIN=8
+    -D WS2812_PIN=27
+
 
 ; ================================================================
 ; General environment section
@@ -88,8 +122,8 @@ platform = espressif32 @ 6.8.1
 framework = espidf
 monitor_speed = 115200
 monitor_filters =
-	direct
-	esp32_exception_decoder
+    direct
+    esp32_exception_decoder
 build_flags =
 	${factory_settings.build_flags}
     ${features.build_flags}
@@ -102,8 +136,6 @@ build_flags =
     -fdata-sections
     -Wl,--gc-sections
     -I submodules/nanopb
-    -D PB_FIELD_32BIT=1
-    -D PB_ENABLE_MALLOC=1
     -Wno-missing-braces
     -Wno-format
     -D CONFIG_HTTPD_WS_SUPPORT=1