@alteriom/painlessmesh 1.9.0 → 1.9.2

package/CHANGELOG.md

@@ -5,6 +5,58 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.2] - 2025-12-01
+
+### Changed
+
+- **Release Version Update** - Consolidated release across all distribution channels
+  - Synchronized version numbers in library.properties, library.json, and package.json
+  - Ensures consistent versioning for NPM, PlatformIO, and Arduino Library Manager
+
+### Documentation
+
+- **README Update** - Updated version banner to reflect 1.9.2 release
+
+## [1.9.1] - 2025-12-01
+
+### Added
+
+- **Isolated Bridge Retry Mechanism** - Nodes that fail initial bridge setup can now retry automatically
+  - New `attemptIsolatedBridgePromotion()` method for direct bridge promotion when isolated
+  - Periodic retry task runs every 60 seconds when node is isolated (no mesh connections)
+  - Requires 6 consecutive empty mesh scans before attempting retry
+  - Limited to 5 actual retry attempts before 5-minute cooldown
+  - Counter resets on success, mesh reconnection, or after cooldown
+  - **Impact**: Fixes issue where nodes with `INITIAL_BRIDGE=true` that fail router connection
+    would never retry becoming a bridge (endless "Bridge monitor: Skipping - no active mesh connections")
+
+- **Comprehensive Test Coverage** - Added tests for all woodlist use cases
+  - Use Case 1: INITIAL_BRIDGE=true with router temporarily unavailable
+  - Use Case 2: Regular node with no mesh found - isolated retry
+  - Use Case 3: Router association refused error handling
+  - Use Case 4: Node loses mesh connection to bridge
+  - Use Case 5: Multiple retry attempts with cooldown
+  - Use Case 6: Correct serial output for bridge failure
+
+### Fixed
+
+- **Bridge Retry for Isolated Nodes** (#212) - Fixed nodes not retrying bridge connection
+  - **Root Cause**: Bridge monitor task skips isolated nodes to prevent split-brain scenarios,
+    but this prevented retry when initial bridge setup fails
+  - **Symptom**: Endless "Bridge monitor: Skipping - no active mesh connections" log messages
+  - **Solution**: Added separate isolated bridge retry mechanism that activates when:
+    - Node has router credentials configured
+    - Node is isolated (no mesh connections)
+    - Multiple empty scans have occurred (mesh not found)
+  - **Behavior**: Node scans for router, checks RSSI, and attempts direct bridge promotion
+  - Addresses feedback from @woodlist regarding failed initial bridge setup scenarios
+
+### Changed
+
+- **Updated bridge_failover Example** - Added documentation about automatic retry behavior
+  - Example now notes that isolated nodes will retry bridge connection periodically
+  - Clearer messaging about fallback and retry mechanisms
+
 ## [1.9.0] - 2025-11-30
 
 ### Added

package/README.md

@@ -4,7 +4,7 @@
 
 <div align="center">
 
-**Version 1.9.0** - Major update with improved bridge detection, consolidated examples, and cleaned documentation
+**Version 1.9.2** - Consolidated release across all distribution channels
 
 [![CI/CD Pipeline](https://github.com/Alteriom/painlessMesh/actions/workflows/ci.yml/badge.svg)](https://github.com/Alteriom/painlessMesh/actions/workflows/ci.yml)
 [![Documentation](https://github.com/Alteriom/painlessMesh/actions/workflows/docs.yml/badge.svg)](https://github.com/Alteriom/painlessMesh/actions/workflows/docs.yml)

package/examples/bridge_failover/README.md

@@ -2,6 +2,56 @@
 
 This example demonstrates automatic bridge failover with RSSI-based election in painlessMesh networks.
 
+## ⚠️ Important: Understanding Internet Connectivity
+
+**`hasInternetConnection()` indicates a GATEWAY has Internet access, NOT that this node can make HTTP requests!**
+
+Regular mesh nodes do NOT have direct IP routing to the Internet. They only communicate via the painlessMesh protocol (node-to-node messages). When `hasInternetConnection()` returns `true`, it means a bridge/gateway node in the mesh has Internet access.
+
+**To send data to the Internet from a regular mesh node, you must:**
+
+1. **Use `sendToInternet()`** - Routes data through a gateway node
+2. **Use `initAsSharedGateway()`** - Configures all nodes with direct router access (requires router credentials - see below)
+3. **Send mesh messages to the bridge** - Bridge node handles Internet communication
+
+**DON'T do this on regular mesh nodes:**
+```cpp
+// This will FAIL with "connection refused" on regular mesh nodes!
+HTTPClient http;
+http.begin("https://api.example.com");
+int httpCode = http.GET();  // FAILS!
+```
+
+**DO this instead:**
+```cpp
+// Check if a gateway is available, then use sendToInternet()
+if (mesh.hasInternetConnection()) {
+  mesh.sendToInternet(
+    "https://api.example.com/data",
+    jsonPayload,
+    [](bool success, uint16_t status, String error) {
+      Serial.printf("Delivery: %s\n", success ? "OK" : error.c_str());
+    }
+  );
+}
+```
+
+For use cases where all nodes need direct Internet access, see the [sharedGateway example](../sharedGateway/).
+
+**Note on `initAsSharedGateway()` usage:**
+```cpp
+// initAsSharedGateway() requires ROUTER credentials since all nodes connect to router
+// Signature: initAsSharedGateway(meshSSID, meshPassword, ROUTER_SSID, ROUTER_PASSWORD, scheduler, port)
+mesh.initAsSharedGateway(
+  MESH_PREFIX,      // Mesh network name
+  MESH_PASSWORD,    // Mesh network password
+  ROUTER_SSID,      // Your WiFi router SSID (required!)
+  ROUTER_PASSWORD,  // Your WiFi router password (required!)
+  &userScheduler,   // Task scheduler
+  MESH_PORT         // TCP port for mesh
+);
+```
+
 ## Problem Statement
 
 In a typical mesh network with a bridge node connecting to the Internet, the bridge represents a single point of failure. If the bridge loses Internet connectivity or goes offline, the entire mesh loses its gateway to the Internet.
@@ -483,6 +533,38 @@ evaluateElection(): 1 candidates
 - Ensure bridge timeout passed (60 seconds)
 - Verify nodes can see router (RSSI scan)
 
+### Isolated Node Never Retries Bridge Connection (Fixed in v1.9.1)
+
+**Symptoms**: Node with `INITIAL_BRIDGE=true` fails to connect to router at startup, then endlessly logs "Bridge monitor: Skipping - no active mesh connections" without ever retrying to become a bridge.
+
+**Root Cause (Before v1.9.1)**: 
+When a node configured as `INITIAL_BRIDGE=true` failed to connect to the router during setup(), it correctly fell back to regular node mode with failover enabled. However, the bridge monitor task skipped isolated nodes (those with no mesh connections) to prevent split-brain scenarios. This prevented the node from ever retrying to become a bridge.
+
+**Solution (Automatic in v1.9.1+)**:
+A new isolated bridge retry mechanism now handles this case:
+1. Periodic task runs every 60 seconds when the node is isolated
+2. After 6 consecutive empty mesh scans, retry is triggered
+3. Node scans for router signal and checks minimum RSSI threshold (-80 dBm)
+4. If router is visible with adequate signal, attempts direct bridge promotion
+5. Limited to 5 retry attempts before 5-minute cooldown
+6. Counter resets on success, mesh reconnection, or after cooldown
+
+**Expected Behavior** (v1.9.1+):
+```
+Isolated bridge retry: Node isolated with 6 empty scans, attempting bridge promotion
+=== Isolated Bridge Promotion Attempt ===
+Attempt 1 of 5
+attemptIsolatedBridgePromotion(): Router visible with RSSI -45 dBm
+Attempting direct bridge promotion (bypassing election)
+✓ Isolated bridge promotion complete on channel 6
+```
+
+**Manual Solutions**:
+- Update to painlessMesh v1.9.1 or later
+- Ensure router credentials are configured: `mesh.setRouterCredentials()`
+- Ensure failover is enabled: `mesh.enableBridgeFailover(true)`
+- Check router is visible and signal strength is adequate (>= -80 dBm)
+
 ### Multiple Nodes Claim Bridge Role
 
 **Symptoms**: Split-brain scenario with multiple bridges

package/examples/bridge_failover/bridge_failover.ino

@@ -5,6 +5,27 @@
 // When the primary bridge loses Internet connectivity, nodes automatically
 // hold an election to select a new bridge based on router signal strength.
 //
+// IMPORTANT - UNDERSTANDING INTERNET CONNECTIVITY:
+// ================================================
+// The mesh.hasInternetConnection() method checks if a GATEWAY (bridge) node
+// has Internet access - it does NOT mean THIS node can make HTTP requests!
+//
+// Regular mesh nodes do NOT have direct IP routing to the Internet.
+// They only communicate via the painlessMesh protocol (node-to-node).
+//
+// To send data to the Internet from a regular node:
+//   1. Use mesh.sendToInternet() to route through a gateway
+//   2. Use initAsSharedGateway() so all nodes have router access
+//      NOTE: initAsSharedGateway() requires ROUTER credentials:
+//      mesh.initAsSharedGateway(MESH_PREFIX, MESH_PASSWORD,
+//                               ROUTER_SSID, ROUTER_PASSWORD,  // Router creds required!
+//                               &userScheduler, MESH_PORT);
+//   3. Send mesh messages to bridge node which handles Internet comms
+//
+// DON'T DO THIS on regular mesh nodes:
+//   HTTPClient http;
+//   http.begin("https://api.example.com");  // FAILS with "connection refused"
+//
 // Hardware Required:
 // - ESP32 or ESP8266
 // - WiFi router with Internet connection
@@ -35,6 +56,8 @@
 // - Seamless promotion to bridge role
 // - Bridge takeover announcements
 // - Automatic mesh channel detection for bridge discovery
+// - Isolated node retry: Nodes that fail initial bridge setup will
+//   periodically retry connecting to the router when no mesh is found
 //
 // Important Note:
 // Regular nodes MUST use channel auto-detection (channel=0) to discover
@@ -145,6 +168,7 @@ void setup() {
       mesh.setElectionTimeout(5000);
       
       Serial.println("✓ Running as regular node - will auto-promote when router available");
+      Serial.println("Note: If isolated (no mesh found), will retry bridge connection periodically");
     }
   } else {
     Serial.println("Mode: REGULAR NODE (Failover Enabled)");
@@ -201,7 +225,11 @@ void loop() {
     
     Serial.println("\n--- Bridge Status ---");
     Serial.printf("I am bridge: %s\n", mesh.isBridge() ? "YES" : "NO");
-    Serial.printf("Internet available: %s\n", mesh.hasInternetConnection() ? "YES" : "NO");
+    
+    // NOTE: "Internet available" means a GATEWAY node has Internet access.
+    // This does NOT mean THIS node can make direct HTTP requests!
+    // Regular mesh nodes must use sendToInternet() to reach the Internet.
+    Serial.printf("Internet available via gateway: %s\n", mesh.hasInternetConnection() ? "YES" : "NO");
     Serial.printf("Mesh connections active: %s\n", mesh.hasActiveMeshConnections() ? "YES" : "NO");
     
     auto bridges = mesh.getBridges();

package/examples/sendToInternet/README.md

@@ -0,0 +1,158 @@
+# sendToInternet Example - WhatsApp/Callmebot Integration
+
+This example demonstrates how to use `mesh.sendToInternet()` to send data to Internet endpoints (like WhatsApp via Callmebot) from **any node** in the mesh network.
+
+## ⚠️ Important: Understanding sendToInternet()
+
+Regular mesh nodes do **NOT** have direct IP routing to the Internet. The `sendToInternet()` API routes your data **through a gateway node** that has Internet access.
+
+```
+┌─────────────┐                    ┌─────────────┐                    ┌─────────────┐
+│ Sensor Node │ ──sendToInternet──▶│   Gateway   │ ──HTTP Request──▶  │  Internet   │
+│  (no WiFi)  │                    │ (has WiFi)  │                    │  (Callmebot)│
+└─────────────┘                    └─────────────┘                    └─────────────┘
+       ▲                                  │                                  │
+       │                                  │                                  │
+       └──────────── ACK/Result ◀─────────┴──────────── HTTP Response ◀──────┘
+```
+
+**This is different from making direct HTTP requests** (which would fail on regular mesh nodes with "connection refused").
+
+## Use Cases
+
+- 🐟 **Fish farm sensors** sending O2 alarms to WhatsApp
+- 🏭 **Industrial IoT** sending alerts to cloud APIs
+- 🏠 **Smart home sensors** reporting to home automation servers
+- 📊 **Remote monitoring** sending data to ThingsBoard, AWS IoT, etc.
+
+## Prerequisites
+
+1. **At least one node must be a bridge/gateway** with Internet access
+2. **OR** use `initAsSharedGateway()` so all nodes have Internet
+3. Enable the API after mesh init: `mesh.enableSendToInternet()`
+
+## Setup for Callmebot WhatsApp
+
+1. Get your API key from: https://www.callmebot.com/blog/free-api-whatsapp-messages/
+2. Update the configuration in the sketch:
+
+```cpp
+#define WHATSAPP_PHONE  "+1234567890"    // Your phone with country code
+#define WHATSAPP_APIKEY "your_api_key"   // Your Callmebot API key
+```
+
+## API Usage
+
+### Basic Usage
+
+```cpp
+// Check if Internet is available via any gateway
+if (mesh.hasInternetConnection()) {
+  
+  // Send data to Internet - routed through gateway automatically
+  uint32_t msgId = mesh.sendToInternet(
+    "https://api.callmebot.com/whatsapp.php?phone=+1234567890&apikey=KEY&text=Hello",
+    "",  // Empty payload for GET (params in URL)
+    [](bool success, uint16_t httpStatus, String error) {
+      if (success) {
+        Serial.printf("✅ Sent! HTTP: %d\n", httpStatus);
+      } else {
+        Serial.printf("❌ Failed: %s\n", error.c_str());
+      }
+    }
+  );
+}
+```
+
+### Sending JSON to REST API
+
+```cpp
+String payload = "{\"temperature\": 25.5, \"humidity\": 60}";
+
+mesh.sendToInternet(
+  "https://api.yourserver.com/sensors",
+  payload,
+  [](bool success, uint16_t httpStatus, String error) {
+    Serial.printf("Result: %s, HTTP: %d\n", 
+                  success ? "OK" : error.c_str(), httpStatus);
+  },
+  static_cast<uint8_t>(painlessmesh::gateway::GatewayPriority::PRIORITY_HIGH)
+);
+```
+
+### Priority Levels
+
+| Value | Enum | Use Case |
+|-------|------|----------|
+| 0 | `PRIORITY_CRITICAL` | Alarms, emergencies |
+| 1 | `PRIORITY_HIGH` | Important alerts |
+| 2 | `PRIORITY_NORMAL` | Regular sensor data |
+| 3 | `PRIORITY_LOW` | Bulk/background data |
+
+## Hardware Setup
+
+### Option A: Bridge + Sensor Nodes
+
+**Bridge Node** (has Internet):
+```cpp
+#define IS_BRIDGE_NODE true
+// Update ROUTER_SSID and ROUTER_PASSWORD
+```
+
+**Sensor Nodes** (no direct Internet):
+```cpp
+#define IS_BRIDGE_NODE false
+```
+
+### Option B: Shared Gateway Mode
+
+All nodes connect to the same router:
+```cpp
+mesh.initAsSharedGateway(
+  MESH_PREFIX, MESH_PASSWORD,
+  ROUTER_SSID, ROUTER_PASSWORD,  // Router credentials required!
+  &userScheduler, MESH_PORT
+);
+mesh.enableSendToInternet();
+```
+
+## Common Issues
+
+### "No Internet available - no gateway with Internet found"
+
+- Make sure at least one node is initialized as a bridge with router credentials
+- Check that the bridge has successfully connected to the router
+- Use `mesh.hasInternetConnection()` to verify gateway availability
+
+### "connection refused" when using HTTPClient directly
+
+**DON'T do this on regular mesh nodes:**
+```cpp
+// This FAILS on regular mesh nodes!
+HTTPClient http;
+http.begin("https://api.callmebot.com/...");
+```
+
+**DO this instead:**
+```cpp
+// This works - routes through gateway
+mesh.sendToInternet("https://api.callmebot.com/...", "", callback);
+```
+
+### WhatsApp message not received
+
+1. Verify your Callmebot API key is correct
+2. Ensure phone number includes country code (e.g., `+1234567890`)
+3. Check HTTP status code in callback (200 = success)
+4. URL-encode special characters in the message
+
+## Files
+
+- `sendToInternet.ino` - Main example sketch
+- `README.md` - This documentation
+
+## Related Examples
+
+- [sharedGateway](../sharedGateway/) - All nodes with direct Internet access
+- [bridge_failover](../bridge_failover/) - Automatic gateway failover
+- [mqttBridge](../mqttBridge/) - MQTT integration

package/examples/sendToInternet/platformio.ini

@@ -0,0 +1,23 @@
+; PlatformIO Project Configuration File
+;
+; sendToInternet Example - WhatsApp/Callmebot Integration
+;
+; Upload to ESP32 or ESP8266 to test mesh.sendToInternet() API
+
+[env:esp32dev]
+platform = espressif32
+board = esp32dev
+framework = arduino
+lib_deps = 
+    alteriom/AlteriomPainlessMesh
+    bblanchon/ArduinoJson@^7.0.0
+monitor_speed = 115200
+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_deps = 
+    alteriom/AlteriomPainlessMesh
+    bblanchon/ArduinoJson@^7.0.0
+monitor_speed = 115200

package/examples/sendToInternet/sendToInternet.ino

@@ -0,0 +1,340 @@
+//************************************************************
+// sendToInternet Example - WhatsApp/Callmebot Integration
+//
+// This example demonstrates how to use mesh.sendToInternet() to send
+// messages to Internet endpoints (like WhatsApp via Callmebot) from
+// ANY node in the mesh network - not just the bridge/gateway.
+//
+// IMPORTANT:
+// Regular mesh nodes do NOT have direct IP routing to the Internet.
+// The sendToInternet() API routes your data THROUGH a gateway node
+// that has Internet access. This is different from making direct
+// HTTP requests (which would fail on regular mesh nodes).
+//
+// How it works:
+// 1. Node calls mesh.sendToInternet() with destination URL and payload
+// 2. The mesh routes the request to a gateway node with Internet
+// 3. Gateway makes the actual HTTP request to the destination
+// 4. Gateway sends acknowledgment back through the mesh
+// 5. Your callback is invoked with the result
+//
+// Use Cases:
+// - Fish farm sensors sending O2 alarms to WhatsApp
+// - Industrial IoT sending alerts to cloud APIs
+// - Smart home sensors reporting to home automation servers
+//
+// Prerequisites:
+// - At least one node must be a bridge/gateway with Internet access
+// - OR use initAsSharedGateway() so all nodes have Internet
+// - Enable sendToInternet() after mesh.init(): mesh.enableSendToInternet()
+//
+// For Callmebot WhatsApp API:
+// - Get your API key from https://www.callmebot.com/blog/free-api-whatsapp-messages/
+// - Format: https://api.callmebot.com/whatsapp.php?phone=PHONE&apikey=KEY&text=MESSAGE
+//
+//************************************************************
+#include "painlessMesh.h"
+#include <WiFiClientSecure.h>
+
+// ============================================
+// Mesh Network Configuration
+// ============================================
+#define MESH_PREFIX     "SensorMesh"
+#define MESH_PASSWORD   "meshPassword123"
+#define MESH_PORT       5555
+
+// ============================================
+// Router Configuration (for bridge/gateway)
+// ============================================
+#define ROUTER_SSID     "YourRouterSSID"
+#define ROUTER_PASSWORD "YourRouterPassword"
+
+// ============================================
+// Callmebot/WhatsApp Configuration
+// ============================================
+// Get your API key from: https://www.callmebot.com/blog/free-api-whatsapp-messages/
+#define WHATSAPP_PHONE  "+1234567890"    // Your phone number with country code
+#define WHATSAPP_APIKEY "your_api_key"   // Your Callmebot API key
+
+// ============================================
+// Sensor Simulation Configuration
+// ============================================
+// These define the ranges for simulated sensor values
+#define TEMP_MIN        20.0   // Minimum temperature (°C)
+#define TEMP_RANGE      10.0   // Temperature range (20-30°C)
+#define HUMIDITY_MIN    40.0   // Minimum humidity (%)
+#define HUMIDITY_RANGE  40.0   // Humidity range (40-80%)
+#define O2_MIN          5.0    // Minimum O2 level (mg/L)
+#define O2_RANGE        5.0    // O2 range (5-10 mg/L)
+#define O2_ALARM_THRESHOLD 6.0 // O2 level below this triggers alarm
+
+// ============================================
+// Mode Selection
+// ============================================
+// Set to true to make this node a bridge with Internet access
+// Set to false for regular mesh nodes that will send via the bridge
+#define IS_BRIDGE_NODE  false
+
+// ============================================
+// Task Scheduler and Mesh Instance
+// ============================================
+Scheduler userScheduler;
+painlessMesh mesh;
+
+// ============================================
+// Function Prototypes
+// ============================================
+void sendAlertToWhatsApp(String message);
+void sendSensorDataToCloud();
+void receivedCallback(uint32_t from, String& msg);
+void newConnectionCallback(uint32_t nodeId);
+void changedConnectionCallback();
+String urlEncode(const String& str);
+
+// ============================================
+// Task Definitions
+// ============================================
+// Task to periodically send sensor data (simulated)
+Task taskSendSensorData(60000, TASK_FOREVER, &sendSensorDataToCloud);
+
+// ============================================
+// URL Encoding Helper
+// ============================================
+
+/**
+ * URL-encode a string for safe transmission in URLs
+ * 
+ * Encodes special characters to their percent-encoded equivalents.
+ * This is required for WhatsApp messages containing special characters.
+ * 
+ * @param str The string to encode
+ * @return URL-encoded string
+ */
+String urlEncode(const String& str) {
+  String encoded = "";
+  for (size_t i = 0; i < str.length(); i++) {
+    char c = str.charAt(i);
+    if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
+      // Safe characters - no encoding needed
+      encoded += c;
+    } else if (c == ' ') {
+      encoded += "%20";
+    } else {
+      // Encode other characters as %XX
+      char hex[4];
+      snprintf(hex, sizeof(hex), "%%%02X", (unsigned char)c);
+      encoded += hex;
+    }
+  }
+  return encoded;
+}
+
+// ============================================
+// sendToInternet() Usage Example
+// ============================================
+
+/**
+ * Send a WhatsApp message via Callmebot using sendToInternet()
+ * 
+ * This function demonstrates how to use mesh.sendToInternet() to send
+ * data to an Internet endpoint. The request is automatically routed
+ * through a gateway node that has Internet access.
+ * 
+ * @param message The message to send via WhatsApp
+ */
+void sendAlertToWhatsApp(String message) {
+  // Check if Internet is available via any gateway
+  if (!mesh.hasInternetConnection()) {
+    Serial.println("❌ No Internet available - no gateway with Internet found");
+    Serial.println("   Make sure at least one node is a bridge with router access");
+    return;
+  }
+  
+  // URL-encode the message for safe transmission
+  String encodedMessage = urlEncode(message);
+  
+  // Build the Callmebot WhatsApp API URL
+  // Format: https://api.callmebot.com/whatsapp.php?phone=PHONE&apikey=KEY&text=MESSAGE
+  String url = "https://api.callmebot.com/whatsapp.php";
+  url += "?phone=" + String(WHATSAPP_PHONE);
+  url += "&apikey=" + String(WHATSAPP_APIKEY);
+  url += "&text=" + encodedMessage;
+  
+  Serial.println("\n📱 Sending WhatsApp message via sendToInternet()...");
+  Serial.printf("   Message: %s\n", message.c_str());
+  Serial.printf("   URL: %s\n", url.c_str());
+  
+  // Use sendToInternet() to route the request through a gateway
+  // The callback will be invoked when we get a response (or timeout)
+  uint32_t msgId = mesh.sendToInternet(
+    url,
+    "",  // No payload needed for GET request - params are in URL
+    [](bool success, uint16_t httpStatus, String error) {
+      if (success) {
+        Serial.printf("✅ WhatsApp message sent! HTTP Status: %d\n", httpStatus);
+      } else {
+        Serial.printf("❌ Failed to send WhatsApp: %s (HTTP: %d)\n", error.c_str(), httpStatus);
+      }
+    },
+    static_cast<uint8_t>(painlessmesh::gateway::GatewayPriority::PRIORITY_HIGH)
+  );
+  
+  if (msgId > 0) {
+    Serial.printf("   Message queued with ID: %u\n", msgId);
+  } else {
+    Serial.println("   ❌ Failed to queue message - no gateway available");
+  }
+}
+
+/**
+ * Send sensor data to a cloud API
+ * 
+ * This demonstrates sending JSON sensor data to a REST API endpoint.
+ * In a real application, you would replace the URL with your actual
+ * cloud API endpoint (AWS, Azure, ThingsBoard, etc.)
+ */
+void sendSensorDataToCloud() {
+  // Simulate sensor readings using configured ranges
+  float temperature = TEMP_MIN + random(0, (int)(TEMP_RANGE * 10)) / 10.0;
+  float humidity = HUMIDITY_MIN + random(0, (int)(HUMIDITY_RANGE * 10)) / 10.0;
+  float o2Level = O2_MIN + random(0, (int)(O2_RANGE * 10)) / 10.0;
+  
+  // Create JSON payload
+  String payload = "{";
+  payload += "\"nodeId\":" + String(mesh.getNodeId()) + ",";
+  payload += "\"temperature\":" + String(temperature, 1) + ",";
+  payload += "\"humidity\":" + String(humidity, 1) + ",";
+  payload += "\"o2Level\":" + String(o2Level, 1) + ",";
+  payload += "\"timestamp\":" + String(millis());
+  payload += "}";
+  
+  Serial.println("\n📊 Sending sensor data to cloud...");
+  Serial.printf("   Payload: %s\n", payload.c_str());
+  
+  // Check for alarm conditions using configured threshold
+  if (o2Level < O2_ALARM_THRESHOLD) {
+    // O2 level critical - send WhatsApp alert!
+    String alertMsg = "⚠️ ALARM: O2 level critical at " + String(o2Level, 1) + " mg/L! Node: " + String(mesh.getNodeId());
+    sendAlertToWhatsApp(alertMsg);
+  }
+  
+  // Only send if Internet is available
+  if (!mesh.hasInternetConnection()) {
+    Serial.println("   ⚠️ No Internet - data not sent (would be queued in production)");
+    return;
+  }
+  
+  // Send to cloud API (replace with your actual endpoint)
+  // Example endpoints:
+  // - ThingsBoard: "https://demo.thingsboard.io/api/v1/YOUR_TOKEN/telemetry"
+  // - AWS IoT: "https://YOUR_ENDPOINT.iot.us-east-1.amazonaws.com/topics/sensors"
+  // - Custom API: "https://api.yourserver.com/sensors/data"
+  
+  String cloudUrl = "https://api.example.com/sensors";  // Replace with your endpoint
+  
+  uint32_t msgId = mesh.sendToInternet(
+    cloudUrl,
+    payload,
+    [](bool success, uint16_t httpStatus, String error) {
+      if (success) {
+        Serial.printf("   ✅ Cloud data sent! HTTP: %d\n", httpStatus);
+      } else {
+        Serial.printf("   ❌ Cloud send failed: %s\n", error.c_str());
+      }
+    }
+  );
+  
+  Serial.printf("   Message ID: %u\n", msgId);
+}
+
+// ============================================
+// Mesh Callbacks
+// ============================================
+
+void receivedCallback(uint32_t from, String& msg) {
+  Serial.printf("📨 Received from %u: %s\n", from, msg.c_str());
+}
+
+void newConnectionCallback(uint32_t nodeId) {
+  Serial.printf("✓ New connection: Node %u\n", nodeId);
+}
+
+void changedConnectionCallback() {
+  Serial.printf("🔄 Mesh topology changed. Nodes: %d\n", mesh.getNodeList().size());
+}
+
+// ============================================
+// Setup Function
+// ============================================
+void setup() {
+  Serial.begin(115200);
+  delay(1000);
+  
+  Serial.println("\n");
+  Serial.println("================================================");
+  Serial.println("   painlessMesh - sendToInternet Example");
+  Serial.println("   WhatsApp/Callmebot Integration Demo");
+  Serial.println("================================================\n");
+  
+  // Configure debug output
+  mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION);
+  
+  bool success = false;
+  
+#if IS_BRIDGE_NODE
+  // Initialize as bridge with router connection
+  Serial.println("Mode: BRIDGE (Gateway with Internet access)\n");
+  success = mesh.initAsBridge(
+    MESH_PREFIX, MESH_PASSWORD,
+    ROUTER_SSID, ROUTER_PASSWORD,
+    &userScheduler, MESH_PORT
+  );
+  
+  if (success) {
+    Serial.println("✓ Bridge initialized - this node has Internet access");
+    Serial.println("  Other nodes can use sendToInternet() through this gateway\n");
+  } else {
+    Serial.println("✗ Bridge init failed - falling back to regular mesh");
+    mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  }
+#else
+  // Initialize as regular mesh node
+  Serial.println("Mode: REGULAR NODE (sends to Internet via gateway)\n");
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  success = true;
+#endif
+  
+  // IMPORTANT: Enable the sendToInternet() API
+  mesh.enableSendToInternet();
+  
+  // Register callbacks
+  mesh.onReceive(&receivedCallback);
+  mesh.onNewConnection(&newConnectionCallback);
+  mesh.onChangedConnections(&changedConnectionCallback);
+  
+  // Start periodic sensor data task
+  userScheduler.addTask(taskSendSensorData);
+  taskSendSensorData.enable();
+  
+  // Print startup info
+  Serial.println("================================================");
+  Serial.printf("Node ID: %u\n", mesh.getNodeId());
+  Serial.printf("Is Bridge: %s\n", mesh.isBridge() ? "YES" : "NO");
+  Serial.println("================================================\n");
+  
+  // Send a startup notification via WhatsApp (demonstrates sendToInternet)
+  String startupMsg = "🚀 Node " + String(mesh.getNodeId()) + " started!";
+  
+  // Delay to allow mesh to connect first
+  Serial.println("Will attempt to send startup WhatsApp in 30 seconds...\n");
+  mesh.addTask([startupMsg]() {
+    sendAlertToWhatsApp(startupMsg);
+  }, 30000);  // 30 second delay
+}
+
+// ============================================
+// Main Loop
+// ============================================
+void loop() {
+  mesh.update();
+}

package/library.json

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

package/library.properties

@@ -1,5 +1,5 @@
 name=Alteriom PainlessMesh
-version=1.9.0
+version=1.9.2
 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.9.0",
+  "version": "1.9.2",
   "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

@@ -205,6 +205,71 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       }
     });
 
+    // Add separate periodic task for isolated bridge retry
+    // This handles the case where a node:
+    // - Has router credentials configured
+    // - Is isolated (no mesh connections)
+    // - Should attempt to become a bridge directly
+    // This is different from the election mechanism which requires mesh connectivity
+    this->addTask(isolatedBridgeRetryIntervalMs, TASK_FOREVER, [this]() {
+      // Only retry if failover is enabled and we have credentials
+      if (!bridgeFailoverEnabled || !routerCredentialsConfigured) {
+        return;
+      }
+      
+      // Don't retry if we're already a bridge
+      if (this->isBridge()) {
+        return;
+      }
+      
+      // Skip during startup period
+      if (millis() < electionStartupDelayMs) {
+        return;
+      }
+      
+      // Only retry when isolated (no mesh connections found)
+      if (this->hasActiveMeshConnections()) {
+        // Reset retry counter when mesh is active
+        _isolatedBridgeRetryAttempts = 0;
+        return;
+      }
+      
+      // Limit retry attempts with reset after timeout
+      if (_isolatedBridgeRetryAttempts >= MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS) {
+        // Check if enough time has passed to reset the counter
+        if (millis() > _isolatedBridgeRetryResetTime) {
+          Log(CONNECTION, "Isolated bridge retry: Reset timeout reached, resetting attempt counter\n");
+          _isolatedBridgeRetryAttempts = 0;
+        } else {
+          Log(CONNECTION, "Isolated bridge retry: Max attempts (%d) reached, reset in %u seconds\n",
+              MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS, (_isolatedBridgeRetryResetTime - millis()) / 1000);
+          return;
+        }
+      }
+      
+      // Check if mesh network exists on any channel before trying to become bridge
+      // If mesh exists but we can't connect, don't try to become bridge
+      uint16_t emptyScans = stationScan.getConsecutiveEmptyScans();
+      if (emptyScans < ISOLATED_BRIDGE_RETRY_SCAN_THRESHOLD) {
+        Log(CONNECTION, "Isolated bridge retry: Only %d empty scans, waiting for more scans\n",
+            emptyScans);
+        return;
+      }
+      
+      Log(CONNECTION, "Isolated bridge retry: Node isolated with %d empty scans, attempting bridge promotion\n",
+          emptyScans);
+      
+      // Attempt to become bridge directly (bypassing election since we're isolated)
+      // Only increment retry counter if we actually attempted promotion
+      if (this->attemptIsolatedBridgePromotion()) {
+        _isolatedBridgeRetryAttempts++;
+        // Set reset time when reaching max attempts
+        if (_isolatedBridgeRetryAttempts >= MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS) {
+          _isolatedBridgeRetryResetTime = millis() + isolatedBridgeRetryResetIntervalMs;
+        }
+      }
+    });
+
     tcpServerInit();
     eventHandleInit();
 
@@ -812,12 +877,35 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   }
 
   /**
-   * Check if any bridge in the mesh has Internet connectivity
+   * Check if any bridge/gateway in the mesh has Internet connectivity
+   * 
+   * IMPORTANT: This method checks if a GATEWAY node (bridge) in the mesh has
+   * Internet access, NOT whether THIS node can directly make HTTP/HTTPS requests.
+   * 
+   * Regular mesh nodes do NOT have direct IP routing to the Internet. They only
+   * communicate via the painlessMesh protocol. To send data to the Internet from
+   * a regular node, you must use sendToInternet() which routes through a gateway,
+   * or use initAsSharedGateway(meshSSID, meshPwd, ROUTER_SSID, ROUTER_PWD, scheduler, port)
+   * to give all nodes direct router access (requires router credentials).
    * 
    * Override of base class method to also check if THIS node is a bridge
    * with Internet connectivity, not just other bridges in the mesh.
    * 
+   * \code
+   * if (mesh.hasInternetConnection()) {
+   *   // A gateway exists - use sendToInternet() to reach Internet
+   *   mesh.sendToInternet("https://api.example.com", data, callback);
+   * }
+   * 
+   * // DON'T DO THIS on regular nodes - will fail with "connection refused":
+   * // HTTPClient http;
+   * // http.begin("https://api.example.com");
+   * \endcode
+   * 
    * @return true if at least one bridge (including this node) has Internet
+   * @see hasLocalInternet() to check if THIS node has direct Internet access
+   * @see sendToInternet() to send data to Internet via gateway
+   * @see initAsSharedGateway() requires router credentials (ROUTER_SSID, ROUTER_PASSWORD)
    */
   bool hasInternetConnection() {
     // First check if THIS node is a bridge with Internet
@@ -1529,6 +1617,95 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     });
   }
 
+  /**
+   * Attempt to promote an isolated node to bridge
+   * 
+   * This method handles the case where a node is isolated (no mesh connections)
+   * but has router credentials. Unlike the election-based promotion, this
+   * directly attempts to connect to the router without requiring mesh connectivity.
+   * 
+   * This is useful for:
+   * - Nodes that failed initial bridge setup and need to retry
+   * - Nodes that are the first to start and no mesh exists yet
+   * - Recovery scenarios where mesh network is unavailable
+   *
+   * @return true if promotion was attempted (regardless of success), false if skipped
+   */
+  bool attemptIsolatedBridgePromotion() {
+    using namespace logger;
+    
+    Log(CONNECTION, "=== Isolated Bridge Promotion Attempt ===\n");
+    Log(CONNECTION, "Attempt %d of %d\n", _isolatedBridgeRetryAttempts + 1, MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS);
+    
+    // First, scan for router to check if it's visible
+    int8_t routerRSSI = scanRouterSignalStrength(routerSSID);
+    
+    if (routerRSSI == 0) {
+      Log(CONNECTION, "attemptIsolatedBridgePromotion(): Router %s not visible\n", routerSSID.c_str());
+      return false;  // Don't count as an attempt - router not visible
+    }
+    
+    // Check minimum RSSI threshold for isolated promotion
+    if (routerRSSI < minimumBridgeRSSI) {
+      Log(CONNECTION, "attemptIsolatedBridgePromotion(): Router RSSI %d dBm below threshold %d dBm\n",
+          routerRSSI, minimumBridgeRSSI);
+      return false;  // Don't count as an attempt - signal too weak
+    }
+    
+    Log(CONNECTION, "attemptIsolatedBridgePromotion(): Router visible with RSSI %d dBm\n", routerRSSI);
+    Log(CONNECTION, "Attempting direct bridge promotion (bypassing election)\n");
+    
+    // Save current mesh configuration
+    uint8_t savedChannel = _meshChannel;
+    
+    // Stop current mesh operations
+    this->stop();
+    delay(1000);
+    
+    // Attempt to initialize as bridge
+    bool bridgeInitSuccess = this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
+                                                 mScheduler, _meshPort);
+    
+    if (!bridgeInitSuccess) {
+      Log(ERROR, "✗ Isolated bridge promotion failed - router unreachable\n");
+      Log(ERROR, "Reverting to regular node on channel %d\n", savedChannel);
+      
+      // Re-initialize as regular node on the original channel
+      this->init(_meshSSID, _meshPassword, mScheduler, _meshPort, WIFI_AP_STA,
+                 savedChannel, _meshHidden, MAX_CONN);
+      
+      // Re-configure router credentials for future retry attempts
+      this->setRouterCredentials(routerSSID, routerPassword);
+      this->enableBridgeFailover(true);
+      
+      // Notify via callback
+      if (bridgeRoleChangedCallback) {
+        bridgeRoleChangedCallback(false, "Isolated bridge promotion failed - router unreachable");
+      }
+      
+      return true;  // Count as an attempt - we tried but failed
+    }
+    
+    // Success! Reset retry counter
+    _isolatedBridgeRetryAttempts = 0;
+    lastRoleChangeTime = millis();
+    
+    Log(STARTUP, "✓ Isolated bridge promotion complete on channel %d\n", _meshChannel);
+    
+    // Notify via callback
+    if (bridgeRoleChangedCallback) {
+      bridgeRoleChangedCallback(true, "Isolated node promoted to bridge");
+    }
+    
+    // Send bridge status announcement to attract other nodes
+    this->addTask(3000, TASK_ONCE, [this]() {
+      Log(STARTUP, "Sending bridge status announcement on channel %d\n", _meshChannel);
+      this->sendBridgeStatus();
+    });
+    
+    return true;  // Count as an attempt - we succeeded
+  }
+
   /**
    * Handle received bridge election package
    * Called by package handler when election message arrives
@@ -1760,6 +1937,14 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   std::vector<BridgeCandidate> electionCandidates;
   std::function<void(bool isBridge, TSTRING reason)> bridgeRoleChangedCallback;
 
+  // Isolated bridge retry state and configuration
+  uint8_t _isolatedBridgeRetryAttempts = 0;
+  uint32_t _isolatedBridgeRetryResetTime = 0;  // Time when retry counter can be reset
+  static const uint8_t MAX_ISOLATED_BRIDGE_RETRY_ATTEMPTS = 5;  // Max retry attempts before waiting
+  static const uint32_t isolatedBridgeRetryIntervalMs = 60000;  // Retry every 60 seconds
+  static const uint32_t isolatedBridgeRetryResetIntervalMs = 300000;  // Reset counter after 5 minutes
+  static const uint16_t ISOLATED_BRIDGE_RETRY_SCAN_THRESHOLD = 6;  // Require 6 empty scans before retrying
+
   // Multi-bridge coordination state and configuration
  protected:
   bool multiBridgeEnabled = false;

package/src/painlessmesh/mesh.hpp

@@ -606,14 +606,42 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   }
 
   /**
-   * Check if any bridge in the mesh has Internet connectivity
+   * Check if any bridge/gateway in the mesh has Internet connectivity
+   * 
+   * IMPORTANT: This method checks if a GATEWAY node (bridge) in the mesh has
+   * Internet access, NOT whether THIS node can directly make HTTP/HTTPS requests.
+   * 
+   * Regular mesh nodes do NOT have direct IP routing to the Internet - they only
+   * communicate over the painlessMesh protocol. To send data to the Internet from
+   * a regular node, you must either:
+   * 
+   * 1. Use sendToInternet() to route data through a gateway node
+   * 2. Use initAsSharedGateway(meshSSID, meshPwd, ROUTER_SSID, ROUTER_PWD, scheduler, port)
+   *    to give all nodes direct router access (requires router credentials)
+   * 3. Send mesh messages to a bridge node that handles Internet communication
+   * 
+   * Use hasLocalInternet() to check if THIS specific node has direct Internet access.
    * 
    * When connected to mesh, requires recent bridge status (within timeout).
    * When disconnected from mesh, returns true if any bridge previously
    * reported Internet connectivity - allowing operations to be queued for
    * when mesh connectivity is restored.
    * 
-   * @return true if at least one bridge reports Internet connection
+   * \code
+   * if (mesh.hasInternetConnection()) {
+   *   // A gateway exists with Internet - use sendToInternet() to reach Internet
+   *   mesh.sendToInternet("https://api.example.com/data", jsonPayload, callback);
+   * }
+   * 
+   * // DON'T DO THIS - regular mesh nodes cannot make direct HTTP requests:
+   * // HTTPClient http;
+   * // http.begin("https://api.example.com");  // Will fail with "connection refused"
+   * \endcode
+   * 
+   * @return true if at least one gateway/bridge reports Internet connection
+   * @see hasLocalInternet() to check if THIS node has direct Internet access
+   * @see sendToInternet() to send data to Internet via gateway
+   * @see initAsSharedGateway() to give all nodes direct Internet access (requires router credentials)
    */
   bool hasInternetConnection() {
     bool hasConnections = hasActiveMeshConnections();