@alteriom/painlessmesh 1.9.1 → 1.9.2

package/CHANGELOG.md

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

package/README.md

@@ -4,7 +4,7 @@
 
 <div align="center">
 
-**Version 1.9.1** - Isolated bridge retry mechanism for failed initial bridge setup
+**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.

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
@@ -204,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.1",
+  "version": "1.9.2",
   "frameworks": [
     "arduino"
   ],

package/library.properties

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

@@ -877,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

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