@alteriom/painlessmesh 1.8.9 → 1.8.11

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.11",
   "frameworks": [
     "arduino"
   ],

package/library.properties

@@ -1,5 +1,5 @@
 name=Alteriom PainlessMesh
-version=1.8.9
+version=1.8.11
 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.11",
   "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.11"
 #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 11
 
 /**
  * @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,43 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       this->sendBridgeStatus();
     });
     
-    // Also broadcast when new nodes connect so they can discover the bridge immediately
-    this->newConnectionCallbacks.push_back([this](uint32_t nodeId) {
-      Log(CONNECTION, "New node %u connected, sending bridge status\n", nodeId);
-      this->sendBridgeStatus();
+    // 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
+    // Using changedConnectionCallbacks instead of newConnectionCallbacks ensures routing is ready
+    this->changedConnectionCallbacks.push_back([this](uint32_t nodeId) {
+      Log(CONNECTION, "Node %u connection changed, sending bridge status directly\n", nodeId);
+      
+      // Small delay to ensure connection is fully stable, 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 using routing table (which is now ready)
+        this->sendSingle(nodeId, msg);
+      });
     });
     
     Log(STARTUP, "Bridge status broadcast enabled (interval: %d ms)\n", 
@@ -1077,6 +1125,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 +1451,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.11
+ * @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/buffer.hpp

@@ -1,4 +1,4 @@
-#ifndef _PAINLESS_MESH_BUFFER_HPP_
+#ifndef _PAINLESS_MESH_BUFFER_HPP_
 #define _PAINLESS_MESH_BUFFER_HPP_
 
 #include <list>
@@ -37,7 +37,7 @@ class ReceiveBuffer {
     do {
       auto len = strnlen(data_ptr, length);
       do {
-        auto read_len = std::min(len, buf.length);
+        auto read_len = (std::min)(len, buf.length);
         memcpy(buf.buffer, data_ptr, read_len);
         buf.buffer[read_len] = '\0';
         auto newBuffer = T(buf.buffer);
@@ -179,7 +179,7 @@ class SentBuffer {
     else
       // String.toCharArray automatically turns the last character into
       // a \0, we need the extra space to deal with that annoyance
-      return std::min(buffer_length - 1, msg->length() + 1);
+      return (std::min)(buffer_length - 1, msg->length() + 1);
   }
 
   /**

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

@@ -1,4 +1,4 @@
-#ifndef _PAINLESS_MESH_MESH_HPP_
+#ifndef _PAINLESS_MESH_MESH_HPP_
 #define _PAINLESS_MESH_MESH_HPP_
 
 #include <vector>
@@ -428,7 +428,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   /** Set a callback routine for any messages that are addressed to this node.
    *
    * Every time this node receives a message, this callback routine will the
-   * called.  “from” is the id of the original sender of the message, and “msg”
+   * called.  “from” is the id of the original sender of the message, and “msg”
    * is a string that contains the message.  The message can be anything.  A
    * JSON, some other text string, or binary data.
    *
@@ -1861,7 +1861,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * // === painlessMesh Diagnostics ===
    * // Mode: Regular Node
    * // Mesh: ProductionMesh (25 nodes)
-   * // Bridge: 123456789 (RSSI: -42 dBm, Internet: ✓)
+   * // Bridge: 123456789 (RSSI: -42 dBm, Internet: ✓)
    * // Queue: 3 messages (2 CRITICAL, 1 NORMAL)
    * // Uptime: 02:15:33
    * // Last Election: 00:45:12 ago (Winner: 123456789)
@@ -1889,7 +1889,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       if (primaryBridge != nullptr) {
         report += "Bridge: " + TSTRING(std::to_string(primaryBridge->nodeId).c_str());
         report += " (RSSI: " + TSTRING(std::to_string(primaryBridge->routerRSSI).c_str()) + " dBm";
-        report += ", Internet: " + TSTRING(primaryBridge->internetConnected ? "✓" : "✗") + ")\n";
+        report += ", Internet: " + TSTRING(primaryBridge->internetConnected ? "✓" : "✗") + ")\n";
       } else {
         report += "Bridge: None available\n";
       }
@@ -1960,6 +1960,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     isExternalScheduler = true;
   }
 
+ public:  // Windows MSVC: router functions need access
   void startTimeSync(std::shared_ptr<T> conn) {
     using namespace logger;
     Log(S_TIME, "startTimeSync(): from %u with %u\n", this->nodeId,
@@ -2033,6 +2034,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
         [](const std::shared_ptr<T> &conn) { return !conn->connected(); });
   }
 
+ public:  // Windows MSVC: TCP lambdas need access to droppedConnectionCallbacks
   // Callback functions
   callback::List<uint32_t> newConnectionCallbacks;
   callback::List<uint32_t, bool> droppedConnectionCallbacks;
@@ -2056,6 +2058,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
 
   Scheduler *mScheduler;
 
+ public:  // Windows MSVC: lambdas in friend functions need public access
+
   /**
    * Wrapper function for ESP32 semaphore function
    *
@@ -2285,7 +2289,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/message_queue.hpp

@@ -143,8 +143,8 @@ public:
     // Check for state change
     checkStateChange();
     
-    Log(logger::GENERAL, "MessageQueue: Enqueued message #%u (priority=%d, size=%u/%u)\n",
-        msgId, priority, messages.size(), maxQueueSize);
+    Log(logger::GENERAL, "MessageQueue: Enqueued message #%u (priority=%d, size=%zu/%zu)\n",
+        msgId, priority, messages.size(), (size_t)maxQueueSize);
     
     return msgId;
   }
@@ -167,7 +167,7 @@ public:
       updatePriorityStats();
       checkStateChange();
       
-      Log(logger::GENERAL, "MessageQueue: Removed message #%u (size=%u)\n",
+      Log(logger::GENERAL, "MessageQueue: Removed message #%u (size=%zu)\n",
           messageId, messages.size());
       return true;
     }

package/src/painlessmesh/ntp.hpp

@@ -1,4 +1,4 @@
-#ifndef _PAINLESS_MESH_NTP_HPP_
+#ifndef _PAINLESS_MESH_NTP_HPP_
 #define _PAINLESS_MESH_NTP_HPP_
 
 #ifndef TIME_SYNC_INTERVAL
@@ -42,7 +42,7 @@ class MeshTime {
    */
   uint32_t getNodeTime() { return micros() + timeOffset; }
 
- protected:
+ public:  // Windows MSVC: friend functions need access to timeOffset
   uint32_t timeOffset = 0;
 };
 

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);

package/src/painlessmesh/router.hpp

@@ -1,4 +1,4 @@
-#ifndef _PAINLESS_MESH_ROUTER_HPP_
+#ifndef _PAINLESS_MESH_ROUTER_HPP_
 #define _PAINLESS_MESH_ROUTER_HPP_
 
 #include <algorithm>
@@ -235,14 +235,14 @@ void routePackage(layout::Layout<T> layout, std::shared_ptr<T> connection,
   // Base capacity: message length + overhead for JSON structure
   // Each nesting level adds overhead for pointers and metadata
   size_t calculatedCapacity = pkg.length() + 
-                              JSON_OBJECT_SIZE(10) * std::max(nestingDepth, size_t(1)) + 
+                              JSON_OBJECT_SIZE(10) * (std::max)(nestingDepth, size_t(1)) + 
                               512;  // Additional buffer for strings and padding
 #endif
   
   // Cap at 8KB for safety on ESP8266 (which has ~80KB total heap)
   // Messages larger than this should be rejected
   constexpr size_t MAX_MESSAGE_CAPACITY = 8192;
-  size_t capacity = std::min(calculatedCapacity, MAX_MESSAGE_CAPACITY);
+  size_t capacity = (std::min)(calculatedCapacity, MAX_MESSAGE_CAPACITY);
   
   auto variant = std::make_shared<protocol::Variant>(pkg, capacity);
   
@@ -330,7 +330,7 @@ void handleNodeSync(T& mesh, protocol::NodeTree newTree,
         [&mesh, nodeId]() { mesh.changedConnectionCallbacks.execute(nodeId); });
   } else {
     conn->nodeSyncTask.delay();
-    mesh.stability += std::min(1000 - mesh.stability, (size_t)25);
+    mesh.stability += (std::min)(1000 - mesh.stability, (size_t)25);
   }
 }