Creazione di una rete ESP-Mesh in pochi passi

Con l'aumento del numero di dispositivi IoT, cresce la necessità di strumenti di rete superiori che possano supportare il maggiore carico. Tuttavia, se consideriamo un host comune (come un router generico), esso può connettersi ad un numero limitato di nodi, meno di 32 per l'esattezza. E con un numero crescente di dispositivi IoT che potrebbero trovarsi nelle vicinanze, questo non è sufficiente. Una possibile soluzione al problema risiede nell'utilizzare un protocollo di rete noto come rete mesh. In questo articolo vedremo come creare una semplice configurazione di rete mesh composta da dispositivi ESP.

Introduzione

Una rete mesh è data da un gruppo di dispositivi collegati che agisce come un'unica rete. La rete mesh è una topologia di rete locale in cui i nodi sono collegati tra loro direttamente, dinamicamente e non gerarchicamente e cooperano tra loro per instradare in modo efficiente i dati da/verso i client. La rete mesh supporta il collegamento in rete automatico, ovvero quando l'utente configura una rete mesh, qualsiasi nodo può scansionare il punto di accesso e connettersi facilmente. Circa 87 nodi possono essere collegati con un unico router. ESP-Mesh è abbastanza diversa da una configurazione mesh tradizionale. ESP-Mesh è un protocollo di rete basato sul protocollo Wi-Fi. ESP-Mesh consente a numerosi dispositivi (generalmente indicati come nodi) distribuiti su una vasta area fisica di essere interconnessi in un'unica WLAN. ESP-Mesh consente a più nodi di comunicare tra loro in un'unica rete locale wireless. Tale protocollo è supportato sulle schede ESP32 e ESP8266. In una ESP-Mesh, il nodo o il singolo dispositivo può connettersi contemporaneamente al suo vicino. Un singolo nodo può connettersi a più nodi e trasmettere gli stessi dati a tutti. Questo processo non è solo efficiente ma è anche ridondante. Se uno qualsiasi dei nodi viene scollegato dalla rete, i dati provenienti da altri nodi possono raggiungere la loro destinazione senza problemi. Ciò apre anche la possibilità di realizzare l'interconnessione senza la necessità di un nodo centrale, il che estende significativamente l'area di copertura della rete mesh. ESP-Mesh è una rete auto-organizzante e auto-rigenerante, il che significa che la rete può essere costruita e mantenuta autonomamente. In questo articolo utilizzeremo entrambe le schede ESP32 ed ESP8266 in modo da poter creare una rete mesh ESP8266 o una rete mesh ESP32 utilizzando lo stesso metodo. Per costruire la rete mesh, utilizzeremo la libreria painlessMesh per Arduino, che supporta sia i moduli ESP8266 che ESP32.

Architettura di rete Wi-Fi tradizionale

In un'architettura di rete Wi-Fi tradizionale, un singolo nodo (punto di accesso - solitamente il router) è connesso a tutti gli altri nodi (stazioni). Ciascun nodo può comunicare con gli altri utilizzando il punto di accesso. Tuttavia, questo è limitato alla copertura Wi-Fi del punto di accesso. Ogni stazione deve trovarsi nel raggio d'azione per connettersi direttamente al punto di accesso, come evidenziato in Figura 1. Questo non accade con ESP-Mesh.

Figura 1: Rappresentazione di un'architettura di rete wireless tradizionale

Architettura di rete ESP-Mesh

Con ESP-Mesh, i nodi non hanno bisogno di connettersi ad un nodo centrale. I nodi sono responsabili dell'inoltro reciproco delle trasmissioni. Ciò consente a più dispositivi di distribuirsi su una vasta area fisica. I nodi possono auto-organizzarsi e dialogare dinamicamente tra loro per garantire che il pacchetto raggiunga la destinazione finale del nodo. Se un nodo viene rimosso dalla rete, essa è in grado di auto-organizzarsi per assicurarsi che i pacchetti raggiungano la loro destinazione. La rete ESP-Mesh ha un'area di copertura molto più ampia poiché i nodi possono raggiungere l'interconnettività senza dover essere nel raggio del nodo centrale, come evidenziato in Figura 2.

Figura 2: Rappresentazione di un'architettura di rete mesh

La libreria painlessMesh

In questo articolo utilizzeremo l'IDE Arduino per programmare le schede ESP32 e ESP8266. Useremo inoltre la libreria painlessMesh per costruire la nostra rete mesh. La libreria painlessMesh consente di creare una rete mesh con le schede ESP8266 e/o ESP32 in modo semplice. Per installare la libreria tramite il gestore delle librerie Arduino, basta seguire le seguenti istruzioni:

Andare su "Strumenti" -> "Gestisci librerie"
Aperto il gestore delle librerie cercare painlessMesh e installare la libreria
Questa libreria necessita di altre dipendenze. Dovrebbe quindi apparire una nuova finestra che chiede di installare eventuali dipendenze mancanti. Selezionare "Installa tutto"
Nel caso la finestra non dovesse apparire, sarà necessario installare singolarmente le dipendenze, che sono: ArduinoJson (by bblanchon), TaskScheduler, ESPAsyncTCP (ESP8266), AsyncTCP (ESP32)

Per iniziare con ESP-Mesh, sperimenteremo prima l'esempio di base fornito dalla libreria. Questo esempio, denominato Basic, crea una rete mesh in cui tutte le schede trasmettono un messaggio a tutte le altre schede.

//************************************************************
// 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
//
//
//************************************************************
#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 ); // 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);

userScheduler.addTask( taskSendMessage );
taskSendMessage.enable();
}

void loop() {
// it will run the user scheduler as well
mesh.update();
}

Il codice è compatibile con entrambe le schede ESP32 e ESP8266. Prima di caricare per mezzo dell'IDE il codice in ogni scheda, occorre modificare le variabili MESH_PREFIX e MESH_PASSWORD, che rappresentano rispettivamente il nome e la password della rete mesh. Tali variabili possono essere scelte a piacimento. Inoltre, è raccomandabile modificare la riga che permette di identificare il nodo che ha inviato il messaggio. Ad esempio, per facilitare l'identificazione del nodo 1, conviene modificare la seguente linea:

[...]

ATTENZIONE: quello che hai appena letto è solo un estratto, l'Articolo Tecnico completo è composto da ben 2284 parole ed è riservato agli ABBONATI. Con l'Abbonamento avrai anche accesso a tutti gli altri Articoli Tecnici che potrai leggere in formato PDF per un anno. ABBONATI ORA, è semplice e sicuro.