Verbind ESP32 + D1 Mini 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.

 

 

Esp-32Esp-8266Projekte für anfänger

21 Kommentare

Bernhard Brennicke

Bernhard Brennicke

Hallo,
so wie Stefan Ludwig am April 05, 2020 habe ich das gleiche Problem beim Master und komme nicht weiter.
Am Ende von bool manageSlave() wo geschweifte Klammer zu die Methode beendet bekomme ich eine Fehlermeldung: “control reaches end of non-void function [-Werror=return-type]”
Hatte jemand eine Lösung? Für eine kleinen Anstoß währe ich sehr dankbar.
Viele Grüße
Bernhard

georg

georg

hallo,
läuft der master auch auf dem D1 mini pro? Beim versuch der compilierung mit der einstellung auf ein ESP8266 wird das fehlen der lib “esp_now.h” und noch ein paar anderer bemängelt.

georg

georg

hallo,
ich würde gerne mit den teilen ein dreiergespann (1x ESP32 und 2x ESP8266 D1 mini) zusammenbringen wollen:
- der ESP32 ist der master, hält über wlan verbindung zum slave_1, beide sind jeweils auf einem fahrrad angebracht und geben sich gegenseitig zeichen über bestehende verbindung (grün blinkende RGB LED signalisiert verbindung), so lange bis ein abstand von ca. 100m überschritten wird und die wifiverbindung abreisst. Dann blinkt die rote LED.
- der slave_2 bekommt (über wifi oder bluetooth) über vier tasten am gehäuse des masters befehle mit denen das ebike gesteuert wird (die unterstützung). Der slave_2 ist am gleichen fahrrad angebracht wie der master, abstand ca. 2m.
-————————————————————————
jetzt habe ich es mit zwei ESP8266, master mit zusätzlichem HC05 bluetoothmodul, slave auf dem zweiten fahrrad ohne zusatz, beide sind über wifi verbunden, bei ca. 100metern reisst die verbindung ab, das wird auf beiden seiten gemeldet (rote LED blinkt). Die verbindung zum “slave_2” (mit arduino mini pro und einem HC05 modul) und die datenübertragung findet über bluetooth statt.
fragen:
- die eigentlich wifiverbindung des masters zu den beiden slaves über wifi könnte ich mir vorstellen zu realisieren, der sketch für slave_2 müsste angepasst werden. Der esp32 hat aber keine externe antenne – über welche reichweite reden wir hier mit der internen antenne?
- lässt sich das jetzige modul (mit arduino mini pro und HC05) – so wie es ist – an die kombination master / slave_1 über bluetooth anbinden? Feste, sich automatisch erneuende verbindung?
wenn nicht –
- ob und wie die übertragung der tastensignale vom master zum slave_2 für die ebikesteuerung auszusehen hätte, da habe ich keine vorstellung…
Könnten Sie mir ein paar tipps geben?
gruss

Hans Stoller

Hans Stoller

Hallo
wo bekomme ich die Library: “esp.now.h” her?
Danke Grüsse Hans

Gerald

Gerald

Hallo Emmo!
Danke für den Hinweis, der Fehler ist jetzt korrigiert.

Emmo Emminghaus

Emmo Emminghaus

Ähhh korrigiert doch mal bitte die on_receive_data Funktion für den ESP8266:

void on_receive_data(uint8_t *mac, uint8_t *r_data, uint8_t len) {
//zur Information wandeln wir die MAC Adresse des Absenders in einen String und geben sie aus
char MACmaster6; // <- HIER WERDEN 18 byte benötigt!!!! -————————-
sprintf(MACmaster, “%02X:%02X:%02X:%02X:%02X:%02X”,mac0,mac1,mac2,mac3,mac4,mac5);
Serial.print("Empfang von MAC: "); Serial.print(MACmaster);

Das gibt eine schöne Stack-Coruption.

Gruß
Emmo

Gerald

Gerald

Hallo Rüdiger,
Ich habe die Versuchsanordnung nochmals aufgebaut mit deiner Änderung (DHT11 Code auskommentiert) und hatte keine Probleme.
Ausgabe vom Master:
Sending: Send Status: Success
Last Packet Sent to: 26:62:ab:0b:97:df
Last Packet Send Status: Delivery Success
Empfangen von 26:62:ab:0b:97:df
Temperatur: 11 °C
Feuchte : 54 %
Ausgabe vom Slave:
Slave Loop
Empfang von MAC: 30:AE:A4:7B:85:0CSlave Loop
Slave Loop
Slave Loop
Empfang von MAC: 30:AE:A4:7B:85:0CSlave Loop
Slave Loop
Slave Loop
Empfang von MAC: 30:AE:A4:7B:85:0CSlave Loop
Slave Loop

Rüdiger

Rüdiger

Hallo Gerald,
vielen Dank für die Anleitung.
Ich bekomme leider die Kommunikation zwischen Master und Slave nicht hin. Am Slave kommt nichts an und der Master zeigt folgende Meldung:
Sending: Send Status: Success
Last Packet Sent to: a6:cf:12:d6:d8:8d
Last Packet Send Status: Delivery Fail
Ich verwende einen ESP32-WROOM-32 als Master und eine D1 Mini Pro ESP-8266EX als Slave, beide von AZ.
Den Code habe ich fast komplett übernommen, außer im Slave habe ich die Zeilen für die DHT-Sensorabfrage im Loop auskommentiert, was aber für die Kommunikation keine Rolle spielen dürfte:
void loop() {
Serial.println(“Slave Loop”);
//messwerte vom Sensor mit Fehlerüberprüfung
temperatur = 11;
feuchte = 54;
/*
int err = SimpleDHTErrSuccess;
err = dht11.read(dataPin, &temperatur, &feuchte, NULL);
if (err != SimpleDHTErrSuccess) {
Serial.print("Fehler beim Lesen vom DHT11. Fehler = ");
Serial.println(err);
}
*/
// warte 1.5 s Der DHT11 macht 1 Messung / s
delay(1500);
}

Die MAC-Adresse vom Slave wurde korrekt vom Master ermittelt und angezeigt.

Gibt es irgendeine Idee für dieses Verhalten?
Für jede Hilfe wäre ich sehr dankbar.

Viele Grüße
Rüdiger

Bernd Albrecht

Bernd Albrecht

@Stefan Ludwig: Habe den Versuchsaufbau mir ESP8266 und DHT22 an GP2 nachgebaut, den Code kopiert. Bis auf die fehlende ESP8266, die ich noch installieren musste, lief alles einwandfrei.
Sending: Send Status: Success
Last Packet Sent to: 62:01:94:1c:de:6a
Last Packet Send Status: Delivery Success
Empfangen von 62:01:94:1c:de:6a
Temperatur: 21 °C
Feuchte : 30 %

@Max: Der eigentliche Code müsste passen. Verändert werden müssen ggf. die libraries #include <…> und selbstverständlich der GPIO pin.

Stefan Ludwig

Stefan Ludwig

So nachdem ich jetzt einen sorgfältigen Vergleich von dem Quellcode hier auf dieser Seite und einem funktonierendem Demo-Code für DHT-Sensoren gemacht habe, habe ich den Quellcode des ESP8266-slaves zum laufen bekommen. so dass auch wirklich Daten aus dem Sensor ausgelesen werden.
Ich weiß nicht ob das jetzt ein Fehler in eurem Quellcode ist oder ob die simpleDHT-library in der Zwischenzeit geändert wurde. Ich benutze Arduino 1.8.12 und habe mir die simpleDHT am 05.04.2020 heruntergeladen. Im Aufruf zum Datenauslesen aus dem DHT-Sensor gab es einen Parameter ZUVIEL
In eurem code steht da
err = dht22.read(dataPin, &temperatur, &feuchte, NULL); //daten-pin GPIO
es muss aber
err = dht22.read(&temperatur, &feuchte, NULL); //daten-pin GPIO
heißen.
Der Datenpin wird durch schon beim Erzeugen des DHT-Objektes festgelegt.

Nun ja schön dass es jetzt funktoniert. Und auch schön dass man die MAC-adressen nicht hardcodieren muss.
viele Grüße

Stefan Ludwig

Stefan Ludwig

Stefan Ludwig

Hallo,

ich habe den Sketch für den ESP32-Master einmal von Oben nach unten und einmal von unten nach oben sorgfältig markiert und in die Arduino-IDE eingefügt. Dann bekomme ich zwei Fehlermeldungen:
Einmal stimmt etwas mit der Formatierung zur Ausgabe der Mac-ADressse nicht. Das konnte ich beheben. Aber am Ende von bool manageSlave() wo geschweifte Klammer zu die Methode beendet bekomme ich eine Fehlermeldung
control reaches end of non-void function [-Werror=return-type]
Wie kann ich das beheben?
Was ich besonders merkwürdig finde ist die Tatsache dass andere Kommentare berichten funktionierte auf Anhieb. WIe kann das sein? Ist die Internetseit egehackt worden und jemand hat einen Fehler in den Quellcode eingebaut? Ist die Arduino-IDE so empfindlich das man die IDE so eingestellt haben kann, dass es nicht geht?
Wäre für Hinweise sehr dankbar
viele Grüße

Stefan

Max

Max

Hallo!
Ich möchte das Programm gerne so umdrehen, dass der Wemos D1 empfängt und der Esp32 sendet.
Hat das schon jemand gemeistert?

Sitze jetzt leider schon einige Stunden ohne erfolg dran:((

Danke!

Andreas

Andreas

Deine Anleitung funktioniert auf Anhieb. Und eröffnet ein weites Experimentierfeld.
Danke für deine ausgezeichnete Beschreibung.
Andreas

Peter

Peter

Feine Sache! Nur leider funktioniert (bei mir) ESP-Now nicht mit ESP.deepSleep.
Sobald ich D0 mit RST verbinde (was man ja nach dem Hochladen tun muss, um den µC nach der eingestellten Zeit aufwecken zu können), startet der Sketch ständig neu. Mehrmals pro Sekunde.

Stephan

Stephan

Hallo,
toll, funktioniert auf Anhieb. Aber: Wie kann ich denn die Variablen “temperatur” und “feuchte” im loop-void verwenden?
<<Serial.println(ed.feuchte);>> funktioniert ja nicht.

Johannes

Johannes

Genau das hab ich schon lange gesucht!
Was muss ich ändern wenn ich als Master ein ESP8266 einsetze?

Hardy

Hardy

Hallo, tolle Anleitung!

An welcher Stelle müsste ich den Code beim Slave/Sender ändern, wenn ich einen HIGH/LOW Wert eines Pins z.B. Pin18 an den Master Pin18 senden möchte?
Und die Stelle beim Master-Code bitte auch.

Wäre echt toll, wenn mir das jemand mitteilen könnte.

Hintergrund: Habe 2 ESP32 mit einer Lichtschranke und 1 ESP32 mit einer Stoppuhr.

Gerald Lechner

Gerald Lechner

Hallo Gerald
Damit mehrere Slaves angesteuert werden können, reicht es nicht nur das break im Scan zu entfernen. Es ist vielmehr notwendig alle gefundenen Slaves zu Registrieren (Pairing). Ich befürchte außerdem, dass dann die hier verwendete Antwort vom Slave mit mehreren Slaves nicht richtig funktioniert. Ein Beispiel zum Thema Multislave findest Du im ESP32 Package. Arduino IDE Menü: Beispiele→ESP32→ESPNow→Multi-Slave.
Ich hoffe ich konnte dir helfen.
Gruß Gerald

Gerald Lechner

Gerald Lechner

Hallo Wolf
Ich habe dasselbe Problem auch schon entdeckt und noch nicht gelöst. Es sieht so aus als ob eine Verbindung von Master zu Slave immer funktioniert aber die Antwort vom Slave zwar gesendet wird aber nicht den Empfangstrigger im Master auslöst. Mit dem ESP8266 als Slave hat es bei mir immer funktioniert. Werde aber noch weiter forschen und meine Ergebnisse in diesem Blog posten.
Grüße Gerald

G.Koebel

G.Koebel

Hallo,
mit einem Slave funktioniert der Code wie beschrieben.
Ich habe beim Master den break heraus genommen und einen zweiten Slave geschaltet, der dann auch erkannt wird.
Es werden aber immer nur die Daten vom zufällig zuletzt erkannten Slave genommen.
Was stimmt da nicht?
mfG
Gerald

W. Lindner

W. Lindner

Hallo.
Code funktioniert grundsätzlich.
Habe das an den ESP32 angepasst:
mit
- #include
- esp_now_set_self_role(2); entfernt

Master sendet, Slave empfängt, Slave sendet zurück;
aber beim Master on_data_recv(…) kommen keine Daten an.

Eine Idee dazu ?

Grüße
wolf

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert

Aanbevolen blog berichten

  1. Installeer ESP32 nu van de raad van bestuur
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - ESP Programmeren via Wi-Fi