@alteriom/painlessmesh 1.8.9 → 1.8.10

package/CHANGELOG.md

@@ -7,6 +7,24 @@ 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

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.9",
+  "version": "1.8.10",
   "frameworks": [
     "arduino"
   ],

package/library.properties

@@ -1,5 +1,5 @@
 name=Alteriom PainlessMesh
-version=1.8.9
+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.9",
+  "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.9"
+#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 9
+#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
    * 
@@ -789,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", 
@@ -1077,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);
@@ -1381,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.9
- * @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);