Collegare ESP32 e D1 Mini tramite ESP-Now

A differenza del modo tradizionale di collegare un controller a un altro tramite Wi-Fi, ESP-Now utilizza un protocollo speciale che collega direttamente due microcontroller abilitati per WLAN senza passare attraverso un router. La connessione avviene direttamente tramite i rispettivi indirizzi MAC e può ovviamente avvenire solo all'interno di una Rete WLAN.

Questo protocollo semplificato rende la connessione molto più veloce e quindi riduce anche il consumo di energia del controller. Tuttavia, ESP-Now presenta anche svantaggi, la quantità di dati per pacchetto è limitata a 250 byte e Internet può essere raggiunto solo tramite un gateway.

Un maestro può essere accoppiato con un massimo di 20 schiavi. Se si desidera crittografare la rete ESP-Now, il numero di possibili slave viene ridotto a 10.

Nel nostro esempio, useremo un ESP32 come master e un D1 Mini come slave. Lo slave viene avviato come un punto di accesso soft in modo che il master possa trovarlo tramite una scansione di rete.

Su richiesta del padrone, lo schiavo è quello di inviare i valori misurati da un sensore di temperatura e umidità.

Schiavo:

Lo schiavo è un D1 Minitramite il pin D0 - GPIO 16 con il pin di dati di un Sensori di temperatura DHT11 Collegato.

Il seguente schizzo dettagliato annotato mostra il programma utilizzato. Il punto di accesso esporta la rete WLAN denominata Slave_1, la password non è necessaria per stabilire la connessione.  :

/1 Mini con sensore di temperatura e umidità DHT11 come
 - Schiavo in una comunicazione ESP-NOW
 Lo slave genera la rete WiFi Slave_1 e attende i dati dal master
 Ogni volta che viene ricevuto un pacchetto di dati, lo schiavo risponde con
 : i valori misurati dal sensore
 */

 Librerie per WiFi e per il sensore
#include <ESP8266WiFi.H>
#include <SimpleDHT (SempliceDHT).H>

Libreria per ESP-Now
Esterno "C"{
#include <espnow.H>
}

Canale WiFi
# define Canale 1

Struttura dei dati per lo scambio di dati
Struct DATEN_STRUKTUR {     uint16_t Temperatura = 0;     uint32_t Umido = 0;
};

Istanza per accedere al sensore
SimpleDHT11 dht11;

Pin di dati su D1Mini : D0 è uguale a GPIO16 
Const Byte dataPin = 16; Pin di dati del DHT11

variabili globali per i valori misurati
Byte Temperatura = 0;
Byte Umido = 0;

Abbiamo bisogno di un punto di accesso WiFi
Vuoto configDeviceAP (configurazione)() {   Char* Ssid = "Slave_1";   Bool Risultato = Wifi.softAP(Ssid, "Slave_1_Password", Canale, 0);   Se (!Risultato) {     Seriale.println("Configurazione AP non riuscita.");   } Altro {     Seriale.println("AP Config Success. Trasmissione con AP: " + Stringa(Ssid));   }
}

Funzione di callback quando i dati sono stati ricevutiCallback function when data has been received 
Vuoto on_receive_data(uint8_t *Mac, uint8_t *r_data, uint8_t Len) {     per informazioni, convertiamo l'indirizzo MAC del mittente in una stringa e lo esporemo     Char MaCmaster[6];     Sprintf(MaCmaster, "%02X:%02X:%02x:%02X:%02X:%02X:%02X",Mac[0],Mac[1],Mac[2],Mac[3],Mac[4],Mac[5]);     Seriale.Stampare("Ricevere MAC: "); Seriale.Stampare(MaCmaster);       DATEN_STRUKTUR Ed;     copiamo i dati ricevuti nella struttura dei dati     accesso alla struttura dei dati     Memcpy(&Ed, r_data, Sizeof(Ed));     qui abbiamo potuto accedere a questi dati tramite ed.temperatur ed ed.feuchte     che il mittente ha inviato       ora impostiamo i valori con i dati del sensore     Ed.Temperatura = Temperatura;     Ed.Umido = Umido;     copiamo i dati in un blocco di archiviazione e li inviamo di nuovo al mittente     uint8_t s_data[Sizeof(Ed)]; Memcpy(s_data, &Ed, Sizeof(Ed));     esp_now_send(Mac, s_data, Sizeof(s_data));        };
 

Vuoto Installazione() {   Seriale.Iniziare(115200); Seriale.println();   Configurazione del punto di accesso   Wifi.Moda(WIFI_AP);   configDeviceAP (configurazione)();    Inizializza ESOP-Now     Se (esp_now_init()!=0) {     Seriale.println("Protocollo ESP-NOW non inizializzato...");     Spagnolo.Riavviare();     Ritardo(1);   }     Indirizzi MACb per info   Seriale.Stampare("AP MAC: "); Seriale.println(Wifi.softAPmacAddress());   Seriale.Stampare("STA MAC: "); Seriale.println(Wifi.Macaddress());     SET ESP ruolo 1 : Master, 2 - Slave 3 - Master - Slave   esp_now_set_self_role(2);    e registrare la funzione di callback   esp_now_register_recv_cb(on_receive_data);     }

Vuoto Ciclo() {      valori misurati dal sensore con controllo degli errori   Int Err = SimpleDHTErrSuccess;   Err = dht11.Leggere(dataPin, &Temperatura, &Umido, Null);   Se (Err != SimpleDHTErrSuccess) {     Seriale.Stampare("Impossibile leggere il DHT11. Errore : ");     Seriale.println(Err);   }   attendere 1,5 s Il DHT11 fa 1 misura / s   Ritardo(1500);    }

Master:

Per il Maestro, ho un Scheda di sviluppo ESP-32 Utilizzato. Naturalmente, ogni altra scheda ESP può essere utilizzata anche qui. Il master viene avviato in modalità stazione. Nel suo ciclo principale, può utilizzare le reti WiFi disponibili fino a quando non ha trovato una rete il cui nome inizia con "slave". Se ha trovato la rete, determina l'indirizzo MAC del punto di accesso, che viene utilizzato per ulteriori comunicazioni. Anche se la rete slave si guasta nel frattempo, il master non deve eseguire un'altra scansione.

Ecco lo schizzo per il master:

ESP32 come master per una connessione ESP-Now
 L'ESP32 cerca una rete WiFi il cui nome inizia con slave
 Quando ha trovato una tale rete, ricorda l'indirizzo MAC del
 - Schiavi e possono comunicare con loro tramite ESP_Now
 */

Includi librerie per Esp-Now e WiFi
#include <esp_now.H>
#include <Wifi.H>

Copia globale delle informazioni sugli slave
e una bandiera per sapere se lo schiavo è già stato trovato
Bool slaveFound = 0;
esp_now_peer_info_t Schiavo;

# define Canale 3

Struttura dei dati per lo scambio di dati
Struct DATEN_STRUKTUR {     uint16_t Temperatura = 0;     uint32_t Umido = 0;
};
 

Init ESP Ora con Restart nel caso in cui ciò che va storto
Vuoto InitESPNow() {   Se (esp_now_init() == ESP_OK) {     Seriale.println("ESPNow Init Successo");   }   Altro {     Seriale.println("ESPNow Init Failed");     Errore in tal modo nuovo tentativo     Spagnolo.Riavviare();   }
}

Stiamo cercando uno schiavo
Vuoto ScanForSlave() {   int8_t scanResults = Wifi.scanNetworks();   azzeramento su ogni scansione   Memset(&Schiavo, 0, Sizeof(Schiavo));   Seriale.println("");   Se (scanResults == 0) {     Seriale.println("Dispositivo WiFi NoNo trovato in modalità AP");   } Altro {     Seriale.Stampare(scanResults); Seriale.println(" Dispositivi trovati ");     Per (Int Ho. = 0; Ho. < scanResults; ++Ho.) {       Stampa SSID e RSSI per ogni dispositivo trovato       Stringa Ssid = Wifi.Ssid(Ho.);       int32_t Rssi = Wifi.Rssi(Ho.);       Stringa BSSIDstr = Wifi.BSSIDstr(Ho.);       Verificare se il nome della rete inizia con 'Slave'       Se (Ssid.Indice di("Schiavo") == 0) {         Sì, poi abbiamo trovato uno schiavo         Seriale.println("Slave trovato.");         Seriale.Stampare(Ho. + 1); Seriale.Stampare(": "); Seriale.Stampare(Ssid); Seriale.Stampare(" ["); Seriale.Stampare(BSSIDstr); Seriale.Stampare("]"); Seriale.Stampare(" ("); Seriale.Stampare(Rssi); Seriale.Stampare(")"); Seriale.println("");         Determinare l'indirizzo MAC dagli slave bssiD ses e memorizzarli nella struttura delle informazioni slave         Int Mac[6];         Se ( 6 == Sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x%c",  &Mac[0], &Mac[1], &Mac[2], &Mac[3], &Mac[4], &Mac[5] ) ) {           Per (Int Ⅱ. = 0; Ⅱ. < 6; ++Ⅱ. ) {             Schiavo.peer_addr[Ⅱ.] = (uint8_t) Mac[Ⅱ.];           }         }         Schiavo.Canale = Canale; scegliere un canale         Schiavo.Crittografare = 0; nessuna crittografia         slaveFound = 1;         Senza questa pausa si potrebbe anche connettersi a più di uno schiavo         Se non viene utilizzata alcuna crittografia, sono possibili fino a 20 slave         Pausa;       }     }   }   pulire ram   Wifi.scanDelete();
}

Verificare se uno slave è già associato
In caso contrario, lo slave viene associato al master
Bool manageSlave() {   Se (Schiavo.Canale == Canale) {     Const esp_now_peer_info_t *compagno = &Schiavo;     Const uint8_t *peer_addr = Schiavo.peer_addr;     verificare se il peer esiste     Bool Esiste = esp_now_is_peer_exist(peer_addr);     Se ( !Esiste) {       Schiavo non accoppiato, provare coppia       Seriale.Stampare("Stato Slave: ");       esp_err_t addStatus (stato aggiuntivo) = esp_now_add_peer(compagno);       Se (addStatus (stato aggiuntivo) == ESP_OK) {         Positivo della coppia         Seriale.println("Coppia riuscita");         Ritorno Vero;       } Altro Se (addStatus (stato aggiuntivo) == ESP_ERR_ESPNOW_NOT_INIT) {         Come siamo riusciti ad arrivare finora!!         Seriale.println("ESPNOW Non Init");         Ritorno False;       } Altro Se (addStatus (stato aggiuntivo) == ESP_ERR_ESPNOW_ARG) {         Seriale.println("Argomento non valido");         Ritorno False;       } Altro Se (addStatus (stato aggiuntivo) == ESP_ERR_ESPNOW_FULL) {         Seriale.println("Elenco peer completo");         Ritorno False;       } Altro Se (addStatus (stato aggiuntivo) == ESP_ERR_ESPNOW_NO_MEM) {         Seriale.println("Memoria insufficiente");         Ritorno False;       } Altro Se (addStatus (stato aggiuntivo) == ESP_ERR_ESPNOW_EXIST) {         Seriale.println("Esiste il peer");         Ritorno Vero;       } Altro {         Seriale.println("Non so cosa sia successo");         Ritorno False;       }     }   } Altro {     Nessun schiavo trovato per elaborare     Seriale.println("Nessuno schiavo trovato per elaborare");     Ritorno False;   }
}

inviare dati a slave
Vuoto Senddata() {
 DATEN_STRUKTUR Ed;       Perché ignoriamo i dati in questo esempio nello slave     non importa quello che inviamo                        Ed.Temperatura = 0;     Ed.Umido = 0;     copiamo la struttura dei dati in un blocco di memoria     uint8_t Dati[Sizeof(Ed)]; Memcpy(Dati, &Ed, Sizeof(Ed));     Const uint8_t *peer_addr = Schiavo.peer_addr;     Inviamo i dati e controlliamo lo stato   Seriale.Stampare("Invio: ");   esp_err_t Risultato = esp_now_send(peer_addr, Dati, Sizeof(Dati));   Seriale.Stampare("Invia stato: ");   Se (Risultato == ESP_OK) {     Seriale.println("Successo");   } Altro Se (Risultato == ESP_ERR_ESPNOW_NOT_INIT) {     Come siamo riusciti ad arrivare finora!!     Seriale.println("ESPNOW non Init.");   } Altro Se (Risultato == ESP_ERR_ESPNOW_ARG) {     Seriale.println("Argomento non valido");   } Altro Se (Risultato == ESP_ERR_ESPNOW_INTERNAL) {     Seriale.println("Errore interno");   } Altro Se (Risultato == ESP_ERR_ESPNOW_NO_MEM) {     Seriale.println("ESP_ERR_ESPNOW_NO_MEM");   } Altro Se (Risultato == ESP_ERR_ESPNOW_NOT_FOUND) {     Seriale.println("Peer non trovato.");   } Altro {     Seriale.println("Non so cosa sia successo");   }
}

richiamata quando i dati sono stati inviati allo slave
qui si può vedere se lo schiavo non era raggiungibile
Vuoto on_data_sent(Const uint8_t *mac_addr, esp_now_send_status_t Stato) {   Char macStr[18];   Snprintf(macStr, Sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",            mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);   Seriale.Stampare("Ultimo pacchetto inviato a: "); Seriale.println(macStr);   Seriale.Stampare("Ultimo stato invio pacchetto: "); Seriale.println(Stato == ESP_NOW_SEND_SUCCESS ? "Operazione di consegna riuscita" : "Consegna non riuscita");
}


callback quando otteniamo dati dallo slave
Vuoto on_data_recv(Const uint8_t *mac_addr, Const uint8_t *Dati, Int data_len) {   Char macStr[18];   Indirizzo MAC dello schiavo per info   Snprintf(macStr, Sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",            mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);   DATEN_STRUKTUR Ed;   copiamo i dati nella struttura dei dati     Memcpy(&Ed, Dati, Sizeof(Ed));     e visualizzarli     Seriale.Stampare("Ricezione"); Seriale.println(macStr);     Seriale.Stampare("Temperatura": "); Seriale.Stampare(Ed.Temperatura); Seriale.println(" C ");     Seriale.Stampare("Umidità: "); Seriale.Stampare(Ed.Umido); Seriale.println(" %");
}

Vuoto Installazione() {   Seriale.Iniziare(115200);   Impostare il dispositivo in modalità STA per iniziare con   Wifi.Moda(WIFI_STA);   Wifi.Scollegare();   Seriale.println("ESPNow ESP32 come Master");   questo è l'indirizzo mac del maestro   Seriale.Stampare("STA MAC: "); Seriale.println(Wifi.Macaddress());   Init ESPNow con una logica di fallbackInit ESPNow with a fallback logic   InitESPNow();   Registriamo la funzione di callback alla fine del processo di invio   esp_now_register_send_cb(on_data_sent);   Registriamo la funzione di richiamata per la ricezione   esp_now_register_recv_cb(on_data_recv);
}

Vuoto Ciclo() {   Se non abbiamo ancora trovato uno schiavo, stiamo ancora cercando   Se (!slaveFound) ScanForSlave();   Se (slaveFound) {     abbiamo uno schiavo che deve essere accoppiato     se questo non è ancora accaduto     Bool isPaired (Associato a is) = manageSlave();     Se (isPaired (Associato a is)) {       Se padrone e schiavo sono accoppiati, possiamo inviare       Senddata();     } Altro {       coppia di schiavi non riuscito       Seriale.println("La coppia degli schiavi non è riuscita!");     }   }   Altro {     Nessun schiavo trovato per elaborare   }   5 secondi di attesa   Ritardo(5000);
}

mancia:

È possibile modificare più di una scheda da un PC con l'IDE Arduino allo stesso tempo. A tale scopo, è necessario avviare l'IDE solo in due istanze, vale a dire non più finestre della stessa istanza. Quindi il tipo di scheda e il numero di porta possono essere impostati separatamente.

Test:

Iniziamo prima il master: il monitor seriale indicherà che il master non riesce a trovare una rete adatta. Quando iniziamo lo schiavo, il maestro dovrebbe trovare la rete e connettersi. Il padrone dovrebbe quindi visualizzare la temperatura e l'umidità che riceve dallo schiavo.

Se disattiviamo lo schiavo, il padrone continuerà a cercare di raggiungere lo schiavo, ma questo finirà con un errore. Non appena riaccendiamo lo slave, il master può inviare e ricevere di nuovo i dati con successo.

Utilizzeremo anche ESP-Now nel progetto Home-Control.

Divertiti a sperimentare.