Sluit ESP32 + D1 Mini aan via ESP-Now

In tegenstelling tot de traditionele manier om de ene controller via Wi-Fi met de andere te verbinden, maakt ESP-Now gebruik van een speciaal protocol dat twee WLAN-enabled microcontrollers rechtstreeks verbindt zonder via een router te gaan. De verbinding gebeurt rechtstreeks via de respectievelijke MAC-adressen en kan uiteraard alleen binnen een WLAN plaatsvinden.

Dit vereenvoudigde protocol maakt de verbinding veel sneller en vermindert dus ook het stroomverbruik van de controller. Esp-Now heeft echter ook nadelen, de hoeveelheid gegevens per pakket is beperkt tot 250 bytes en het internet is alleen via een gateway te bereiken.

Een meester kan worden gekoppeld aan maximaal 20 slaven. Als u het ESP-Now-netwerk wilt versleutelen, wordt het aantal mogelijke slaven teruggebracht tot 10.

In ons voorbeeld zullen we een ESP32 gebruiken als de meester en een D1 Mini als slaaf. De slaaf wordt gestart als een zacht toegangspunt, zodat de meester het kan vinden via een netwerkscan.

Op verzoek van de meester moet de slaaf gemeten waarden verzenden van een temperatuur- en vochtigheidssensor.

Slaaf:

De slaaf is een D1 Minivia de pin D0 = GPIO 16 met de datapin van een DHT11 Temperatuursensoren Aangesloten.

De volgende gedetailleerde geannoteerde schets toont het gebruikte programma. Het toegangspunt exporteert het WLAN-netwerk met de naam Slave_1, het wachtwoord is niet vereist om de verbinding tot stand te brengen.  :

/* D1 Mini met DHT11 temperatuur- en vochtigheidssensor als
 * Slaaf in een ESP-NOW communicatie
 * De slaaf genereert het WiFi-netwerk Slave_1 en wacht op gegevens van de master
 * Wanneer een datapakket wordt ontvangen, reageert de slaaf met
 * de gemeten waarden van de sensor
 */

 Bibliotheken voor WiFi en voor de sensor
#include <ESP8266WiFi.H>
#include <EenvoudigeDHT.H>

Bibliotheek voor ESP-Now
Externe "C"{
#include <espnow.H>
}

WiFi-kanaal
#define Kanaal 1

Gegevensstructuur voor gegevensuitwisseling
Struct DATEN_STRUKTUR {     uint16_t Temperatuur = 0;     uint32_t Vochtige = 0;
};

Instantie om toegang te krijgen tot de sensor
EenvoudigeDHT11 dht11 dht11;

Gegevenspen op D1Mini = D0 is gelijk aan GPIO16 
Const Byte gegevenspin = 16; Gegevenspen van de DHT11

globale variabelen voor gemeten waarden
Byte Temperatuur = 0;
Byte Vochtige = 0;

We hebben een WiFi-toegangspunt nodig.
Void configDeviceAP() {   Char* Ssid = "Slave_1";   Bool Resultaat = Wifi.softAP(Ssid, "Slave_1_Password", Kanaal, 0);   Als (!Resultaat) {     Seriële.println("AP Config faalde.");   } Anders {     Seriële.println("AP Config Succes. Uitzenden met AP: " + Tekenreeks(Ssid));   }
}

Terugroepfunctie wanneer gegevens zijn ontvangen 
Void on_receive_data(uint8_t *Mac, uint8_t *r_data, uint8_t Len) {     voor informatie zetten we het MAC-adres van de afzender om in een tekenreeks en     Char MACmaster MACmaster[6];     Sprintf (Sprintf)(MACmaster MACmaster, "%02X:%02X:%02x:%02X:%02X:%02X:%02X",Mac[0],Mac[1],Mac[2],Mac[3],Mac[4],Mac[5]);     Seriële.Afdrukken("Ontvangen mac: "); Seriële.Afdrukken(MACmaster MACmaster);       DATEN_STRUKTUR Ed;     we kopiëren de ontvangen gegevens naar de gegevensstructuur     toegang tot de gegevensstructuur     Memcpy Memcpy(&Ed, r_data, Grootte van(Ed));     hier konden we toegang krijgen tot deze gegevens via ed.temperatur en ed.feuchte     die de afzender heeft verzonden       nu stellen we de waarden met de gegevens van de sensor     Ed.Temperatuur = Temperatuur;     Ed.Vochtige = Vochtige;     we kopiëren de gegevens naar een opslagblok en sturen deze terug naar de afzender     uint8_t s_data[Grootte van(Ed)]; Memcpy Memcpy(s_data, &Ed, Grootte van(Ed));     esp_now_send(Mac, s_data, Grootte van(s_data));        };
 

Void Setup() {   Seriële.Beginnen(115200); Seriële.println();   Configuratie van het toegangspunt   Wifi.Mode(WIFI_AP);   configDeviceAP();    Initialiseer ESOP-Now     Als (esp_now_init()!=0) {     Seriële.println("Protocol ESP-NOW niet geinitialiseerd...");     Ihb.Opnieuw starten();     Vertraging(1);   }     MAC-adressenb voor informatie ***/   Seriële.Afdrukken("AP MAC: "); Seriële.println(Wifi.softAPmacAddress());   Seriële.Afdrukken("STA MAC: "); Seriële.println(Wifi.macAdres());     SET ESP rol 1=Master, 2 = Slave 3 = Master + Slave   esp_now_set_self_role(2);    en callbackfunctie registreren   esp_now_register_recv_cb(on_receive_data);     }

Void Lus() {      gemeten waarden van de sensor met foutcontrole   Int Err = SimpleDHTErrSucces;   Err = dht11 dht11.Lezen(gegevenspin, &Temperatuur, &Vochtige, Null Null Null);   Als (Err != SimpleDHTErrSucces) {     Seriële.Afdrukken("Niet om de DHT11 te lezen. Fout = ");     Seriële.println(Err);   }   wacht 1,5 s De DHT11 maakt 1 meting / s   Vertraging(1500);    }

Master:

Voor de Meester heb ik een ESP-32 Developmentboard Gebruikt. Natuurlijk kan elk ander ESP-bord hier ook worden gebruikt. De master start in de stationsmodus. In zijn belangrijkste lus, kan het de beschikbare Netwerken WiFi gebruiken tot het een netwerk heeft gevonden de waarvan naam met "slaaf" begint. Als hij het netwerk heeft gevonden, bepaalt het het MAC-adres van het toegangspunt, dat wordt gebruikt voor verdere communicatie. Zelfs als het slavennetwerk in de tussentijd uitvalt, hoeft de master geen andere scan uit te voeren.

Hier is de schets voor de meester:

/* ESP32 als master voor een ESP-Now-verbinding
 * De ESP32 zoekt naar een WiFi Netzerk wiens naam begint met slaaf
 * Wanneer hij een dergelijk netwerk heeft gevonden, herinnert hij zich het MAC-adres van de
 * Slaven en kunnen communiceren met hen via ESP_Now
 */

Bibliotheken opnemen voor Esp-Now en WiFi
#include <esp_now.H>
#include <Wifi.H>

Globale kopie van slaveninformatie
en een vlag om te weten of de slaaf al is gevonden
Bool slaveFound = 0;
esp_now_peer_info_t Slaaf;

#define Kanaal 3

Gegevensstructuur voor gegevensuitwisseling
Struct DATEN_STRUKTUR {     uint16_t Temperatuur = 0;     uint32_t Vochtige = 0;
};
 

Init ESP Nu met Opnieuw opstarten voor het geval wat er mis gaat
Void InitESPNow() {   Als (esp_now_init() == ESP_OK) {     Seriële.println("ESPNow Init Succes");   }   Anders {     Seriële.println("ESPNow Init mislukt");     Fout dus nieuwe poging     Ihb.Opnieuw starten();   }
}

We zijn op zoek naar een slaaf
Void ScanForSlave() {   int8_t scanResultaten = Wifi.scanNetwerken();   reset op elke scan   Memset(&Slaaf, 0, Grootte van(Slaaf));   Seriële.println("");   Als (scanResultaten == 0) {     Seriële.println("NoNo WiFi-apparaat gevonden in AP-modus");   } Anders {     Seriële.Afdrukken(scanResultaten); Seriële.println(" Apparaten gevonden ");     Voor (Int I. = 0; I. < scanResultaten; ++I.) {       SSID en RSSI afdrukken voor elk gevonden apparaat       Tekenreeks Ssid = Wifi.Ssid(I.);       int32_t Rssi = Wifi.Rssi(I.);       Tekenreeks BSSIDstr BSSIDstr = Wifi.BSSIDstr BSSIDstr(I.);       Controleer of de netwerknaam begint met 'Slave'       Als (Ssid.Indexof("Slaaf") == 0) {         Ja, toen vonden we een slaaf.         Seriële.println("Slaaf gevonden.");         Seriële.Afdrukken(I. + 1); Seriële.Afdrukken(": "); Seriële.Afdrukken(Ssid); Seriële.Afdrukken(" ["); Seriële.Afdrukken(BSSIDstr BSSIDstr); Seriële.Afdrukken("]"); Seriële.Afdrukken(" ("); Seriële.Afdrukken(Rssi); Seriële.Afdrukken(")"); Seriële.println("");         Bepaal MAC-adres van de BSSID ses slaven en bewaar ze in de slave info structuur         Int Mac[6];         Als ( 6 == sscanf(BSSIDstr BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x%c",  &Mac[0], &Mac[1], &Mac[2], &Mac[3], &Mac[4], &Mac[5] ) ) {           Voor (Int Ii. = 0; Ii. < 6; ++Ii. ) {             Slaaf.peer_addr[Ii.] = (uint8_t) Mac[Ii.];           }         }         Slaaf.Kanaal = Kanaal; een kanaal kiezen         Slaaf.Coderen = 0; geen encryptie         slaveFound = 1;         Zonder deze pauze kun je ook verbinding maken met meer dan één slaaf         Als er geen encryptie wordt gebruikt, zijn maximaal 20 slaven mogelijk         Breken;       }     }   }   opruimen ram   Wifi.scanDelete();
}

Controleer of een slaaf al is gekoppeld
Anders wordt de slaaf gekoppeld aan de meester
Bool manageSlave() {   Als (Slaaf.Kanaal == Kanaal) {     Const esp_now_peer_info_t *Peer = &Slaaf;     Const uint8_t *peer_addr = Slaaf.peer_addr;     controleren of de peer bestaat     Bool Bestaat = esp_now_is_peer_exist(peer_addr);     Als ( !Bestaat) {       Slaaf niet gekoppeld, probeer paar       Seriële.Afdrukken("Slavenstatus: ");       esp_err_t addStatus = esp_now_add_peer(Peer);       Als (addStatus == ESP_OK) {         Succes van het paar         Seriële.println("Paar succes");         Terug Waar;       } Anders Als (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {         Hoe zijn we zo ver gekomen!         Seriële.println("ESPNOW niet init");         Terug Valse;       } Anders Als (addStatus == ESP_ERR_ESPNOW_ARG) {         Seriële.println("Ongeldig argument");         Terug Valse;       } Anders Als (addStatus == ESP_ERR_ESPNOW_FULL) {         Seriële.println("Peer lijst vol");         Terug Valse;       } Anders Als (addStatus == ESP_ERR_ESPNOW_NO_MEM) {         Seriële.println("Uit het geheugen");         Terug Valse;       } Anders Als (addStatus == ESP_ERR_ESPNOW_EXIST) {         Seriële.println("Peer bestaat");         Terug Waar;       } Anders {         Seriële.println("Niet zeker wat er gebeurd is");         Terug Valse;       }     }   } Anders {     Geen slaaf gevonden om te verwerken     Seriële.println("Geen slaaf gevonden te verwerken");     Terug Valse;   }
}

gegevens naar slaaf te sturen
Void sendData() {
 DATEN_STRUKTUR Ed;       Omdat we negeren de gegevens in dit voorbeeld in de slaaf     het maakt niet uit wat we sturen                        Ed.Temperatuur = 0;     Ed.Vochtige = 0;     we kopiëren de gegevensstructuur naar een geheugenblok     uint8_t Gegevens[Grootte van(Ed)]; Memcpy Memcpy(Gegevens, &Ed, Grootte van(Ed));     Const uint8_t *peer_addr = Slaaf.peer_addr;     We sturen de gegevens en controleren de status   Seriële.Afdrukken("Verzenden: ");   esp_err_t Resultaat = esp_now_send(peer_addr, Gegevens, Grootte van(Gegevens));   Seriële.Afdrukken("Status verzenden: ");   Als (Resultaat == ESP_OK) {     Seriële.println("Succes");   } Anders Als (Resultaat == ESP_ERR_ESPNOW_NOT_INIT) {     Hoe zijn we zo ver gekomen!     Seriële.println("ESPNOW niet Init.");   } Anders Als (Resultaat == ESP_ERR_ESPNOW_ARG) {     Seriële.println("Ongeldig argument");   } Anders Als (Resultaat == ESP_ERR_ESPNOW_INTERNAL) {     Seriële.println("Interne fout");   } Anders Als (Resultaat == ESP_ERR_ESPNOW_NO_MEM) {     Seriële.println("ESP_ERR_ESPNOW_NO_MEM");   } Anders Als (Resultaat == ESP_ERR_ESPNOW_NOT_FOUND) {     Seriële.println("Peer niet gevonden.");   } Anders {     Seriële.println("Niet zeker wat er gebeurd is");   }
}

callback toen de gegevens naar de slaaf werden verzonden
hier u zien of de slaaf niet bereikbaar was
Void on_data_sent(Const uint8_t *mac_addr, esp_now_send_status_t Status) {   Char macStr macStr[18];   Snprintf Snprintf(macStr macStr, Grootte van(macStr 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]);   Seriële.Afdrukken("Laatste pakket verzonden naar: "); Seriële.println(macStr macStr);   Seriële.Afdrukken("Last Packet Send Status: "); Seriële.println(Status == ESP_NOW_SEND_SUCCESS ? "Succes van de levering" : "Levering mislukken");
}


callback wanneer we gegevens krijgen van de slaaf
Void on_data_recv(Const uint8_t *mac_addr, Const uint8_t *Gegevens, Int data_len) {   Char macStr macStr[18];   MAC-adres van de slaaf voor info   Snprintf Snprintf(macStr macStr, Grootte van(macStr 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;   we kopiëren de gegevens naar de gegevensstructuur     Memcpy Memcpy(&Ed, Gegevens, Grootte van(Ed));     en ze weer te geven     Seriële.Afdrukken("Ontvangen "); Seriële.println(macStr macStr);     Seriële.Afdrukken("Temperatuur: "); Seriële.Afdrukken(Ed.Temperatuur); Seriële.println(" °C");     Seriële.Afdrukken("Vochtigheid: "); Seriële.Afdrukken(Ed.Vochtige); Seriële.println(" %");
}

Void Setup() {   Seriële.Beginnen(115200);   Apparaat instellen in STA-modus om te beginnen   Wifi.Mode(WIFI_STA);   Wifi.Verbreken();   Seriële.println("ESPNow ESP32 als Master");   dit is het mac-adres van de master   Seriële.Afdrukken("STA MAC: "); Seriële.println(Wifi.macAdres());   Init ESPNow met een terugvallogica   InitESPNow();   We registreren de terugroepfunctie aan het einde van het verzendproces   esp_now_register_send_cb(on_data_sent);   Wij registreren de terugroepfunctie voor het ontvangen van   esp_now_register_recv_cb(on_data_recv);
}

Void Lus() {   Als we nog geen slaaf hebben gevonden, zoeken we nog steeds.   Als (!slaveFound) ScanForSlave();   Als (slaveFound) {     We hebben een slaaf die hij moet worden gekoppeld     als dit nog niet is gebeurd     Bool isPaired = manageSlave();     Als (isPaired) {       Als meester en slaaf zijn gekoppeld, kunnen we sturen       sendData();     } Anders {       slavenpaar mislukt       Seriële.println("Slave pair mislukt!");     }   }   Anders {     Geen slaaf gevonden om te verwerken   }   5 seconden wachten   Vertraging(5000);
}

Tip:

U meer dan één bord bewerken vanaf een pc met de Arduino IDE op hetzelfde moment. Om dit te doen, is het alleen nodig om de IDE in twee instanties te starten, d.w.z. niet meerdere vensters van hetzelfde exemplaar. Vervolgens kunnen het bordtype en het poortnummer afzonderlijk worden ingesteld.

Test:

We starten de master eerst: De seriële monitor geeft aan dat de master geen geschikt netwerk kan vinden. Als we de slaaf beginnen, moet de meester het netwerk vinden en verbinding maken. De meester moet dan de temperatuur en vochtigheid weergeven die het van de slaaf ontvangt.

Als we de slaaf uitschakelen, zal de meester blijven proberen om de slaaf te bereiken, maar dit zal eindigen in een fout. Zodra we de slaaf weer aanzetten, kan de meester met succes gegevens verzenden en ontvangen.

WE zullen ESP-Now ook gebruiken in het Home-Control project.

Veel plezier experimenteren.