@alteriom/painlessmesh 1.6.1

package/examples/bridge/bridge.ino

@@ -0,0 +1,51 @@
+//************************************************************
+// this is a simple example that uses the painlessMesh library to
+// connect to a node on another network. Please see the WIKI on gitlab
+// for more details
+// https://gitlab.com/painlessMesh/painlessMesh/wikis/bridge-between-mesh-and-another-network
+//************************************************************
+#include "painlessMesh.h"
+
+#define MESH_PREFIX "whateverYouLike"
+#define MESH_PASSWORD "somethingSneaky"
+#define MESH_PORT 5555
+
+#define STATION_SSID "MSYSSID"
+#define STATION_PASSWORD "SSIDPASSWORD"
+#define STATION_PORT 5555
+uint8_t station_ip[4] = {192, 168, 1, 3};  // IP of the server
+
+// prototypes
+void receivedCallback(uint32_t from, String &msg);
+
+painlessMesh mesh;
+
+void setup() {
+  Serial.begin(115200);
+  mesh.setDebugMsgTypes(
+      ERROR | STARTUP |
+      CONNECTION);  // set before init() so that you can see startup messages
+
+  // Channel set to 6. Make sure to use the same channel for your mesh and for
+  // you other network (STATION_SSID)
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, MESH_PORT, WIFI_AP_STA, 1);
+  // Setup over the air update support
+  mesh.initOTAReceive("bridge");
+
+  mesh.stationManual(STATION_SSID, STATION_PASSWORD, STATION_PORT, station_ip);
+  // Bridge node, should (in most cases) be a root node. See [the
+  // wiki](https://gitlab.com/painlessMesh/painlessMesh/wikis/Possible-challenges-in-mesh-formation)
+  // for some background
+  mesh.setRoot(true);
+  // This node and all other nodes should ideally know the mesh contains a root,
+  // so call this on all nodes
+  mesh.setContainsRoot(true);
+
+  mesh.onReceive(&receivedCallback);
+}
+
+void loop() { mesh.update(); }
+
+void receivedCallback(uint32_t from, String &msg) {
+  Serial.printf("bridge: Received from %u msg=%s\n", from, msg.c_str());
+}

package/examples/bridge/platformio.ini

@@ -0,0 +1,25 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_extra_dirs = ../../
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP  ; 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/echoNode/echoNode.ino

@@ -0,0 +1,33 @@
+//************************************************************
+// this is a simple example that uses the painlessMesh library and echos any
+// messages it receives
+//
+//************************************************************
+#include "painlessMesh.h"
+
+#define   MESH_PREFIX     "whateverYouLike"
+#define   MESH_PASSWORD   "somethingSneaky"
+#define   MESH_PORT       5555
+
+// Prototypes
+void receivedCallback( uint32_t from, String &msg );
+
+painlessMesh  mesh;
+
+void setup() {
+  Serial.begin(115200);
+    
+  mesh.setDebugMsgTypes( ERROR | STARTUP | CONNECTION );  // set before init() so that you can see startup messages
+
+  mesh.init( MESH_PREFIX, MESH_PASSWORD, MESH_PORT );
+  mesh.onReceive(&receivedCallback);
+}
+
+void loop() {
+  mesh.update();
+}
+
+void receivedCallback( uint32_t from, String &msg ) {
+  Serial.printf("echoNode: Received from %u msg=%s\n", from, msg.c_str());
+  mesh.sendSingle(from, msg);
+}

package/examples/echoNode/platformio.ini

@@ -0,0 +1,25 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_extra_dirs = ../../
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP  ; 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/logClient/logClient.ino

@@ -0,0 +1,109 @@
+//************************************************************
+// this is a simple example that uses the painlessMesh library to 
+// setup a node that logs to a central logging node
+// The logServer example shows how to configure the central logging nodes
+//************************************************************
+#include "painlessMesh.h"
+
+#define   MESH_PREFIX     "whateverYouLike"
+#define   MESH_PASSWORD   "somethingSneaky"
+#define   MESH_PORT       5555
+
+Scheduler     userScheduler; // to control your personal task
+painlessMesh  mesh;
+
+// Prototype
+void receivedCallback( uint32_t from, String &msg );
+
+size_t logServerId = 0;
+
+// Send message to the logServer every 10 seconds 
+Task myLoggingTask(10000, TASK_FOREVER, []() {
+#if ARDUINOJSON_VERSION_MAJOR==7
+        JsonDocument jsonBuffer;
+        JsonObject msg = jsonBuffer.to<JsonObject>();
+#elif ARDUINOJSON_VERSION_MAJOR==6
+        DynamicJsonDocument jsonBuffer(1024);
+        JsonObject msg = jsonBuffer.to<JsonObject>();
+#else
+        DynamicJsonBuffer jsonBuffer;
+        JsonObject& msg = jsonBuffer.createObject();
+#endif
+    msg["topic"] = "sensor";
+    msg["value"] = random(0, 180);
+
+    String str;
+#if ARDUINOJSON_VERSION_MAJOR>=6
+    serializeJson(msg, str);
+#else
+    msg.printTo(str);
+#endif
+    if (logServerId == 0) // If we don't know the logServer yet
+        mesh.sendBroadcast(str);
+    else
+        mesh.sendSingle(logServerId, str);
+
+    // log to serial
+#if ARDUINOJSON_VERSION_MAJOR>=6
+    serializeJson(msg, Serial);
+#else
+    msg.printTo(Serial);
+#endif
+    Serial.printf("\n");
+});
+
+void setup() {
+  Serial.begin(115200);
+    
+  mesh.setDebugMsgTypes( ERROR | STARTUP | CONNECTION );  // set before init() so that you can see startup messages
+
+  mesh.init( MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT, WIFI_AP_STA, 6 );
+  mesh.onReceive(&receivedCallback);
+
+  // Add the task to the your scheduler
+  userScheduler.addTask(myLoggingTask);
+  myLoggingTask.enable();
+}
+
+void loop() {
+  // it will run the user scheduler as well
+  mesh.update();
+}
+
+void receivedCallback( uint32_t from, String &msg ) {
+  Serial.printf("logClient: Received from %u msg=%s\n", from, msg.c_str());
+
+  // Saving logServer
+#if ARDUINOJSON_VERSION_MAJOR==7
+  JsonDocument jsonBuffer;
+  DeserializationError error = deserializeJson(jsonBuffer, msg);
+  if (error) {
+    Serial.printf("DeserializationError\n");
+    return;
+  }
+  JsonObject root = jsonBuffer.as<JsonObject>();
+#elif ARDUINOJSON_VERSION_MAJOR==6
+  DynamicJsonDocument jsonBuffer(1024 + msg.length());
+  DeserializationError error = deserializeJson(jsonBuffer, msg);
+  if (error) {
+    Serial.printf("DeserializationError\n");
+    return;
+  }
+  JsonObject root = jsonBuffer.as<JsonObject>();
+#else
+  DynamicJsonBuffer jsonBuffer;
+  JsonObject& root = jsonBuffer.parseObject(msg);
+#endif
+#if ARDUINOJSON_VERSION_MAJOR < 7
+  if (root.containsKey("topic")) {
+#else
+  if (root["topic"].is<String>()) {
+#endif
+      if (String("logServer").equals(root["topic"].as<String>())) {
+          // check for on: true or false
+          logServerId = root["nodeId"];
+          Serial.printf("logServer detected!!!\n");
+      }
+      Serial.printf("Handled from %u msg=%s\n", from, msg.c_str());
+  }
+}

package/examples/logClient/platformio.ini

@@ -0,0 +1,25 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_extra_dirs = ../../
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP  ; 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/logServer/logServer.ino

@@ -0,0 +1,81 @@
+//************************************************************
+// this is a simple example that uses the painlessMesh library to 
+// setup a single node (this node) as a logging node
+// The logClient example shows how to configure the other nodes
+// to log to this server
+//************************************************************
+#include "painlessMesh.h"
+
+#define   MESH_PREFIX     "whateverYouLike"
+#define   MESH_PASSWORD   "somethingSneaky"
+#define   MESH_PORT       5555
+
+Scheduler     userScheduler; // to control your personal task
+painlessMesh  mesh;
+// Prototype
+void receivedCallback( uint32_t from, String &msg );
+
+
+// Send my ID every 10 seconds to inform others
+Task logServerTask(10000, TASK_FOREVER, []() {
+#if ARDUINOJSON_VERSION_MAJOR==7
+        JsonDocument jsonBuffer;
+        JsonObject msg = jsonBuffer.to<JsonObject>();
+#elif ARDUINOJSON_VERSION_MAJOR==6
+        DynamicJsonDocument jsonBuffer(1024);
+        JsonObject msg = jsonBuffer.to<JsonObject>();
+#else
+        DynamicJsonBuffer jsonBuffer;
+        JsonObject& msg = jsonBuffer.createObject();
+#endif
+    msg["topic"] = "logServer";
+    msg["nodeId"] = mesh.getNodeId();
+
+    String str;
+#if ARDUINOJSON_VERSION_MAJOR>=6
+    serializeJson(msg, str);
+#else
+    msg.printTo(str);
+#endif
+    mesh.sendBroadcast(str);
+
+    // log to serial
+#if ARDUINOJSON_VERSION_MAJOR>=6
+    serializeJson(msg, Serial);
+#else
+    msg.printTo(Serial);
+#endif
+    Serial.printf("\n");
+});
+
+void setup() {
+  Serial.begin(115200);
+    
+  //mesh.setDebugMsgTypes( ERROR | MESH_STATUS | CONNECTION | SYNC | COMMUNICATION | GENERAL | MSG_TYPES | REMOTE | DEBUG ); // all types on
+  //mesh.setDebugMsgTypes( ERROR | CONNECTION | SYNC | S_TIME );  // set before init() so that you can see startup messages
+  mesh.setDebugMsgTypes( ERROR | CONNECTION | S_TIME );  // set before init() so that you can see startup messages
+
+  mesh.init( MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT, WIFI_AP_STA, 6 );
+  mesh.onReceive(&receivedCallback);
+
+  mesh.onNewConnection([](size_t nodeId) {
+    Serial.printf("New Connection %u\n", nodeId);
+  });
+
+  mesh.onDroppedConnection([](size_t nodeId) {
+    Serial.printf("Dropped Connection %u\n", nodeId);
+  });
+
+  // Add the task to the your scheduler
+  userScheduler.addTask(logServerTask);
+  logServerTask.enable();
+}
+
+void loop() {
+  // it will run the user scheduler as well
+  mesh.update();
+}
+
+void receivedCallback( uint32_t from, String &msg ) {
+  Serial.printf("logServer: Received from %u msg=%s\n", from, msg.c_str());
+}

package/examples/logServer/platformio.ini

@@ -0,0 +1,25 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_extra_dirs = ../../
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP  ; 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/mqttBridge/mqttBridge.ino

@@ -0,0 +1,118 @@
+//************************************************************
+// this is a simple example that uses the painlessMesh library to
+// connect to a another network and relay messages from a MQTT broker to the nodes of the mesh network.
+// To send a message to a mesh node, you can publish it to "painlessMesh/to/12345678" where 12345678 equals the nodeId.
+// To broadcast a message to all nodes in the mesh you can publish it to "painlessMesh/to/broadcast".
+// When you publish "getNodes" to "painlessMesh/to/gateway" you receive the mesh topology as JSON
+// Every message from the mesh which is send to the gateway node will be published to "painlessMesh/from/12345678" where 12345678 
+// is the nodeId from which the packet was send.
+//************************************************************
+
+#include <Arduino.h>
+#include <painlessMesh.h>
+#include <PubSubClient.h>
+#include <WiFiClient.h>
+
+#define   MESH_PREFIX     "whateverYouLike"
+#define   MESH_PASSWORD   "somethingSneaky"
+#define   MESH_PORT       5555
+
+#define   STATION_SSID     "YourAP_SSID"
+#define   STATION_PASSWORD "YourAP_PWD"
+
+#define HOSTNAME "MQTT_Bridge"
+
+// Prototypes
+void receivedCallback( const uint32_t &from, const String &msg );
+void mqttCallback(char* topic, byte* payload, unsigned int length);
+
+IPAddress getlocalIP();
+
+IPAddress myIP(0,0,0,0);
+IPAddress mqttBroker(192, 168, 1, 1);
+
+painlessMesh  mesh;
+WiFiClient wifiClient;
+PubSubClient mqttClient(mqttBroker, 1883, mqttCallback, wifiClient);
+
+void setup() {
+  Serial.begin(115200);
+
+  mesh.setDebugMsgTypes( ERROR | STARTUP | CONNECTION );  // set before init() so that you can see startup messages
+
+  // Channel set to 6. Make sure to use the same channel for your mesh and for you other
+  // network (STATION_SSID)
+  mesh.init( MESH_PREFIX, MESH_PASSWORD, MESH_PORT, WIFI_AP_STA, 6 );
+  mesh.onReceive(&receivedCallback);
+
+  mesh.stationManual(STATION_SSID, STATION_PASSWORD);
+  mesh.setHostname(HOSTNAME);
+
+  // Bridge node, should (in most cases) be a root node. See [the wiki](https://gitlab.com/painlessMesh/painlessMesh/wikis/Possible-challenges-in-mesh-formation) for some background
+  mesh.setRoot(true);
+  // This node and all other nodes should ideally know the mesh contains a root, so call this on all nodes
+  mesh.setContainsRoot(true);
+}
+
+void loop() {
+  mesh.update();
+  mqttClient.loop();
+
+  if(myIP != getlocalIP()){
+    myIP = getlocalIP();
+    Serial.println("My IP is " + myIP.toString());
+
+    if (mqttClient.connect("painlessMeshClient")) {
+      mqttClient.publish("painlessMesh/from/gateway","Ready!");
+      mqttClient.subscribe("painlessMesh/to/#");
+    } 
+  }
+}
+
+void receivedCallback( const uint32_t &from, const String &msg ) {
+  Serial.printf("bridge: Received from %u msg=%s\n", from, msg.c_str());
+  String topic = "painlessMesh/from/" + String(from);
+  mqttClient.publish(topic.c_str(), msg.c_str());
+}
+
+void mqttCallback(char* topic, uint8_t* payload, unsigned int length) {
+  char* cleanPayload = (char*)malloc(length+1);
+  memcpy(cleanPayload, payload, length);
+  cleanPayload[length] = '\0';
+  String msg = String(cleanPayload);
+  free(cleanPayload);
+
+  String targetStr = String(topic).substring(16);
+
+  if(targetStr == "gateway")
+  {
+    if(msg == "getNodes")
+    {
+      auto nodes = mesh.getNodeList(true);
+      String str;
+      for (auto &&id : nodes)
+        str += String(id) + String(" ");
+      mqttClient.publish("painlessMesh/from/gateway", str.c_str());
+    }
+  }
+  else if(targetStr == "broadcast") 
+  {
+    mesh.sendBroadcast(msg);
+  }
+  else
+  {
+    uint32_t target = strtoul(targetStr.c_str(), NULL, 10);
+    if(mesh.isConnected(target))
+    {
+      mesh.sendSingle(target, msg);
+    }
+    else
+    {
+      mqttClient.publish("painlessMesh/from/gateway", "Client not connected!");
+    }
+  }
+}
+
+IPAddress getlocalIP() {
+  return IPAddress(mesh.getStationIP());
+}

package/examples/mqttBridge/platformio.ini

@@ -0,0 +1,26 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+    PubSubClient
+
+[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/namedMesh/namedMesh.ino

@@ -0,0 +1,97 @@
+//************************************************************
+// this is a simple example that uses the painlessMesh library
+//
+// This example shows how to build a mesh with named nodes using the plugin
+// system
+//
+//
+//************************************************************
+#include <cstdint>
+#include <map>
+#include "Arduino.h"
+#include "painlessMesh.h"
+#include "painlessmesh/plugin.hpp"
+
+#define MESH_PREFIX "whateverYouLike"
+#define MESH_PASSWORD "somethingSneaky"
+#define MESH_PORT 5555
+
+painlessMesh mesh;
+
+// NOTE: various ideas for improvement
+// - Send new names regularly and only send all names sometimes
+// - Keep track of the names the neighbour already knows (when we receive them)
+//   and only send unknown names/nodes
+// - Use some kind of bidirectoral map, so both get_name_from_id and
+//   get_id_from_name are fast
+
+// Send the names you know to your neighbours
+class NamePackage : public painlessmesh::plugin::NeighbourPackage {
+ public:
+  std::map<TSTRING, uint32_t> names;
+
+  // Set an id for the package. Id can be any unique int not already in use. The
+  // mesh uses the numbers 1..12, so using a number larger than that
+  NamePackage() : painlessmesh::plugin::NeighbourPackage(21) {}
+
+  NamePackage(JsonObject jsonObj)
+      : painlessmesh::plugin::NeighbourPackage(jsonObj) {
+    for (JsonPair kv : jsonObj) {
+      names.insert(std::pair<TSTRING, uint32_t>(kv.key().c_str(), kv.value()));
+    }
+  }
+
+  JsonObject addTo(JsonObject&& jsonObj) const {
+    jsonObj = painlessmesh::plugin::NeighbourPackage::addTo(std::move(jsonObj));
+    for (auto&& kv : names) {
+      jsonObj[kv.first] = kv.second;
+    }
+    return jsonObj;
+  }
+};
+
+std::map<TSTRING, uint32_t> known_names;
+TSTRING get_name_from_id(uint32_t id) {
+  for (auto&& kv : known_names) {
+    if (kv.second == id) {
+      return kv.first;
+    }
+  }
+  return String(id);
+}
+
+uint32_t get_id_from_name(TSTRING name) {
+  auto it = known_names.find(name);
+  return (it != known_names.end()) ? it->second : 0;
+}
+
+void setup() {
+  Serial.begin(115200);
+  mesh.setDebugMsgTypes(ERROR | STARTUP);
+
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, MESH_PORT);
+
+  auto sendPkg = std::make_shared<NamePackage>();
+  sendPkg->names = known_names;
+  // Every minute we send the names we know to our neighbours
+  mesh.addTask(TASK_MINUTE, TASK_FOREVER, [sendPkg, &mesh]() {
+    sendPkg->names = known_names;
+    mesh.sendPackage(sendPkg.get());
+  });
+
+  // When we receive a message of the correct type, then insert the names they
+  // know into our map of names
+  mesh.onPackage(sendPkg->type, [](painlessmesh::protocol::Variant& var) {
+    const auto& pkg = var.to<NamePackage>();
+    for (auto&& kv : pkg.names) {
+      known_names.insert(kv);
+    }
+
+    return false;
+  });
+}
+
+void loop() {
+  // it will run the user scheduler as well
+  mesh.update();
+}

package/examples/namedMesh/platformio.ini

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