Connectez ESP32 + D1 Mini via ESP-Now

Contrairement à la façon traditionnelle de connecter un contrôleur à un autre via Wi-Fi, ESP-Now utilise un protocole spécial qui relie deux microcontrôleurs compatibles WLAN directement sans passer par un routeur. La connexion est faite directement au moyen des adresses MAC respectives et ne peut bien sûr avoir lieu que dans un WLAN.

Ce protocole simplifié rend la connexion beaucoup plus rapide et réduit ainsi la consommation d’énergie du contrôleur. Cependant, ESP-Now a également des inconvénients, la quantité de données par paquet est limitée à 250 octets et l’Internet ne peut être atteint via une passerelle.

Un maître peut être jumelé à jusqu’à 20 esclaves. Si vous voulez chiffrer le réseau ESP-Now, le nombre d’esclaves possibles est réduit à 10.

Dans notre exemple, nous utiliserons un ESP32 comme maître et une D1 Mini comme esclave. L’esclave est commencé comme un point d’accès doux afin que le maître peut le trouver à travers un balayage réseau.

À la demande du maître, l’esclave doit envoyer des valeurs mesurées à partir d’un capteur de température et d’humidité.

Esclave:

L’esclave est un D1 Minivia la broche D0 - GPIO 16 avec la goupille de données d’un Capteurs de température DHT11 Connecté.

L’esquisse annotée détaillée suivante montre le programme utilisé. Le point d’accès exporte le réseau WLAN nommé Slave_1, le mot de passe n’est pas nécessaire pour établir la connexion.  :

 

Mini D1 avec capteur de température et d’humidité DHT11
 Esclave dans une communication ESP-NOW
 L’esclave génère le réseau WiFi Slave_1 et attend les données du maître
 Chaque fois qu’un paquet de données est reçu, l’esclave répond avec
 les valeurs mesurées du capteur
 */

 Bibliothèques pour WiFi et pour le capteur
#include <ESP8266WiFi.H (en)>
#include <SimpleDHT.H (en)>

Bibliothèque pour ESP-Now
Externe "C"{
#include <espnow espnow.H (en)>
}

Chaîne WiFi
#define Canal 1

Structure de données pour l’échange de données
Struct DATEN_STRUKTUR {     uint16_t Température = 0;     uint32_t Humide = 0;
};

Instance d’accès au capteur
SimpleDHT11 dht11;

La goupille de données sur D1Mini et D0 équivaut à GPIO16 
Const Octet donnéesPin = 16; Épingle de données de la DHT11

variables globales pour les valeurs mesurées
Octet Température = 0;
Octet Humide = 0;

Nous avons besoin d’un point d’accès WiFi
Vide configDeviceAP() {   Char Char* Ssid = "Slave_1";   Bool Résultat = Wifi.softAP (softAP)(Ssid, "Slave_1_Password", Canal, 0);   Si (!Résultat) {     Série.println("AP Config a échoué.");   } Autre {     Série.println("AP Config Succès. Diffusion avec AP: " + String(Ssid));   }
}

Fonction de rappel lorsque les données ont été reçues 
Vide on_receive_data(uint8_t *Mac, uint8_t *r_data, uint8_t Len) {     pour plus d’informations, nous convertissons l’adresse MAC de l’expéditeur en chaîne et la     Char Char Macmaster[6];     Sprintf(Macmaster, "%02X:%02X:%02x:%02X:%02X:%02X",Mac[0],Mac[1],Mac[2],Mac[3],Mac[4],Mac[5]);     Série.Imprimer("Recevoir MAC: "); Série.Imprimer(Macmaster);       DATEN_STRUKTUR Ed;     nous copieons les données reçues à la structure de données     accès à la structure de données     Memcpy Memcpy (Memcpy)(&Ed, r_data, Sizeof(Ed));     ici, nous avons pu accéder à ces données via ed.temperatur et ed.feuchte     que l’expéditeur a envoyé       maintenant nous définissons les valeurs avec les données du capteur     Ed.Température = Température;     Ed.Humide = Humide;     nous copions les données dans un bloc de stockage et les renvoyons à l’expéditeur     uint8_t s_data[Sizeof(Ed)]; Memcpy Memcpy (Memcpy)(s_data, &Ed, Sizeof(Ed));     esp_now_send(Mac, s_data, Sizeof(s_data));        };
 

Vide Configuration() {   Série.Commencer(115200); Série.println();   Configuration du point d’accès   Wifi.Mode(WIFI_AP);   configDeviceAP();    Initialiser ESOP-Maintenant     Si (esp_now_init()!=0) {     Série.println("Protocole ESP-NOW pas initialisé...");     Esp.Redémarrer();     Retard(1);   }     Adresses MAC pour plus d’informations .   Série.Imprimer("AP MAC: "); Série.println(Wifi.softAPmacAddress (en)());   Série.Imprimer("STA MAC: "); Série.println(Wifi.macAddress macAddress (en)());     SET ESP rôle 1-Master, 2 ' Esclave 3 ' Maître et Esclave   esp_now_set_self_role(2);    et enregistrer la fonction de rappel   esp_now_register_recv_cb(on_receive_data);     }

Vide Boucle() {      valeurs mesurées à partir du capteur avec vérification d’erreur   Int Err = SimpleDHTErrSuccess;   Err = dht11.Lire(donnéesPin, &Température, &Humide, Null);   Si (Err != SimpleDHTErrSuccess) {     Série.Imprimer("N’a pas lu le DHT11. Erreur - ");     Série.println(Err);   }   attendre 1.5 s Le DHT11 fait 1 mesure / s   Retard(1500);    }




Maître:

Pour le Maître, j’ai un ESP-32 Developmentboard Utilisé. Bien sûr, tous les autres conseils ESP peuvent être utilisés ici aussi. Le maître commence en mode station. Dans sa boucle principale, il peut utiliser les réseaux WiFi disponibles jusqu’à ce qu’il ait trouvé un réseau dont le nom commence par "esclave". S’il a trouvé le réseau, il détermine l’adresse MAC du point d’accès, qui est utilisé pour une communication ultérieure. Même si le réseau d’esclaves échoue entre-temps, le maître n’a pas à effectuer un autre scan.

Voici le croquis pour le maître:

 

 

/ESP32 en tant que maître pour une connexion ESP-Now
 L’ESP32 recherche un Netzerk WiFi dont le nom commence avec l’esclave
 Lorsqu’il a trouvé un tel réseau, il se souvient de l’adresse du MAC
 Les esclaves et peuvent communiquer avec eux par ESP_Now
 */

Inclure les bibliothèques pour Esp-Now et WiFi
#include <esp_now.H (en)>
#include <Wifi.H (en)>

Copie globale de l’information sur les esclaves
et un drapeau pour savoir si l’esclave a déjà été trouvé
Bool esclaveFound = 0;
esp_now_peer_info_t Esclave;

#define Canal 3

Structure de données pour l’échange de données
Struct DATEN_STRUKTUR {     uint16_t Température = 0;     uint32_t Humide = 0;
};
 

Init ESP Maintenant avec redémarrer au cas où ce qui se passe mal
Vide InitESPNow() {   Si (esp_now_init() == ESP_OK) {     Série.println("ESPNow Init Succès");   }   Autre {     Série.println("ESPNow Init a échoué");     Erreur si nouvelle tentative     Esp.Redémarrer();   }
}

Nous sommes à la recherche d’un esclave
Vide ScanForSlave() {   int8_t scanResults = Wifi.scanNetworks (scanNetworks)();   réinitialiser chaque analyse   Memset (Memset)(&Esclave, 0, Sizeof(Esclave));   Série.println("");   Si (scanResults == 0) {     Série.println("NoNo WiFi dispositif trouvé en mode AP");   } Autre {     Série.Imprimer(scanResults); Série.println(" Dispositifs trouvés ");     Pour (Int Ⅰ. = 0; Ⅰ. < scanResults; ++Ⅰ.) {       Imprimer SSID et RSSI pour chaque appareil trouvé       String Ssid = Wifi.Ssid(Ⅰ.);       int32_t Rssi Rssi = Wifi.Rssi Rssi(Ⅰ.);       String BSSIDstr = Wifi.BSSIDstr(Ⅰ.);       Vérifiez si le nom du réseau commence par 'Slave'       Si (Ssid.Indexof("Esclave") == 0) {         Oui, alors nous avons trouvé un esclave         Série.println("Esclave trouvé.");         Série.Imprimer(Ⅰ. + 1); Série.Imprimer(": "); Série.Imprimer(Ssid); Série.Imprimer(" ["); Série.Imprimer(BSSIDstr); Série.Imprimer("]"); Série.Imprimer(" ("); Série.Imprimer(Rssi Rssi); Série.Imprimer(")"); Série.println("");         Déterminer l’adresse MAC des esclaves BSSID ses et les stocker dans la structure d’information sur les esclaves         Int Mac[6];         Si ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x%c",  &Mac[0], &Mac[1], &Mac[2], &Mac[3], &Mac[4], &Mac[5] ) ) {           Pour (Int Ⅱ. = 0; Ⅱ. < 6; ++Ⅱ. ) {             Esclave.peer_addr[Ⅱ.] = (uint8_t) Mac[Ⅱ.];           }         }         Esclave.Canal = Canal; choisir un canal         Esclave.Crypter = 0; pas de cryptage         esclaveFound = 1;         Sans cette pause, vous pourriez également vous connecter à plus d’un esclave         Si aucun chiffrement n’est utilisé, jusqu’à 20 esclaves sont possibles         Pause;       }     }   }   nettoyer bélier   Wifi.scanDelete();
}

Vérifiez si un esclave est déjà jumelé
Sinon, l’esclave est jumelé avec le maître
Bool manageSlave() {   Si (Esclave.Canal == Canal) {     Const esp_now_peer_info_t *Peer = &Esclave;     Const uint8_t *peer_addr = Esclave.peer_addr;     vérifier si le pair existe     Bool Existe = esp_now_is_peer_exist(peer_addr);     Si ( !Existe) {       Esclave pas jumelé, essayer paire       Série.Imprimer("Statut d’esclave: ");       esp_err_t addStatus = esp_now_add_peer(Peer);       Si (addStatus == ESP_OK) {         Succès de paire         Série.println("Succès pair");         Retour Vrai;       } Autre Si (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {         Comment sommes-nous allés jusqu’à présent!!         Série.println("ESPNOW Pas Init");         Retour Faux;       } Autre Si (addStatus == ESP_ERR_ESPNOW_ARG) {         Série.println("Argument invalide");         Retour Faux;       } Autre Si (addStatus == ESP_ERR_ESPNOW_FULL) {         Série.println("Liste des pairs complète");         Retour Faux;       } Autre Si (addStatus == ESP_ERR_ESPNOW_NO_MEM) {         Série.println("Hors mémoire");         Retour Faux;       } Autre Si (addStatus == ESP_ERR_ESPNOW_EXIST) {         Série.println("Peer Existes");         Retour Vrai;       } Autre {         Série.println("Je ne sais pas ce qui s’est passé");         Retour Faux;       }     }   } Autre {     Aucun esclave trouvé à traiter     Série.println("Aucun esclave trouvé à traiter");     Retour Faux;   }
}

envoyer des données à l’esclave
Vide sendData() {
 DATEN_STRUKTUR Ed;       Parce que nous ignorons les données dans cet exemple dans l’esclave     il n’a pas d’importance ce que nous envoyons                        Ed.Température = 0;     Ed.Humide = 0;     nous copions la structure de données en un bloc de mémoire     uint8_t Données[Sizeof(Ed)]; Memcpy Memcpy (Memcpy)(Données, &Ed, Sizeof(Ed));     Const uint8_t *peer_addr = Esclave.peer_addr;     Nous envoyons les données et vérifions l’état   Série.Imprimer("Envoi: ");   esp_err_t Résultat = esp_now_send(peer_addr, Données, Sizeof(Données));   Série.Imprimer("Envoyer le statut: ");   Si (Résultat == ESP_OK) {     Série.println("Succès");   } Autre Si (Résultat == ESP_ERR_ESPNOW_NOT_INIT) {     Comment sommes-nous allés jusqu’à présent!!     Série.println("ESPNOW pas Init.");   } Autre Si (Résultat == ESP_ERR_ESPNOW_ARG) {     Série.println("Argument invalide");   } Autre Si (Résultat == ESP_ERR_ESPNOW_INTERNAL) {     Série.println("Erreur interne");   } Autre Si (Résultat == ESP_ERR_ESPNOW_NO_MEM) {     Série.println("ESP_ERR_ESPNOW_NO_MEM");   } Autre Si (Résultat == ESP_ERR_ESPNOW_NOT_FOUND) {     Série.println("Peer pas trouvé.");   } Autre {     Série.println("Je ne sais pas ce qui s’est passé");   }
}

rappel lorsque les données ont été envoyées à l’esclave
ici, vous pouvez voir si l’esclave n’était pas accessible
Vide on_data_sent(Const uint8_t *mac_addr, esp_now_send_status_t Statut) {   Char Char macStr (en)[18];   Snprintf (Snprintf)(macStr (en), Sizeof(macStr (en)), "%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]);   Série.Imprimer("Dernier paquet envoyé à: "); Série.println(macStr (en));   Série.Imprimer("Dernier paquet Envoyer statut: "); Série.println(Statut == ESP_NOW_SEND_SUCCESS ? "Succès de livraison" : "Échec de livraison");
}


rappel lorsque nous obtenons des données de l’esclave
Vide on_data_recv(Const uint8_t *mac_addr, Const uint8_t *Données, Int data_len) {   Char Char macStr (en)[18];   Adresse MAC de l’esclave pour info   Snprintf (Snprintf)(macStr (en), Sizeof(macStr (en)), "%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;   nous copions les données dans la structure des données     Memcpy Memcpy (Memcpy)(&Ed, Données, Sizeof(Ed));     et les afficher     Série.Imprimer("Recevoir"); Série.println(macStr (en));     Série.Imprimer("Température: "); Série.Imprimer(Ed.Température); Série.println(" C ");     Série.Imprimer("Humidité: "); Série.Imprimer(Ed.Humide); Série.println(" %");
}

Vide Configuration() {   Série.Commencer(115200);   Définir l’appareil en mode STA pour commencer   Wifi.Mode(WIFI_STA);   Wifi.Débrancher();   Série.println("ESPNow ESP32 en tant que Maître");   c’est l’adresse mac du maître   Série.Imprimer("STA MAC: "); Série.println(Wifi.macAddress macAddress (en)());   Init ESPNow avec une logique de repli   InitESPNow();   Nous enregistrons la fonction de rappel à la fin du processus d’envoi   esp_now_register_send_cb(on_data_sent);   Nous enregistrons la fonction de rappel pour recevoir   esp_now_register_recv_cb(on_data_recv);
}

Vide Boucle() {   Si nous n’avons pas encore trouvé d’esclave, nous cherchons toujours   Si (!esclaveFound) ScanForSlave();   Si (esclaveFound) {     nous avons un esclave, il doit être jumelé     si cela ne s’est pas encore produit     Bool estPaired = manageSlave();     Si (estPaired) {       Si maître et esclave sont jumelés, nous pouvons envoyer       sendData();     } Autre {       paire d’esclaves a échoué       Série.println("Le couple d’esclaves a échoué !");     }   }   Autre {     Aucun esclave trouvé à traiter   }   5 secondes à attendre   Retard(5000);
}

Pointe:

Vous pouvez modifier plus d’un tableau à partir d’un PC avec l’IDE Arduino en même temps. Pour ce faire, il n’est nécessaire de démarrer l’IDE que dans deux cas, c’est-à-dire pas plusieurs fenêtres d’une même instance. Ensuite, le type de panneau et le numéro de port peuvent être définis séparément.

Test:

Nous commençons le maître en premier: Le moniteur de série indiquera que le maître ne peut pas trouver un réseau approprié. Lorsque nous commençons l’esclave, le maître doit trouver le réseau et se connecter. Le maître doit alors afficher la température et l’humidité qu’il reçoit de l’esclave.

Si nous éteignent l’esclave, le maître continuera d’essayer d’atteindre l’esclave, mais cela se terminera par une erreur. Dès que nous renvoyons l’esclave, le maître peut envoyer et recevoir des données avec succès à nouveau.

NOUS utiliserons également ESP-Now dans le cadre du projet Home-Control.

Amusez-vous à expérimenter.

 

 

Esp-32Esp-8266Projets pour les débutants

21 commentaires

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

Laisser un commentaire

Tous les commentaires sont modérés avant d'être publiés

Messages de blogs recommandés

  1. Installez maintenant ESP32 via l'administrateur de la carte
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA-Over the Air-ESP Programmation par WiFi

Produits recommandés