Merge pull request 'feature/base-firmware-size-optimization' (#18) from feature/base-firmware-size-optimization into main

Reviewed-on: #18

examples/neopattern/NeoPatternService.cpp

@@ -195,13 +195,13 @@ void NeoPatternService::registerEventHandlers() {
         JsonDocument doc;
         DeserializationError err = deserializeJson(doc, *jsonStr);
         if (err) {
-            LOG_WARN("NeoPattern", String("Failed to parse CLUSTER_EVENT data: ") + err.c_str());
+            LOG_WARN("NeoPattern", String("Failed to parse cluster/event data: ") + err.c_str());
             return;
         }
         JsonObject obj = doc.as<JsonObject>();
         bool applied = applyControlParams(obj);
         if (applied) {
-            LOG_INFO("NeoPattern", "Applied control from CLUSTER_EVENT");
+            LOG_INFO("NeoPattern", "Applied control from cluster/event");
         }
     });
 

examples/pixelstream/PixelStreamService.cpp

@@ -0,0 +1,202 @@
+#include "PixelStreamService.h"
+#include "spore/util/Logging.h"
+#include <Adafruit_NeoPixel.h>
+
+PixelStreamService::PixelStreamService(NodeContext& ctx, ApiServer& apiServer, PixelStreamController* controller)
+    : ctx(ctx), apiServer(apiServer), controller(controller) {}
+
+void PixelStreamService::registerEndpoints(ApiServer& api) {
+    // Config endpoint for setting pixelstream configuration
+    api.registerEndpoint("/api/pixelstream/config", HTTP_PUT,
+        [this](AsyncWebServerRequest* request) { handleConfigRequest(request); },
+        std::vector<ParamSpec>{
+            ParamSpec{String("pin"), false, String("body"), String("number"), {}, String("")},
+            ParamSpec{String("pixel_count"), false, String("body"), String("number"), {}, String("")},
+            ParamSpec{String("brightness"), false, String("body"), String("number"), {}, String("")},
+            ParamSpec{String("matrix_width"), false, String("body"), String("number"), {}, String("")},
+            ParamSpec{String("matrix_serpentine"), false, String("body"), String("boolean"), {}, String("")},
+            ParamSpec{String("pixel_type"), false, String("body"), String("number"), {}, String("")}
+        });
+
+    // Config endpoint for getting pixelstream configuration
+    api.registerEndpoint("/api/pixelstream/config", HTTP_GET,
+        [this](AsyncWebServerRequest* request) { handleGetConfigRequest(request); },
+        std::vector<ParamSpec>{});
+}
+
+void PixelStreamService::registerTasks(TaskManager& taskManager) {
+    // PixelStreamService doesn't register any tasks itself
+}
+
+PixelStreamConfig PixelStreamService::loadConfig() {
+    // Initialize with proper defaults
+    PixelStreamConfig config;
+    config.pin = 2;
+    config.pixelCount = 16;
+    config.brightness = 80;
+    config.matrixWidth = 16;
+    config.matrixSerpentine = false;
+    config.pixelType = NEO_GRB + NEO_KHZ800;
+    
+    if (!LittleFS.begin()) {
+        LOG_WARN("PixelStream", "Failed to initialize LittleFS, using defaults");
+        return config;
+    }
+    
+    if (!LittleFS.exists(CONFIG_FILE())) {
+        LOG_INFO("PixelStream", "No pixelstream config file found, using defaults");
+        // Save defaults
+        saveConfig(config);
+        return config;
+    }
+    
+    File file = LittleFS.open(CONFIG_FILE(), "r");
+    if (!file) {
+        LOG_ERROR("PixelStream", "Failed to open config file for reading");
+        return config;
+    }
+    
+    JsonDocument doc;
+    DeserializationError error = deserializeJson(doc, file);
+    file.close();
+    
+    if (error) {
+        LOG_ERROR("PixelStream", "Failed to parse config file: " + String(error.c_str()));
+        return config;
+    }
+    
+    if (doc["pin"].is<uint8_t>()) config.pin = doc["pin"].as<uint8_t>();
+    if (doc["pixel_count"].is<uint16_t>()) config.pixelCount = doc["pixel_count"].as<uint16_t>();
+    if (doc["brightness"].is<uint8_t>()) config.brightness = doc["brightness"].as<uint8_t>();
+    if (doc["matrix_width"].is<uint16_t>()) config.matrixWidth = doc["matrix_width"].as<uint16_t>();
+    if (doc["matrix_serpentine"].is<bool>()) config.matrixSerpentine = doc["matrix_serpentine"].as<bool>();
+    if (doc["pixel_type"].is<uint8_t>()) config.pixelType = static_cast<neoPixelType>(doc["pixel_type"].as<uint8_t>());
+    
+    LOG_INFO("PixelStream", "Configuration loaded from " + String(CONFIG_FILE()));
+    return config;
+}
+
+bool PixelStreamService::saveConfig(const PixelStreamConfig& config) {
+    if (!LittleFS.begin()) {
+        LOG_ERROR("PixelStream", "LittleFS not initialized, cannot save config");
+        return false;
+    }
+    
+    File file = LittleFS.open(CONFIG_FILE(), "w");
+    if (!file) {
+        LOG_ERROR("PixelStream", "Failed to open config file for writing");
+        return false;
+    }
+    
+    JsonDocument doc;
+    doc["pin"] = config.pin;
+    doc["pixel_count"] = config.pixelCount;
+    doc["brightness"] = config.brightness;
+    doc["matrix_width"] = config.matrixWidth;
+    doc["matrix_serpentine"] = config.matrixSerpentine;
+    doc["pixel_type"] = static_cast<uint8_t>(config.pixelType);
+    
+    size_t bytesWritten = serializeJson(doc, file);
+    file.close();
+    
+    if (bytesWritten > 0) {
+        LOG_INFO("PixelStream", "Configuration saved to " + String(CONFIG_FILE()) + " (" + String(bytesWritten) + " bytes)");
+        return true;
+    } else {
+        LOG_ERROR("PixelStream", "Failed to write configuration to file");
+        return false;
+    }
+}
+
+void PixelStreamService::handleConfigRequest(AsyncWebServerRequest* request) {
+    // Load current config from file
+    PixelStreamConfig config = loadConfig();
+    
+    bool updated = false;
+    
+    // Handle individual form parameters
+    if (request->hasParam("pin", true)) {
+        String pinStr = request->getParam("pin", true)->value();
+        if (pinStr.length() > 0) {
+            int pinValue = pinStr.toInt();
+            if (pinValue >= 0 && pinValue <= 255) {
+                config.pin = static_cast<uint8_t>(pinValue);
+                updated = true;
+            }
+        }
+    }
+    if (request->hasParam("pixel_count", true)) {
+        String countStr = request->getParam("pixel_count", true)->value();
+        if (countStr.length() > 0) {
+            int countValue = countStr.toInt();
+            if (countValue > 0 && countValue <= 65535) {
+                config.pixelCount = static_cast<uint16_t>(countValue);
+                updated = true;
+            }
+        }
+    }
+    if (request->hasParam("brightness", true)) {
+        String brightnessStr = request->getParam("brightness", true)->value();
+        if (brightnessStr.length() > 0) {
+            int brightnessValue = brightnessStr.toInt();
+            if (brightnessValue >= 0 && brightnessValue <= 255) {
+                config.brightness = static_cast<uint8_t>(brightnessValue);
+                updated = true;
+            }
+        }
+    }
+    if (request->hasParam("matrix_width", true)) {
+        String widthStr = request->getParam("matrix_width", true)->value();
+        if (widthStr.length() > 0) {
+            int widthValue = widthStr.toInt();
+            if (widthValue > 0 && widthValue <= 65535) {
+                config.matrixWidth = static_cast<uint16_t>(widthValue);
+                updated = true;
+            }
+        }
+    }
+    if (request->hasParam("matrix_serpentine", true)) {
+        String serpentineStr = request->getParam("matrix_serpentine", true)->value();
+        config.matrixSerpentine = (serpentineStr.equalsIgnoreCase("true") || serpentineStr == "1");
+        updated = true;
+    }
+    if (request->hasParam("pixel_type", true)) {
+        String typeStr = request->getParam("pixel_type", true)->value();
+        if (typeStr.length() > 0) {
+            int typeValue = typeStr.toInt();
+            config.pixelType = static_cast<neoPixelType>(typeValue);
+            updated = true;
+        }
+    }
+    
+    if (!updated) {
+        request->send(400, "application/json", "{\"error\":\"No valid configuration fields provided\"}");
+        return;
+    }
+    
+    // Save config to file
+    if (saveConfig(config)) {
+        LOG_INFO("PixelStreamService", "Configuration updated and saved to pixelstream.json");
+        request->send(200, "application/json", "{\"status\":\"success\",\"message\":\"Configuration updated and saved\"}");
+    } else {
+        LOG_ERROR("PixelStreamService", "Failed to save configuration to file");
+        request->send(500, "application/json", "{\"error\":\"Failed to save configuration\"}");
+    }
+}
+
+void PixelStreamService::handleGetConfigRequest(AsyncWebServerRequest* request) {
+    PixelStreamConfig config = loadConfig();
+    
+    JsonDocument doc;
+    doc["pin"] = config.pin;
+    doc["pixel_count"] = config.pixelCount;
+    doc["brightness"] = config.brightness;
+    doc["matrix_width"] = config.matrixWidth;
+    doc["matrix_serpentine"] = config.matrixSerpentine;
+    doc["pixel_type"] = static_cast<uint8_t>(config.pixelType);
+    
+    String json;
+    serializeJson(doc, json);
+    request->send(200, "application/json", json);
+}
+

examples/pixelstream/PixelStreamService.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "spore/Service.h"
+#include "spore/core/NodeContext.h"
+#include "PixelStreamController.h"
+#include <ArduinoJson.h>
+#include <LittleFS.h>
+#include "spore/util/Logging.h"
+
+// PixelStreamConfig is defined in PixelStreamController.h
+
+class PixelStreamService : public Service {
+public:
+    PixelStreamService(NodeContext& ctx, ApiServer& apiServer, PixelStreamController* controller);
+    void registerEndpoints(ApiServer& api) override;
+    void registerTasks(TaskManager& taskManager) override;
+    const char* getName() const override { return "PixelStream"; }
+    
+    // Config management
+    PixelStreamConfig loadConfig();
+    bool saveConfig(const PixelStreamConfig& config);
+    void setController(PixelStreamController* ctrl) { controller = ctrl; }
+
+private:
+    NodeContext& ctx;
+    ApiServer& apiServer;
+    PixelStreamController* controller;
+    
+    void handleConfigRequest(AsyncWebServerRequest* request);
+    void handleGetConfigRequest(AsyncWebServerRequest* request);
+    
+    static const char* CONFIG_FILE() { return "/pixelstream.json"; }
+};
+

examples/pixelstream/main.cpp

@@ -2,7 +2,11 @@
 #include "spore/Spore.h"
 #include "spore/util/Logging.h"
 #include "PixelStreamController.h"
+#include "PixelStreamService.h"
+#include <Adafruit_NeoPixel.h>
 
+// Defaults are now loaded from config.json on LittleFS
+// Can still be overridden with preprocessor defines if needed
 #ifndef PIXEL_PIN
 #define PIXEL_PIN 2
 #endif
@@ -34,22 +38,28 @@ Spore spore({
 });
 
 PixelStreamController* controller = nullptr;
+PixelStreamService* service = nullptr;
 
 void setup() {
     spore.setup();
 
-    PixelStreamConfig config{
-        static_cast<uint8_t>(PIXEL_PIN),
-        static_cast<uint16_t>(PIXEL_COUNT),
-        static_cast<uint8_t>(PIXEL_BRIGHTNESS),
-        static_cast<uint16_t>(PIXEL_MATRIX_WIDTH),
-        static_cast<bool>(PIXEL_MATRIX_SERPENTINE),
-        static_cast<neoPixelType>(PIXEL_TYPE)
-    };
+    // Create service first (need it to load config)
+    service = new PixelStreamService(spore.getContext(), spore.getApiServer(), nullptr);
     
+    // Load pixelstream config from LittleFS (pixelstream.json) or use defaults
+    PixelStreamConfig config = service->loadConfig();
+    
+    // Create controller with loaded config
     controller = new PixelStreamController(spore.getContext(), config);
     controller->begin();
     
+    // Update service with the actual controller
+    service->setController(controller);
+    
+    // Register service
+    spore.registerService(service);
+    
+    // Start the API server
     spore.begin();
 }
 

include/spore/Spore.h

@@ -11,7 +11,6 @@
 #include "core/TaskManager.h"
 #include "Service.h"
 #include "util/Logging.h"
-#include "util/CpuUsage.h"
 
 class Spore {
 public:
@@ -35,12 +34,6 @@ public:
     ClusterManager& getCluster() { return cluster; }
     ApiServer& getApiServer() { return apiServer; }
 
-    // CPU usage monitoring
-    CpuUsage& getCpuUsage() { return cpuUsage; }
-    float getCurrentCpuUsage() const { return cpuUsage.getCpuUsage(); }
-    float getAverageCpuUsage() const { return cpuUsage.getAverageCpuUsage(); }
-
-
 private:
     void initializeCore();
     void registerCoreServices();
@@ -51,7 +44,6 @@ private:
     TaskManager taskManager;
     ClusterManager cluster;
     ApiServer apiServer;
-    CpuUsage cpuUsage;
 
     std::vector<std::shared_ptr<Service>> services;
     bool initialized;

include/spore/core/ClusterManager.h

@@ -19,7 +19,7 @@ public:
     void updateAllNodeStatuses();
     void removeDeadNodes();
     void printMemberList();
-    const std::map<String, NodeInfo>& getMemberList() const { return *ctx.memberList; }
+    size_t getMemberCount() const { return ctx.memberList->getMemberCount(); }
     void updateLocalNodeResources(NodeInfo& node);
     void heartbeatTaskCallback();
     void updateAllMembersInfoTaskCallback();

include/spore/core/Memberlist.h

@@ -0,0 +1,133 @@
+#pragma once
+
+#include <Arduino.h>
+#include <map>
+#include <string>
+#include <optional>
+#include <functional>
+#include "spore/types/NodeInfo.h"
+
+/**
+ * @brief Manages the list of cluster members.
+ *
+ * The Memberlist class maintains a collection of cluster members, where each member
+ * is identified by its IP address and associated with a NodeInfo object. It provides
+ * methods to add, update, and remove members, as well as handle node status changes
+ * (stale and dead nodes).
+ */
+class Memberlist {
+public:
+    /**
+     * @brief Default constructor.
+     */
+    Memberlist();
+
+    /**
+     * @brief Destructor.
+     */
+    ~Memberlist();
+
+    /**
+     * @brief Adds or updates a member in the list.
+     *
+     * If the member already exists, updates its information. Otherwise, adds a new member.
+     * @param ip The IP address of the member (as string).
+     * @param node The NodeInfo object containing member details.
+     * @return True if the member was added or updated, false otherwise.
+     */
+    bool addOrUpdateMember(const std::string& ip, const NodeInfo& node);
+
+    /**
+     * @brief Adds a new member to the list.
+     *
+     * @param ip The IP address of the member (as string).
+     * @param node The NodeInfo object containing member details.
+     * @return True if the member was added, false if it already exists.
+     */
+    bool addMember(const std::string& ip, const NodeInfo& node);
+
+    /**
+     * @brief Updates an existing member in the list.
+     *
+     * @param ip The IP address of the member (as string).
+     * @param node The updated NodeInfo object.
+     * @return True if the member was updated, false if it doesn't exist.
+     */
+    bool updateMember(const std::string& ip, const NodeInfo& node);
+
+    /**
+     * @brief Removes a member from the list.
+     *
+     * @param ip The IP address of the member to remove (as string).
+     * @return True if the member was removed, false if it doesn't exist.
+     */
+    bool removeMember(const std::string& ip);
+
+    /**
+     * @brief Retrieves a member by IP address.
+     *
+     * @param ip The IP address of the member (as string).
+     * @return Optional containing the NodeInfo if found, or std::nullopt if not found.
+     */
+    std::optional<NodeInfo> getMember(const std::string& ip) const;
+
+    /**
+     * @brief Iterates over all members and calls the provided callback for each.
+     *
+     * @param callback Function to call for each member. Receives (ip, node) as parameters.
+     */
+    void forEachMember(std::function<void(const std::string&, const NodeInfo&)> callback) const;
+
+    /**
+     * @brief Iterates over all members and calls the provided callback for each.
+     *
+     * @param callback Function to call for each member. Receives (ip, node) as parameters.
+     *                 If callback returns false, iteration stops.
+     * @return True if all members were processed, false if iteration was stopped early.
+     */
+    bool forEachMemberUntil(std::function<bool(const std::string&, const NodeInfo&)> callback) const;
+
+    /**
+     * @brief Gets the number of members in the list.
+     *
+     * @return The number of members.
+     */
+    size_t getMemberCount() const;
+
+    /**
+     * @brief Updates the status of all members based on current time and thresholds.
+     *
+     * Marks nodes as stale or dead based on their last seen time.
+     * @param currentTime The current time in milliseconds.
+     * @param staleThresholdMs Threshold for marking a node as stale (milliseconds).
+     * @param deadThresholdMs Threshold for marking a node as dead (milliseconds).
+     * @param onStatusChange Optional callback fired when a node's status changes.
+     */
+    void updateAllNodeStatuses(unsigned long currentTime,
+                               unsigned long staleThresholdMs,
+                               unsigned long deadThresholdMs,
+                               std::function<void(const std::string&, NodeInfo::Status, NodeInfo::Status)> onStatusChange = nullptr);
+
+    /**
+     * @brief Removes all dead members from the list.
+     *
+     * @return The number of members removed.
+     */
+    size_t removeDeadMembers();
+
+    /**
+     * @brief Checks if a member exists in the list.
+     *
+     * @param ip The IP address of the member (as string).
+     * @return True if the member exists, false otherwise.
+     */
+    bool hasMember(const std::string& ip) const;
+
+    /**
+     * @brief Clears all members from the list.
+     */
+    void clear();
+
+private:
+    std::map<std::string, NodeInfo> m_members;  ///< Internal map holding the members.
+};

include/spore/core/NodeContext.h

@@ -2,12 +2,14 @@
 
 #include <WiFiUdp.h>
 #include <map>
-#include "spore/types/NodeInfo.h"
 #include <functional>
 #include <string>
 #include <initializer_list>
+#include <memory>
+#include "spore/types/NodeInfo.h"
 #include "spore/types/Config.h"
 #include "spore/types/ApiTypes.h"
+#include "spore/core/Memberlist.h"
 
 class NodeContext {
 public:
@@ -18,7 +20,7 @@ public:
     String hostname;
     IPAddress localIP;
     NodeInfo self;
-    std::map<String, NodeInfo>* memberList;
+    std::unique_ptr<Memberlist> memberList;
     ::Config config;
     std::map<String, String> constructorLabels;  // Labels passed to constructor (not persisted)
 

include/spore/internal/Globals.h

@@ -5,10 +5,9 @@
 
 // Cluster protocol and API constants
 namespace ClusterProtocol {
-    // Simplified heartbeat-only protocol
-    constexpr const char* HEARTBEAT_MSG = "CLUSTER_HEARTBEAT";
-    constexpr const char* NODE_UPDATE_MSG = "NODE_UPDATE";
-    constexpr const char* CLUSTER_EVENT_MSG = "CLUSTER_EVENT";
+    constexpr const char* HEARTBEAT_MSG = "cluster/heartbeat";
+    constexpr const char* NODE_UPDATE_MSG = "node/update";
+    constexpr const char* CLUSTER_EVENT_MSG = "cluster/event";
     constexpr const char* RAW_MSG = "RAW";
     constexpr uint16_t UDP_PORT = 4210;
     // Increased buffer to accommodate larger RAW pixel streams and node info JSON over UDP

include/spore/services/MonitoringService.h

@@ -1,11 +1,10 @@
 #pragma once
 #include "spore/Service.h"
-#include "spore/util/CpuUsage.h"
 #include <functional>
 
 class MonitoringService : public Service {
 public:
-    MonitoringService(CpuUsage& cpuUsage);
+    MonitoringService();
     void registerEndpoints(ApiServer& api) override;
     void registerTasks(TaskManager& taskManager) override;
     const char* getName() const override { return "Monitoring"; }
@@ -41,6 +40,4 @@ private:
     
     // Helper methods
     void getFilesystemInfo(size_t& totalBytes, size_t& usedBytes) const;
-
-    CpuUsage& cpuUsage;
 };

include/spore/util/CpuUsage.h

@@ -1,118 +0,0 @@
-#pragma once
-
-#include <Arduino.h>
-
-/**
- * @brief CPU usage measurement utility for ESP32/ESP8266
- * 
- * This class provides methods to measure CPU usage by tracking idle time
- * and calculating the percentage of time the CPU is busy vs idle.
- */
-class CpuUsage {
-public:
-    /**
-     * @brief Construct a new CpuUsage object
-     */
-    CpuUsage();
-    
-    /**
-     * @brief Destructor
-     */
-    ~CpuUsage() = default;
-    
-    /**
-     * @brief Initialize the CPU usage measurement
-     * Call this once during setup
-     */
-    void begin();
-    
-    /**
-     * @brief Start measuring CPU usage for the current cycle
-     * Call this at the beginning of your main loop
-     */
-    void startMeasurement();
-    
-    /**
-     * @brief End measuring CPU usage for the current cycle
-     * Call this at the end of your main loop
-     */
-    void endMeasurement();
-    
-    /**
-     * @brief Get the current CPU usage percentage
-     * @return float CPU usage percentage (0.0 to 100.0)
-     */
-    float getCpuUsage() const;
-    
-    /**
-     * @brief Get the average CPU usage over the measurement window
-     * @return float Average CPU usage percentage (0.0 to 100.0)
-     */
-    float getAverageCpuUsage() const;
-    
-    /**
-     * @brief Get the maximum CPU usage recorded
-     * @return float Maximum CPU usage percentage (0.0 to 100.0)
-     */
-    float getMaxCpuUsage() const;
-    
-    /**
-     * @brief Get the minimum CPU usage recorded
-     * @return float Minimum CPU usage percentage (0.0 to 100.0)
-     */
-    float getMinCpuUsage() const;
-    
-    /**
-     * @brief Reset all CPU usage statistics
-     */
-    void reset();
-    
-    /**
-     * @brief Check if measurement is currently active
-     * @return true if measurement is active, false otherwise
-     */
-    bool isMeasuring() const;
-    
-    /**
-     * @brief Get the number of measurements taken
-     * @return unsigned long Number of measurements
-     */
-    unsigned long getMeasurementCount() const;
-
-private:
-    // Measurement state
-    bool _initialized;
-    bool _measuring;
-    unsigned long _measurementCount;
-    
-    // Timing variables
-    unsigned long _cycleStartTime;
-    unsigned long _idleStartTime;
-    unsigned long _totalIdleTime;
-    unsigned long _totalCycleTime;
-    
-    // Statistics
-    float _currentCpuUsage;
-    float _averageCpuUsage;
-    float _maxCpuUsage;
-    float _minCpuUsage;
-    unsigned long _totalCpuTime;
-    
-    // Rolling average window
-    static constexpr size_t ROLLING_WINDOW_SIZE = 10;
-    float _rollingWindow[ROLLING_WINDOW_SIZE];
-    size_t _rollingIndex;
-    bool _rollingWindowFull;
-    
-    /**
-     * @brief Update rolling average calculation
-     * @param value New value to add to rolling average
-     */
-    void updateRollingAverage(float value);
-    
-    /**
-     * @brief Update min/max statistics
-     * @param value New value to check against min/max
-     */
-    void updateMinMax(float value);
-};

platformio.ini

@@ -18,6 +18,15 @@ monitor_speed = 115200
 lib_deps = 
     esp32async/ESPAsyncWebServer@^3.8.0
     bblanchon/ArduinoJson@^7.4.2
+build_flags = 
+    -Os                          ; Optimize for size
+    -ffunction-sections          ; Place each function in its own section
+    -fdata-sections              ; Place data in separate sections
+    -Wl,--gc-sections            ; Remove unused sections at link time
+    -DNDEBUG                     ; Disable debug assertions
+    -DVTABLES_IN_FLASH           ; Move virtual tables to flash
+    -fno-exceptions              ; Disable C++ exceptions
+    -fno-rtti                    ; Disable runtime type information
 
 [env:base]
 platform = platformio/espressif8266@^4.2.1
@@ -31,6 +40,7 @@ board_build.filesystem = littlefs
 ; note: somehow partition table is not working, so we need to use the ldscript
 board_build.ldscript = eagle.flash.1m64.ld ; 64KB -> FS Size
 lib_deps = ${common.lib_deps}
+build_flags = ${common.build_flags}
 build_src_filter = 
     +<examples/base/*.cpp>
     +<src/spore/*.cpp>
@@ -51,6 +61,7 @@ board_build.flash_mode = dio           ; D1 Mini uses DIO on 4 Mbit flash
 board_build.flash_size = 4M
 board_build.ldscript = eagle.flash.4m1m.ld
 lib_deps = ${common.lib_deps}
+build_flags = ${common.build_flags}
 build_src_filter = 
     +<examples/base/*.cpp>
     +<src/spore/*.cpp>
@@ -71,6 +82,7 @@ board_build.flash_mode = dout
 board_build.ldscript = eagle.flash.1m64.ld
 lib_deps = ${common.lib_deps}
 ;data_dir = examples/relay/data
+build_flags = ${common.build_flags}
 build_src_filter = 
     +<examples/relay/*.cpp>
     +<src/spore/*.cpp>
@@ -91,7 +103,7 @@ board_build.flash_mode = dout
 board_build.ldscript = eagle.flash.1m64.ld
 lib_deps = ${common.lib_deps}
     adafruit/Adafruit NeoPixel@^1.15.1
-build_flags = -DLED_STRIP_PIN=2
+build_flags = -DLED_STRIP_PIN=2 ;${common.build_flags}
 build_src_filter = 
     +<examples/neopattern/*.cpp>
     +<src/spore/*.cpp>
@@ -112,7 +124,7 @@ board_build.flash_mode = dout
 board_build.ldscript = eagle.flash.1m64.ld
 lib_deps = ${common.lib_deps}
     adafruit/Adafruit NeoPixel@^1.15.1
-build_flags =
+build_flags = ${common.build_flags}
 build_src_filter = 
     +<examples/pixelstream/*.cpp>
     +<src/spore/*.cpp>
@@ -133,7 +145,7 @@ board_build.flash_mode = dout
 board_build.ldscript = eagle.flash.4m1m.ld
 lib_deps = ${common.lib_deps}
     adafruit/Adafruit NeoPixel@^1.15.1
-build_flags = -DPIXEL_PIN=TX -DPIXEL_COUNT=256 -DMATRIX_WIDTH=16
+build_flags = -DPIXEL_PIN=TX -DPIXEL_COUNT=256 -DMATRIX_WIDTH=16 ${common.build_flags}
 build_src_filter = 
     +<examples/pixelstream/*.cpp>
     +<src/spore/*.cpp>
@@ -156,6 +168,7 @@ board_build.ldscript = eagle.flash.4m1m.ld
 lib_deps = ${common.lib_deps}
     adafruit/Adafruit NeoPixel@^1.15.1
     dfrobot/DFRobotDFPlayerMini@^1.0.6
+build_flags = ${common.build_flags}
 build_src_filter = 
     +<examples/multimatrix/*.cpp>
     +<examples/pixelstream/PixelStreamController.cpp>

src/spore/Spore.cpp

@@ -9,7 +9,7 @@
 
 Spore::Spore() : ctx(), network(ctx), taskManager(ctx), cluster(ctx, taskManager), 
                  apiServer(ctx, taskManager, ctx.config.api_server_port), 
-                 cpuUsage(), initialized(false), apiServerStarted(false) {
+                 initialized(false), apiServerStarted(false) {
     
     // Rebuild labels from constructor + config labels
     ctx.rebuildLabels();
@@ -18,7 +18,7 @@ Spore::Spore() : ctx(), network(ctx), taskManager(ctx), cluster(ctx, taskManager
 Spore::Spore(std::initializer_list<std::pair<String, String>> initialLabels) 
     : ctx(initialLabels), network(ctx), taskManager(ctx), cluster(ctx, taskManager),
       apiServer(ctx, taskManager, ctx.config.api_server_port),
-      cpuUsage(), initialized(false), apiServerStarted(false) {
+      initialized(false), apiServerStarted(false) {
     
     // Rebuild labels from constructor + config labels (config takes precedence)
     ctx.rebuildLabels();
@@ -40,9 +40,6 @@ void Spore::setup() {
     // Initialize core components
     initializeCore();
     
-    // Initialize CPU usage monitoring
-    cpuUsage.begin();
-    
     // Register core services
     registerCoreServices();
     
@@ -78,15 +75,9 @@ void Spore::loop() {
         return;
     }
 
-    // Start CPU usage measurement
-    cpuUsage.startMeasurement();
-    
     // Execute main tasks
     taskManager.execute();
     
-    // End CPU usage measurement before yield
-    cpuUsage.endMeasurement();
-    
     // Yield to allow other tasks to run
     yield();
 }
@@ -141,7 +132,7 @@ void Spore::registerCoreServices() {
     auto clusterService = std::make_shared<ClusterService>(ctx);
     auto taskService = std::make_shared<TaskService>(taskManager);
     auto staticFileService = std::make_shared<StaticFileService>(ctx, apiServer);
-    auto monitoringService = std::make_shared<MonitoringService>(cpuUsage);
+    auto monitoringService = std::make_shared<MonitoringService>();
     
     // Add to services list
     services.push_back(nodeService);

src/spore/core/ApiServer.cpp

@@ -23,11 +23,12 @@ void ApiServer::registerEndpoint(const String& uri, int method,
     endpoints.push_back(EndpointInfo{uri, method, params, serviceName, true});
     
     // Update cluster if needed
-    if (ctx.memberList && !ctx.memberList->empty()) {
-        auto it = ctx.memberList->find(ctx.hostname);
-        if (it != ctx.memberList->end()) {
-            it->second.endpoints.push_back(EndpointInfo{uri, method, params, serviceName, true});
-        }
+    String localIPStr = ctx.localIP.toString();
+    auto member = ctx.memberList->getMember(localIPStr.c_str());
+    if (member) {
+        NodeInfo updatedNode = *member;
+        updatedNode.endpoints.push_back(EndpointInfo{uri, method, params, serviceName, true});
+        ctx.memberList->updateMember(localIPStr.c_str(), updatedNode);
     }
 }
 

src/spore/core/ClusterManager.cpp

@@ -1,14 +1,15 @@
 #include "spore/core/ClusterManager.h"
 #include "spore/internal/Globals.h"
 #include "spore/util/Logging.h"
+#include "spore/types/NodeInfo.h"
 
 ClusterManager::ClusterManager(NodeContext& ctx, TaskManager& taskMgr) : ctx(ctx), taskManager(taskMgr) {
-    // Register callback for node/discovered event
+    // Register callback for node/discovered event - this fires when network is ready
     ctx.on("node/discovered", [this](void* data) {
         NodeInfo* node = static_cast<NodeInfo*>(data);
         this->addOrUpdateNode(node->hostname, node->ip);
     });
-    // Centralized broadcast handler: services fire 'cluster/broadcast' with CLUSTER_EVENT JSON payload
+    // Centralized broadcast handler: services fire 'cluster/broadcast' with cluster/event JSON payload
     ctx.on("cluster/broadcast", [this](void* data) {
         String* jsonStr = static_cast<String*>(data);
         if (!jsonStr) {
@@ -19,7 +20,7 @@ ClusterManager::ClusterManager(NodeContext& ctx, TaskManager& taskMgr) : ctx(ctx
         IPAddress ip = WiFi.localIP();
         IPAddress mask = WiFi.subnetMask();
         IPAddress bcast(ip[0] | ~mask[0], ip[1] | ~mask[1], ip[2] | ~mask[2], ip[3] | ~mask[3]);
-        LOG_DEBUG("Cluster", String("Broadcasting CLUSTER_EVENT to ") + bcast.toString() + " len=" + String(jsonStr->length()));
+        LOG_DEBUG("Cluster", String("Broadcasting cluster/event to ") + bcast.toString() + " len=" + String(jsonStr->length()));
         this->ctx.udp->beginPacket(bcast, this->ctx.config.udp_port);
         String msg = String(ClusterProtocol::CLUSTER_EVENT_MSG) + ":" + *jsonStr;
         this->ctx.udp->write(msg.c_str());
@@ -119,7 +120,7 @@ bool ClusterManager::isRawMsg(const char* msg) {
 // Discovery functionality removed - using heartbeat-only approach
 
 void ClusterManager::onHeartbeat(const char* msg) {
-    // Extract hostname from heartbeat message: "CLUSTER_HEARTBEAT:hostname"
+    // Extract hostname from heartbeat message: "cluster/heartbeat:hostname"
     const char* colon = strchr(msg, ':');
     if (!colon) {
         LOG_WARN("Cluster", "Invalid heartbeat message format");
@@ -137,7 +138,7 @@ void ClusterManager::onHeartbeat(const char* msg) {
 }
 
 void ClusterManager::onNodeUpdate(const char* msg) {
-    // Message format: "NODE_UPDATE:hostname:{json}"
+    // Message format: "node/update:hostname:{json}"
     const char* firstColon = strchr(msg, ':');
     if (!firstColon) {
         LOG_WARN("Cluster", "Invalid NODE_UPDATE message format");
@@ -165,92 +166,93 @@ void ClusterManager::onNodeUpdate(const char* msg) {
     // but is sent FROM the responding node (ctx.udp->remoteIP())
     // We need to find the responding node in the memberlist, not the target node
     IPAddress respondingNodeIP = ctx.udp->remoteIP();
-    auto& memberList = *ctx.memberList;
+    String respondingIPStr = respondingNodeIP.toString();
 
     // Find the responding node by IP address
-    NodeInfo* respondingNode = nullptr;
-    for (auto& pair : memberList) {
-        if (pair.second.ip == respondingNodeIP) {
-            respondingNode = &pair.second;
-            break;
-        }
-    }
-
-    if (respondingNode) {
-        // Calculate latency only if we recently sent a heartbeat (within last 1 second)
-        unsigned long latency = 0;
-        unsigned long now = millis();
-        if (lastHeartbeatSentAt != 0 && (now - lastHeartbeatSentAt) < 1000) { // 1 second window
-            latency = now - lastHeartbeatSentAt;
-            lastHeartbeatSentAt = 0; // Reset for next calculation
-        }
-
-        // Update the responding node's information
-        bool hostnameChanged = false;
-        if (doc["hostname"].is<const char*>()) {
-            String newHostname = doc["hostname"].as<const char*>();
-            if (respondingNode->hostname != newHostname) {
-                respondingNode->hostname = newHostname;
-                hostnameChanged = true;
-            }
-        }
-
-        if (doc["uptime"].is<unsigned long>()) {
-            respondingNode->uptime = doc["uptime"];
-        }
-
-        // Update labels if provided
-        bool labelsChanged = false;
-        if (doc["labels"].is<JsonObject>()) {
-            // Check if labels actually changed
-            JsonObject labelsObj = doc["labels"].as<JsonObject>();
-            std::map<String, String> newLabels;
-            for (JsonPair kvp : labelsObj) {
-                const char* key = kvp.key().c_str();
-                const char* value = labelsObj[kvp.key()];
-                newLabels[key] = String(value);
-            }
-
-            // Compare with existing labels
-            if (newLabels != respondingNode->labels) {
-                labelsChanged = true;
-                respondingNode->labels = newLabels;
-            }
-        }
-
-        respondingNode->lastSeen = now;
-        respondingNode->status = NodeInfo::ACTIVE;
-
-        // Update latency if we calculated it (preserve existing value if not)
-        if (latency > 0) {
-            respondingNode->latency = latency;
-        }
-
-        // Check if any fields changed that require broadcasting
-        bool nodeInfoChanged = hostnameChanged || labelsChanged;
-
-        if (nodeInfoChanged) {
-            // Fire cluster/node/update event to trigger broadcast
-            ctx.fire("cluster/node/update", nullptr);
-        }
-
-        LOG_DEBUG("Cluster", String("Updated responding node ") + respondingNode->hostname + " @ " + respondingNodeIP.toString() +
-                 " | hostname: " + (hostnameChanged ? "changed" : "unchanged") +
-                 " | labels: " + (labelsChanged ? "changed" : "unchanged") +
-                 " | latency: " + (latency > 0 ? String(latency) + "ms" : "not calculated"));
-    } else {
+    auto respondingMember = ctx.memberList->getMember(respondingIPStr.c_str());
+    if (!respondingMember) {
         LOG_WARN("Cluster", String("Received NODE_UPDATE from unknown node: ") + respondingNodeIP.toString());
+        return;
     }
+
+    // Calculate latency only if we recently sent a heartbeat (within last 1 second)
+    unsigned long latency = 0;
+    unsigned long now = millis();
+    if (lastHeartbeatSentAt != 0 && (now - lastHeartbeatSentAt) < 1000) { // 1 second window
+        latency = now - lastHeartbeatSentAt;
+        lastHeartbeatSentAt = 0; // Reset for next calculation
+    }
+
+    // Create updated node info
+    NodeInfo updatedNode = *respondingMember;
+    bool hostnameChanged = false;
+    bool labelsChanged = false;
+
+    // Update hostname if provided
+    if (doc["hostname"].is<const char*>()) {
+        String newHostname = doc["hostname"].as<const char*>();
+        if (updatedNode.hostname != newHostname) {
+            updatedNode.hostname = newHostname;
+            hostnameChanged = true;
+        }
+    }
+
+    // Update uptime if provided
+    if (doc["uptime"].is<unsigned long>()) {
+        updatedNode.uptime = doc["uptime"];
+    }
+
+    // Update labels if provided
+    if (doc["labels"].is<JsonObject>()) {
+        JsonObject labelsObj = doc["labels"].as<JsonObject>();
+        std::map<String, String> newLabels;
+        for (JsonPair kvp : labelsObj) {
+            const char* key = kvp.key().c_str();
+            const char* value = labelsObj[kvp.key()];
+            newLabels[key] = String(value);
+        }
+
+        // Compare with existing labels
+        if (newLabels != updatedNode.labels) {
+            labelsChanged = true;
+            updatedNode.labels = newLabels;
+        }
+    }
+
+    // Update timing and status
+    updatedNode.lastSeen = now;
+    updatedNode.status = NodeInfo::ACTIVE;
+
+    // Update latency if we calculated it (preserve existing value if not)
+    if (latency > 0) {
+        updatedNode.latency = latency;
+    }
+
+    // Persist the updated node info to the memberlist
+    ctx.memberList->updateMember(respondingIPStr.c_str(), updatedNode);
+
+    // Check if any fields changed that require broadcasting
+    bool nodeInfoChanged = hostnameChanged || labelsChanged;
+
+    if (nodeInfoChanged) {
+        // Fire cluster/node/update event to trigger broadcast
+        ctx.fire("cluster/node/update", nullptr);
+    }
+
+    LOG_DEBUG("Cluster", String("Updated responding node ") + updatedNode.hostname + " @ " + respondingNodeIP.toString() +
+             " | hostname: " + (hostnameChanged ? "changed" : "unchanged") +
+             " | labels: " + (labelsChanged ? "changed" : "unchanged") +
+             " | latency: " + (latency > 0 ? String(latency) + "ms" : "not calculated"));
 }
 
 void ClusterManager::sendNodeInfo(const String& targetHostname, const IPAddress& targetIP) {
     JsonDocument doc;
 
     // Get our node info for the response (we're the responding node)
-    auto& memberList = *ctx.memberList;
-    auto it = memberList.find(ctx.hostname);
-    if (it != memberList.end()) {
-        const NodeInfo& node = it->second;
+    String localIPStr = ctx.localIP.toString();
+    auto member = ctx.memberList->getMember(localIPStr.c_str());
+    if (member) {
+        const NodeInfo& node = *member;
 
         // Response contains info about ourselves (the responding node)
         doc["hostname"] = node.hostname;
@@ -265,7 +267,7 @@ void ClusterManager::sendNodeInfo(const String& targetHostname, const IPAddress&
             }
         }
     } else {
-        // Fallback to basic info
+        // Fallback to basic info if not in memberlist
         doc["hostname"] = ctx.hostname;
         doc["ip"] = ctx.localIP.toString();
         doc["uptime"] = millis();
@@ -284,17 +286,17 @@ void ClusterManager::sendNodeInfo(const String& targetHostname, const IPAddress&
 }
 
 void ClusterManager::onClusterEvent(const char* msg) {
-    // Message format: CLUSTER_EVENT:{"event":"...","data":"<json string>"}
+    // Message format: cluster/event:{"event":"...","data":"<json string>"}
     const char* jsonStart = msg + strlen(ClusterProtocol::CLUSTER_EVENT_MSG) + 1; // skip prefix and ':'
     if (*jsonStart == '\0') {
-        LOG_DEBUG("Cluster", "CLUSTER_EVENT received with empty payload");
+        LOG_DEBUG("Cluster", "cluster/event received with empty payload");
         return;
     }
-    LOG_DEBUG("Cluster", String("CLUSTER_EVENT raw from ") + ctx.udp->remoteIP().toString() + " len=" + String(strlen(jsonStart)));
+    LOG_DEBUG("Cluster", String("cluster/event raw from ") + ctx.udp->remoteIP().toString() + " len=" + String(strlen(jsonStart)));
     JsonDocument doc;
     DeserializationError err = deserializeJson(doc, jsonStart);
     if (err) {
-        LOG_ERROR("Cluster", String("Failed to parse CLUSTER_EVENT JSON from ") + ctx.udp->remoteIP().toString());
+        LOG_ERROR("Cluster", String("Failed to parse cluster/event JSON from ") + ctx.udp->remoteIP().toString());
         return;
     }
     // Robust extraction of event and data
@@ -318,7 +320,7 @@ void ClusterManager::onClusterEvent(const char* msg) {
     if (eventStr.length() == 0 || data.length() == 0) {
         String dbg;
         serializeJson(doc, dbg);
-        LOG_WARN("Cluster", String("CLUSTER_EVENT missing 'event' or 'data' | payload=") + dbg);
+        LOG_WARN("Cluster", String("cluster/event missing 'event' or 'data' | payload=") + dbg);
         return;
     }
 
@@ -345,18 +347,20 @@ void ClusterManager::onRawMessage(const char* msg) {
 }
 
 void ClusterManager::addOrUpdateNode(const String& nodeHost, IPAddress nodeIP) {
-    auto& memberList = *ctx.memberList;
     bool memberlistChanged = false;
+    String ipStr = nodeIP.toString();
 
-    // O(1) lookup instead of O(n) search
-    auto it = memberList.find(nodeHost);
-    if (it != memberList.end()) {
+    // Check if member exists
+    auto existingMember = ctx.memberList->getMember(ipStr.c_str());
+    if (existingMember) {
         // Update existing node - preserve all existing field values
-        if (it->second.ip != nodeIP) {
-            it->second.ip = nodeIP;
+        NodeInfo updatedNode = *existingMember;
+        if (updatedNode.ip != nodeIP) {
+            updatedNode.ip = nodeIP;
             memberlistChanged = true;
         }
-        it->second.lastSeen = millis();
+        updatedNode.lastSeen = millis();
+        ctx.memberList->updateMember(ipStr.c_str(), updatedNode);
     } else {
         // Add new node
         NodeInfo newNode;
@@ -364,7 +368,17 @@ void ClusterManager::addOrUpdateNode(const String& nodeHost, IPAddress nodeIP) {
         newNode.ip = nodeIP;
         newNode.lastSeen = millis();
         updateNodeStatus(newNode, newNode.lastSeen, ctx.config.node_inactive_threshold_ms, ctx.config.node_dead_threshold_ms);
-        memberList[nodeHost] = newNode;
+
+        // Initialize static resources if this is the local node being added for the first time
+        if (nodeIP == ctx.localIP && nodeHost == ctx.hostname) {
+            newNode.resources.chipId = ESP.getChipId();
+            newNode.resources.sdkVersion = String(ESP.getSdkVersion());
+            newNode.resources.cpuFreqMHz = ESP.getCpuFreqMHz();
+            newNode.resources.flashChipSize = ESP.getFlashChipSize();
+            LOG_DEBUG("Cluster", "Initialized static resources for local node");
+        }
+
+        ctx.memberList->addMember(ipStr.c_str(), newNode);
         memberlistChanged = true;
         LOG_INFO("Cluster", "Added node: " + nodeHost + " @ " + newNode.ip.toString() + " | Status: " + statusToStr(newNode.status) + " | last update: 0");
     }
@@ -376,12 +390,14 @@ void ClusterManager::addOrUpdateNode(const String& nodeHost, IPAddress nodeIP) {
 }
 
 void ClusterManager::heartbeatTaskCallback() {
-    auto& memberList = *ctx.memberList;
-    auto it = memberList.find(ctx.hostname);
-    if (it != memberList.end()) {
-        NodeInfo& node = it->second;
+    // Update local node resources and lastSeen since we're actively sending heartbeats
+    String localIPStr = ctx.localIP.toString();
+    auto member = ctx.memberList->getMember(localIPStr.c_str());
+    if (member) {
+        NodeInfo node = *member;
         updateLocalNodeResources(node);
-        addOrUpdateNode(ctx.hostname, ctx.localIP);
+        node.lastSeen = millis();  // Update lastSeen since we're actively participating
+        ctx.memberList->updateMember(localIPStr.c_str(), node);
     }
 
     // Broadcast heartbeat - peers will respond with NODE_UPDATE
@@ -401,13 +417,13 @@ void ClusterManager::updateAllMembersInfoTaskCallback() {
 
 void ClusterManager::broadcastNodeUpdate() {
     // Broadcast our current node info as NODE_UPDATE to all cluster members
-    auto& memberList = *ctx.memberList;
-    auto it = memberList.find(ctx.hostname);
-    if (it == memberList.end()) {
+    String localIPStr = ctx.localIP.toString();
+    auto member = ctx.memberList->getMember(localIPStr.c_str());
+    if (!member) {
         return;
     }
 
-    const NodeInfo& node = it->second;
+    const NodeInfo& node = *member;
 
     JsonDocument doc;
     doc["hostname"] = node.hostname;
@@ -434,48 +450,28 @@ void ClusterManager::broadcastNodeUpdate() {
 }
 
 void ClusterManager::updateAllNodeStatuses() {
-    auto& memberList = *ctx.memberList;
     unsigned long now = millis();
-    for (auto& pair : memberList) {
-        NodeInfo& node = pair.second;
-        updateNodeStatus(node, now, ctx.config.node_inactive_threshold_ms, ctx.config.node_dead_threshold_ms);
-    }
+    ctx.memberList->updateAllNodeStatuses(now, ctx.config.node_inactive_threshold_ms, ctx.config.node_dead_threshold_ms);
 }
 
 void ClusterManager::removeDeadNodes() {
-    auto& memberList = *ctx.memberList;
-    unsigned long now = millis();
-    bool memberlistChanged = false;
-
-    // Use iterator to safely remove elements from map
-    for (auto it = memberList.begin(); it != memberList.end(); ) {
-        unsigned long diff = now - it->second.lastSeen;
-        if (it->second.status == NodeInfo::DEAD && diff > ctx.config.node_dead_threshold_ms) {
-            LOG_INFO("Cluster", "Removing node: " + it->second.hostname);
-            it = memberList.erase(it);
-            memberlistChanged = true;
-        } else {
-            ++it;
-        }
-    }
-
-    // Fire event if memberlist changed
-    if (memberlistChanged) {
+    size_t removedCount = ctx.memberList->removeDeadMembers();
+    if (removedCount > 0) {
+        LOG_INFO("Cluster", String("Removed ") + removedCount + " dead nodes");
         ctx.fire("cluster/memberlist/changed", nullptr);
     }
 }
 
 void ClusterManager::printMemberList() {
-    auto& memberList = *ctx.memberList;
-    if (memberList.empty()) {
+    size_t count = ctx.memberList->getMemberCount();
+    if (count == 0) {
         LOG_INFO("Cluster", "Member List: empty");
         return;
     }
     LOG_INFO("Cluster", "Member List:");
-    for (const auto& pair : memberList) {
-        const NodeInfo& node = pair.second;
+    ctx.memberList->forEachMember([](const std::string& ip, const NodeInfo& node) {
         LOG_INFO("Cluster", "  " + node.hostname + " @ " + node.ip.toString() + " | Status: " + statusToStr(node.status) + " | last seen: " + String(millis() - node.lastSeen));
-    }
+    });
 }
 
 void ClusterManager::updateLocalNodeResources(NodeInfo& node) {
@@ -484,12 +480,9 @@ void ClusterManager::updateLocalNodeResources(NodeInfo& node) {
     node.status = NodeInfo::ACTIVE;
     node.uptime = millis();
 
+    // Update dynamic resources (always updated)
     uint32_t freeHeap = ESP.getFreeHeap();
     node.resources.freeHeap = freeHeap;
-    node.resources.chipId = ESP.getChipId();
-    node.resources.sdkVersion = String(ESP.getSdkVersion());
-    node.resources.cpuFreqMHz = ESP.getCpuFreqMHz();
-    node.resources.flashChipSize = ESP.getFlashChipSize();
 
     // Log memory warnings if heap is getting low
     if (freeHeap < ctx.config.low_memory_threshold_bytes) {

src/spore/core/Memberlist.cpp

@@ -0,0 +1,114 @@
+#include "spore/core/Memberlist.h"
+#include <algorithm>
+
+Memberlist::Memberlist() = default;
+
+Memberlist::~Memberlist() = default;
+
+bool Memberlist::addOrUpdateMember(const std::string& ip, const NodeInfo& node) {
+    auto it = m_members.find(ip);
+    if (it != m_members.end()) {
+        // Update existing member
+        it->second = node;
+        it->second.lastSeen = millis();  // Update last seen time
+        return true;
+    } else {
+        // Add new member
+        NodeInfo newNode = node;
+        newNode.lastSeen = millis();
+        m_members[ip] = newNode;
+        return true;
+    }
+}
+
+bool Memberlist::addMember(const std::string& ip, const NodeInfo& node) {
+    if (m_members.find(ip) != m_members.end()) {
+        return false;  // Member already exists
+    }
+    NodeInfo newNode = node;
+    newNode.lastSeen = millis();
+    m_members[ip] = newNode;
+    return true;
+}
+
+bool Memberlist::updateMember(const std::string& ip, const NodeInfo& node) {
+    auto it = m_members.find(ip);
+    if (it == m_members.end()) {
+        return false;  // Member doesn't exist
+    }
+    it->second = node;
+    it->second.lastSeen = millis();  // Update last seen time
+    return true;
+}
+
+bool Memberlist::removeMember(const std::string& ip) {
+    auto it = m_members.find(ip);
+    if (it == m_members.end()) {
+        return false;  // Member doesn't exist
+    }
+    m_members.erase(it);
+    return true;
+}
+
+std::optional<NodeInfo> Memberlist::getMember(const std::string& ip) const {
+    auto it = m_members.find(ip);
+    if (it != m_members.end()) {
+        return it->second;
+    }
+    return std::nullopt;
+}
+
+void Memberlist::forEachMember(std::function<void(const std::string&, const NodeInfo&)> callback) const {
+    for (const auto& pair : m_members) {
+        callback(pair.first, pair.second);
+    }
+}
+
+bool Memberlist::forEachMemberUntil(std::function<bool(const std::string&, const NodeInfo&)> callback) const {
+    for (const auto& pair : m_members) {
+        if (!callback(pair.first, pair.second)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+size_t Memberlist::getMemberCount() const {
+    return m_members.size();
+}
+
+void Memberlist::updateAllNodeStatuses(unsigned long currentTime,
+                                      unsigned long staleThresholdMs,
+                                      unsigned long deadThresholdMs,
+                                      std::function<void(const std::string&, NodeInfo::Status, NodeInfo::Status)> onStatusChange) {
+    for (auto& [ip, node] : m_members) {
+        NodeInfo::Status oldStatus = node.status;
+        updateNodeStatus(node, currentTime, staleThresholdMs, deadThresholdMs);
+
+        if (oldStatus != node.status && onStatusChange) {
+            onStatusChange(ip, oldStatus, node.status);
+        }
+    }
+}
+
+size_t Memberlist::removeDeadMembers() {
+    size_t removedCount = 0;
+    auto it = m_members.begin();
+    while (it != m_members.end()) {
+        if (it->second.status == NodeInfo::Status::DEAD) {
+            it = m_members.erase(it);
+            ++removedCount;
+        } else {
+            ++it;
+        }
+    }
+    return removedCount;
+}
+
+bool Memberlist::hasMember(const std::string& ip) const {
+    return m_members.find(ip) != m_members.end();
+}
+
+void Memberlist::clear() {
+    m_members.clear();
+}

src/spore/core/NetworkManager.cpp

@@ -119,13 +119,8 @@ void NetworkManager::setupWiFi() {
     ctx.self.status = NodeInfo::ACTIVE;
 
     // Ensure member list has an entry for this node
-    auto &memberList = *ctx.memberList;
-    auto existing = memberList.find(ctx.hostname);
-    if (existing == memberList.end()) {
-        memberList[ctx.hostname] = ctx.self;
-    } else {
-        existing->second = ctx.self;
-    }
+    String localIPStr = ctx.localIP.toString();
+    ctx.memberList->addOrUpdateMember(localIPStr.c_str(), ctx.self);
 
     // Notify listeners that the node is (re)discovered
     ctx.fire("node/discovered", &ctx.self);

src/spore/core/NodeContext.cpp

@@ -2,7 +2,7 @@
 
 NodeContext::NodeContext() {
     udp = new WiFiUDP();
-    memberList = new std::map<String, NodeInfo>();
+    memberList = std::make_unique<Memberlist>();
     hostname = "";
     self.hostname = "";
     self.ip = IPAddress();
@@ -19,7 +19,7 @@ NodeContext::NodeContext(std::initializer_list<std::pair<String, String>> initia
 
 NodeContext::~NodeContext() {
     delete udp;
-    delete memberList;
+    // memberList is a unique_ptr, so no need to delete manually
 }
 
 void NodeContext::on(const std::string& event, EventCallback cb) {

src/spore/services/ClusterService.cpp

@@ -40,8 +40,7 @@ void ClusterService::handleMembersRequest(AsyncWebServerRequest* request) {
     JsonDocument doc;
     JsonArray arr = doc["members"].to<JsonArray>();
     
-    for (const auto& pair : *ctx.memberList) {
-        const NodeInfo& node = pair.second;
+    ctx.memberList->forEachMember([&arr](const std::string& ip, const NodeInfo& node) {
         JsonObject obj = arr.add<JsonObject>();
         obj["hostname"] = node.hostname;
         obj["ip"] = node.ip.toString();
@@ -56,7 +55,7 @@ void ClusterService::handleMembersRequest(AsyncWebServerRequest* request) {
                 labelsObj[kv.first.c_str()] = kv.second;
             }
         }
-    }
+    });
 
     String json;
     serializeJson(doc, json);

src/spore/services/MonitoringService.cpp

@@ -5,8 +5,7 @@
 #include <FS.h>
 #include <LittleFS.h>
 
-MonitoringService::MonitoringService(CpuUsage& cpuUsage)
-    : cpuUsage(cpuUsage) {
+MonitoringService::MonitoringService() {
 }
 
 void MonitoringService::registerEndpoints(ApiServer& api) {
@@ -22,11 +21,11 @@ void MonitoringService::registerTasks(TaskManager& taskManager) {
 MonitoringService::SystemResources MonitoringService::getSystemResources() const {
     SystemResources resources;
     
-    // CPU information
-    resources.currentCpuUsage = cpuUsage.getCpuUsage();
-    resources.averageCpuUsage = cpuUsage.getAverageCpuUsage();
-    resources.measurementCount = cpuUsage.getMeasurementCount();
-    resources.isMeasuring = cpuUsage.isMeasuring();
+    // CPU information - sending fixed value of 100
+    resources.currentCpuUsage = 100.0f;
+    resources.averageCpuUsage = 100.0f;
+    resources.measurementCount = 0;
+    resources.isMeasuring = false;
     
     // Memory information - ESP8266 compatible
     resources.freeHeap = ESP.getFreeHeap();

src/spore/services/NodeService.cpp

@@ -74,20 +74,18 @@ void NodeService::handleStatusRequest(AsyncWebServerRequest* request) {
     doc["flashChipSize"] = ESP.getFlashChipSize();
 
     // Include local node labels if present
-    if (ctx.memberList) {
-        auto it = ctx.memberList->find(ctx.hostname);
-        if (it != ctx.memberList->end()) {
-            JsonObject labelsObj = doc["labels"].to<JsonObject>();
-            for (const auto& kv : it->second.labels) {
-                labelsObj[kv.first.c_str()] = kv.second;
-            }
-        } else if (!ctx.self.labels.empty()) {
+    auto member = ctx.memberList->getMember(ctx.hostname.c_str());
+    if (member) {
+        JsonObject labelsObj = doc["labels"].to<JsonObject>();
+        for (const auto& kv : member->labels) {
+            labelsObj[kv.first.c_str()] = kv.second;
+        }
+    } else if (!ctx.self.labels.empty()) {
             JsonObject labelsObj = doc["labels"].to<JsonObject>();
             for (const auto& kv : ctx.self.labels) {
                 labelsObj[kv.first.c_str()] = kv.second;
             }
         }
-    }
 
     String json;
     serializeJson(doc, json);
@@ -216,17 +214,17 @@ void NodeService::handleConfigRequest(AsyncWebServerRequest* request) {
     // Rebuild self.labels from constructor + config labels
     ctx.rebuildLabels();
     
-    // TODO think of a better way to update the member list entry for the local node
-    // Update the member list entry for this node if it exists
-    if (ctx.memberList) {
-        auto it = ctx.memberList->find(ctx.hostname);
-        if (it != ctx.memberList->end()) {
-            // Update the labels in the member list entry
-            it->second.labels.clear();
-            for (const auto& kv : ctx.self.labels) {
-                it->second.labels[kv.first] = kv.second;
-            }
+    // Update the member list entry for the local node if it exists
+    String localIPStr = ctx.localIP.toString();
+    auto member = ctx.memberList->getMember(localIPStr.c_str());
+    if (member) {
+        // Update the labels in the member list entry
+        NodeInfo updatedNode = *member;
+        updatedNode.labels.clear();
+        for (const auto& kv : ctx.self.labels) {
+            updatedNode.labels[kv.first] = kv.second;
         }
+        ctx.memberList->updateMember(localIPStr.c_str(), updatedNode);
     }
     
     // Save config to file

src/spore/util/CpuUsage.cpp

@@ -1,185 +0,0 @@
-#include "spore/util/CpuUsage.h"
-
-CpuUsage::CpuUsage() 
-    : _initialized(false)
-    , _measuring(false)
-    , _measurementCount(0)
-    , _cycleStartTime(0)
-    , _idleStartTime(0)
-    , _totalIdleTime(0)
-    , _totalCycleTime(0)
-    , _currentCpuUsage(0.0f)
-    , _averageCpuUsage(0.0f)
-    , _maxCpuUsage(0.0f)
-    , _minCpuUsage(100.0f)
-    , _totalCpuTime(0)
-    , _rollingIndex(0)
-    , _rollingWindowFull(false) {
-    
-    // Initialize rolling window
-    for (size_t i = 0; i < ROLLING_WINDOW_SIZE; ++i) {
-        _rollingWindow[i] = 0.0f;
-    }
-}
-
-void CpuUsage::begin() {
-    if (_initialized) {
-        return;
-    }
-    
-    _initialized = true;
-    _measurementCount = 0;
-    _totalIdleTime = 0;
-    _totalCycleTime = 0;
-    _totalCpuTime = 0;
-    _currentCpuUsage = 0.0f;
-    _averageCpuUsage = 0.0f;
-    _maxCpuUsage = 0.0f;
-    _minCpuUsage = 100.0f;
-    _rollingIndex = 0;
-    _rollingWindowFull = false;
-    
-    // Initialize rolling window
-    for (size_t i = 0; i < ROLLING_WINDOW_SIZE; ++i) {
-        _rollingWindow[i] = 0.0f;
-    }
-}
-
-void CpuUsage::startMeasurement() {
-    if (!_initialized) {
-        return;
-    }
-    
-    if (_measuring) {
-        // If already measuring, end the previous measurement first
-        endMeasurement();
-    }
-    
-    _measuring = true;
-    _cycleStartTime = millis();
-    _idleStartTime = millis();
-}
-
-void CpuUsage::endMeasurement() {
-    if (!_initialized || !_measuring) {
-        return;
-    }
-    
-    unsigned long cycleEndTime = millis();
-    unsigned long cycleDuration = cycleEndTime - _cycleStartTime;
-    
-    // Calculate idle time (time spent in yield() calls)
-    unsigned long idleTime = cycleEndTime - _idleStartTime;
-    
-    // Calculate CPU usage
-    if (cycleDuration > 0) {
-        _currentCpuUsage = ((float)(cycleDuration - idleTime) / (float)cycleDuration) * 100.0f;
-        
-        // Clamp to valid range
-        if (_currentCpuUsage < 0.0f) {
-            _currentCpuUsage = 0.0f;
-        } else if (_currentCpuUsage > 100.0f) {
-            _currentCpuUsage = 100.0f;
-        }
-        
-        // Update statistics
-        _totalCycleTime += cycleDuration;
-        _totalIdleTime += idleTime;
-        _totalCpuTime += (cycleDuration - idleTime);
-        _measurementCount++;
-        
-        // Update rolling average
-        updateRollingAverage(_currentCpuUsage);
-        
-        // Update min/max
-        updateMinMax(_currentCpuUsage);
-        
-        // Calculate overall average
-        if (_measurementCount > 0) {
-            _averageCpuUsage = ((float)_totalCpuTime / (float)_totalCycleTime) * 100.0f;
-        }
-    }
-    
-    _measuring = false;
-}
-
-float CpuUsage::getCpuUsage() const {
-    return _currentCpuUsage;
-}
-
-float CpuUsage::getAverageCpuUsage() const {
-    if (_rollingWindowFull) {
-        return _averageCpuUsage;
-    } else if (_measurementCount > 0) {
-        // Calculate average from rolling window
-        float sum = 0.0f;
-        for (size_t i = 0; i < _rollingIndex; ++i) {
-            sum += _rollingWindow[i];
-        }
-        return sum / (float)_rollingIndex;
-    }
-    return 0.0f;
-}
-
-float CpuUsage::getMaxCpuUsage() const {
-    return _maxCpuUsage;
-}
-
-float CpuUsage::getMinCpuUsage() const {
-    return _minCpuUsage;
-}
-
-void CpuUsage::reset() {
-    _measurementCount = 0;
-    _totalIdleTime = 0;
-    _totalCycleTime = 0;
-    _totalCpuTime = 0;
-    _currentCpuUsage = 0.0f;
-    _averageCpuUsage = 0.0f;
-    _maxCpuUsage = 0.0f;
-    _minCpuUsage = 100.0f;
-    _rollingIndex = 0;
-    _rollingWindowFull = false;
-    
-    // Reset rolling window
-    for (size_t i = 0; i < ROLLING_WINDOW_SIZE; ++i) {
-        _rollingWindow[i] = 0.0f;
-    }
-}
-
-bool CpuUsage::isMeasuring() const {
-    return _measuring;
-}
-
-unsigned long CpuUsage::getMeasurementCount() const {
-    return _measurementCount;
-}
-
-void CpuUsage::updateRollingAverage(float value) {
-    _rollingWindow[_rollingIndex] = value;
-    _rollingIndex++;
-    
-    if (_rollingIndex >= ROLLING_WINDOW_SIZE) {
-        _rollingIndex = 0;
-        _rollingWindowFull = true;
-    }
-    
-    // Calculate rolling average
-    float sum = 0.0f;
-    size_t count = _rollingWindowFull ? ROLLING_WINDOW_SIZE : _rollingIndex;
-    
-    for (size_t i = 0; i < count; ++i) {
-        sum += _rollingWindow[i];
-    }
-    
-    _averageCpuUsage = sum / (float)count;
-}
-
-void CpuUsage::updateMinMax(float value) {
-    if (value > _maxCpuUsage) {
-        _maxCpuUsage = value;
-    }
-    if (value < _minCpuUsage) {
-        _minCpuUsage = value;
-    }
-}