Rede Mesh com Módulos ESP-8266, ESP-32 e ESP-01

Introdução

Hoje com a Internet das Coisa (Iot) que é a conexão com objetos do dia-a-dia (carros, geladeiras, televisores, luzes, portões etc) fornecendo informações instantânea a todo momento e  sendo comandados  em qualquer lugar do mundo através da internet faz que exista uma comunicação persistente livre de falhas, porém alguns dispositivo não conseguem alcançar o sinal de Wi-Fi fornecida pelos roteadores deixando esses equipamento off line ou com uma instabilidade muito grande.

Uma solução para resolver esse problema, porém não tão barata, é a instalação de mais roteadores gastando mais dinheiro com equipamento e mão de  obra para gerenciar toda rede.

Mas com a tecnologia Mesh podemos aproveitar os equipamentos já instalados e transformá-los em repetidor de sinal de Wi-Fi sem custos garantindo que o sinal chegue a todos os equipamentos

Ao criar uma rede Mesh, nós podemos aproveitar os módulos ESP8266, Esp32 ou  esp-01 que já estão controlando equipamentos e atribuir mais uma função que é a ponte para fornecer sinais Wi-Fi para aqueles dispositivos que estão fora do alcance do roteador central.

O que é redes Mesh e como elas funcionam

Redes tradicionais

Nas redes tradicionais de Wi-Fi existe um roteador denominado Ponto de Acesso (AP) onde os diversos pontos(estações) se comunicam exclusivamente com ela.

O Ponto de acesso(AP) é o responsável por gerenciar toda a  rede e dar prioridades, fornecer IP ‘s, conectar ou desconectar estações.

Essa concentração gera desvantagem já que toda a rede depende exclusivamente de um aparelho central para funcionar e a distância do alcance do seu sinal de Wi-Fi é a distância da máxima rede.

Assim, se caso uma  estação esteja  longe do AP poderá ficar fora do alcance do sinal Wi-Fi transmitido deixando de se comunicar com rede

Rede Tradicional onde é possível ver que três equipamentos não alcança o sinal de Wi-Fi do Roteador

Redes Mesh

È uma solução barata e criativa para ampliar a conexão de dispositivos onde além de receber o sinal também passam a ser um fornecedor de dados, servindo como ponte para outros dispositivos criando uma malha muito parecida a uma teia de aranha que todos os pontos estão conectados a pelo menos dois pontos e que o rompimento de um nó não faz a comunicação cair, pois existe outro ponto já pré configurada de conexão e fazendo que a rede se auto organize quase que instantaneamente.

Rede Mesh. Esp-8266 trabalhando em rede.

A rede Mesh é uma  solução inovadora já que aquele ponto que não consegue receber o sinal direto do Wi-Fi do AP pode se conectar em ponte com outro dispositivo próximo funcionando e aproveitando uma estrutura já existente não sendo necessário a compra de novos equipamentos e trabalhando com redundância já que o rompimento de uma conexão não afeta o sistema onde a rede trabalha em malha e o ponto quebrado rapidamente vai se conectar a outro ponto instantaneamente e e auto gerenciado

Segundo a documentação oficial da Espressif a rede Mesh pode ligar até 100 nós sem que haja quebra no sistema ou gere instabilidade

Em resumo:

A rede tradicional de Wi-Fi a infraestrutura toda se baseia em conexão em árvore onde as estações se conecta diretamente o roteador.

E na rede Mesh as estações têm dupla função obtendo e fornecendo dados simultaneamente resultando em uma topologia de rede muito parecido a uma teia de aranha(na prática não é igual a uma teia mas para fins didáticos essa definição abraça a ideia de rede Mesh).

Materiais Necessários para o Projeto Rede Mesh com Módulos ESP-8266, ESP-32 e ESP-01

• 1x Módulo WiFi ESP32 Bluetooth 30 pinos
• 1x Módulo WiFi Serial ESP8266 ESP-01
• 1x Módulo WiFi ESP8266 NodeMcu v3 – Lolin
• 1x Adaptador USB para Módulo WiFi ESP8266 ESP-01

Construindo a Rede Mesh

O desenvolvedor da Biblioteca utilizada para criar a Rede Mesh painlessMesh.h facilitou muito a vida do programador, não sendo  preciso se preocupar com a estrutura ou quebra de nó que possa acontecer ou no gerenciamento da rede, tudo ocorre de forma automática.

A rede é uma rede Ad-Hoc que não é necessário o gerenciamento de novos dispositivos, a entrada de um novo dispositivo ou o desligamento ocorre de forma automática, se auto  organizando sem aviso ou sobre salto ao administrador.

Instalando a Biblioteca painlessMesh

No nossos testes a melhor solução foi instalar a biblioteca  painlessMesh através do GitLab, lá encontramos a biblioteca mais atualizada e estável.

Baixe: 

https://gitlab.com/painlessMesh/painlessMesh/-/archive/master/painlessMesh-master.zip

Baixe a biblioteca no formato Zip, abra a IDE do Arduino vá em Sketch>Incluir Biblioteca> Adicionar Biblioteca .ZIP>. Escolha a biblioteca que você salvou e click salvar.

A versão utilizada em nossos testes foi a versão 1.4.7.

A biblioteca instalada vai requerer a instalação de forma automática de outras dependências, assim a IDE Arduino vai solicitar autorização para que isso ocorra. Autorize essa instalação.

Caso não apareça essa solicitação será necessário instalar as seguintes bibliotecas:

• ArduinoJson (por bblanchon)
• Agendador de tarefas
• ESPAsyncTCP (ESP8266)
• AsyncTCP (ESP32)

Nos nossos testes, mesmo não constando na documentação oficial, foi necessário a instalação  da biblioteca  ESPAsyncTCP para e Rede Mesh funcionar.

Essa é uma biblioteca TCP que torna a conexão assíncrona, ela é destinada para habilitar um ambiente de rede multi-conexão sem problemas para os MCUs ESP8266 do Espressif.(não foi realizado testes com o modulo esp32).

Endereço eletrônico onde baixar a biblioteca.

https://github.com/mtnocean/ESP8266_Neopixel_Ping/archive/refs/heads/master.zip

configuração

A configuração básica é bem fácil e intuitiva, bastando colocar o SSID e a senha da rede no Sketch.

#define   MESH_PREFIX     "whateverYouLike"
#define   MESH_PASSWORD   "somethingSneaky"

Código Básico da Rede Mesh

Link do Sketch Original:

https://gitlab.com/painlessMesh/painlessMesh/-/raw/master/examples/basic/basic.ino?inline=false

// este é um exemplo simples que usa a biblioteca PainlessMesh
#include "painlessMesh.h"
#define   MESH_PREFIX     "Nome_da_sua_rede" // aqui coloque o nome da sua rede
#define   MESH_PASSWORD   "Senha" // Senha da sua rede Wi-Fi
#define   MESH_PORT       5555

Scheduler userScheduler;
painlessMesh  mesh;

void sendMessage() ; 

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

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 );
  mesh.setDebugMsgTypes( ERROR | STARTUP );  

  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() {
  mesh.update();
}

Rede Mesh com a Implementação OTA

Uma boa solução para atualizar os Esp’s e aproveitando que os dispositivos estão ligados em rede e também pela quantidade de dispositivos é a implementação de atualização via OTA (Wi-Fi).

Nesse artigo explico o que é atualização OTA, requisitos etc.

link: https://blog.eletrogate.com/atualizando-o-esp8266-via-ota-wi-fi/

Aqui um exemplo de sketch com a rede Mesh e ota Juntos com suporte OTA que pode ser atualizado remotamente.

Link do Sketch Original:

https://gitlab.com/painlessMesh/painlessMesh/-/raw/master/examples/bridge/bridge.ino?inline=false

#include "painlessMesh.h"

#define MESH_PREFIX "nome_da_sua_rede_wifi"   // Troque para o nome da sua rede
#define MESH_PASSWORD "Senha_Wifi"   // coloque a senha da sua rede
#define MESH_PORT 5555

Scheduler userScheduler;  
painlessMesh mesh;
void sendMessage();  /

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);W
  mesh.onChangedConnections(&changedConnectionCallback);
  mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);

  mesh.initOTAReceive("otareceiver");

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

void loop() {
  mesh.update();
}

Observações:

• Esse código é bem básico e servindo como prova de conceito e alterações são bem vindas.

• A utilização da função delay() interrompe o código impossibilitando a realização de tarefas em segundo plano fazendo que a rede Mesh gere instabilidade ou até pare de funcionar.
• Assim, uma solução é utilizar a função Milis() para executar determinada tarefa ou ainda usar um agendador de tarefas.

Soluções de Problemas

Caso alguns dispositivos não conecte com a rede verifique se o nome SSID e senha foram colocado corretamente;

Faça uma varredura no aplicativo de celular Wifi Analyzer e você verá que toda a rede Mesh compartilha o mesmo canal. A discrepância de canais como roteador entre os Esp impede a troca de dados até que os Esp troquem de canal, isso ocorre de forma automática.

Assim, no intuito de evitar queda da rede e  demora nas transmissões dos dados, o usuário deve configurar no roteador para que “NÃO” ocorra a mudança de canal de Wi-Fi de forma automática. 

Observe que a rede Mesh criada (nome da nossa rede “REDeBLUE”) está no canal 1.

Uma boa prática de programação e se não atrapalhar a destinação do módulo é a implementação da ESP8266Ping que executa ping em uma máquina remota avaliando se há internet ou não, assim podemos utilizar um Led no retorno do ping para verificar se existe conexão com a rede.

Notas e Conclusão

Em testes realizados o tempo para criação da rede Mesh em geral é menor que um minuto.

A latência entre salto é de 10 a 30 milissegundos e o tempo dessa latência está diretamente relacionada a quantidade de saltos que existem dentro da rede Mesh.

Otimize ao máximo a quantidade de mensagens transmitida/recebidas  lembrando que nosso módulos Esp são bem limitados tanto no processamento como na memória assim evitamos quebras das mensagens e da rede.

A rede Mesh tem a finalidade na persistência de comunicação, assim não servindo para grande tráfego de informações e velocidade de dados.

Referência

• ESP-WIFI-MESH
• ESP-WIFI-MESH Development Framework
• painlessMesh
• ESP-WIFI-MESH Programming Guide

Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!

Sobre o Autor

André Calazans Programador, Graduando em Ciência da Computação, Técnico em Eletrônica, Eletricista. Onde tiver um Elétron eu vou querer saber porque ele está ali.