@alteriom/painlessmesh 1.9.19 → 1.10.0

package/examples/sendToInternet/pc_mesh_node.cpp

@@ -0,0 +1,361 @@
+/**
+ * PC Mesh Node - Test sendToInternet() from Regular Node Through Bridge
+ * 
+ * This example demonstrates a PC-based mesh node that can join a painlessMesh
+ * network with ESP32/ESP8266 devices and test sendToInternet() functionality
+ * as a REGULAR NODE (not a bridge).
+ * 
+ * PURPOSE:
+ * Test the complete flow: PC Node → Bridge → Internet → Bridge → PC Node
+ * 
+ * CONNECTION METHOD:
+ * ESP nodes use WiFi mesh credentials: mesh.init(MESH_PREFIX, MESH_PASSWORD, &scheduler, MESH_PORT)
+ * PC node uses TCP/IP connection: connects to bridge's IP:port (e.g., 192.168.1.100:5555)
+ * 
+ * Both methods result in a mesh node that can use sendToInternet() - the difference
+ * is the transport layer (WiFi mesh vs TCP/IP), not the painlessMesh protocol.
+ * 
+ * SETUP:
+ * 1. Configure ESP bridge with: mesh.init("FishFarmMesh", "securepass", &scheduler, 5555)
+ * 2. Run this PC node: ./pc_mesh_node <bridge_ip> 5555
+ * 3. Run mock HTTP server: cd test/mock-http-server && python3 server.py
+ * 4. PC node sends HTTP requests via sendToInternet() through bridge
+ * 
+ * COMPILE:
+ * g++ -std=c++14 -o pc_mesh_node pc_mesh_node.cpp \
+ *     -I../../src -I../../test/include -I../../test/ArduinoJson/src \
+ *     -I../../test/TaskScheduler/src -I../../test/boost \
+ *     ../../src/scheduler.cpp \
+ *     -lboost_system -pthread
+ * 
+ * Or use CMake (see CMakeLists.txt in this directory)
+ * 
+ * RUN:
+ * ./pc_mesh_node 192.168.1.100 5555
+ * 
+ * Where:
+ * - 192.168.1.100 is your ESP bridge's IP address on the LAN
+ * - 5555 is the TCP port the bridge is listening on (MESH_PORT)
+ **/
+
+#include <iostream>
+#include <string>
+#include <memory>
+#include <chrono>
+#include <thread>
+
+// Boost includes
+#include <boost/asio/ip/address.hpp>
+
+// Arduino emulation for PC
+#include "Arduino.h"
+#include "boost/asynctcp.hpp"
+
+// painlessMesh includes
+#include "painlessmesh/mesh.hpp"
+#include "painlessmesh/gateway.hpp"
+
+// Global objects required by Arduino emulation
+WiFiClass WiFi;
+ESPClass ESP;
+
+using PMesh = painlessmesh::Mesh<painlessmesh::Connection>;
+using namespace painlessmesh;
+
+// Global logger
+painlessmesh::logger::LogClass Log;
+
+/**
+ * PC Mesh Node Class
+ * 
+ * This class wraps a painlessMesh instance and provides methods
+ * to connect to a bridge node and send Internet requests through it.
+ */
+class PCMeshNode : public PMesh {
+public:
+    PCMeshNode(Scheduler* scheduler, uint32_t nodeId, boost::asio::io_context& io)
+        : io_service(io), scheduler_(scheduler) {
+        this->nodeId = nodeId;
+        this->init(scheduler, this->nodeId);
+        
+        // Start listening server (so bridge can connect back to us if needed)
+        pServer = std::make_shared<AsyncServer>(io_service, this->nodeId);
+        painlessmesh::tcp::initServer<painlessmesh::Connection, PMesh>(*pServer, (*this));
+        
+        std::cout << "✓ PC Mesh Node initialized with ID: " << this->nodeId << std::endl;
+    }
+    
+    /**
+     * Connect to a bridge node
+     */
+    bool connectToBridge(const std::string& bridgeIP, uint16_t bridgePort) {
+        std::cout << "Connecting to bridge at " << bridgeIP << ":" << bridgePort << "..." << std::endl;
+        
+        try {
+            auto pClient = new AsyncClient(io_service);
+            
+            // Set up connection callbacks
+            bool connected = false;
+            pClient->onConnect([&connected](void*, AsyncClient* client) {
+                connected = true;
+                std::cout << "✓ Connected to bridge!" << std::endl;
+            });
+            
+            pClient->onDisconnect([](void*, AsyncClient* client) {
+                std::cout << "✗ Disconnected from bridge" << std::endl;
+            });
+            
+            // Connect to the bridge
+            painlessmesh::tcp::connect<Connection, PMesh>(
+                (*pClient), 
+                boost::asio::ip::make_address(bridgeIP), 
+                bridgePort,
+                (*this)
+            );
+            
+            // Wait for connection with timeout
+            auto startTime = std::chrono::steady_clock::now();
+            while (!connected) {
+                this->update();
+                io_service.poll();
+                
+                // Use longer sleep to reduce CPU usage during wait
+                std::this_thread::sleep_for(std::chrono::milliseconds(100));
+                
+                auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
+                    std::chrono::steady_clock::now() - startTime
+                ).count();
+                
+                if (elapsed > 30) {
+                    std::cout << "✗ Connection timeout after 30 seconds" << std::endl;
+                    return false;
+                }
+            }
+            
+            return true;
+        } catch (const std::exception& e) {
+            std::cout << "✗ Connection error: " << e.what() << std::endl;
+            return false;
+        }
+    }
+    
+    /**
+     * Send an HTTP request to the Internet via the bridge
+     */
+    void testSendToInternet(const std::string& url, const std::string& payload = "") {
+        std::cout << "\n📡 Testing sendToInternet()..." << std::endl;
+        std::cout << "   URL: " << url << std::endl;
+        if (!payload.empty()) {
+            std::cout << "   Payload: " << payload << std::endl;
+        }
+        
+        // Check if we have Internet connection through bridge
+        if (!this->hasInternetConnection()) {
+            std::cout << "   ⚠️  No Internet connection available through bridge" << std::endl;
+            std::cout << "   Make sure the bridge node has router access and is connected" << std::endl;
+            return;
+        }
+        
+        std::cout << "   ✓ Bridge with Internet found" << std::endl;
+        
+        // Send the request
+        uint32_t msgId = this->sendToInternet(
+            url,
+            payload,
+            [url](bool success, uint16_t httpStatus, std::string error) {
+                std::cout << "\n📥 Response received:" << std::endl;
+                std::cout << "   Success: " << (success ? "✓ YES" : "✗ NO") << std::endl;
+                std::cout << "   HTTP Status: " << httpStatus << std::endl;
+                if (!error.empty()) {
+                    std::cout << "   Error: " << error << std::endl;
+                }
+                
+                // Validate the result
+                if (success && httpStatus == 200) {
+                    std::cout << "   🎉 TEST PASSED: Request successful!" << std::endl;
+                } else {
+                    std::cout << "   ❌ TEST FAILED: Request unsuccessful" << std::endl;
+                }
+            }
+        );
+        
+        if (msgId > 0) {
+            std::cout << "   ✓ Request queued with message ID: " << msgId << std::endl;
+            std::cout << "   Waiting for response from bridge..." << std::endl;
+        } else {
+            std::cout << "   ✗ Failed to queue request" << std::endl;
+        }
+    }
+    
+    /**
+     * Main update loop
+     */
+    void runUpdateLoop(int durationSeconds = 0) {
+        std::cout << "\n🔄 Starting update loop";
+        if (durationSeconds > 0) {
+            std::cout << " (running for " << durationSeconds << " seconds)";
+        }
+        std::cout << "..." << std::endl;
+        
+        auto startTime = std::chrono::steady_clock::now();
+        
+        while (true) {
+            this->update();
+            io_service.poll();
+            scheduler_->execute();
+            
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            
+            if (durationSeconds > 0) {
+                auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
+                    std::chrono::steady_clock::now() - startTime
+                ).count();
+                
+                if (elapsed >= durationSeconds) {
+                    std::cout << "✓ Update loop completed after " << elapsed << " seconds" << std::endl;
+                    break;
+                }
+            }
+        }
+    }
+    
+    std::shared_ptr<AsyncServer> pServer;
+    boost::asio::io_context& io_service;
+    Scheduler* scheduler_;
+};
+
+/**
+ * Print usage information
+ */
+void printUsage(const char* programName) {
+    std::cout << "\nUsage: " << programName << " <bridge_ip> <bridge_port> [mock_server_ip] [mock_server_port]\n" << std::endl;
+    std::cout << "Arguments:" << std::endl;
+    std::cout << "  bridge_ip        IP address of ESP bridge node (e.g., 192.168.1.100)" << std::endl;
+    std::cout << "  bridge_port      Mesh port of bridge (default: 5555)" << std::endl;
+    std::cout << "  mock_server_ip   IP address of mock HTTP server (optional, default: localhost)" << std::endl;
+    std::cout << "  mock_server_port Port of mock HTTP server (optional, default: 8080)" << std::endl;
+    std::cout << "\nExample:" << std::endl;
+    std::cout << "  " << programName << " 192.168.1.100 5555" << std::endl;
+    std::cout << "  " << programName << " 192.168.1.100 5555 192.168.1.50 8080" << std::endl;
+    std::cout << std::endl;
+}
+
+/**
+ * Run automated test suite
+ */
+void runTests(PCMeshNode& node, const std::string& mockServerUrl) {
+    std::cout << "\n" << std::string(60, '=') << std::endl;
+    std::cout << "Starting Automated Test Suite" << std::endl;
+    std::cout << std::string(60, '=') << std::endl;
+    
+    // Wait for mesh to stabilize
+    std::cout << "\nWaiting 5 seconds for mesh to stabilize..." << std::endl;
+    std::this_thread::sleep_for(std::chrono::seconds(5));
+    
+    // Test 1: HTTP 200 Success
+    std::cout << "\n[Test 1/5] HTTP 200 Success" << std::endl;
+    node.testSendToInternet(mockServerUrl + "/status/200");
+    node.runUpdateLoop(5);
+    
+    // Test 2: HTTP 404 Not Found
+    std::cout << "\n[Test 2/5] HTTP 404 Not Found" << std::endl;
+    node.testSendToInternet(mockServerUrl + "/status/404");
+    node.runUpdateLoop(5);
+    
+    // Test 3: HTTP 500 Server Error
+    std::cout << "\n[Test 3/5] HTTP 500 Server Error" << std::endl;
+    node.testSendToInternet(mockServerUrl + "/status/500");
+    node.runUpdateLoop(5);
+    
+    // Test 4: WhatsApp API Simulation
+    std::cout << "\n[Test 4/5] WhatsApp API Simulation" << std::endl;
+    std::string whatsappUrl = mockServerUrl + "/whatsapp?phone=%2B1234567890&apikey=test&text=Hello%20from%20PC%20node";
+    node.testSendToInternet(whatsappUrl);
+    node.runUpdateLoop(5);
+    
+    // Test 5: Echo with JSON Payload
+    std::cout << "\n[Test 5/5] Echo Endpoint with JSON Payload" << std::endl;
+    // Using raw string literal for safer JSON construction
+    // In production, consider using ArduinoJson for proper JSON handling
+    char jsonBuffer[256];
+    snprintf(jsonBuffer, sizeof(jsonBuffer), 
+             R"({"source":"pc_node","test":"sendToInternet","timestamp":%lu})", 
+             (unsigned long)millis());
+    std::string payload(jsonBuffer);
+    node.testSendToInternet(mockServerUrl + "/echo", payload);
+    node.runUpdateLoop(5);
+    
+    std::cout << "\n" << std::string(60, '=') << std::endl;
+    std::cout << "Test Suite Complete!" << std::endl;
+    std::cout << std::string(60, '=') << std::endl;
+}
+
+/**
+ * Main entry point
+ */
+int main(int argc, char* argv[]) {
+    std::cout << "\n" << std::string(60, '=') << std::endl;
+    std::cout << "painlessMesh - PC Mesh Node Example" << std::endl;
+    std::cout << "Testing sendToInternet() Through Bridge" << std::endl;
+    std::cout << std::string(60, '=') << std::endl;
+    
+    // Parse command line arguments
+    if (argc < 3) {
+        printUsage(argv[0]);
+        return 1;
+    }
+    
+    std::string bridgeIP = argv[1];
+    uint16_t bridgePort = std::stoi(argv[2]);
+    std::string mockServerIP = (argc > 3) ? argv[3] : "127.0.0.1";
+    uint16_t mockServerPort = (argc > 4) ? std::stoi(argv[4]) : 8080;
+    
+    std::cout << "\nConfiguration:" << std::endl;
+    std::cout << "  Bridge:      " << bridgeIP << ":" << bridgePort << std::endl;
+    std::cout << "  Mock Server: http://" << mockServerIP << ":" << mockServerPort << std::endl;
+    std::cout << std::endl;
+    
+    // Setup logging
+    Log.setLogLevel(painlessmesh::logger::ERROR | painlessmesh::logger::STARTUP | 
+                   painlessmesh::logger::CONNECTION | painlessmesh::logger::COMMUNICATION);
+    
+    // Create IO context and scheduler
+    boost::asio::io_context io_service;
+    Scheduler scheduler;
+    
+    // Create PC mesh node with a random node ID
+    uint32_t nodeId = 1000000 + (millis() % 1000000);
+    PCMeshNode node(&scheduler, nodeId, io_service);
+    
+    // Enable sendToInternet API
+    node.enableSendToInternet();
+    std::cout << "✓ sendToInternet() API enabled" << std::endl;
+    
+    // Connect to bridge
+    if (!node.connectToBridge(bridgeIP, bridgePort)) {
+        std::cerr << "\n✗ Failed to connect to bridge" << std::endl;
+        std::cerr << "Make sure:" << std::endl;
+        std::cerr << "  1. Bridge node is running on " << bridgeIP << ":" << bridgePort << std::endl;
+        std::cerr << "  2. Firewall allows TCP connections on port " << bridgePort << std::endl;
+        std::cerr << "  3. PC and bridge are on the same network" << std::endl;
+        return 1;
+    }
+    
+    // Wait for mesh to establish
+    std::cout << "\nWaiting for mesh to establish..." << std::endl;
+    node.runUpdateLoop(10);
+    
+    // Build mock server URL
+    std::string mockServerUrl = "http://" + mockServerIP + ":" + std::to_string(mockServerPort);
+    
+    // Run automated tests
+    runTests(node, mockServerUrl);
+    
+    // Keep running for a bit to receive any late responses
+    std::cout << "\nKeeping connection alive for 10 more seconds..." << std::endl;
+    node.runUpdateLoop(10);
+    
+    std::cout << "\n✓ PC Mesh Node shutting down..." << std::endl;
+    
+    return 0;
+}

package/examples/tcpRetryConfig/README.md

@@ -0,0 +1,110 @@
+# tcpRetryConfig
+
+Tuning painlessMesh's TCP connection retry behaviour with
+`setTcpRetryConfig()` (issue
+[#378](https://github.com/Alteriom/painlessMesh/issues/378)).
+
+## What this controls
+
+When a node acquires an IP and tries to open its TCP connection to the mesh,
+that connection can fail — the parent's TCP server may not be ready yet, the
+network stack may still be settling, or several nodes may be connecting at
+once. painlessMesh retries with exponential backoff before giving up and
+falling back to a full WiFi reconnect.
+
+Five parameters describe that behaviour:
+
+| Field | Default | Meaning |
+|---|---|---|
+| `maxRetries` | 5 | TCP connect attempts after the first before giving up |
+| `retryDelayMs` | 1000 | Base delay between retries; scaled 1x, 2x, 4x, 8x, 8x |
+| `stabilizationDelayMs` | 500 | Wait after IP acquisition before the first attempt |
+| `exhaustionReconnectDelayMs` | 10000 | Wait before the WiFi reconnect that follows exhaustion |
+| `failureBlockDurationMs` | 60000 | How long a failed peer is skipped during AP selection |
+
+With the defaults, a node that cannot reach its parent spends
+1 + 2 + 4 + 8 + 8 = **23 s** retrying, then waits another **10 s** before
+reconnecting WiFi, and will not re-select that same peer for **60 s**.
+
+## Profiles in this sketch
+
+Switch with `#define ACTIVE_PROFILE`.
+
+| | `PROFILE_REALTIME` | default | `PROFILE_RELIABLE` | `PROFILE_BATTERY` |
+|---|---|---|---|---|
+| `maxRetries` | 1 | 5 | 10 | 2 |
+| `retryDelayMs` | 200 | 1000 | 2000 | 3000 |
+| `stabilizationDelayMs` | 100 | 500 | 1000 | 500 |
+| `exhaustionReconnectDelayMs` | 1000 | 10000 | 30000 | 60000 |
+| `failureBlockDurationMs` | 5000 | 60000 | 180000 | 300000 |
+| worst-case retry time | 0.2 s | 23 s | 126 s | 9 s |
+| full failure cycle | 1.2 s | 33 s | 156 s | 69 s |
+
+- **`PROFILE_REALTIME`** — real-time sensor and LED meshes, the use case from
+  [discussion #368](https://github.com/Alteriom/painlessMesh/discussions/368).
+  A node stuck in a 23 s backoff is worse than one that drops and re-scans, so
+  fail fast and move on.
+- **`PROFILE_RELIABLE`** — industrial meshes where getting connected matters
+  more than how long it takes. `maxRetries = 10` is the maximum the library
+  accepts.
+- **`PROFILE_BATTERY`** — every retry is radio-on time. Few attempts, spaced
+  widely, and a long blocklist so the node stops waking up for a peer that is
+  known to be down.
+
+## Clamping
+
+`setTcpRetryConfig()` coerces the two values that can render a node unusable:
+
+- `maxRetries` is capped at **10**. Each retry allocates an `AsyncClient` and
+  schedules a task, so an unbounded value is a heap and recursion-depth hazard
+  on ESP8266.
+- `retryDelayMs` is held between **50 ms** and **60000 ms**. A zero delay would
+  schedule retries with no spacing — a hot loop allocating an `AsyncClient`
+  every scheduler tick. The ceiling keeps `retryDelayMs * 8` clear of `uint32_t`
+  overflow.
+
+Everything else passes through untouched, including zeros, which are
+meaningful:
+
+- `maxRetries = 0` — do not retry at all; fall straight back to a WiFi
+  reconnect on the first TCP error.
+- `stabilizationDelayMs = 0` — attempt the TCP connection immediately on IP
+  acquisition.
+- `exhaustionReconnectDelayMs = 0` — reconnect WiFi immediately after
+  exhaustion.
+- `failureBlockDurationMs = 0` — never blocklist a failed peer.
+
+Call `getTcpRetryConfig()` after setting to see what actually took effect; the
+sketch prints this at startup.
+
+## The defaults exist for a reason
+
+painlessMesh 1.9.x deliberately *raised* these values (retries 3 → 5, base
+delay 500 ms → 1000 ms) to fix real-world mesh instability. Tuning them back
+down reintroduces the problems that change fixed. Symptoms of an over-aggressive
+profile:
+
+- **Connection churn** — nodes repeatedly connect and drop. `maxRetries` is too
+  low for how long your parent actually takes to be ready; raise it or raise
+  `stabilizationDelayMs`.
+- **Rapid reconnect loops / network congestion** — a node hammers a parent whose
+  TCP server is down. `exhaustionReconnectDelayMs` is too short.
+- **The same dead peer is picked over and over** — `failureBlockDurationMs` is
+  shorter than one full retry-plus-reconnect cycle, so the peer comes off the
+  blocklist before the node has finished failing over. Keep
+  `failureBlockDurationMs` greater than
+  `(sum of retry backoffs) + exhaustionReconnectDelayMs`. All three profiles
+  above satisfy this; `catch_tcp_blocklist.cpp` pins it as a test.
+
+Change one parameter at a time and watch the serial log with
+`mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION)`.
+
+## Building
+
+```bash
+# PlatformIO
+pio run -e esp32     # or -e esp8266
+
+# Arduino CLI
+arduino-cli compile --fqbn esp32:esp32:esp32 examples/tcpRetryConfig/tcpRetryConfig.ino
+```

package/examples/tcpRetryConfig/platformio.ini

@@ -0,0 +1,26 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+
+lib_ldf_mode = deep+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_extra_dirs = ../../
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
+
+[env:esp32]
+platform = espressif32
+board = esp32dev
+framework = arduino
+lib_extra_dirs = ../../
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/AsyncTCP

package/examples/tcpRetryConfig/tcpRetryConfig.ino

@@ -0,0 +1,154 @@
+//************************************************************
+// Tuning the TCP connection retry behaviour (issue #378)
+//
+// painlessMesh retries a failed TCP connection with exponential backoff
+// before giving up and falling back to a full WiFi reconnect. The defaults
+// (5 retries, 1s base delay -> 1s, 2s, 4s, 8s, 8s) are tuned for general
+// purpose meshes and deliberately favour reliability over speed.
+//
+// setTcpRetryConfig() lets you pick a different trade-off. Three ready-made
+// profiles are shown below; switch between them with ACTIVE_PROFILE.
+//
+// Read examples/tcpRetryConfig/README.md before changing these values - the
+// defaults exist because 1.9.x raised them to fix real mesh instability.
+//************************************************************
+#include <painlessMesh.h>
+
+#define   MESH_SSID       "whateverYouLike"
+#define   MESH_PASSWORD   "somethingSneaky"
+#define   MESH_PORT       5555
+
+// ---------------------------------------------------------------------------
+// Profiles
+// ---------------------------------------------------------------------------
+#define PROFILE_REALTIME  1   // low latency: fail fast, reconnect fast
+#define PROFILE_RELIABLE  2   // industrial: many retries, long backoff
+#define PROFILE_BATTERY   3   // conserve power: few retries, long block
+
+// >>> Change this line to try a different profile <<<
+#define ACTIVE_PROFILE    PROFILE_REALTIME
+
+// Prototypes
+void sendMessage();
+void receivedCallback(uint32_t from, String &msg);
+void newConnectionCallback(uint32_t nodeId);
+void droppedConnectionCallback(uint32_t nodeId);
+
+Scheduler     userScheduler;
+painlessMesh  mesh;
+
+Task taskSendMessage(TASK_SECOND * 5, TASK_FOREVER, &sendMessage);
+
+// Build the retry configuration for the selected profile.
+painlessmesh::tcp::TcpRetryConfig buildRetryConfig() {
+  painlessmesh::tcp::TcpRetryConfig cfg;  // starts at the library defaults
+
+#if ACTIVE_PROFILE == PROFILE_REALTIME
+  // Real-time sensor / LED meshes: a stalled node is worse than a dropped
+  // one. Give up on the TCP handshake almost immediately and go straight
+  // back to scanning for another parent.
+  cfg.maxRetries = 1;                    // default 5
+  cfg.retryDelayMs = 200;                // default 1000
+  cfg.stabilizationDelayMs = 100;        // default 500
+  cfg.exhaustionReconnectDelayMs = 1000; // default 10000
+  cfg.failureBlockDurationMs = 5000;     // default 60000
+
+#elif ACTIVE_PROFILE == PROFILE_RELIABLE
+  // Industrial / high-reliability meshes: connectivity matters more than
+  // how long it takes to get there. Retry patiently and keep a failed peer
+  // out of the running for a good while.
+  cfg.maxRetries = 10;                     // default 5 (this is the maximum)
+  cfg.retryDelayMs = 2000;                 // default 1000
+  cfg.stabilizationDelayMs = 1000;         // default 500
+  cfg.exhaustionReconnectDelayMs = 30000;  // default 10000
+  // Must exceed one full failure cycle (126s of retries + 30s reconnect),
+  // otherwise a dead peer leaves the blocklist before we finished failing
+  // over and gets re-selected immediately.
+  cfg.failureBlockDurationMs = 180000;     // default 60000
+
+#elif ACTIVE_PROFILE == PROFILE_BATTERY
+  // Battery-powered nodes: every retry is radio time. Few attempts, spaced
+  // widely, and a long blocklist so we do not keep waking up for a peer
+  // that is known to be down.
+  cfg.maxRetries = 2;                      // default 5
+  cfg.retryDelayMs = 3000;                 // default 1000
+  cfg.stabilizationDelayMs = 500;          // default 500
+  cfg.exhaustionReconnectDelayMs = 60000;  // default 10000
+  cfg.failureBlockDurationMs = 300000;     // default 60000
+
+#else
+  #error "ACTIVE_PROFILE must be one of PROFILE_REALTIME, PROFILE_RELIABLE, PROFILE_BATTERY"
+#endif
+
+  return cfg;
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION);
+
+  // Apply the retry configuration BEFORE init() so the very first connection
+  // attempt already uses it.
+  mesh.setTcpRetryConfig(buildRetryConfig());
+
+  mesh.init(MESH_SSID, MESH_PASSWORD, &userScheduler, MESH_PORT);
+
+  // Read the configuration back. Values outside safe operating bounds are
+  // clamped by the setter, so this prints what is actually in effect - not
+  // necessarily what was requested.
+  painlessmesh::tcp::TcpRetryConfig active = mesh.getTcpRetryConfig();
+  Serial.println();
+  Serial.println(F("Effective TCP retry configuration:"));
+  Serial.printf("  maxRetries                 = %u\n",
+                (unsigned)active.maxRetries);
+  Serial.printf("  retryDelayMs               = %u\n",
+                (unsigned)active.retryDelayMs);
+  Serial.printf("  stabilizationDelayMs       = %u\n",
+                (unsigned)active.stabilizationDelayMs);
+  Serial.printf("  exhaustionReconnectDelayMs = %u\n",
+                (unsigned)active.exhaustionReconnectDelayMs);
+  Serial.printf("  failureBlockDurationMs     = %u\n",
+                (unsigned)active.failureBlockDurationMs);
+
+  // Worst-case time spent retrying before falling back to a WiFi reconnect.
+  uint32_t worstCase = 0;
+  for (uint8_t i = 0; i < active.maxRetries; ++i) {
+    worstCase += painlessmesh::tcp::retryBackoffDelay(active, i);
+  }
+  Serial.printf("  -> worst-case retry time   = %u ms\n", (unsigned)worstCase);
+  Serial.printf("  -> plus reconnect delay    = %u ms\n",
+                (unsigned)(worstCase + active.exhaustionReconnectDelayMs));
+  Serial.println();
+
+  mesh.onReceive(&receivedCallback);
+  mesh.onNewConnection(&newConnectionCallback);
+  mesh.onDroppedConnection(&droppedConnectionCallback);
+
+  userScheduler.addTask(taskSendMessage);
+  taskSendMessage.enable();
+}
+
+void loop() {
+  mesh.update();
+}
+
+void sendMessage() {
+  String msg = "Hello from node ";
+  msg += mesh.getNodeId();
+  mesh.sendBroadcast(msg);
+}
+
+void receivedCallback(uint32_t from, String &msg) {
+  Serial.printf("tcpRetryConfig: Received from %u msg=%s\n", from, msg.c_str());
+}
+
+void newConnectionCallback(uint32_t nodeId) {
+  Serial.printf("--> Connected to node %u\n", nodeId);
+}
+
+void droppedConnectionCallback(uint32_t nodeId) {
+  // With an aggressive profile you should expect to see this more often -
+  // and to see the reconnect that follows it happen much sooner.
+  Serial.printf("--> Dropped connection to node %u\n", nodeId);
+}

package/keywords.txt

@@ -4,6 +4,7 @@
 painlessMesh	KEYWORD1
 Scheduler	KEYWORD1
 Task	KEYWORD1
+TcpRetryConfig	KEYWORD1
 
 # Methods and Functions (KEYWORD2)
 init	KEYWORD2
@@ -18,6 +19,8 @@ getNodeList	KEYWORD2
 getNodeId	KEYWORD2
 getNodeTime	KEYWORD2
 setDebugMsgTypes	KEYWORD2
+setTcpRetryConfig	KEYWORD2
+getTcpRetryConfig	KEYWORD2
 subConnectionJson	KEYWORD2
 asNodeTree	KEYWORD2
 

package/library.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "https://github.com/Alteriom/painlessMesh"
   },
-  "version": "1.9.19",
+  "version": "1.10.0",
   "frameworks": [
     "arduino"
   ],
@@ -87,7 +87,10 @@
     "examples/namedMesh/namedMesh.ino",
     "examples/otaReceiver/otaReceiver.ino",
     "examples/otaSender/otaSender.ino",
+    "examples/alteriom/mppt_example/alteriom_mppt_example.ino",
     "examples/priority/priority_basic_example.ino",
+    "examples/priority/priority_with_queue.ino",
+    "examples/sendToInternet/mock_server_test.ino",
     "examples/sendToInternet/sendToInternet.ino",
     "examples/sharedGateway/sharedGateway.ino",
     "examples/startHere/startHere.ino",