@alteriom/painlessmesh 1.6.1

package/examples/otaReceiver/otaReceiver.ino

@@ -0,0 +1,79 @@
+//************************************************************
+// this is a simple example that uses the painlessMesh library
+//
+// 1. sends a silly message to every node on the mesh at a random time between 1
+// and 5 seconds
+// 2. prints anything it receives to Serial.print
+// 3. has OTA support and can be updated remotely
+//
+//************************************************************
+#include "painlessMesh.h"
+
+#define MESH_PREFIX "whateverYouLike"
+#define MESH_PASSWORD "somethingSneaky"
+#define MESH_PORT 5555
+
+Scheduler userScheduler;  // to control your personal task
+painlessMesh mesh;
+
+// User stub
+void sendMessage();  // Prototype so PlatformIO doesn't complain
+
+Task taskSendMessage(TASK_SECOND * 1, TASK_FOREVER, &sendMessage);
+
+void sendMessage() {
+  String msg = "Hello from node ";
+  msg += mesh.getNodeId();
+  mesh.sendBroadcast(msg);
+  taskSendMessage.setInterval(random(TASK_SECOND * 1, TASK_SECOND * 5));
+}
+
+// Needed for painless library
+void receivedCallback(uint32_t from, String &msg) {
+  Serial.printf("startHere: Received from %u msg=%s\n", from, msg.c_str());
+}
+
+void newConnectionCallback(uint32_t nodeId) {
+  Serial.printf("--> startHere: New Connection, nodeId = %u\n", nodeId);
+}
+
+void changedConnectionCallback() { Serial.printf("Changed connections\n"); }
+
+void nodeTimeAdjustedCallback(int32_t offset) {
+  Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(), offset);
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  // mesh.setDebugMsgTypes( ERROR | MESH_STATUS | CONNECTION | SYNC |
+  // COMMUNICATION | GENERAL | MSG_TYPES | REMOTE ); // all types on
+  mesh.setDebugMsgTypes(
+      ERROR | STARTUP |
+      DEBUG);  // set before init() so that you can see startup messages
+
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  mesh.onReceive(&receivedCallback);
+  mesh.onNewConnection(&newConnectionCallback);
+  mesh.onChangedConnections(&changedConnectionCallback);
+  mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);
+
+  // if you want your node to accept OTA firmware, simply include this line
+  // with whatever role you want your hardware to be. For instance, a
+  // mesh network may have a thermometer, rain detector, and bridge. Each of
+  // those may require different firmware, so different roles are preferrable.
+  //
+  // MAKE SURE YOUR UPLOADED OTA FIRMWARE INCLUDES OTA SUPPORT OR YOU WILL LOSE
+  // THE ABILITY TO UPLOAD MORE FIRMWARE OVER OTA. YOU ALSO WANT TO MAKE SURE
+  // THE ROLES ARE CORRECT
+  mesh.initOTAReceive("otareceiver");
+  mesh.setContainsRoot(true);
+
+  userScheduler.addTask(taskSendMessage);
+  taskSendMessage.enable();
+}
+
+void loop() {
+  // it will run the user scheduler as well
+  mesh.update();
+}

package/examples/otaReceiver/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/otaSender/otaSender.ino

@@ -0,0 +1,151 @@
+//************************************************************
+// this is an example that uses the painlessmesh library to
+// upload firmware to another node on the network. 
+// This will upload to an ESP device running the otaReceiver.ino
+//
+// The naming convetions should be as follows for bin files
+// firmware_<hardware>_<role>.bin
+// To create your own binary files, export them and rename
+// them to follow this format, where hardware will be
+// "ESP8266" or "ESP32" (capitalized.)
+// If sending to the otacreceiver sketch, role should be
+// "otareceiver" (lowercase)
+//
+// This sketch assumes a Nodemcu-32s with an SD card
+// connected as shown in the jpg included in the sketch folder
+// This code may have to be reworked/hardware adjusted for
+// other boards or ESP8266. The core code works well though
+//
+// MAKE SURE YOUR UPLOADED OTA FIRMWARE INCLUDES OTA SUPPORT 
+// OR YOU WILL LOSE THE ABILITY TO UPLOAD MORE FIRMWARE.
+// THE INCLUDED .bin DOES NOT HAVE OTA SUPPORT SO THIS MUST BE
+// REFLASHED
+//************************************************************
+
+#ifdef ESP32
+#else
+#define CS_PIN  D8
+#endif
+
+#include "painlessMesh.h"
+
+#include <FS.h>
+#include "SD.h"
+#include "SPI.h"
+
+#define MESH_PREFIX "whateverYouLike"
+#define MESH_PASSWORD "somethingSneaky"
+#define MESH_PORT 5555
+
+#define OTA_PART_SIZE 1024 //How many bytes to send per OTA data packet
+
+painlessMesh mesh;
+
+void setup() {
+  Serial.begin(115200);
+  delay(1000);
+  mesh.setDebugMsgTypes(
+      ERROR | STARTUP | CONNECTION |
+      DEBUG);  // set before init() so that you can see startup messages
+
+  mesh.init(MESH_PREFIX, MESH_PASSWORD, MESH_PORT);
+
+  // 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);
+
+  delay(1000);
+  #ifdef ESP32
+  if (!SD.begin()) {
+  #else
+  if (!SD.begin(CS_PIN)) {
+  #endif
+    rebootEspWithReason("Could not mount SD card, restarting");
+  }
+
+  File dir = SD.open("/");
+  while (true) {
+    File entry = dir.openNextFile();
+    if (!entry) { //End of files
+      rebootEspWithReason("Could not find valid firmware, please validate");
+    }
+
+    //This block of code parses the file name to make sure it is valid.
+    //It will also get the role and hardware the firmware is targeted at.
+    if (!entry.isDirectory()) {
+      TSTRING name = entry.name();
+      if (name.length() > 1 && name.indexOf('_') != -1 &&
+          name.indexOf('_') != name.lastIndexOf('_') &&
+          name.indexOf('.') != -1) {
+        TSTRING firmware = name.substring(1, name.indexOf('_'));
+        TSTRING hardware =
+            name.substring(name.indexOf('_') + 1, name.lastIndexOf('_'));
+        TSTRING role =
+            name.substring(name.lastIndexOf('_') + 1, name.indexOf('.'));
+        TSTRING extension =
+            name.substring(name.indexOf('.') + 1, name.length());
+        if (firmware.equals("firmware") &&
+            (hardware.equals("ESP8266") || hardware.equals("ESP32")) &&
+            extension.equals("bin")) {
+
+          Serial.println("OTA FIRMWARE FOUND, NOW BROADCASTING");
+
+          //This is the important bit for OTA, up to now was just getting the file. 
+          //If you are using some other way to upload firmware, possibly from 
+          //mqtt or something, this is what needs to be changed.
+          //This function could also be changed to support OTA of multiple files
+          //at the same time, potentially through using the pkg.md5 as a key in
+          //a map to determine which to send
+          mesh.initOTASend(
+              [&entry](painlessmesh::plugin::ota::DataRequest pkg,
+                       char* buffer) {
+                
+                //fill the buffer with the requested data packet from the node.
+                entry.seek(OTA_PART_SIZE * pkg.partNo);
+                entry.readBytes(buffer, OTA_PART_SIZE);
+                
+                //The buffer can hold OTA_PART_SIZE bytes, but the last packet may
+                //not be that long. Return the actual size of the packet.
+                return min((unsigned)OTA_PART_SIZE,
+                           entry.size() - (OTA_PART_SIZE * pkg.partNo));
+              },
+              OTA_PART_SIZE);
+
+          //Calculate the MD5 hash of the firmware we are trying to send. This will be used
+          //to validate the firmware as well as tell if a node needs this firmware.
+          MD5Builder md5;
+          md5.begin();
+          md5.addStream(entry, entry.size());
+          md5.calculate(); 
+
+          //Make it known to the network that there is OTA firmware available.
+          //This will send a message every minute for an hour letting nodes know
+          //that firmware is available.
+          //This returns a task that allows you to do things on disable or more,
+          //like closing your files or whatever.
+          mesh.offerOTA(role, hardware, md5.toString(),
+                        ceil(((float)entry.size()) / OTA_PART_SIZE), false);
+
+          while (true) {
+            //This program will not reach loop() so we dont have to worry about
+            //file scope.
+            mesh.update();
+            delay(1000);
+          }
+        }
+      }
+    }
+  }
+}
+
+void rebootEspWithReason(String reason) {
+  Serial.println(reason);
+  delay(1000);
+  ESP.restart();
+}
+
+void loop(){};

package/examples/otaSender/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@^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/startHere/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 = ../../  ; Load the local copy of painlessmesh. For your own example add painlessmesh to the lib_deps
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP  ; Only for ESP8266
+
+[env:esp32]
+platform = espressif32
+board = esp32dev
+framework = arduino
+lib_extra_dirs = ../../  ; Load the local copy of painlessmesh. For your own example add painlessmesh to the lib_deps
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/AsyncTCP

package/examples/startHere/startHere.ino

@@ -0,0 +1,159 @@
+//************************************************************
+// this is a simple example that uses the easyMesh library
+//
+// 1. blinks led once for every node on the mesh
+// 2. blink cycle repeats every BLINK_PERIOD
+// 3. sends a silly message to every node on the mesh at a random time between 1 and 5 seconds
+// 4. prints anything it receives to Serial.print
+//
+//
+//************************************************************
+#include <painlessMesh.h>
+
+// some gpio pin that is connected to an LED...
+// on my rig, this is 2, change to the right number of your LED.
+#ifndef LED
+  #ifdef LED_BUILTIN
+    #define LED LED_BUILTIN
+  #else
+    #define LED 2
+  #endif
+#endif
+
+#define   BLINK_PERIOD    3000 // milliseconds until cycle repeat
+#define   BLINK_DURATION  100  // milliseconds LED is on for
+
+#define   MESH_SSID       "whateverYouLike"
+#define   MESH_PASSWORD   "somethingSneaky"
+#define   MESH_PORT       5555
+
+// Prototypes
+void sendMessage(); 
+void receivedCallback(uint32_t from, String & msg);
+void newConnectionCallback(uint32_t nodeId);
+void changedConnectionCallback(); 
+void nodeTimeAdjustedCallback(int32_t offset); 
+void delayReceivedCallback(uint32_t from, int32_t delay);
+
+Scheduler     userScheduler; // to control your personal task
+painlessMesh  mesh;
+
+bool calc_delay = false;
+SimpleList<uint32_t> nodes;
+
+void sendMessage() ; // Prototype
+Task taskSendMessage( TASK_SECOND * 1, TASK_FOREVER, &sendMessage ); // start with a one second interval
+
+// Task to blink the number of nodes
+Task blinkNoNodes;
+bool onFlag = false;
+
+void setup() {
+  Serial.begin(115200);
+
+  pinMode(LED, OUTPUT);
+
+  mesh.setDebugMsgTypes(ERROR | DEBUG);  // set before init() so that you can see error messages
+
+  mesh.init(MESH_SSID, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  mesh.onReceive(&receivedCallback);
+  mesh.onNewConnection(&newConnectionCallback);
+  mesh.onChangedConnections(&changedConnectionCallback);
+  mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);
+  mesh.onNodeDelayReceived(&delayReceivedCallback);
+
+  userScheduler.addTask( taskSendMessage );
+  taskSendMessage.enable();
+
+  blinkNoNodes.set(BLINK_PERIOD, (mesh.getNodeList().size() + 1) * 2, []() {
+      // If on, switch off, else switch on
+      if (onFlag)
+        onFlag = false;
+      else
+        onFlag = true;
+      blinkNoNodes.delay(BLINK_DURATION);
+
+      if (blinkNoNodes.isLastIteration()) {
+        // Finished blinking. Reset task for next run 
+        // blink number of nodes (including this node) times
+        blinkNoNodes.setIterations((mesh.getNodeList().size() + 1) * 2);
+        // Calculate delay based on current mesh time and BLINK_PERIOD
+        // This results in blinks between nodes being synced
+        blinkNoNodes.enableDelayed(BLINK_PERIOD - 
+            (mesh.getNodeTime() % (BLINK_PERIOD*1000))/1000);
+      }
+  });
+  userScheduler.addTask(blinkNoNodes);
+  blinkNoNodes.enable();
+
+  randomSeed(analogRead(A0));
+}
+
+void loop() {
+  mesh.update();
+  digitalWrite(LED, !onFlag);
+}
+
+void sendMessage() {
+  String msg = "Hello from node ";
+  msg += mesh.getNodeId();
+  msg += " myFreeMemory: " + String(ESP.getFreeHeap());
+  mesh.sendBroadcast(msg);
+
+  if (calc_delay) {
+    SimpleList<uint32_t>::iterator node = nodes.begin();
+    while (node != nodes.end()) {
+      mesh.startDelayMeas(*node);
+      node++;
+    }
+    calc_delay = false;
+  }
+
+  Serial.printf("Sending message: %s\n", msg.c_str());
+  
+  taskSendMessage.setInterval( random(TASK_SECOND * 1, TASK_SECOND * 5));  // between 1 and 5 seconds
+}
+
+
+void receivedCallback(uint32_t from, String & msg) {
+  Serial.printf("startHere: Received from %u msg=%s\n", from, msg.c_str());
+}
+
+void newConnectionCallback(uint32_t nodeId) {
+  // Reset blink task
+  onFlag = false;
+  blinkNoNodes.setIterations((mesh.getNodeList().size() + 1) * 2);
+  blinkNoNodes.enableDelayed(BLINK_PERIOD - (mesh.getNodeTime() % (BLINK_PERIOD*1000))/1000);
+ 
+  Serial.printf("--> startHere: New Connection, nodeId = %u\n", nodeId);
+  Serial.printf("--> startHere: New Connection, %s\n", mesh.subConnectionJson(true).c_str());
+}
+
+void changedConnectionCallback() {
+  Serial.printf("Changed connections\n");
+  // Reset blink task
+  onFlag = false;
+  blinkNoNodes.setIterations((mesh.getNodeList().size() + 1) * 2);
+  blinkNoNodes.enableDelayed(BLINK_PERIOD - (mesh.getNodeTime() % (BLINK_PERIOD*1000))/1000);
+ 
+  nodes = mesh.getNodeList();
+
+  Serial.printf("Num nodes: %d\n", nodes.size());
+  Serial.printf("Connection list:");
+
+  SimpleList<uint32_t>::iterator node = nodes.begin();
+  while (node != nodes.end()) {
+    Serial.printf(" %u", *node);
+    node++;
+  }
+  Serial.println();
+  calc_delay = true;
+}
+
+void nodeTimeAdjustedCallback(int32_t offset) {
+  Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(), offset);
+}
+
+void delayReceivedCallback(uint32_t from, int32_t delay) {
+  Serial.printf("Delay to node %u is %d us\n", from, delay);
+}

package/examples/webServer/platformio.ini

@@ -0,0 +1,27 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+    esp32async/ESPAsyncWebServer
+
+[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
+    AsyncWebServer

package/examples/webServer/webServer.ino

@@ -0,0 +1,89 @@
+//************************************************************
+// this is a simple example that uses the painlessMesh library to
+// connect to a another network and broadcast message from a webpage to the edges of the mesh network.
+// This sketch can be extended further using all the abilities of the AsyncWebserver library (WS, events, ...)
+// for more details
+// https://gitlab.com/painlessMesh/painlessMesh/wikis/bridge-between-mesh-and-another-network
+// for more details about my version
+// https://gitlab.com/Assassynv__V/painlessMesh
+// and for more details about the AsyncWebserver library
+// https://github.com/me-no-dev/ESPAsyncWebServer
+//************************************************************
+
+#include "IPAddress.h"
+#include "painlessMesh.h"
+
+#ifdef ESP8266
+#include "Hash.h"
+#include <ESPAsyncTCP.h>
+#else
+#include <AsyncTCP.h>
+#endif
+#include <ESPAsyncWebServer.h>
+
+#define   MESH_PREFIX     "whateverYouLike"
+#define   MESH_PASSWORD   "somethingSneaky"
+#define   MESH_PORT       5555
+
+#define   STATION_SSID     "mySSID"
+#define   STATION_PASSWORD "myPASSWORD"
+
+#define HOSTNAME "HTTP_BRIDGE"
+
+// Prototype
+void receivedCallback( const uint32_t &from, const String &msg );
+IPAddress getlocalIP();
+
+painlessMesh  mesh;
+AsyncWebServer server(80);
+IPAddress myIP(0,0,0,0);
+IPAddress myAPIP(0,0,0,0);
+
+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);
+
+  myAPIP = IPAddress(mesh.getAPIP());
+  Serial.println("My AP IP is " + myAPIP.toString());
+
+  //Async webserver
+  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
+    request->send(200, "text/html", "<form>Text to Broadcast<br><input type='text' name='BROADCAST'><br><br><input type='submit' value='Submit'></form>");
+    if (request->hasArg("BROADCAST")){
+      String msg = request->arg("BROADCAST");
+      mesh.sendBroadcast(msg);
+    }
+  });
+  server.begin();
+
+}
+
+void loop() {
+  mesh.update();
+  if(myIP != getlocalIP()){
+    myIP = getlocalIP();
+    Serial.println("My IP is " + myIP.toString());
+  }
+}
+
+void receivedCallback( const uint32_t &from, const String &msg ) {
+  Serial.printf("bridge: Received from %u msg=%s\n", from, msg.c_str());
+}
+
+IPAddress getlocalIP() {
+  return IPAddress(mesh.getStationIP());
+}

package/keywords.txt

@@ -0,0 +1,49 @@
+# painlessMesh library keywords
+
+# Classes (KEYWORD1)
+painlessMesh	KEYWORD1
+Scheduler	KEYWORD1
+Task	KEYWORD1
+
+# Methods and Functions (KEYWORD2)
+init	KEYWORD2
+update	KEYWORD2
+sendBroadcast	KEYWORD2
+sendSingle	KEYWORD2
+onReceive	KEYWORD2
+onNewConnection	KEYWORD2
+onChangedConnections	KEYWORD2
+onNodeTimeAdjusted	KEYWORD2
+getNodeList	KEYWORD2
+getNodeId	KEYWORD2
+getNodeTime	KEYWORD2
+setDebugMsgTypes	KEYWORD2
+subConnectionJson	KEYWORD2
+asNodeTree	KEYWORD2
+
+# Alteriom Extensions (KEYWORD1)
+SensorPackage	KEYWORD1
+CommandPackage	KEYWORD1
+StatusPackage	KEYWORD1
+
+# Alteriom Methods (KEYWORD2)
+addTo	KEYWORD2
+jsonObjectSize	KEYWORD2
+
+# Constants (LITERAL1)
+MESH_PREFIX	LITERAL1
+MESH_PASSWORD	LITERAL1
+MESH_PORT	LITERAL1
+TASK_SECOND	LITERAL1
+TASK_MINUTE	LITERAL1
+TASK_HOUR	LITERAL1
+TASK_FOREVER	LITERAL1
+ERROR	LITERAL1
+STARTUP	LITERAL1
+CONNECTION	LITERAL1
+SYNC	LITERAL1
+COMMUNICATION	LITERAL1
+GENERAL	LITERAL1
+MSG_TYPES	LITERAL1
+REMOTE	LITERAL1
+DEBUG	LITERAL1

package/library.json

@@ -0,0 +1,34 @@
+{
+    "name": "painlessMesh",
+    "keywords": "ethernet, m2m, iot, mesh, alteriom, sensor",
+    "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.",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Alteriom/painlessMesh"
+    },
+    "version": "1.6.1",
+    "frameworks": "arduino",
+    "platforms": "espressif8266, espressif32",
+    "dependencies": [
+        { "owner": "esp32async", "name": "AsyncTCP", "version": "^3.4.7",  "platforms" : ["espressif32"] },
+        { "owner": "esp32async", "name": "ESPAsyncTCP", "version": "^2.0.0",  "platforms" : ["espressif8266"] },
+        { "owner": "bblanchon", "name": "ArduinoJson", "version": "^7.4.2" },
+        { "owner": "arkhipenko", "name": "TaskScheduler", "version": "^3.8.5" }
+    ],
+    "authors": [
+        { "name": "Scotty Franzyshen" }, 
+        { 
+            "name": "Coopdis",
+            "url": "https://github.com/Coopdis"
+        }, 
+        { "name": "Edwin van Leeuwen" },
+        { "name": "Germán Martín" },
+        { "name": "Maximilian Schwarz" },
+        { "name": "Doanh Doanh" },
+        { 
+            "name": "Alteriom",
+            "url": "https://github.com/Alteriom"
+        }
+    ],
+    "headers": "painlessMesh.h"
+}

package/library.properties

@@ -0,0 +1,11 @@
+name=AlteriomPainlessMesh
+version=1.6.1
+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
+paragraph=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.
+category=Communication
+url=https://github.com/Alteriom/painlessMesh
+architectures=esp8266,esp32
+includes=AlteriomPainlessMesh.h
+depends=ArduinoJson, TaskScheduler