@alteriom/painlessmesh 1.8.2 → 1.8.4

package/examples/routing_demo/README.md

@@ -0,0 +1,172 @@
+# Multi-Hop Routing Demo
+
+This example demonstrates the new multi-hop routing capabilities implemented in painlessMesh.
+
+## Features Demonstrated
+
+### 1. Hop Count Calculation (`getHopCount()`)
+- Calculates the actual number of hops to reach any node in the mesh
+- Returns 0 for self, 1 for direct connections, actual count for multi-hop paths
+- Returns -1 if the node is unreachable
+
+### 2. Routing Table (`getRoutingTable()`)
+- Returns a complete routing table mapping each destination to its next hop
+- For direct connections, destination equals next hop
+- For multi-hop paths, shows which neighbor to route through
+
+### 3. Path Discovery (`getPathToNode()`)
+- Finds the complete path from this node to any target node
+- Returns a vector of node IDs representing the shortest path
+- Useful for visualizing mesh topology and debugging connectivity
+
+## How It Works
+
+The implementation uses **Breadth-First Search (BFS)** to:
+- Find shortest paths in the mesh topology
+- Build accurate routing tables
+- Calculate hop counts efficiently
+
+### Algorithm Complexity
+- **Time**: O(V + E) where V = nodes, E = edges
+- **Space**: O(V) for visited set and queue
+- **Suitable for**: ESP8266 (80KB RAM) and ESP32 (320KB RAM)
+
+## Running the Example
+
+### Hardware Requirements
+- 2 or more ESP32 or ESP8266 boards
+- No additional hardware needed
+
+### Software Requirements
+- painlessMesh library (with multi-hop routing support)
+- TaskScheduler library
+- ArduinoJson library
+
+### Setup Instructions
+
+1. Upload this sketch to multiple ESP devices
+2. Each device will automatically join the mesh
+3. Open Serial Monitor (115200 baud) on any device
+4. Observe routing information every 10 seconds
+
+### Expected Output
+
+```
+Routing Demo Started
+Node ID: 123456789
+
+=== Routing Information ===
+Mesh contains 3 nodes (plus this node)
+
+Hop Counts:
+  Node 234567890: 1 hop
+  Node 345678901: 2 hops
+  Node 456789012: 3 hops
+
+Routing Table (Destination -> Next Hop):
+  To 234567890 -> via 234567890 (direct connection)
+  To 345678901 -> via 234567890
+  To 456789012 -> via 234567890
+
+Path to node 456789012:
+  123456789 -> 234567890 -> 345678901 -> 456789012
+  (Total: 3 hops)
+========================
+```
+
+## Use Cases
+
+### Network Diagnostics
+- Monitor mesh topology changes in real-time
+- Identify connectivity issues
+- Measure network depth
+
+### Load Balancing
+- Choose optimal paths for data transmission
+- Distribute traffic across multiple routes
+- Avoid overloading single-hop nodes
+
+### Network Visualization
+- Build visual representations of mesh topology
+- Display on OLED/LCD screens
+- Create web-based network maps
+
+## Performance Considerations
+
+### Memory Usage
+- Routing table size: ~8 bytes per node
+- BFS temporary storage: ~16 bytes per node
+- Example mesh of 50 nodes: ~1.2KB total
+
+### CPU Usage
+- Routing calculation: ~1-5ms for typical meshes
+- Triggered only on topology changes
+- No continuous overhead
+
+## Advanced Usage
+
+### Custom Routing Logic
+
+```cpp
+// Find nodes within N hops
+std::vector<uint32_t> findNodesWithinRange(int maxHops) {
+  std::vector<uint32_t> nearby;
+  auto nodeList = mesh.getNodeList(false);
+  
+  for (auto nodeId : nodeList) {
+    int hops = mesh.getHopCount(nodeId);
+    if (hops > 0 && hops <= maxHops) {
+      nearby.push_back(nodeId);
+    }
+  }
+  
+  return nearby;
+}
+```
+
+### Route Optimization
+
+```cpp
+// Select best route based on hop count
+uint32_t selectBestRoute(std::vector<uint32_t> candidates) {
+  uint32_t best = 0;
+  int minHops = 999;
+  
+  for (auto candidate : candidates) {
+    int hops = mesh.getHopCount(candidate);
+    if (hops > 0 && hops < minHops) {
+      minHops = hops;
+      best = candidate;
+    }
+  }
+  
+  return best;
+}
+```
+
+## Troubleshooting
+
+### "All nodes show 2 hops"
+- Old firmware without multi-hop support
+- Update to latest painlessMesh version
+
+### "Routing table is empty"
+- No other nodes in the mesh
+- Check mesh credentials (SSID/password)
+- Verify mesh is initialized
+
+### "Path discovery returns empty vector"
+- Target node is unreachable or left the mesh
+- Check connectivity with `getHopCount()` first
+
+## Related Examples
+
+- `namedMesh.ino` - Basic mesh setup
+- `diagnosticsExample.ino` - Advanced diagnostics
+- `bridge_failover.ino` - Multi-bridge routing
+
+## References
+
+- [painlessMesh Documentation](https://alteriom.github.io/painlessMesh/)
+- [Multi-Hop Routing Issue #XXX](https://github.com/Alteriom/painlessMesh/issues/XXX)
+- BFS Algorithm: [Wikipedia](https://en.wikipedia.org/wiki/Breadth-first_search)

package/examples/routing_demo/routing_demo.ino

@@ -0,0 +1,102 @@
+/**
+ * Multi-Hop Routing Demo
+ * 
+ * This example demonstrates the new multi-hop routing capabilities of painlessMesh.
+ * It shows how to:
+ * - Calculate hop count to any node in the mesh
+ * - Get the complete routing table
+ * - Find the path from this node to any other node
+ * 
+ * The functions work automatically with any mesh topology - linear chains,
+ * star configurations, or complex multi-hop meshes.
+ */
+
+#include "painlessMesh.h"
+
+#define MESH_PREFIX     "routingDemo"
+#define MESH_PASSWORD   "meshPassword"
+#define MESH_PORT       5555
+
+Scheduler userScheduler;
+painlessMesh mesh;
+
+// Task to periodically display routing information
+Task taskShowRouting(10000, TASK_FOREVER, []() {
+  Serial.println("\n=== Routing Information ===");
+  
+  // Get list of all nodes in the mesh
+  auto nodeList = mesh.getNodeList(false);  // false = don't include self
+  Serial.printf("Mesh contains %d nodes (plus this node)\n", nodeList.size());
+  
+  // Display hop count to each node
+  Serial.println("\nHop Counts:");
+  for (auto nodeId : nodeList) {
+    int hops = mesh.getHopCount(nodeId);
+    Serial.printf("  Node %u: %d hop%s\n", nodeId, hops, hops == 1 ? "" : "s");
+  }
+  
+  // Display complete routing table
+  Serial.println("\nRouting Table (Destination -> Next Hop):");
+  auto routingTable = mesh.getRoutingTable();
+  for (auto& entry : routingTable) {
+    Serial.printf("  To %u -> via %u", entry.first, entry.second);
+    if (entry.first == entry.second) {
+      Serial.print(" (direct connection)");
+    }
+    Serial.println();
+  }
+  
+  // Example: Show path to first node in list
+  if (!nodeList.empty()) {
+    uint32_t targetNode = nodeList.front();
+    auto path = mesh.getPathToNode(targetNode);
+    
+    if (!path.empty()) {
+      Serial.printf("\nPath to node %u:\n  ", targetNode);
+      for (size_t i = 0; i < path.size(); i++) {
+        Serial.printf("%u", path[i]);
+        if (i < path.size() - 1) {
+          Serial.print(" -> ");
+        }
+      }
+      Serial.printf("\n  (Total: %d hop%s)\n", path.size() - 1, 
+                    path.size() - 1 == 1 ? "" : "s");
+    } else {
+      Serial.printf("\nNode %u is unreachable\n", targetNode);
+    }
+  }
+  
+  Serial.println("========================\n");
+});
+
+void setup() {
+  Serial.begin(115200);
+  
+  // Initialize mesh
+  mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION);
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  
+  // Setup callbacks
+  mesh.onNewConnection([](uint32_t nodeId) {
+    Serial.printf("\nNew connection: Node %u joined the mesh\n", nodeId);
+  });
+  
+  mesh.onDroppedConnection([](uint32_t nodeId) {
+    Serial.printf("\nConnection dropped: Node %u left the mesh\n", nodeId);
+  });
+  
+  mesh.onChangedConnections([]() {
+    Serial.println("\nMesh topology changed - routing tables updated");
+  });
+  
+  // Add routing display task
+  userScheduler.addTask(taskShowRouting);
+  taskShowRouting.enable();
+  
+  Serial.println("\nRouting Demo Started");
+  Serial.printf("Node ID: %u\n", mesh.getNodeId());
+}
+
+void loop() {
+  mesh.update();
+}

package/library.json

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

package/library.properties

@@ -1,5 +1,5 @@
-name=AlteriomPainlessMesh
-version=1.8.2
+name=Alteriom PainlessMesh
+version=1.8.4
 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
@@ -7,5 +7,5 @@ paragraph=painlessMesh is a user-friendly library for creating mesh networks wit
 category=Communication
 url=https://github.com/Alteriom/painlessMesh
 architectures=esp8266,esp32
-includes=painlessMesh.h
+includes=painlessMesh.h,AlteriomPainlessMesh.h
 depends=ArduinoJson, TaskScheduler

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alteriom/painlessmesh",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "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/arduino/wifi.hpp

@@ -367,16 +367,33 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     this->droppedConnectionCallbacks.push_back(
         [this](uint32_t nodeId, bool station) {
           if (station) {
-            if (WiFi.status() == WL_CONNECTED) WiFi.disconnect();
-            // TODO: Can we do this when we get signalled that wifi disconnect
-            // is complete
-            this->stationScan.yieldConnectToAP();
-            // Re-enable it if it was disabled
-            this->stationScan.task.enableIfNot();
+            if (WiFi.status() == WL_CONNECTED) {
+              WiFi.disconnect();
+              // Schedule reconnection after disconnect completes
+              // The WiFi event handler will signal when disconnect is complete
+              _pendingStationReconnect = true;
+            } else {
+              // Already disconnected, reconnect immediately
+              handleStationDisconnectComplete();
+            }
           }
         });
   }
 
+  /**
+   * Handle station disconnect completion
+   * Called after WiFi disconnect event is fully processed
+   * This ensures proper sequencing: disconnect -> event -> reconnect
+   */
+  void handleStationDisconnectComplete() {
+    if (_pendingStationReconnect) {
+      _pendingStationReconnect = false;
+      this->stationScan.yieldConnectToAP();
+      // Re-enable scanning if it was disabled
+      this->stationScan.task.enableIfNot();
+    }
+  }
+
   void tcpServerInit() {
     using namespace logger;
     Log(GENERAL, "tcpServerInit():\n");
@@ -387,26 +404,35 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     return;
   }
 
+  /**
+   * Establish TCP connection to mesh network
+   * 
+   * This method is called by WiFi event handlers when station gets IP address.
+   * It creates a TCP client connection to the mesh network gateway.
+   * 
+   * Architecture Note: This is intentionally kept in the Mesh class rather than
+   * extracted to a separate StationConnection class because:
+   * - It's tightly coupled with WiFi event lifecycle
+   * - Needs access to mesh state and callbacks
+   * - Moving it would increase complexity without clear benefits
+   * - The existing design keeps connection logic cohesive with WiFi management
+   */
   void tcpConnect() {
     using namespace logger;
-    // TODO: move to Connection or StationConnection?
     Log(GENERAL, "tcpConnect():\n");
     if (stationScan.manual && stationScan.port == 0)
       return;  // We have been configured not to connect to the mesh
 
-    // TODO: We could pass this to tcpConnect instead of loading it here
     if (WiFi.status() == WL_CONNECTED && WiFi.localIP()) {
+      // Determine target IP and port for connection
+      IPAddress targetIP = stationScan.manualIP ? stationScan.manualIP : WiFi.gatewayIP();
+      uint16_t targetPort = stationScan.port;
+      
       AsyncClient *pConn = new AsyncClient();
-
-      IPAddress ip = WiFi.gatewayIP();
-      if (stationScan.manualIP) {
-        ip = stationScan.manualIP;
-      }
-
       painlessmesh::tcp::connect<Connection, painlessmesh::Mesh<Connection>>(
-          (*pConn), ip, stationScan.port, (*this));
+          (*pConn), targetIP, targetPort, (*this));
     } else {
-      Log(ERROR, "tcpConnect(): err Something un expected in tcpConnect()\n");
+      Log(ERROR, "tcpConnect(): err Something unexpected in tcpConnect()\n");
     }
   }
 
@@ -688,6 +714,19 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       }
     );
     
+    // Send immediate broadcast so nodes can discover this bridge right away
+    // This ensures bridge is discoverable before the first periodic broadcast
+    this->addTask([this]() {
+      Log(STARTUP, "Sending initial bridge status broadcast\n");
+      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();
+    });
+    
     Log(STARTUP, "Bridge status broadcast enabled (interval: %d ms)\n", 
         this->bridgeStatusIntervalMs);
   }
@@ -1153,6 +1192,8 @@ class Mesh : public painlessmesh::Mesh<Connection> {
                 "eventSTADisconnectedHandler: "
                 "ARDUINO_EVENT_WIFI_STA_DISCONNECTED\n");
             this->droppedConnectionCallbacks.execute(0, true);
+            // Handle station disconnect completion after callbacks
+            this->handleStationDisconnectComplete();
             this->semaphoreGive();
           }
         },
@@ -1189,6 +1230,8 @@ class Mesh : public painlessmesh::Mesh<Connection> {
         [&](const WiFiEventStationModeDisconnected &event) {
           Log(CONNECTION, "Event: Station Mode Disconnected\n");
           this->droppedConnectionCallbacks.execute(0, true);
+          // Handle station disconnect completion after callbacks
+          this->handleStationDisconnectComplete();
         });
 
     eventSTAGotIPHandler =
@@ -1215,6 +1258,9 @@ class Mesh : public painlessmesh::Mesh<Connection> {
 #endif  // ESP8266
   AsyncServer *_tcpListener;
   std::shared_ptr<Task> bridgeStatusTask;
+  
+  // Station disconnect handling state
+  bool _pendingStationReconnect = false;
 
   // Bridge failover state and configuration
   enum ElectionState {

package/src/painlessMesh.h

@@ -1,6 +1,21 @@
 #ifndef _EASY_MESH_H_
 #define _EASY_MESH_H_
 
+/**
+ * @file painlessMesh.h
+ * @brief Main header file for Alteriom painlessMesh library
+ * 
+ * @version 1.8.4
+ * @date 2025-11-12
+ * 
+ * painlessMesh is a user-friendly library for creating mesh networks with 
+ * ESP8266 and ESP32 devices. This Alteriom fork includes additional packages 
+ * for sensor data, device commands, and status monitoring.
+ * 
+ * For the latest version and updates, visit:
+ * https://github.com/Alteriom/painlessMesh
+ */
+
 #include "painlessTaskOptions.h"
 
 #include <Arduino.h>

package/src/painlessMeshSTA.cpp

@@ -189,7 +189,13 @@ void ICACHE_FLASH_ATTR StationScan::connectToAP() {
         mesh->closeConnectionSTA();
         task.enableDelayed(10 * SCAN_INTERVAL);
         return;
-      } else if (aps.empty() || !ssid.equals(aps.begin()->ssid)) {
+      } else {
+        // For manual router connections, reconnect directly using WiFi.begin()
+        // Don't rely on scan results since router may be on different channel
+        Log(CONNECTION, 
+            "connectToAP(): Manual connection - attempting to reconnect to %s\n",
+            ssid.c_str());
+        WiFi.begin(ssid.c_str(), password.c_str());
         task.enableDelayed(SCAN_INTERVAL);
         return;
       }