Por Fernando Koyanagi

Intenção dessa aula

1. Introdução ao ESP-NOW.

1. Fazer vários ESP32 se comunicarem

através do protocolo ESP-NOW

1. Um ESP32 irá fazer a leitura dos pinos

e transmitir seus valores

1. Os demais ESP32 irão receber estes

valores e alterar a saída dos pinos de

acordo com os valores recebidos

ESP32 Pinout

Sobre o ESP-NOW

• Protocolo de comunicação criado pela Espressif. • Não necessita de uma rede WiFi • Similar ao protocolo de baixo consumo utilizado em mouse sem fio de 2.4GHz • Necessário pareamento inicial • Após o pareamento a conexão é persistente peer-to-peer

Exemplo do tutorial

Master faz a leitura dos pinos

Broadcast dos valores lidos

Slaves alteram a saída dos seus pinos para ficar igual aos valores recebidos do Master

Demonstração

Distância

Nos testes realizados os ESPs 32 conseguiram se comunicar por até 165,47m

Seu e-mail Em www.fernandok.com

ESPNowMaster.ino //Libs do espnow e wifi

#include <esp_now.h>

#include <WiFi.h>

//Canal usado para conexão

#define CHANNEL 1

//Pinos que iremos ler (digitalRead) e enviar para os Slaves

//É importante que o código fonte dos Slaves tenha este mesmo array com os mesmos gpios

//na mesma ordem

uint8_t gpios[] = {23, 2};

//No setup iremos calcular a quantidade de pinos e colocar nesta variável,

//assim não precisamos trocar aqui toda vez que mudarmos a quantidade de pinos,

//tudo é calculado no setup

int gpioCount;

//Mac Address dos slaves para os quais iremos enviar a leitura

//Se quiser enviar para todos os Slaves utilize apenas o endereço de broadcast {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}.

//Se quiser enviar para ESPs específicos coloque o Mac Address (obtido através da função WiFi.macAddress())

uint8_t macSlaves[][6] = {

//Se for enviar para ESPs específicos, coloque cada endereço separado por vírgula

// {0x24, 0x0A, 0xC4, 0x0E, 0x3F, 0xD1}, {0x24, 0x0A, 0xC4, 0x0E, 0x4E, 0xC3}

//Se for enviar para todos, apenas deixe o endereço de broadcast {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}

{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}

};

ESPNowMaster.ino - setup 1/3 void setup() {

Serial.begin(115200);

//Cálculo do tamanho do array de gpios que serão lidos com o digitalRead

//sizeof(gpios) retorna a quantidade de bytes que o array gpios aponta

//Sabemos que todos os elementos do array são do tipo uint8_t

//sizeof(uint8_t) retorna a quantidade de bytes que o tipo uint8_t possui

//Sendo assim para saber quantos elementos o array possui

//fazemos a divisão entre a quantidade total de bytes do array e quantos

//bytes cada elemento possui

gpioCount = sizeof(gpios)/sizeof(uint8_t);

//Colocamos o ESP em modo station

WiFi.mode(WIFI_STA);

//Mostramos no Monitor Serial o Mac Address deste ESP quando em modo station

Serial.print("Mac Address in Station: ");

Serial.println(WiFi.macAddress());

//Chama a função que inicializa o ESPNow

InitESPNow();

ESPNowMaster.ino - setup 2/3 //Cálculo do tamanho do array com os mac address dos slaves

//sizeof(macSlaves) retorna a quantidade de bytes que o array macSlaves aponta

//Sabemos que cada mac address é um array de 6 posições e

//cada posição possui sizeof(uint8_t) bytes, então

//a quantidade de slaves é a divisão da quantidade de bytes

//total do array pela quantidade de posições e o resultado

//dessa divisão dividimos novamente por quantos bytes cada posição possui

int slavesCount = sizeof(macSlaves)/6/sizeof(uint8_t);

//Para cada slave

for(int i=0; i<slavesCount; i++){

//Criamos uma variável que irá guardar as informações do slave

esp_now_peer_info_t slave;

//Informamos o canal

slave.channel = CHANNEL;

//0 para não usar criptografia ou 1 para usar

slave.encrypt = 0;

//Copia o endereço do array para a estrutura

memcpy(slave.peer_addr, macSlaves[i], sizeof(macSlaves[i]));

//Adiciona o slave

esp_now_add_peer(&slave);

}

ESPNowMaster.ino - setup 3/3

//Registra o callback que nos informará sobre o status do envio

//A função que será executada é OnDataSent e está declarada mais abaixo

esp_now_register_send_cb(OnDataSent);

//Para cada pino que está no array gpios

for(int i=0; i<gpioCount; i++){

//Colocamos em modo de leitura

pinMode(gpios[i], INPUT);

}

//Chama a função send

send();

}

ESPNowMaster.ino - InitESPNow

void InitESPNow() {

//Se a inicialização foi bem sucedida

if (esp_now_init() == ESP_OK) {

Serial.println("ESPNow Init Success");

}

//Se houve erro na inicialização

else {

Serial.println("ESPNow Init Failed");

ESP.restart();

}

}

ESPNowMaster.ino - send 1/2

//Função que irá fazer a leitura dos pinos

//que estão no array gpios e enviar os valores

//lidos para os outros ESPs

void send(){

//Array que irá armazenar os valores lidos

uint8_t values[gpioCount];

//Para cada pino

for(int i=0; i<gpioCount; i++){

//Lê o estado do pino e armazena no array

values[i] = digitalRead(gpios[i]);

}

ESPNowMaster.ino - send 2/2

//O endereço de broadcast irá enviar as informações para todos os ESPs

//Se quiser que a informação vá para ESPs específicos você deve chamar a função

//esp_now_send para cada Mac Address, passando o Mac Address como primeiro

//parâmetro no lugar do broadcast

uint8_t broadcast[] = {0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF};

esp_err_t result = esp_now_send(broadcast, (uint8_t*) &values, sizeof(values));

Serial.print("Send Status: ");

//Se o envio foi bem sucedido

if (result == ESP_OK) {

Serial.println("Success");

}

//Se aconteceu algum erro no envio

else {

Serial.println("Error");

}

}

ESPNowMaster.ino - OnDataSent

//Função que serve de callback para nos avisar

//sobre a situação do envio que fizemos

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {

char macStr[18];

//Copiamos o Mac Address destino para uma string

snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",

mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);

//Mostramos o Mac Address que foi destino da mensagem

Serial.print("Sent to: ");

Serial.println(macStr);

//Mostramos se o status do envio foi bem sucedido ou não

Serial.print("Status: ");

Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Success" : "Fail");

//Enviamos novamente os dados

send();

}

ESPNowMaster.ino - loop

//Não precisamos fazer nada no loop

//pois sempre que recebemos o feedback

//do envio através da função OnDataSent

//nós enviamos os dados novamente,

//fazendo com que os dados estejam sempre

//sendo enviados em sequência

void loop() {

}

ESPNowSlave.ino

//Libs do espnow e wifi

#include <esp_now.h>

#include <WiFi.h>

//Pinos que iremos escrever (digitalWrite) cujos valores são recebios do Master

//É importante que o código fonte do Master tenha este mesmo array com os mesmos gpios

//na mesma ordem

uint8_t gpios[] = {23, 2};

//No setup iremos calcular a quantidade de pinos e colocar nesta variável,

//assim não precisamos trocar aqui toda vez que mudarmos a quantidade de pinos,

//tudo é calculado no setup

int gpioCount;

ESPNowSlave.ino - setup 1/2

void setup() {

Serial.begin(115200);

//Cálculo do tamanho do array de gpios

//sizeof(gpios) retorna a quantidade de bytes que o array gpios aponta

//Sabemos que todos os elementos do array são do tipo uint8_t

//sizeof(uint8_t) retorna a quantidade de bytes que o tipo uint8_t possui

//Sendo assim para saber quantos elementos o array possui

//fazemos a divisão entre a quantidade total de bytes do array e quantos

//bytes cada elemento possui

gpioCount = sizeof(gpios)/sizeof(uint8_t);

//Colocamos o ESP em modo station

WiFi.mode(WIFI_STA);

//Mostramos no Monitor Serial o Mac Address deste ESP quando em modo station

//Se quiser que o Master mande para ESPs em específico, altere no

//array de slaves (no código fonte do Master) para que ele possua apenas os Mac Addresses printados aqui

Serial.print("Mac Address in Station: ");

Serial.println(WiFi.macAddress());

//Chama a função que inicializa o ESPNow

InitESPNow();

ESPNowSlave.ino - setup 2/2

//Registra o callback que nos informará quando o Master enviou algo

//A função que será executada é OnDataRecv e está declarada mais abaixo

esp_now_register_recv_cb(OnDataRecv);

//Para cada pino que está no array gpios

for(int i=0; i<gpioCount; i++){

//Colocamos em modo de output

pinMode(gpios[i], OUTPUT);

}

}

ESPNowSlave.ino - InitESPNow

void InitESPNow() {

//Se a inicialização foi bem sucedida

if (esp_now_init() == ESP_OK) {

Serial.println("ESPNow Init Success");

}

//Se houve erro na inicialização

else {

Serial.println("ESPNow Init Failed");

ESP.restart();

}

}

ESPNowSlave.ino - OnDataRecv

//Função que serve de callback para nos avisar

//quando chegou algo do Master

void OnDataRecv(const uint8_t *mac_addr, const uint8_t *data, int data_len) {

char macStr[18];

//Copiamos o Mac Address origem para uma string

snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",

mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);

//Mostramos o Mac Address que foi a origem da mensagem

Serial.print("Received from: ");

Serial.println(macStr);

Serial.println("");

//Para cada pino

for(int i=0; i<gpioCount; i++){

//Colocamos o valor recebido do Master na saída do respectivo pino

digitalWrite(gpios[i], data[i]);

}

}

ESPNowSlave.ino - loop

//Não precisamos fazer nada no loop

//Sempre que chegar algo do Master

//a função OnDataRecv é executada automaticamente

//já que adicionamos como callback utilizando a função

//esp_now_register_recv_cb

void loop() {

}

Em www.fernandok.com

Download arquivos PDF e INO do código fonte