⚡ Adds event bus

esp32/include/ap_service.h

@@ -1,16 +1,15 @@
 #pragma once
 
-#include <template/stateful_service.h>
-#include <template/stateful_proto_endpoint.h>
-#include <template/stateful_persistence_pb.h>
+#include <event_bus/event_bus.h>
 #include <settings/ap_settings.h>
 #include <utils/timing.h>
 #include <wifi/wifi_idf.h>
 #include <wifi/dns_server.h>
 #include <esp_timer.h>
+#include <esp_http_server.h>
 #include <string>
 
-class APService : public StatefulService<APSettings> {
+class APService {
   public:
     APService();
     ~APService();
@@ -23,10 +22,16 @@ class APService : public StatefulService<APSettings> {
     void statusProto(api_APStatus &proto);
     APNetworkStatus getAPNetworkStatus();
 
-    StatefulProtoEndpoint<APSettings, api_APSettings> protoEndpoint;
+    esp_err_t getSettings(httpd_req_t *request);
+    esp_err_t updateSettings(httpd_req_t *request, api_Request *protoReq);
 
   private:
-    FSPersistencePB<APSettings> _persistence;
+    static constexpr const char *TAG = "APService";
+
+    void onSettingsChanged(const api_APSettings &newSettings);
+
+    APSettings _settings = APSettings_defaults();
+    EventBus::Handle<api_APSettings> _settingsHandle;
     DNSServer *_dnsServer;
 
     volatile unsigned long _lastManaged;

esp32/include/consumers/event_storage_manager.h

@@ -0,0 +1,51 @@
+#pragma once
+#include <consumers/proto_event_storage.h>
+#include <platform_shared/api.pb.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 <esp_log.h>
+
+class EventStorageManager {
+  public:
+    void initialize() {
+        ESP_LOGI(TAG, "Loading settings from storage");
+
+        _wifiStorage.begin();
+        _apStorage.begin();
+        _mdnsStorage.begin();
+        _peripheralStorage.begin();
+#if FT_ENABLED(USE_CAMERA)
+        _cameraStorage.begin();
+#endif
+
+        ESP_LOGI(TAG, "Settings loaded and published");
+    }
+
+  private:
+    static constexpr const char* TAG = "StorageManager";
+
+    ProtoEventStorage<api_WifiSettings, WiFiSettings_defaults> _wifiStorage =
+        ProtoEventStorage<api_WifiSettings, WiFiSettings_defaults>("/config/wifiSettings.pb", api_WifiSettings_fields,
+                                                                   api_WifiSettings_size, 1000);
+
+    ProtoEventStorage<api_APSettings, APSettings_defaults> _apStorage =
+        ProtoEventStorage<api_APSettings, APSettings_defaults>("/config/apSettings.pb", api_APSettings_fields,
+                                                               api_APSettings_size, 1000);
+
+    ProtoEventStorage<api_MDNSSettings, MDNSSettings_defaults> _mdnsStorage =
+        ProtoEventStorage<api_MDNSSettings, MDNSSettings_defaults>("/config/mdnsSettings.pb", api_MDNSSettings_fields,
+                                                                   api_MDNSSettings_size, 1000);
+
+    ProtoEventStorage<api_PeripheralSettings, PeripheralsConfiguration_defaults> _peripheralStorage =
+        ProtoEventStorage<api_PeripheralSettings, PeripheralsConfiguration_defaults>(
+            "/config/peripheralSettings.pb", api_PeripheralSettings_fields, api_PeripheralSettings_size, 500);
+
+#if FT_ENABLED(USE_CAMERA)
+    ProtoEventStorage<api_CameraSettings, Camera::CameraSettings_defaults> _cameraStorage =
+        ProtoEventStorage<api_CameraSettings, Camera::CameraSettings_defaults>(
+            "/config/cameraSettings.pb", api_CameraSettings_fields, api_CameraSettings_size, 1000);
+#endif
+};

esp32/include/consumers/proto_event_storage.h

@@ -0,0 +1,72 @@
+#pragma once
+#include <event_bus/event_bus.h>
+#include <pb_encode.h>
+#include <pb_decode.h>
+#include <esp_log.h>
+#include <memory>
+#include <cstdio>
+
+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() {
+        auto loaded = std::unique_ptr<ProtoMsg>(new ProtoMsg {});
+        loadOrDefault(*loaded);
+        EventBus::publish(*loaded, "EventStorage");
+        ESP_LOGI(TAG, "Loaded %s", _filename);
+
+        _handle = EventBus::subscribe<ProtoMsg>(_debounceMs, [this](const ProtoMsg& msg) { save(msg); });
+    }
+
+  private:
+    static constexpr const char* TAG = "ProtoStorage";
+    const char* _filename;
+    const pb_msgdesc_t* _descriptor;
+    size_t _maxSize;
+    uint32_t _debounceMs;
+    typename EventBus::Handle<ProtoMsg> _handle;
+
+    void loadOrDefault(ProtoMsg& outMsg) {
+        FILE* file = fopen(_filename, "rb");
+        if (!file) {
+            outMsg = DefaultsFn();
+            return;
+        }
+
+        fseek(file, 0, SEEK_END);
+        size_t size = ftell(file);
+        fseek(file, 0, SEEK_SET);
+
+        if (size == 0 || size > _maxSize) {
+            fclose(file);
+            outMsg = DefaultsFn();
+            return;
+        }
+
+        auto buffer = std::make_unique<uint8_t[]>(size);
+        fread(buffer.get(), 1, size, file);
+        fclose(file);
+
+        pb_istream_t stream = pb_istream_from_buffer(buffer.get(), size);
+        if (!pb_decode(&stream, _descriptor, &outMsg)) {
+            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)) return;
+
+        FILE* file = fopen(_filename, "wb");
+        if (!file) return;
+
+        fwrite(buffer.get(), 1, stream.bytes_written, file);
+        fclose(file);
+        ESP_LOGD(TAG, "Saved %s", _filename);
+    }
+};

esp32/include/event_bus/event_bus.h

@@ -0,0 +1,65 @@
+#pragma once
+#include <event_bus/typed_event_bus.h>
+#include <event_bus/event_registry.h>
+#include <event_bus/event_metadata.h>
+#include <esp_timer.h>
+#include <atomic>
+
+class EventBus {
+  public:
+    template <typename Msg>
+    using Bus = TypedEventBus<Msg, EventBusConfig<Msg>::QueueDepth, EventBusConfig<Msg>::MaxSubs,
+                              EventBusConfig<Msg>::BatchSize>;
+
+    template <typename Msg>
+    using Handle = typename Bus<Msg>::Handle;
+
+    template <typename Msg>
+    static bool publish(const Msg& msg, const char* source = nullptr) {
+        if (_hasGlobalListeners.load(std::memory_order_acquire)) {
+            notifyGlobalListeners(msg, source);
+        }
+
+        return Bus<Msg>::publish(msg);
+    }
+
+    template <typename Msg, typename Callback>
+    static auto subscribe(Callback&& callback) {
+        return Bus<Msg>::subscribe(std::forward<Callback>(callback));
+    }
+
+    template <typename Msg, typename Callback>
+    static auto subscribe(uint32_t intervalMs, Callback&& callback) {
+        return Bus<Msg>::subscribe(intervalMs, std::forward<Callback>(callback));
+    }
+
+    template <typename Msg>
+    static void publishISR(const Msg& msg, BaseType_t* higherPriorityTaskWoken = nullptr) {
+        Bus<Msg>::publishISR(msg, higherPriorityTaskWoken);
+    }
+
+    template <typename Msg>
+    static bool peek(Msg& out) {
+        return Bus<Msg>::peek(out);
+    }
+
+    template <typename Msg>
+    static bool take(Msg& out) {
+        return Bus<Msg>::take(out);
+    }
+
+    template <typename Msg>
+    static bool hasSubscribers() {
+        return Bus<Msg>::hasSubscribers();
+    }
+
+    using GlobalHandler = FixedFn<void(EventType, const void*, size_t, uint64_t), 64>;
+    static size_t subscribeGlobal(GlobalHandler&& handler);
+    static void unsubscribeGlobal(size_t id);
+
+  private:
+    static std::atomic<bool> _hasGlobalListeners;
+
+    template <typename Msg>
+    static void notifyGlobalListeners(const Msg& msg, const char* source);
+};

esp32/include/event_bus/event_metadata.h

@@ -0,0 +1,16 @@
+#pragma once
+#include <event_bus/event_types.h>
+#include <cstdint>
+
+struct EventMetadata {
+    EventType type;
+    uint64_t timestamp;
+    uint32_t sequence;
+    const char* source;
+};
+
+template <typename Msg>
+struct EventEnvelope {
+    EventMetadata metadata;
+    Msg payload;
+};

esp32/include/event_bus/event_registry.h

@@ -0,0 +1,41 @@
+#pragma once
+#include <event_bus/event_types.h>
+#include <platform_shared/api.pb.h>
+#include <platform_shared/message.pb.h>
+
+template <typename T>
+struct EventTypeTraits;
+
+template <typename T>
+struct EventBusConfig {
+    static constexpr size_t QueueDepth = 64;
+    static constexpr size_t MaxSubs = 8;
+    static constexpr size_t BatchSize = 16;
+};
+
+#define REGISTER_EVENT_TYPE(MsgType, EventTypeValue)      \
+    template <>                                           \
+    struct EventTypeTraits<MsgType> {                     \
+        static constexpr EventType type = EventTypeValue; \
+        static constexpr const char* name = #MsgType;     \
+    };
+
+#define REGISTER_SETTINGS_TYPE(MsgType, EventTypeValue) \
+    REGISTER_EVENT_TYPE(MsgType, EventTypeValue)        \
+    template <>                                         \
+    struct EventBusConfig<MsgType> {                    \
+        static constexpr size_t QueueDepth = 1;         \
+        static constexpr size_t MaxSubs = 6;            \
+        static constexpr size_t BatchSize = 1;          \
+    };
+
+REGISTER_SETTINGS_TYPE(api_WifiSettings, EventType::WIFI_SETTINGS)
+REGISTER_SETTINGS_TYPE(api_APSettings, EventType::AP_SETTINGS)
+REGISTER_SETTINGS_TYPE(api_MDNSSettings, EventType::MDNS_SETTINGS)
+REGISTER_SETTINGS_TYPE(api_PeripheralSettings, EventType::PERIPHERAL_SETTINGS)
+REGISTER_SETTINGS_TYPE(api_ServoSettings, EventType::SERVO_SETTINGS)
+REGISTER_SETTINGS_TYPE(api_CameraSettings, EventType::CAMERA_SETTINGS)
+
+REGISTER_EVENT_TYPE(socket_message_IMUData, EventType::IMU_DATA)
+REGISTER_EVENT_TYPE(socket_message_ControllerData, EventType::MOTION_COMMAND)
+REGISTER_EVENT_TYPE(socket_message_ModeData, EventType::MOTION_MODE)

esp32/include/event_bus/event_types.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <cstdint>
+
+enum class EventType : uint16_t {
+    WIFI_SETTINGS = 100,
+    AP_SETTINGS = 110,
+    MDNS_SETTINGS = 120,
+    PERIPHERAL_SETTINGS = 130,
+    SERVO_SETTINGS = 140,
+    CAMERA_SETTINGS = 150,
+
+    WIFI_STATUS = 101,
+    AP_STATUS = 111,
+    IMU_DATA = 131,
+    MOTION_COMMAND = 200,
+    MOTION_MODE = 201,
+    SERVO_STATE = 141,
+
+    SYSTEM_BOOT = 300,
+    STORAGE_HYDRATION_COMPLETE = 301,
+};
+
+const char* eventTypeName(EventType type);
+bool isSettingsEvent(EventType type);

esp32/include/event_bus/rest_endpoints.h

@@ -0,0 +1,55 @@
+#pragma once
+#include <event_bus/event_bus.h>
+#include <event_bus/event_registry.h>
+#include <communication/webserver.h>
+#include <esp_http_server.h>
+
+template <typename TMsg, pb_size_t RequestTag, pb_size_t ResponseTag>
+class RestSettingsEndpoint {
+  public:
+    static esp_err_t getSettings(httpd_req_t *request) {
+        api_Response response = api_Response_init_zero;
+        response.status_code = 200;
+        response.which_payload = ResponseTag;
+
+        TMsg settings;
+        if (!EventBus::peek(settings)) {
+            return WebServer::sendError(request, 404, "Settings not found");
+        }
+
+        *reinterpret_cast<TMsg *>(&response.payload) = settings;
+        return WebServer::send(request, 200, response, api_Response_fields);
+    }
+
+    static esp_err_t updateSettings(httpd_req_t *request, api_Request *protoReq) {
+        if (protoReq->which_payload != RequestTag) {
+            return WebServer::sendError(request, 400, "Invalid payload type");
+        }
+
+        const TMsg &settings = *reinterpret_cast<const TMsg *>(&protoReq->payload);
+        EventBus::publish(settings, "HTTPEndpoint");
+
+        api_Response response = api_Response_init_zero;
+        response.status_code = 200;
+        response.which_payload = api_Response_empty_message_tag;
+        return WebServer::send(request, 200, response, api_Response_fields);
+    }
+};
+
+using WiFiSettingsEndpoint =
+    RestSettingsEndpoint<api_WifiSettings, api_Request_wifi_settings_tag, api_Response_wifi_settings_tag>;
+
+using ServoSettingsEndpoint =
+    RestSettingsEndpoint<api_ServoSettings, api_Request_servo_settings_tag, api_Response_servo_settings_tag>;
+
+using PeripheralSettingsEndpoint = RestSettingsEndpoint<api_PeripheralSettings, api_Request_peripheral_settings_tag,
+                                                        api_Response_peripheral_settings_tag>;
+
+using APSettingsEndpoint =
+    RestSettingsEndpoint<api_APSettings, api_Request_ap_settings_tag, api_Response_ap_settings_tag>;
+
+using MDNSSettingsEndpoint =
+    RestSettingsEndpoint<api_MDNSSettings, api_Request_mdns_settings_tag, api_Response_mdns_settings_tag>;
+
+using CameraSettingsEndpoint =
+    RestSettingsEndpoint<api_CameraSettings, api_Request_camera_settings_tag, api_Response_camera_settings_tag>;

esp32/include/event_bus/system_events.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <cstdint>
+
+enum class SystemEventType : uint8_t {
+    STORAGE_HYDRATION_COMPLETE,
+    SYSTEM_BOOT_COMPLETE,
+};
+
+struct SystemEvent {
+    SystemEventType type;
+};

esp32/include/event_bus/typed_event_bus.h

@@ -0,0 +1,287 @@
+#pragma once
+#include <vector>
+#include <functional>
+#include <type_traits>
+#include <cstddef>
+#include <cstring>
+#include <array>
+#include <optional>
+#include <atomic>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+#include <freertos/queue.h>
+
+template <typename Sig, size_t MaxSize>
+class FixedFn;
+
+template <typename R, typename... A, size_t MaxSize>
+class FixedFn<R(A...), MaxSize> {
+    alignas(void*) std::byte buf[MaxSize];
+    R (*call)(void*, A&&...) {};
+    void (*moveFn)(void*, void*) {};
+    void (*destroy)(void*) {};
+
+  public:
+    template <typename Fun>
+    void set(Fun&& f) {
+        static_assert(sizeof(Fun) <= MaxSize);
+        new (buf) Fun(std::forward<Fun>(f));
+        call = [](void* p, A&&... as) -> R { return (*reinterpret_cast<Fun*>(p))(std::forward<A>(as)...); };
+        moveFn = [](void* d, void* s) { new (d) Fun(std::move(*reinterpret_cast<Fun*>(s))); };
+        destroy = [](void* p) { reinterpret_cast<Fun*>(p)->~Fun(); };
+    }
+    R operator()(A... as) const {
+        return call(const_cast<void*>(static_cast<const void*>(buf)), std::forward<A>(as)...);
+    }
+    FixedFn() = default;
+    FixedFn(FixedFn&& o) noexcept {
+        if (o.moveFn) o.moveFn(buf, o.buf);
+        call = o.call;
+        moveFn = o.moveFn;
+        destroy = o.destroy;
+        o.call = nullptr;
+        o.moveFn = nullptr;
+        o.destroy = nullptr;
+    }
+    FixedFn(const FixedFn&) = delete;
+    FixedFn& operator=(const FixedFn&) = delete;
+    FixedFn& operator=(FixedFn&&) = delete;
+    ~FixedFn() {
+        if (destroy) destroy(buf);
+    }
+};
+
+enum class EmitMode { Latest, Batch };
+
+template <typename Msg, size_t QueueDepth = 64, size_t MaxSubs = 8, size_t BatchSize = 16>
+class TypedEventBus {
+    struct Item {
+        Msg payload;
+        size_t exclude;
+    };
+    static constexpr size_t NO_EX = MaxSubs;
+    struct Sub {
+        FixedFn<void(const Msg*, size_t), 48> cb;
+        TickType_t interval;
+        TickType_t last;
+        EmitMode mode;
+        std::array<Msg, BatchSize> buf;
+        size_t cnt;
+        std::atomic<bool> enabled;
+        std::atomic<uint32_t> running;
+    };
+    inline static StaticQueue_t qbuf;
+    inline static Item qStorage[QueueDepth];
+    inline static QueueHandle_t queue =
+        xQueueCreateStatic(QueueDepth, sizeof(Item), reinterpret_cast<uint8_t*>(qStorage), &qbuf);
+    inline static std::array<std::optional<Sub>, MaxSubs> subs {};
+    inline static portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
+    inline static Msg latest {};
+    inline static std::atomic<bool> hasLatest {false};
+    inline static std::atomic<size_t> subCount {0};
+    inline static std::atomic<bool> taskStarted {false};
+
+    static void storeISR(const Msg& m) {
+        UBaseType_t s = portSET_INTERRUPT_MASK_FROM_ISR();
+        latest = m;
+        hasLatest.store(true, std::memory_order_release);
+        portCLEAR_INTERRUPT_MASK_FROM_ISR(s);
+    }
+
+    static void dispatch(const Msg& m, size_t ex) {
+        TickType_t now = xTaskGetTickCount();
+        Sub* ready[MaxSubs];
+        size_t readyCnt = 0;
+
+        portENTER_CRITICAL(&mux);
+        for (size_t i = 0; i < MaxSubs; ++i) {
+            auto& opt = subs[i];
+            if (!opt || i == ex) continue;
+            Sub& s = *opt;
+            if (!s.enabled.load(std::memory_order_acquire)) continue;
+
+            TickType_t dt = now - s.last;
+
+            if (s.interval && dt < s.interval) {
+                if (s.mode == EmitMode::Batch) {
+                    if (s.cnt < BatchSize)
+                        s.buf[s.cnt++] = m;
+                    else
+                        s.buf[BatchSize - 1] = m;
+                } else {
+                    s.buf[0] = m;
+                    s.cnt = 1;
+                }
+            } else {
+                if (s.cnt < BatchSize)
+                    s.buf[s.cnt++] = m;
+                else
+                    s.buf[BatchSize - 1] = m;
+                s.last = now;
+                s.running.fetch_add(1, std::memory_order_acq_rel);
+                ready[readyCnt++] = &s;
+            }
+        }
+        portEXIT_CRITICAL(&mux);
+
+        for (size_t i = 0; i < readyCnt; ++i) {
+            Sub* s = ready[i];
+            s->cb(s->buf.data(), s->cnt);
+            s->cnt = 0;
+            s->running.fetch_sub(1, std::memory_order_acq_rel);
+        }
+    }
+
+    static void worker(void*) {
+        Item it;
+        while (xQueueReceive(queue, &it, portMAX_DELAY) == pdTRUE) dispatch(it.payload, it.exclude);
+    }
+
+    static void ensureTask() {
+        if (!taskStarted.load(std::memory_order_acquire)) {
+            bool expected = false;
+            if (taskStarted.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
+                xTaskCreatePinnedToCore(worker, "evtbus", 4096, nullptr, 6, nullptr, 1);
+            }
+        }
+    }
+
+    static bool push(const Msg& m, size_t ex = NO_EX, TickType_t to = 0) {
+        ensureTask();
+        Item it {m, ex};
+        return xQueueSend(queue, &it, to) == pdTRUE;
+    }
+
+  public:
+    class Handle {
+        size_t idx {NO_EX};
+        friend class TypedEventBus;
+        explicit Handle(size_t i) : idx(i) {}
+
+      public:
+        Handle() = default;
+        Handle(const Handle&) = delete;
+        Handle& operator=(const Handle&) = delete;
+        Handle(Handle&& o) noexcept : idx(o.idx) { o.idx = NO_EX; }
+        Handle& operator=(Handle&& o) noexcept {
+            if (this != &o) {
+                unsubscribe();
+                idx = o.idx;
+                o.idx = NO_EX;
+            }
+            return *this;
+        }
+        ~Handle() { unsubscribe(); }
+        void unsubscribe() {
+            if (idx < MaxSubs) {
+                Sub* s = nullptr;
+                portENTER_CRITICAL(&mux);
+                if (subs[idx]) {
+                    s = &*subs[idx];
+                    s->enabled.store(false, std::memory_order_release);
+                }
+                portEXIT_CRITICAL(&mux);
+                if (s) {
+                    while (s->running.load(std::memory_order_acquire) != 0) taskYIELD();
+                    portENTER_CRITICAL(&mux);
+                    subs[idx].reset();
+                    portEXIT_CRITICAL(&mux);
+                    subCount.fetch_sub(1, std::memory_order_acq_rel);
+                }
+                idx = NO_EX;
+            }
+        }
+        bool valid() const { return idx < MaxSubs; }
+    };
+
+    static void store(const Msg& m) {
+        portENTER_CRITICAL(&mux);
+        latest = m;
+        hasLatest.store(true, std::memory_order_release);
+        portEXIT_CRITICAL(&mux);
+    }
+
+    template <typename C>
+    static void consume(C fn) {
+        static Handle h = subscribe(std::forward<C>(fn));
+        (void)h;
+    }
+
+    template <typename C>
+    static Handle subscribe(uint32_t ms, EmitMode mode, C fn) {
+        ensureTask();
+        portENTER_CRITICAL(&mux);
+        for (size_t i = 0; i < MaxSubs; ++i)
+            if (!subs[i]) {
+                subs[i].emplace();
+                Sub& s = *subs[i];
+                s.cb.set(std::move(fn));
+                s.interval = pdMS_TO_TICKS(ms);
+                s.last = xTaskGetTickCount() - s.interval;
+                s.mode = mode;
+                s.cnt = 0;
+                s.enabled.store(true, std::memory_order_release);
+                s.running.store(0, std::memory_order_release);
+                subCount.fetch_add(1, std::memory_order_acq_rel);
+                portEXIT_CRITICAL(&mux);
+                return Handle(i);
+            }
+        portEXIT_CRITICAL(&mux);
+        return Handle(NO_EX);
+    }
+
+    template <typename C>
+    static Handle subscribe(C fn) {
+        if constexpr (std::is_invocable_v<C, const Msg*, size_t>)
+            return subscribe(0, EmitMode::Latest, std::move(fn));
+        else
+            return subscribe(0, EmitMode::Latest, [fn = std::move(fn)](const Msg* p, size_t n) {
+                for (size_t i = 0; i < n; ++i) fn(p[i]);
+            });
+    }
+
+    template <typename C>
+    static Handle subscribe(uint32_t ms, C fn) {
+        if constexpr (std::is_invocable_v<C, const Msg*, size_t>)
+            return subscribe(ms, EmitMode::Batch, std::move(fn));
+        else
+            return subscribe(ms, EmitMode::Batch, [fn = std::move(fn)](const Msg* p, size_t n) {
+                for (size_t i = 0; i < n; ++i) fn(p[i]);
+            });
+    }
+
+    static bool publish(const Msg& m) {
+        store(m);
+        return push(m);
+    }
+
+    static bool publish(const Msg& m, const Handle& h) {
+        store(m);
+        return push(m, h.valid() ? h.idx : NO_EX);
+    }
+
+    static void publishISR(const Msg& m, BaseType_t* hpw = nullptr) {
+        storeISR(m);
+        Item it {m, NO_EX};
+        xQueueSendFromISR(queue, &it, hpw);
+    }
+
+    static bool peek(Msg& out) {
+        if (!hasLatest.load(std::memory_order_acquire)) return false;
+        portENTER_CRITICAL(&mux);
+        out = latest;
+        portEXIT_CRITICAL(&mux);
+        return true;
+    }
+
+    static bool take(Msg& out) {
+        if (!hasLatest.load(std::memory_order_acquire)) return false;
+        portENTER_CRITICAL(&mux);
+        out = latest;
+        hasLatest.store(false, std::memory_order_release);
+        portEXIT_CRITICAL(&mux);
+        return true;
+    }
+
+    static bool hasSubscribers() { return subCount.load(std::memory_order_acquire) > 0; }
+};

esp32/include/mdns_service.h

@@ -2,13 +2,11 @@
 
 #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 <event_bus/event_bus.h>
 #include <settings/mdns_settings.h>
 #include <utils/timing.h>
 
-class MDNSService : public StatefulService<MDNSSettings> {
+class MDNSService {
   public:
     MDNSService();
     ~MDNSService();
@@ -18,10 +16,16 @@ 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;
+    esp_err_t getSettings(httpd_req_t *request);
+    esp_err_t updateSettings(httpd_req_t *request, api_Request *protoReq);
 
   private:
-    FSPersistencePB<MDNSSettings> _persistence;
+    static constexpr const char *TAG = "MDNSService";
+
+    void onSettingsChanged(const api_MDNSSettings &newSettings);
+
+    MDNSSettings _settings = MDNSSettings_defaults();
+    EventBus::Handle<api_MDNSSettings> _settingsHandle;
     bool _started {false};
 
     void reconfigureMDNS();

esp32/include/peripherals/camera_service.h

@@ -3,9 +3,7 @@
 #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 <event_bus/event_bus.h>
 
 #include <settings/camera_settings.h>
 
@@ -23,7 +21,7 @@ camera_fb_t *safe_camera_fb_get();
 sensor_t *safe_sensor_get();
 void safe_sensor_return();
 
-class CameraService : public StatefulService<CameraSettings> {
+class CameraService {
   public:
     CameraService();
 
@@ -32,10 +30,16 @@ 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;
+    esp_err_t getSettings(httpd_req_t *request);
+    esp_err_t updateSettings(httpd_req_t *request, api_Request *protoReq);
 
   private:
-    FSPersistencePB<CameraSettings> _persistence;
+    static constexpr const char *TAG = "CameraService";
+
+    void onSettingsChanged(const api_CameraSettings &newSettings);
     void updateCamera();
+
+    CameraSettings _settings = CameraSettings_defaults();
+    EventBus::Handle<api_CameraSettings> _settingsHandle;
 };
 } // namespace Camera

esp32/include/peripherals/peripherals.h

@@ -1,14 +1,13 @@
 #pragma once
 
-#include <template/stateful_persistence_pb.h>
-#include <template/stateful_service.h>
-#include <template/stateful_proto_endpoint.h>
+#include <event_bus/event_bus.h>
 #include <utils/math_utils.h>
 #include <utils/timing.h>
 #include <filesystem.h>
 #include <features.h>
 #include <settings/peripherals_settings.h>
 #include <platform_shared/message.pb.h>
+#include <esp_http_server.h>
 
 #include <list>
 
@@ -26,7 +25,7 @@
  */
 #define MAX_DISTANCE 200
 
-class Peripherals : public StatefulService<PeripheralsConfiguration> {
+class Peripherals {
   public:
     Peripherals();
 
@@ -42,7 +41,6 @@ class Peripherals : public StatefulService<PeripheralsConfiguration> {
     void getIMUProto(socket_message_IMUData &data);
     void getSettingsProto(socket_message_PeripheralSettingsData &data);
 
-    /* IMU FUNCTIONS */
     bool readImu();
 
     bool readMag();
@@ -66,10 +64,16 @@ class Peripherals : public StatefulService<PeripheralsConfiguration> {
 
     bool calibrateIMU();
 
-    StatefulProtoEndpoint<PeripheralsConfiguration, api_PeripheralSettings> protoEndpoint;
+    esp_err_t getSettings(httpd_req_t *request);
+    esp_err_t updateSettings(httpd_req_t *request, api_Request *protoReq);
 
   private:
-    FSPersistencePB<PeripheralsConfiguration> _persistence;
+    static constexpr const char *TAG = "Peripherals";
+
+    void onSettingsChanged(const api_PeripheralSettings &newSettings);
+
+    PeripheralsConfiguration _settings = PeripheralsConfiguration_defaults();
+    EventBus::Handle<api_PeripheralSettings> _settingsHandle;
 
     SemaphoreHandle_t _accessMutex;
     inline void beginTransaction() { xSemaphoreTakeRecursive(_accessMutex, portMAX_DELAY); }

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 <event_bus/event_bus.h>
 #include <utils/math_utils.h>
 #include <platform_shared/api.pb.h>
+#include <esp_http_server.h>
 
 #ifndef FACTORY_SERVO_PWM_FREQUENCY
 #define FACTORY_SERVO_PWM_FREQUENCY 50
@@ -24,43 +23,34 @@ 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()) {}
+    ServoController() {}
 
     void begin() {
-        _persistence.readFromFS();
+        _settingsHandle = EventBus::subscribe<api_ServoSettings>(
+            [this](const api_ServoSettings &settings) { onSettingsChanged(settings); });
+
+        api_ServoSettings initialSettings;
+        if (EventBus::peek(initialSettings)) {
+            onSettingsChanged(initialSettings);
+        }
         initializePCA();
     }
 
+    esp_err_t getSettings(httpd_req_t *request);
+    esp_err_t updateSettings(httpd_req_t *request, api_Request *protoReq);
+
     void pcaWrite(int index, int value) {
         if (value < 0 || value > 4096) {
             ESP_LOGE("Peripherals", "Invalid PWM value %d for %d :: Valid range 0-4096", value, index);
@@ -109,7 +99,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,16 +111,20 @@ class ServoController : public StatefulService<ServoSettings> {
         if (control_state == SERVO_CONTROL_STATE::ANGLE) calculatePWM();
     }
 
-    StatefulProtoEndpoint<ServoSettings, ServoSettings> protoEndpoint;
-
   private:
+    static constexpr const char *TAG = "ServoController";
+
+    void onSettingsChanged(const api_ServoSettings &newSettings) { _settings = newSettings; }
+
     void initializePCA() {
         _pca.begin();
         _pca.setOscillatorFrequency(FACTORY_SERVO_OSCILLATOR_FREQUENCY);
         _pca.setPWMFreq(FACTORY_SERVO_PWM_FREQUENCY);
         _pca.sleep();
     }
-    FSPersistencePB<ServoSettings> _persistence;
+
+    api_ServoSettings _settings = ServoSettings_defaults();
+    EventBus::Handle<api_ServoSettings> _settingsHandle;
 
     PCA9685Driver _pca;
 

esp32/include/template/stateful_proto_endpoint.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include <esp_http_server.h>
 #include <template/stateful_service.h>
 #include <communication/webserver.h>
@@ -27,7 +28,8 @@ class StatefulProtoEndpoint {
     // 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
+    // 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&)>;
@@ -51,8 +53,8 @@ class StatefulProtoEndpoint {
      * @param responseAssigner Assigns specific type to Response oneof
      */
     StatefulProtoEndpoint(ProtoStateReader stateReader, ProtoStateUpdater stateUpdater,
-                          StatefulService<T>* statefulService,
-                          RequestExtractor requestExtractor, ResponseAssigner responseAssigner)
+                          StatefulService<T>* statefulService, RequestExtractor requestExtractor,
+                          ResponseAssigner responseAssigner)
         : _stateReader(stateReader),
           _stateUpdater(stateUpdater),
           _statefulService(statefulService),
@@ -81,9 +83,7 @@ class StatefulProtoEndpoint {
     /**
      * Handles GET requests: reads current state and returns it as Response
      */
-    esp_err_t getState(httpd_req_t* request) {
-        return sendStateResponse(request, 200);
-    }
+    esp_err_t getState(httpd_req_t* request) { return sendStateResponse(request, 200); }
 
   private:
     /** Sends current state wrapped in Response */
@@ -115,21 +115,21 @@ class StatefulProtoEndpoint {
  * 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;                                                              \
+#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;                                             \
+#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/wifi_service.h

@@ -5,18 +5,15 @@
 #include <mdns.h>
 #include <string>
 
-#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 <event_bus/event_bus.h>
 #include <settings/wifi_settings.h>
+#include <utils/timing.h>
 
 #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,27 +24,39 @@ class WiFiService : public StatefulService<WiFiSettings> {
     void setupMDNS(const char *hostname);
     void selectNetwork(uint32_t index);
 
-    const char *getHostname() { return state().hostname; }
+    const char *getHostname() {
+        static api_WifiSettings cached_settings;
+        EventBus::peek(cached_settings);
+        return cached_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;
-
   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;
+    void onSettingsChanged(const api_WifiSettings &newSettings);
 
     void reconfigureWiFiConnection();
     void manageSTA();
-    void configureNetwork(WiFiNetwork &network);
+    void configureNetwork(const WiFiNetwork &network);
 
+    api_WifiSettings getSettings() const {
+        api_WifiSettings settings;
+        EventBus::peek(settings);
+        return settings;
+    }
+
+    EventBus::Handle<api_WifiSettings> _settingsHandle;
+
+    bool _initialized;
     unsigned long _lastConnectionAttempt;
     bool _stopping;
 
     constexpr static uint16_t reconnectDelay {10000};
+    static constexpr const char *TAG = "WiFiService";
 };

esp32/src/CMakeLists.txt

@@ -5,6 +5,7 @@ idf_component_register(
         "peripherals"
         "wifi"
         "platform_shared"
+        "event_bus"
         "../../submodules/nanopb"
     INCLUDE_DIRS 
         "../include"

esp32/src/ap_service.cpp

@@ -1,19 +1,7 @@
 #include <ap_service.h>
 #include <communication/webserver.h>
 
-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 +10,30 @@ APService::~APService() {
     }
 }
 
-void APService::begin() { _persistence.readFromFS(); }
+void APService::begin() {
+    _settingsHandle =
+        EventBus::subscribe<api_APSettings>([this](const api_APSettings &settings) { onSettingsChanged(settings); });
+
+    api_APSettings initialSettings;
+    if (EventBus::peek(initialSettings)) {
+        onSettingsChanged(initialSettings);
+    }
+}
+
+void APService::onSettingsChanged(const api_APSettings &newSettings) {
+    strncpy(_settings.ssid, newSettings.ssid, sizeof(_settings.ssid) - 1);
+    _settings.ssid[sizeof(_settings.ssid) - 1] = '\0';
+    strncpy(_settings.password, newSettings.password, sizeof(_settings.password) - 1);
+    _settings.password[sizeof(_settings.password) - 1] = '\0';
+    _settings.local_ip = newSettings.local_ip;
+    _settings.gateway_ip = newSettings.gateway_ip;
+    _settings.subnet_mask = newSettings.subnet_mask;
+    _settings.channel = newSettings.channel;
+    _settings.ssid_hidden = newSettings.ssid_hidden;
+    _settings.max_clients = newSettings.max_clients;
+    _settings.provision_mode = newSettings.provision_mode;
+    reconfigureAP();
+}
 
 esp_err_t APService::getStatusProto(httpd_req_t *request) {
     api_Response res = api_Response_init_zero;
@@ -44,7 +55,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 +81,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 +94,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
@@ -109,3 +120,24 @@ void APService::stopAP() {
 }
 
 void APService::handleDNS() {}
+
+esp_err_t APService::getSettings(httpd_req_t *request) {
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_ap_settings_tag;
+    response.payload.ap_settings = _settings;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}
+
+esp_err_t APService::updateSettings(httpd_req_t *request, api_Request *protoReq) {
+    if (protoReq->which_payload != api_Request_ap_settings_tag) {
+        return ESP_FAIL;
+    }
+
+    EventBus::publish(protoReq->payload.ap_settings, "HTTPEndpoint");
+
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_empty_message_tag;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}

esp32/src/event_bus/event_bus.cpp

@@ -0,0 +1,54 @@
+#include <event_bus/event_bus.h>
+#include <vector>
+#include <memory>
+#include <mutex>
+#include <algorithm>
+
+std::atomic<bool> EventBus::_hasGlobalListeners {false};
+
+struct GlobalSubscription {
+    size_t id;
+    std::unique_ptr<EventBus::GlobalHandler> handler;
+};
+
+static std::vector<GlobalSubscription> globalSubs;
+static std::mutex globalMutex;
+static size_t nextGlobalId = 1;
+
+size_t EventBus::subscribeGlobal(GlobalHandler&& handler) {
+    std::lock_guard<std::mutex> lock(globalMutex);
+    size_t id = nextGlobalId++;
+    auto h = std::make_unique<GlobalHandler>(std::move(handler));
+    globalSubs.push_back({id, std::move(h)});
+    _hasGlobalListeners.store(true, std::memory_order_release);
+    return id;
+}
+
+void EventBus::unsubscribeGlobal(size_t id) {
+    std::lock_guard<std::mutex> lock(globalMutex);
+    globalSubs.erase(std::remove_if(globalSubs.begin(), globalSubs.end(), [id](const auto& s) { return s.id == id; }),
+                     globalSubs.end());
+    _hasGlobalListeners.store(!globalSubs.empty(), std::memory_order_release);
+}
+
+template <typename Msg>
+void EventBus::notifyGlobalListeners(const Msg& msg, const char* source) {
+    uint64_t timestamp = esp_timer_get_time();
+    EventType type = EventTypeTraits<Msg>::type;
+
+    std::lock_guard<std::mutex> lock(globalMutex);
+    for (auto& sub : globalSubs) {
+        (*sub.handler)(type, &msg, sizeof(Msg), timestamp);
+    }
+}
+
+template void EventBus::notifyGlobalListeners<api_WifiSettings>(const api_WifiSettings&, const char*);
+template void EventBus::notifyGlobalListeners<api_APSettings>(const api_APSettings&, const char*);
+template void EventBus::notifyGlobalListeners<api_MDNSSettings>(const api_MDNSSettings&, const char*);
+template void EventBus::notifyGlobalListeners<api_PeripheralSettings>(const api_PeripheralSettings&, const char*);
+template void EventBus::notifyGlobalListeners<api_ServoSettings>(const api_ServoSettings&, const char*);
+template void EventBus::notifyGlobalListeners<api_CameraSettings>(const api_CameraSettings&, const char*);
+template void EventBus::notifyGlobalListeners<socket_message_IMUData>(const socket_message_IMUData&, const char*);
+template void EventBus::notifyGlobalListeners<socket_message_ControllerData>(const socket_message_ControllerData&,
+                                                                             const char*);
+template void EventBus::notifyGlobalListeners<socket_message_ModeData>(const socket_message_ModeData&, const char*);

esp32/src/event_bus/event_types.cpp

@@ -0,0 +1,26 @@
+#include <event_bus/event_types.h>
+
+const char* eventTypeName(EventType type) {
+    switch (type) {
+        case EventType::WIFI_SETTINGS: return "WIFI_SETTINGS";
+        case EventType::AP_SETTINGS: return "AP_SETTINGS";
+        case EventType::MDNS_SETTINGS: return "MDNS_SETTINGS";
+        case EventType::PERIPHERAL_SETTINGS: return "PERIPHERAL_SETTINGS";
+        case EventType::SERVO_SETTINGS: return "SERVO_SETTINGS";
+        case EventType::CAMERA_SETTINGS: return "CAMERA_SETTINGS";
+        case EventType::WIFI_STATUS: return "WIFI_STATUS";
+        case EventType::AP_STATUS: return "AP_STATUS";
+        case EventType::IMU_DATA: return "IMU_DATA";
+        case EventType::MOTION_COMMAND: return "MOTION_COMMAND";
+        case EventType::MOTION_MODE: return "MOTION_MODE";
+        case EventType::SERVO_STATE: return "SERVO_STATE";
+        case EventType::SYSTEM_BOOT: return "SYSTEM_BOOT";
+        case EventType::STORAGE_HYDRATION_COMPLETE: return "STORAGE_HYDRATION_COMPLETE";
+        default: return "UNKNOWN";
+    }
+}
+
+bool isSettingsEvent(EventType type) {
+    return static_cast<uint16_t>(type) >= 100 && static_cast<uint16_t>(type) < 200 &&
+           static_cast<uint16_t>(type) % 10 == 0;
+}

esp32/src/main.cpp

@@ -20,6 +20,8 @@
 #include <ap_service.h>
 #include <mdns_service.h>
 #include <system_service.h>
+#include <consumers/event_storage_manager.h>
+#include <event_bus/rest_endpoints.h>
 
 #include <www_mount.hpp>
 
@@ -42,7 +44,7 @@ WiFiService wifiService;
 APService apService;
 
 void setupServer() {
-    server.config(50 + WWW_ASSETS_COUNT, 16384);
+    server.config(50 + WWW_ASSETS_COUNT, 12288);
     server.listen(80);
 
     server.on("/api/system/reset", HTTP_POST,
@@ -56,21 +58,21 @@ void setupServer() {
     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);
+              [](httpd_req_t *request) { return CameraSettingsEndpoint::getSettings(request); });
+    server.on("/api/camera/settings", HTTP_POST, [](httpd_req_t *request, api_Request *protoReq) {
+        return CameraSettingsEndpoint::updateSettings(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);
+              [](httpd_req_t *request) { return ServoSettingsEndpoint::getSettings(request); });
+    server.on("/api/servo/config", HTTP_POST, [](httpd_req_t *request, api_Request *protoReq) {
+        return ServoSettingsEndpoint::updateSettings(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);
+              [](httpd_req_t *request) { return WiFiSettingsEndpoint::getSettings(request); });
+    server.on("/api/wifi/sta/settings", HTTP_POST, [](httpd_req_t *request, api_Request *protoReq) {
+        return WiFiSettingsEndpoint::updateSettings(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); });
@@ -79,22 +81,22 @@ void setupServer() {
 
     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);
+              [](httpd_req_t *request) { return APSettingsEndpoint::getSettings(request); });
+    server.on("/api/ap/settings", HTTP_POST, [](httpd_req_t *request, api_Request *protoReq) {
+        return APSettingsEndpoint::updateSettings(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);
+              [](httpd_req_t *request) { return PeripheralSettingsEndpoint::getSettings(request); });
+    server.on("/api/peripherals/settings", HTTP_POST, [](httpd_req_t *request, api_Request *protoReq) {
+        return PeripheralSettingsEndpoint::updateSettings(request, protoReq);
     });
 
 #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);
+              [](httpd_req_t *request) { return MDNSSettingsEndpoint::getSettings(request); });
+    server.on("/api/mdns/settings", HTTP_POST, [](httpd_req_t *request, api_Request *protoReq) {
+        return MDNSSettingsEndpoint::updateSettings(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) {
@@ -276,6 +278,10 @@ void IRAM_ATTR SpotControlLoopEntry(void *) {
 void IRAM_ATTR serviceLoopEntry(void *) {
     ESP_LOGI("main", "Service task starting");
 
+    static EventStorageManager storageManager;
+    storageManager.initialize();
+    ESP_LOGI("main", "Event storage initialized, settings loaded and published");
+
     WiFi.init();
     wifiService.begin();
     mdns_init();

esp32/src/mdns_service.cpp

@@ -2,16 +2,7 @@
 #include <communication/webserver.h>
 #include <esp_netif.h>
 
-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) {
@@ -20,10 +11,32 @@ MDNSService::~MDNSService() {
 }
 
 void MDNSService::begin() {
-    _persistence.readFromFS();
+    _settingsHandle = EventBus::subscribe<api_MDNSSettings>(
+        [this](const api_MDNSSettings &settings) { onSettingsChanged(settings); });
+
+    api_MDNSSettings initialSettings;
+    if (EventBus::peek(initialSettings)) {
+        onSettingsChanged(initialSettings);
+    }
     startMDNS();
 }
 
+void MDNSService::onSettingsChanged(const api_MDNSSettings &newSettings) {
+    strncpy(_settings.hostname, newSettings.hostname, sizeof(_settings.hostname) - 1);
+    _settings.hostname[sizeof(_settings.hostname) - 1] = '\0';
+    strncpy(_settings.instance, newSettings.instance, sizeof(_settings.instance) - 1);
+    _settings.instance[sizeof(_settings.instance) - 1] = '\0';
+    _settings.services_count = newSettings.services_count;
+    for (size_t i = 0; i < newSettings.services_count; i++) {
+        _settings.services[i] = newSettings.services[i];
+    }
+    _settings.global_txt_records_count = newSettings.global_txt_records_count;
+    for (size_t i = 0; i < newSettings.global_txt_records_count; i++) {
+        _settings.global_txt_records[i] = newSettings.global_txt_records[i];
+    }
+    reconfigureMDNS();
+}
+
 void MDNSService::reconfigureMDNS() {
     if (_started) {
         stopMDNS();
@@ -32,7 +45,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 +54,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 +62,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 +70,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 +80,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 +94,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 +109,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);
@@ -163,3 +176,24 @@ esp_err_t MDNSService::queryServices(httpd_req_t *request, api_Request *protoReq
 
     return WebServer::send(request, 200, response, api_Response_fields);
 }
+
+esp_err_t MDNSService::getSettings(httpd_req_t *request) {
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_mdns_settings_tag;
+    response.payload.mdns_settings = _settings;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}
+
+esp_err_t MDNSService::updateSettings(httpd_req_t *request, api_Request *protoReq) {
+    if (protoReq->which_payload != api_Request_mdns_settings_tag) {
+        return ESP_FAIL;
+    }
+
+    EventBus::publish(protoReq->payload.mdns_settings, "HTTPEndpoint");
+
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_empty_message_tag;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}

esp32/src/peripherals/camera_service.cpp

@@ -4,8 +4,6 @@
 
 namespace Camera {
 
-static const char *const TAG = "CameraService";
-
 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";
@@ -31,18 +29,16 @@ 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();
+    _settingsHandle = EventBus::subscribe<api_CameraSettings>(
+        [this](const api_CameraSettings &settings) { onSettingsChanged(settings); });
+
+    api_CameraSettings initialSettings;
+    if (EventBus::peek(initialSettings)) {
+        onSettingsChanged(initialSettings);
+    }
     camera_config_t camera_config;
     camera_config.ledc_channel = LEDC_CHANNEL_0;
     camera_config.ledc_timer = LEDC_TIMER_0;
@@ -146,39 +142,65 @@ esp_err_t CameraService::cameraStream(httpd_req_t *request) {
     return ESP_OK;
 }
 
+void CameraService::onSettingsChanged(const api_CameraSettings &newSettings) {
+    _settings = newSettings;
+    updateCamera();
+}
+
 void CameraService::updateCamera() {
-    ESP_LOGI("CameraSettings", "Updating camera settings");
+    ESP_LOGI(TAG, "Updating camera settings");
     sensor_t *s = safe_sensor_get();
     if (!s) {
-        ESP_LOGE("CameraSettings", "Failed to update camera settings");
+        ESP_LOGE(TAG, "Failed to update camera settings");
         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();
 }
 
+esp_err_t CameraService::getSettings(httpd_req_t *request) {
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_camera_settings_tag;
+    response.payload.camera_settings = _settings;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}
+
+esp_err_t CameraService::updateSettings(httpd_req_t *request, api_Request *protoReq) {
+    if (protoReq->which_payload != api_Request_camera_settings_tag) {
+        return ESP_FAIL;
+    }
+
+    EventBus::publish(protoReq->payload.camera_settings, "HTTPEndpoint");
+
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_empty_message_tag;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}
+
 } // namespace Camera

esp32/src/peripherals/peripherals.cpp

@@ -1,18 +1,16 @@
 #include <peripherals/peripherals.h>
+#include <communication/webserver.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();
+    _settingsHandle = EventBus::subscribe<api_PeripheralSettings>(
+        [this](const api_PeripheralSettings &settings) { onSettingsChanged(settings); });
+
+    api_PeripheralSettings initialSettings;
+    if (EventBus::peek(initialSettings)) {
+        onSettingsChanged(initialSettings);
+    }
 
     updatePins();
 
@@ -42,14 +40,21 @@ void Peripherals::update() {
     EXECUTE_EVERY_N_MS(500, { readSonar(); });
 }
 
+void Peripherals::onSettingsChanged(const api_PeripheralSettings &newSettings) {
+    _settings.sda = newSettings.sda;
+    _settings.scl = newSettings.scl;
+    _settings.frequency = newSettings.frequency;
+    updatePins();
+}
+
 void Peripherals::updatePins() {
     if (i2c_active) {
         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,12 +97,33 @@ 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;
 }
 
+esp_err_t Peripherals::getSettings(httpd_req_t *request) {
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_peripheral_settings_tag;
+    response.payload.peripheral_settings = _settings;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}
+
+esp_err_t Peripherals::updateSettings(httpd_req_t *request, api_Request *protoReq) {
+    if (protoReq->which_payload != api_Request_peripheral_settings_tag) {
+        return ESP_FAIL;
+    }
+
+    EventBus::publish(protoReq->payload.peripheral_settings, "HTTPEndpoint");
+
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_empty_message_tag;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}
+
 /* IMU FUNCTIONS */
 bool Peripherals::readImu() {
     bool updated = false;

esp32/src/peripherals/servo_controller.cpp

@@ -0,0 +1,23 @@
+#include <peripherals/servo_controller.h>
+#include <communication/webserver.h>
+
+esp_err_t ServoController::getSettings(httpd_req_t *request) {
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_servo_settings_tag;
+    response.payload.servo_settings = _settings;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}
+
+esp_err_t ServoController::updateSettings(httpd_req_t *request, api_Request *protoReq) {
+    if (protoReq->which_payload != api_Request_servo_settings_tag) {
+        return ESP_FAIL;
+    }
+
+    EventBus::publish(protoReq->payload.servo_settings, "HTTPEndpoint");
+
+    api_Response response = api_Response_init_zero;
+    response.status_code = 200;
+    response.which_payload = api_Response_empty_message_tag;
+    return WebServer::send(request, 200, response, api_Response_fields);
+}

esp32/src/wifi_service.cpp

@@ -1,18 +1,7 @@
 #include <wifi_service.h>
 #include <communication/webserver.h>
 
-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);
-}
+WiFiService::WiFiService() : _initialized(false), _lastConnectionAttempt(0), _stopping(false) {}
 
 WiFiService::~WiFiService() {}
 
@@ -25,15 +14,41 @@ 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();
-    _lastConnectionAttempt = 0;
+    _settingsHandle = EventBus::subscribe<api_WifiSettings>(
+        [this](const api_WifiSettings &settings) { onSettingsChanged(settings); });
 
-    if (state().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]);
+    api_WifiSettings initialSettings;
+    if (EventBus::peek(initialSettings)) {
+        ESP_LOGI(TAG, "Applying initial WiFi settings from storage");
+        onSettingsChanged(initialSettings);
+    } else {
+        ESP_LOGW(TAG, "No WiFi settings found, using defaults");
+    }
+}
+
+void WiFiService::onSettingsChanged(const api_WifiSettings &newSettings) {
+    api_WifiSettings oldSettings = getSettings();
+
+    bool needsReconnect = _initialized && (strcmp(oldSettings.hostname, newSettings.hostname) != 0 ||
+                                           oldSettings.selected_network != newSettings.selected_network ||
+                                           oldSettings.wifi_networks_count != newSettings.wifi_networks_count);
+
+    if (!_initialized) {
+        _initialized = true;
+        _lastConnectionAttempt = 0;
+
+        ESP_LOGI(TAG, "Initializing WiFi with loaded settings");
+
+        if (newSettings.wifi_networks_count >= 1) {
+            WiFi.mode(WIFI_MODE_STA);
+            vTaskDelay(100 / portTICK_PERIOD_MS);
+            uint32_t idx = newSettings.selected_network;
+            if (idx >= newSettings.wifi_networks_count) idx = 0;
+            configureNetwork(newSettings.wifi_networks[idx]);
+        }
+    } else if (needsReconnect) {
+        ESP_LOGI(TAG, "Settings changed, reconnecting");
+        reconfigureWiFiConnection();
     }
 }
 
@@ -43,12 +58,12 @@ 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();
+    api_WifiSettings settings = getSettings();
+    if (index >= settings.wifi_networks_count) return;
+
+    settings.selected_network = index;
+    EventBus::publish(settings, "WiFiService");
+
     reconfigureWiFiConnection();
 }
 
@@ -99,7 +114,8 @@ esp_err_t WiFiService::getNetworks(httpd_req_t *request) {
 
 void WiFiService::setupMDNS(const char *hostname) {
     mdns_init();
-    mdns_hostname_set(state().hostname);
+    api_WifiSettings settings = getSettings();
+    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 +154,8 @@ esp_err_t WiFiService::getNetworkStatus(httpd_req_t *request) {
 }
 
 void WiFiService::manageSTA() {
-    if (WiFi.isConnected() || state().wifi_networks_count == 0) return;
+    api_WifiSettings settings = getSettings();
+    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,23 +170,24 @@ 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]);
     }
 }
 
-void WiFiService::configureNetwork(WiFiNetwork &network) {
+void WiFiService::configureNetwork(const WiFiNetwork &network) {
     if (network.static_ip_config) {
         WiFi.config(IPAddress(network.local_ip), IPAddress(network.gateway_ip), IPAddress(network.subnet_mask),
                     IPAddress(network.dns_ip_1), IPAddress(network.dns_ip_2));
     } else {
         WiFi.config(IPAddress(0, 0, 0, 0), IPAddress(0, 0, 0, 0), IPAddress(0, 0, 0, 0));
     }
-    WiFi.setHostname(state().hostname);
+    api_WifiSettings settings = getSettings();
+    WiFi.setHostname(settings.hostname);
     WiFi.begin(network.ssid, network.password);
 
 #if CONFIG_IDF_TARGET_ESP32C3