@alteriom/painlessmesh 1.8.8 → 1.8.9

package/CHANGELOG.md

@@ -7,6 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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/library.json

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

package/library.properties

@@ -1,5 +1,5 @@
 name=Alteriom PainlessMesh
-version=1.8.8
+version=1.8.9
 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.9",
   "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.9"
 #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 9
 
 /**
  * @brief Library description and usage information

package/src/arduino/wifi.hpp

@@ -752,6 +752,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,
@@ -791,6 +812,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 +908,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",
@@ -1195,10 +1227,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 +1246,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() {

package/src/painlessMesh.h

@@ -5,7 +5,7 @@
  * @file painlessMesh.h
  * @brief Main header file for Alteriom painlessMesh library
  * 
- * @version 1.8.7
+ * @version 1.8.9
  * @date 2025-11-12
  * 
  * painlessMesh is a user-friendly library for creating mesh networks with