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.

 

 

Esp-32Esp-8266Progetti per principianti

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

Post di blog consigliati

  1. Installa ESP32 ora dal gestore del consiglio di amministrazione
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - Programmazione ESP tramite WLAN