@alteriom/painlessmesh 1.8.8 → 1.8.10

package/CHANGELOG.md

@@ -7,6 +7,70 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.8.10] - 2025-11-18
+
+### Fixed
+
+- **Bridge Status Discovery - Direct Messaging** - Fixed newly connected nodes not receiving bridge status
+  - **Root Cause**: Broadcast messages were not reaching newly connected nodes reliably
+    - Time sync (NTP) was interfering with bridge discovery
+    - Broadcast routing may not be fully established immediately after connection
+  - **Solution**: Send bridge status directly to new node using `sendSingle()`
+    - Changed from broadcast (`routing=2`) to single (`routing=1`) 
+    - Minimal 500ms delay (just for connection stability)
+    - Direct targeted delivery ensures message reaches the new node
+    - Time sync no longer affects bridge discovery
+  - Location: `src/arduino/wifi.hpp` line ~809 in `initBridgeStatusBroadcast()`
+  - Impact: Nodes discover bridges immediately (within 500ms) after connecting
+  - Backward compatible: No API changes, internal delivery mechanism improved
+  - Resolves GitHub issue #135 "The latest fix does not work"
+
+## [1.8.9] - 2025-11-12
+
+### Fixed
+
+- **Bridge Self-Registration (Type 610 & 613)** - Bridge nodes now properly track themselves in status and coordination
+  - **Bridge Status Broadcasting (Type 610)**: Fixed bridge nodes reporting "Known bridges: 0" despite being active
+    - Added immediate self-registration task in `initBridgeStatusBroadcast()` (line ~746)
+    - Bridge now calls `updateBridgeStatus()` with own nodeId immediately after initialization
+    - Added self-update in `sendBridgeStatus()` (line ~1192) before broadcasting
+    - Ensures bridge appears in its own `knownBridges` list from the start
+  - **Bridge Coordination (Type 613)**: Fixed multi-bridge priority tracking
+    - Added self-registration in `initBridgeCoordination()` (line ~803)
+    - Bridge now adds own priority to `bridgePriorities` map: `bridgePriorities[this->nodeId] = bridgePriority`
+    - Added priority self-update in `sendBridgeCoordination()` (line ~869) before broadcasting
+    - Ensures primary bridge selection works correctly with multiple bridges
+  - **Root Cause**: Mesh networks don't loop broadcasts back to sender by design
+    - Nodes receive broadcasts from other nodes but not their own messages
+    - Requires explicit local state management for any tracking data
+  - **Before Fix**:
+    - Bridge reports "Known bridges: 0" and "No primary bridge available!"
+    - Multi-bridge setups fail to select primary bridge (missing own priority)
+    - Bridge failover unreliable due to incomplete bridge tracking
+  - **After Fix**:
+    - Bridge correctly reports "Known bridges: 1" (or more in multi-bridge setups)
+    - Primary bridge selection works properly with all bridge priorities present
+    - Self-tracking pattern now consistent across all periodic broadcast types
+  - Core fixes in `src/arduino/wifi.hpp`
+  - Resolves @woodlist GitHub issue - bridge showing "Known bridges: 0"
+  - Comprehensive analysis documented in COMPREHENSIVE_BROADCAST_ANALYSIS.md
+
+### Changed
+
+- **Build System** - Switched Docker compiler from clang++ to g++
+  - Changed ENV CXX in Dockerfile from clang++ to g++
+  - Resolves template instantiation crashes during Docker builds
+  - Build verification confirms successful compilation with g++
+
+### Documentation
+
+- **Broadcast Message Analysis** - Added comprehensive review documentation
+  - Created COMPREHENSIVE_BROADCAST_ANALYSIS.md with full analysis of all 4 broadcast types
+  - Documents self-tracking requirements for Type 610 (STATUS) and 613 (COORDINATION)
+  - Confirms Type 611 (ELECTION) already implements correct self-registration
+  - Confirms Type 612 (TAKEOVER) doesn't require self-tracking (notification only)
+  - Establishes pattern guidelines for future broadcast implementations
+
 ## [1.8.8] - 2025-11-12
 
 ### Fixed

package/docs/releases/BRIDGE_STATUS_SELF_REGISTRATION_FIX.md

@@ -0,0 +1,221 @@
+# Bridge Status Self-Registration Fix
+
+## Issue Reported by @woodlist
+
+**Problem**: After successfully promoting to bridge via election, the node reports:
+```
+I am bridge: YES
+Internet available: NO
+Known bridges: 0
+No primary bridge available! ❌
+```
+
+## Root Cause
+
+When a node becomes a bridge (either via `initAsBridge()` or election promotion), it broadcasts bridge status messages to the mesh network, but **it does not add itself to its own `knownBridges` list**.
+
+### Why This Happens
+
+1. Node wins election and promotes to bridge ✅
+2. Node calls `initBridgeStatusBroadcast()` ✅  
+3. Node sends bridge status broadcasts ✅
+4. **Other nodes receive broadcasts and update their `knownBridges` ✅**
+5. **Bridge node itself never receives its own broadcast ❌**
+6. Bridge node's `knownBridges` remains empty ❌
+7. `getPrimaryBridge()` returns `nullptr` because list is empty ❌
+
+### Code Flow
+
+```cpp
+// When bridge promotes
+promoteToBridge() 
+  → initAsBridge()
+    → initBridgeStatusBroadcast()
+      → sendBridgeStatus() // Broadcasts to network
+        → sendBroadcast(msg) // Bridge doesn't receive its own broadcasts
+```
+
+## The Fix
+
+### Changes to `src/arduino/wifi.hpp`
+
+#### 1. Modified `initBridgeStatusBroadcast()`
+
+Added self-registration during bridge initialization:
+
+```cpp
+void initBridgeStatusBroadcast() {
+    using namespace logger;
+    
+    if (!this->isBridge() || !this->bridgeStatusBroadcastEnabled) {
+      return;
+    }
+    
+    Log(STARTUP, "initBridgeStatusBroadcast(): Setting up bridge status broadcast\n");
+    
+    // NEW: Register ourselves as a bridge in the knownBridges list
+    // This ensures the bridge knows about itself and reports correct status
+    this->addTask([this]() {
+      bool hasInternet = (WiFi.status() == WL_CONNECTED) && 
+                         (WiFi.localIP() != IPAddress(0, 0, 0, 0));
+      
+      this->updateBridgeStatus(
+        this->nodeId,               // bridgeNodeId
+        hasInternet,                // internetConnected
+        WiFi.RSSI(),                // routerRSSI
+        WiFi.channel(),             // routerChannel
+        millis(),                   // uptime
+        WiFi.gatewayIP().toString(),// gatewayIP
+        this->getNodeTime()         // timestamp
+      );
+      
+      Log(STARTUP, "initBridgeStatusBroadcast(): Registered self as bridge (nodeId: %u)\n", 
+          this->nodeId);
+    });
+    
+    // ... rest of method unchanged
+}
+```
+
+#### 2. Modified `sendBridgeStatus()`
+
+Added self-update before broadcasting:
+
+```cpp
+void sendBridgeStatus() {
+    using namespace logger;
+    
+    if (!this->bridgeStatusBroadcastEnabled) {
+      return;
+    }
+    
+    // ... create JSON message ...
+    
+    bool hasInternet = (WiFi.status() == WL_CONNECTED) && 
+                       (WiFi.localIP() != IPAddress(0, 0, 0, 0));
+    
+    int8_t rssi = WiFi.RSSI();
+    uint8_t channel = WiFi.channel();
+    uint32_t uptime = millis();
+    TSTRING gatewayIP = WiFi.gatewayIP().toString();
+    
+    // ... add to JSON ...
+    
+    Log(GENERAL, "sendBridgeStatus(): Broadcasting status (Internet: %s)\n",
+        hasInternet ? "Connected" : "Disconnected");
+    Log(GENERAL, "sendBridgeStatus(): WiFi status=%d, localIP=%s, gatewayIP=%s\n",
+        WiFi.status(), WiFi.localIP().toString().c_str(), WiFi.gatewayIP().toString().c_str());
+    
+    // NEW: Update our own bridge status in knownBridges list
+    // This ensures the bridge reports itself correctly when queried
+    this->updateBridgeStatus(this->nodeId, hasInternet, rssi, channel, 
+                            uptime, gatewayIP, this->getNodeTime());
+    
+    this->sendBroadcast(msg);
+}
+```
+
+## Expected Behavior After Fix
+
+### Before Fix
+```
+--- Bridge Status ---
+I am bridge: YES
+Internet available: NO
+Known bridges: 0
+No primary bridge available! ❌
+--------------------
+```
+
+### After Fix
+```
+--- Bridge Status ---
+I am bridge: YES
+Internet available: NO ⚠️ (May be YES if router has internet)
+Known bridges: 1
+Primary bridge: 3394043125 (RSSI: -36 dBm) ✅
+--------------------
+```
+
+## Technical Details
+
+### Why Two Registration Points?
+
+1. **`initBridgeStatusBroadcast()`** - Initial registration when bridge first starts
+   - Ensures bridge is in `knownBridges` immediately after promotion
+   - Provides accurate status for early queries
+
+2. **`sendBridgeStatus()`** - Periodic updates
+   - Keeps bridge info current in `knownBridges`
+   - Updates RSSI, uptime, internet connectivity dynamically
+   - Ensures consistency between broadcast and local state
+
+### Internet Connectivity
+
+The "Internet available: NO" in @woodlist's log may be accurate depending on:
+- Router has active internet connection
+- DHCP has assigned valid IP address (not 0.0.0.0)
+- `WiFi.localIP()` returns valid address
+
+Check with:
+```cpp
+Log(GENERAL, "sendBridgeStatus(): WiFi status=%d, localIP=%s, gatewayIP=%s\n",
+    WiFi.status(), WiFi.localIP().toString().c_str(), WiFi.gatewayIP().toString().c_str());
+```
+
+This log line was present in the code but not visible in the serial output @woodlist provided.
+
+## Impact
+
+### Fixed Issues
+✅ Bridge nodes now correctly report themselves in `knownBridges`  
+✅ `getPrimaryBridge()` returns valid bridge pointer for bridge nodes  
+✅ Bridge status displays accurately show "Known bridges: 1" minimum  
+✅ Regular nodes can immediately discover newly promoted bridges  
+
+### Backward Compatibility
+✅ No breaking changes to existing API  
+✅ Compatible with existing bridge setups  
+✅ Works with both manual `initAsBridge()` and election-based promotion  
+✅ Multi-bridge configurations continue to function normally  
+
+## Testing
+
+### Manual Test Procedure
+1. Flash bridge_failover example to ESP32/ESP8266
+2. Start all nodes without pre-configured bridge
+3. Wait for 60-second grace period
+4. Observe election and promotion
+5. Check bridge status output
+
+Expected to see:
+- "Known bridges: 1" or more
+- Valid primary bridge with node ID and RSSI
+- No "No primary bridge available!" error
+
+### Unit Tests
+Existing tests in `test/catch/catch_diagnostics_api.cpp` verify:
+- `updateBridgeStatus()` adds bridges correctly
+- `getPrimaryBridge()` returns correct bridge based on RSSI/health
+- Bridge tracking and health monitoring work as expected
+
+## Files Modified
+- `src/arduino/wifi.hpp`
+  - `initBridgeStatusBroadcast()` - Added self-registration
+  - `sendBridgeStatus()` - Added periodic self-update
+
+## Related Issues
+- Fixes "No primary bridge available" on bridge nodes
+- Related to bridge election feature (v1.8.6)
+- Complements bridge failover implementation
+
+## Credits
+**Reported by**: @woodlist  
+**Analysis**: GitHub Copilot  
+**Fix**: Self-registration pattern for bridge tracking  
+
+---
+
+**Version**: To be included in v1.8.7+  
+**Date**: November 12, 2025  
+**Status**: Implementation complete, pending testing

package/examples/bridge_failover/README.md

@@ -233,6 +233,10 @@ mesh.enableBridgeFailover(true);
 // Set election timeout (milliseconds)
 mesh.setElectionTimeout(5000);
 
+// Set minimum RSSI for isolated bridge elections (default: -80 dBm)
+// Prevents nodes with poor signal from becoming bridges when isolated
+mesh.setMinimumBridgeRSSI(-80);
+
 // Set bridge status broadcast interval
 mesh.setBridgeStatusInterval(30000);
 
@@ -357,6 +361,37 @@ bool amBridge = mesh.isBridge();
 - Works reliably with all network types including mobile hotspots and tethering
 - Local IP check is more reliable than gateway IP, which may not be available on all network types
 
+### Isolated Node with Poor Signal Attempting Bridge
+
+**Symptoms**: Node logs "Election Failed: Insufficient Signal Quality" or has -85+ dBm RSSI
+
+**Root Cause**: Node cannot see the mesh (isolated) and has poor router signal below minimum threshold
+
+**What's Happening**:
+1. Node comes online and doesn't detect existing bridge
+2. Triggers election where it's the only candidate
+3. Has poor router RSSI (e.g., -87 dBm, below -80 dBm threshold)
+4. Election automatically rejected to prevent unreliable bridge
+5. Node remains as regular node until mesh connection or better signal
+
+**Expected Behavior** (v1.8.10+):
+```
+=== Evaluating Election ===
+evaluateElection(): 1 candidates
+=== Election Failed: Insufficient Signal Quality ===
+  Single candidate with RSSI -87 dBm (minimum required: -80 dBm)
+  Node is isolated from mesh with poor router signal
+  Rejecting election to prevent unreliable bridge
+  Recommendation: Move closer to router or wait for mesh connection
+```
+
+**Solutions**:
+- **Best**: Move node closer to router for better signal strength
+- **Wait**: Node will join existing bridge once mesh connection established
+- **Adjust threshold**: `mesh.setMinimumBridgeRSSI(-85)` to relax requirement (not recommended)
+- **Check existing bridge**: Ensure another node with good signal is already bridge
+- **Verify mesh**: Ensure nodes can communicate with each other
+
 ### Election Doesn't Start
 
 **Symptoms**: Bridge fails but no election occurs
@@ -381,10 +416,23 @@ bool amBridge = mesh.isBridge();
 
 **Symptoms**: Node with weak signal becomes bridge
 
-**Solutions**:
+**Root Cause (Fixed in v1.8.10+)**: 
+When a node with poor router signal (e.g., -87 dBm) comes online and cannot see the existing bridge, it may trigger an election where it's the only candidate. Previously, it could win by default despite inadequate signal strength.
+
+**Solution (Automatic)**:
+Starting in v1.8.10, the election system enforces a minimum RSSI threshold (-80 dBm by default) for single-candidate elections. This prevents isolated nodes with poor signal from becoming bridges.
+
+**Behavior**:
+- **Single candidate with poor RSSI**: Election fails with warning message
+- **Multiple candidates**: Best RSSI wins regardless of threshold (mesh is connected)
+- **Single candidate with good RSSI**: Election proceeds normally
+
+**Manual Solutions**:
+- Update to painlessMesh v1.8.10 or later
+- Adjust minimum RSSI threshold: `mesh.setMinimumBridgeRSSI(-75)` (stricter)
 - Verify RSSI values in election logs
 - Check router positioning and interference
-- Consider adjusting tiebreaker weightings
+- Move nodes closer to router for better signal
 - Review signal strength readings
 
 ### Frequent Re-elections

package/examples/bridge_failover/bridge_failover.ino

@@ -136,6 +136,10 @@ void setup() {
     mesh.setRouterCredentials(ROUTER_SSID, ROUTER_PASSWORD);
     mesh.enableBridgeFailover(true);
     mesh.setElectionTimeout(5000);  // 5 second election window
+    
+    // Optional: Set minimum RSSI for isolated bridge elections (default: -80 dBm)
+    // This prevents nodes with poor signal from becoming bridges when isolated
+    // mesh.setMinimumBridgeRSSI(-80);  // Uncomment to customize threshold
   }
 
   // Register callbacks

package/library.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "https://github.com/Alteriom/painlessMesh"
   },
-  "version": "1.8.8",
+  "version": "1.8.10",
   "frameworks": [
     "arduino"
   ],

package/library.properties

@@ -1,5 +1,5 @@
 name=Alteriom PainlessMesh
-version=1.8.8
+version=1.8.10
 author=Coopdis,Scotty Franzyshen,Edwin van Leeuwen,Germán Martín,Maximilian Schwarz,Doanh Doanh,Alteriom
 maintainer=Alteriom
 sentence=A painless way to setup a mesh with ESP8266 and ESP32 devices with Alteriom extensions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alteriom/painlessmesh",
-  "version": "1.8.8",
+  "version": "1.8.10",
   "description": "painlessMesh is a user-friendly library for creating mesh networks with ESP8266 and ESP32 devices. This Alteriom fork includes additional packages for sensor data (SensorPackage), device commands (CommandPackage), and status monitoring (StatusPackage). It handles routing and network management automatically, so you can focus on your application. The library uses JSON-based messaging and syncs time across all nodes, making it ideal for coordinated behaviour like synchronized light displays or sensor networks reporting to a central node.",
   "keywords": [
     "arduino",

package/src/AlteriomPainlessMesh.h

@@ -29,10 +29,10 @@
 /**
  * @brief AlteriomPainlessMesh library version information
  */
-#define ALTERIOM_PAINLESS_MESH_VERSION "1.8.7"
+#define ALTERIOM_PAINLESS_MESH_VERSION "1.8.10"
 #define ALTERIOM_PAINLESS_MESH_VERSION_MAJOR 1
 #define ALTERIOM_PAINLESS_MESH_VERSION_MINOR 8
-#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 7
+#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 10
 
 /**
  * @brief Library description and usage information

package/src/arduino/wifi.hpp

@@ -534,6 +534,21 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     electionTimeoutMs = timeoutMs;
   }
 
+  /**
+   * Set the minimum RSSI required for bridge election
+   * 
+   * Prevents nodes with poor router signal from becoming bridges in isolated
+   * elections. When a node is the only candidate, it must meet this threshold.
+   * When multiple candidates exist, the best RSSI wins regardless of threshold.
+   * 
+   * @param minRSSI Minimum RSSI in dBm (default: -80 dBm, range: -100 to -30)
+   */
+  void setMinimumBridgeRSSI(int8_t minRSSI) {
+    if (minRSSI < -100) minRSSI = -100;
+    if (minRSSI > -30) minRSSI = -30;
+    minimumBridgeRSSI = minRSSI;
+  }
+
   /**
    * Set callback for when this node's bridge role changes
    * 
@@ -752,6 +767,27 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     
     Log(STARTUP, "initBridgeStatusBroadcast(): Setting up bridge status broadcast\n");
     
+    // Register ourselves as a bridge in the knownBridges list
+    // This ensures the bridge knows about itself and reports correct status
+    this->addTask([this]() {
+      // Check Internet connectivity: WiFi connected AND valid IP address
+      bool hasInternet = (WiFi.status() == WL_CONNECTED) && 
+                         (WiFi.localIP() != IPAddress(0, 0, 0, 0));
+      
+      this->updateBridgeStatus(
+        this->nodeId,               // bridgeNodeId
+        hasInternet,                // internetConnected
+        WiFi.RSSI(),                // routerRSSI
+        WiFi.channel(),             // routerChannel
+        millis(),                   // uptime
+        WiFi.gatewayIP().toString(),// gatewayIP
+        this->getNodeTime()         // timestamp
+      );
+      
+      Log(STARTUP, "initBridgeStatusBroadcast(): Registered self as bridge (nodeId: %u)\n", 
+          this->nodeId);
+    });
+    
     // Create periodic task to broadcast bridge status
     bridgeStatusTask = this->addTask(
       this->bridgeStatusIntervalMs,
@@ -768,10 +804,42 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       this->sendBridgeStatus();
     });
     
-    // Also broadcast when new nodes connect so they can discover the bridge immediately
+    // Also send bridge status when new nodes connect so they can discover the bridge immediately
+    // Send directly to the new node to ensure delivery, independent of time sync
     this->newConnectionCallbacks.push_back([this](uint32_t nodeId) {
-      Log(CONNECTION, "New node %u connected, sending bridge status\n", nodeId);
-      this->sendBridgeStatus();
+      Log(CONNECTION, "New node %u connected, sending bridge status directly\n", nodeId);
+      
+      // Small delay to ensure connection is ready, then send directly to the new node
+      // This avoids issues with time sync blocking broadcast messages
+      this->addTask(500, TASK_ONCE, [this, nodeId]() {
+        // Create bridge status message
+        JsonDocument doc;
+        JsonObject obj = doc.to<JsonObject>();
+        
+        obj["type"] = 610;  // BRIDGE_STATUS type
+        obj["from"] = this->nodeId;
+        obj["routing"] = 1;  // SINGLE routing (direct to node)
+        obj["dest"] = nodeId;
+        obj["timestamp"] = this->getNodeTime();
+        
+        bool hasInternet = (WiFi.status() == WL_CONNECTED) && 
+                           (WiFi.localIP() != IPAddress(0, 0, 0, 0));
+        obj["internetConnected"] = hasInternet;
+        obj["routerRSSI"] = WiFi.RSSI();
+        obj["routerChannel"] = WiFi.channel();
+        obj["uptime"] = millis();
+        obj["gatewayIP"] = WiFi.gatewayIP().toString();
+        obj["message_type"] = 610;
+        
+        String msg;
+        serializeJson(doc, msg);
+        
+        Log(CONNECTION, "Sending bridge status directly to node %u (Internet: %s)\n",
+            nodeId, hasInternet ? "YES" : "NO");
+        
+        // Send directly to the new node, bypassing broadcast routing
+        this->sendSingle(nodeId, msg);
+      });
     });
     
     Log(STARTUP, "Bridge status broadcast enabled (interval: %d ms)\n", 
@@ -791,6 +859,12 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     
     Log(STARTUP, "initBridgeCoordination(): Setting up multi-bridge coordination\n");
     
+    // Register our own priority in the bridgePriorities map
+    // This ensures getRecommendedBridge() with PRIORITY_BASED strategy works correctly
+    bridgePriorities[this->nodeId] = bridgePriority;
+    Log(STARTUP, "initBridgeCoordination(): Registered self priority (nodeId: %u, priority: %d)\n",
+        this->nodeId, bridgePriority);
+    
     // Register handler for incoming coordination messages (Type 613)
     this->callbackList.onPackage(
         613,  // BRIDGE_COORDINATION type
@@ -881,6 +955,11 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     
     String msg;
     serializeJson(doc, msg);
+    
+    // Update our own priority in bridgePriorities map
+    // This ensures priority-based selection always has current data
+    bridgePriorities[this->nodeId] = bridgePriority;
+    
     this->sendBroadcast(msg);
     
     Log(CONNECTION, "Bridge coordination sent: priority=%d, role=%s, load=%d%%\n",
@@ -1045,6 +1124,28 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       return;
     }
     
+    // Validate RSSI threshold for single-candidate elections
+    // When only one candidate exists, it indicates the node is isolated from the mesh.
+    // In this case, require minimum signal quality to prevent poor connections.
+    // When multiple candidates exist, the mesh is connected and best RSSI wins.
+    if (electionCandidates.size() == 1 && winner->routerRSSI < minimumBridgeRSSI) {
+      Log(CONNECTION, "=== Election Failed: Insufficient Signal Quality ===\n");
+      Log(CONNECTION, "  Single candidate with RSSI %d dBm (minimum required: %d dBm)\n",
+          winner->routerRSSI, minimumBridgeRSSI);
+      Log(CONNECTION, "  Node is isolated from mesh with poor router signal\n");
+      Log(CONNECTION, "  Rejecting election to prevent unreliable bridge\n");
+      Log(CONNECTION, "  Recommendation: Move closer to router or wait for mesh connection\n");
+      
+      electionState = ELECTION_IDLE;
+      electionCandidates.clear();
+      
+      // Notify via callback that election failed
+      if (bridgeRoleChangedCallback) {
+        bridgeRoleChangedCallback(false, "Insufficient signal quality for isolated bridge");
+      }
+      return;
+    }
+    
     Log(CONNECTION, "=== Election Winner: Node %u ===\n", winner->nodeId);
     Log(CONNECTION, "  Router RSSI: %d dBm\n", winner->routerRSSI);
     Log(CONNECTION, "  Uptime: %u ms\n", winner->uptime);
@@ -1195,10 +1296,15 @@ class Mesh : public painlessmesh::Mesh<Connection> {
                        (WiFi.localIP() != IPAddress(0, 0, 0, 0));
     obj["internetConnected"] = hasInternet;
     
-    obj["routerRSSI"] = WiFi.RSSI();
-    obj["routerChannel"] = WiFi.channel();
-    obj["uptime"] = millis();
-    obj["gatewayIP"] = WiFi.gatewayIP().toString();
+    int8_t rssi = WiFi.RSSI();
+    uint8_t channel = WiFi.channel();
+    uint32_t uptime = millis();
+    TSTRING gatewayIP = WiFi.gatewayIP().toString();
+    
+    obj["routerRSSI"] = rssi;
+    obj["routerChannel"] = channel;
+    obj["uptime"] = uptime;
+    obj["gatewayIP"] = gatewayIP;
     obj["message_type"] = 610;
     
     String msg;
@@ -1209,6 +1315,11 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     Log(GENERAL, "sendBridgeStatus(): WiFi status=%d, localIP=%s, gatewayIP=%s\n",
         WiFi.status(), WiFi.localIP().toString().c_str(), WiFi.gatewayIP().toString().c_str());
     
+    // Update our own bridge status in knownBridges list
+    // This ensures the bridge reports itself correctly when queried
+    this->updateBridgeStatus(this->nodeId, hasInternet, rssi, channel, 
+                            uptime, gatewayIP, this->getNodeTime());
+    
     this->sendBroadcast(msg);
   }
   void eventHandleInit() {
@@ -1339,6 +1450,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   TSTRING routerSSID = "";
   TSTRING routerPassword = "";
   uint32_t electionTimeoutMs = 5000;  // Default 5 seconds
+  int8_t minimumBridgeRSSI = -80;  // Default -80 dBm minimum for isolated elections
   uint32_t lastRoleChangeTime = 0;
   ElectionState electionState = ELECTION_IDLE;
   uint32_t electionDeadline = 0;

package/src/boost/asynctcp.hpp

@@ -233,8 +233,13 @@ class AsyncServer {
   void begin() {
     mAcceptor.open(tcp::v4());
     int one = 1;
+#ifdef _WIN32
+    setsockopt(mAcceptor.native_handle(), SOL_SOCKET,
+               SO_REUSEADDR | SO_REUSEPORT, reinterpret_cast<const char*>(&one), sizeof(one));
+#else
     setsockopt(mAcceptor.native_handle(), SOL_SOCKET,
                SO_REUSEADDR | SO_REUSEPORT, &one, sizeof(one));
+#endif
     boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), _port);
     mAcceptor.set_option(boost::asio::socket_base::reuse_address(true));
     mAcceptor.set_option(boost::asio::ip::tcp::no_delay(true));

package/src/painlessMesh.h

@@ -5,8 +5,8 @@
  * @file painlessMesh.h
  * @brief Main header file for Alteriom painlessMesh library
  * 
- * @version 1.8.7
- * @date 2025-11-12
+ * @version 1.8.10
+ * @date 2025-11-18
  * 
  * painlessMesh is a user-friendly library for creating mesh networks with 
  * ESP8266 and ESP32 devices. This Alteriom fork includes additional packages 

package/src/painlessmesh/logger.hpp

@@ -10,6 +10,11 @@ namespace logger {
 
 #define REMOTE_QUEUE_SIZE 10
 
+// Windows defines ERROR as a macro, undefine it to avoid conflicts
+#ifdef ERROR
+#undef ERROR
+#endif
+
 typedef enum {
   ERROR = 1 << 0,
   STARTUP = 1 << 1,
@@ -132,7 +137,7 @@ class LogClass {
 
       vsnprintf(str, 200, format, args);
 
-      remote_queue.push_back(std::pair<uint, TSTRING>(remote_uuid, str));
+      remote_queue.push_back(std::pair<uint32_t, TSTRING>(remote_uuid, str));
       ++remote_uuid;
       if (remote_queue.size() > REMOTE_QUEUE_SIZE) {
         // No place to store the reason, but do signify the queue is full,
@@ -142,15 +147,15 @@ class LogClass {
     }
   }
 
-  std::list<std::pair<uint, TSTRING>> &get_remote_queue() {
+  std::list<std::pair<uint32_t, TSTRING>> &get_remote_queue() {
     return remote_queue;
   }
 
  private:
   uint16_t types = 0;
   char str[200];
-  std::list<std::pair<uint, TSTRING>> remote_queue;
-  uint remote_uuid;
+  std::list<std::pair<uint32_t, TSTRING>> remote_queue;
+  uint32_t remote_uuid;
 };
 
 }  // namespace logger

package/src/painlessmesh/mesh.hpp

@@ -2285,7 +2285,7 @@ class Connection : public painlessmesh::layout::Neighbour,
       quality -= (80 + rssi);  // e.g., -90 dBm = penalty of 10
     }
 
-    return std::max(0, std::min(100, quality));
+    return (std::max)(0, (std::min)(100, quality));
   }
 
   /**

package/src/painlessmesh/protocol.hpp

@@ -380,7 +380,7 @@ class TimeSync : public PackageInterface {
   /**
    * Create a reply to the current message with the new time set
    */
-  void reply(uint newT0) {
+  void reply(uint32_t newT0) {
     msg.t0 = newT0;
     ++msg.type;
     std::swap(from, dest);