Connect ESP32 + D1 Mini via ESP-Now

Unlike the traditional way of connecting One Controller to another via Wi-Fi, ESP-Now uses a special protocol that connects two Wi-Fi-enabled microcontrollers directly to each other without going through a Router. The connection takes place directly via the respective MAC addresses and can of course only take place within a WLAN.

Thanks to this simplified protocol, the connection setup is much faster and thus also reduces the power consumption of the controller. However, ESP - now also has disadvantages, the amount of data per packet is limited to 250 Bytes and the Internet can only be reached via a Gateway.

A Master can be paired with up to 20 Slaves. If you want to encrypt the ESP-Now Network, the number of possible Slaves is reduced to 10.

In our example we will use an ESP32 as Master and a D1 Mini as Slave. The Slave is started as a Soft Access Point, so that the Master can find it through a network Scan.

The Slave should send measured values from a temperature and humidity Sensor at the request of the master.

Slave:

The Slave is a D1 Mini using the Pin D0 = GPIO 16 with the data Pin of a DHT11 temperature sensor is connected.

The following extensively commented Sketch shows the program used. The Access Point exports the WLAN network with the name Slave_1, the password is not needed to establish the connection.  :

 

/ * D1 Mini with DHT11 temperature and humidity Sensor as
 * Slave in an ESP-now communication
 * The Slave generates the WiFi network Slave_1 and waits for data from the Master
 * Whenever a data packet has been received, the Slave responds with
 * the measured values from the Sensor
 */

 //Libraries for WiFi and for the Sensor
#include <ESP8266WiFi.houses>
#include <SimpleDHT.houses>

// Library for ESP-Now
external "C"{
#include <espnow.houses>
}

// WiFi Channel
#define CHANNEL 1

//Data structure for data exchange
struct DATA_STRUCTURE {     uint16_t temperature = 0;     uint32_t dampness = 0;
};

//Instance to access the Sensor
SimpleDHT11 dht11;

//Data pin on the D1Mini = D0 corresponds to GPIO16 
const byte dataPin = 16; // Data pin of DHT11

//global variables for measured values
byte temperature = 0;
byte dampness = 0;

// We need a WiFi Access Point
void configDeviceAP() {   char* SSID broadcast = "Slave_1";   bool result = WiFi.softAP(SSID broadcast, "Slave_1_Password", CHANNEL, 0);   if (!result) {     Serial.println("AP Config failed.");   } else {     Serial.println("AP Config Success. Broadcasting with AP: " + String(SSID broadcast));   }
}

//Callback function when data has been received 
void on_receive_data(uint8_t *Mac, uint8_t *r_data, uint8_t len) {     //for Information we convert the MAC address of the sender into a String and output it     char MACmaster[6];     sprintf(MACmaster, "%02X:%02X:%02X:%02X:%02X:%02X",Mac[0],Mac[1],Mac[2],Mac[3],Mac[4],Mac[5]);     Serial.print("Receiving MAC: "); Serial.print(MACmaster);       DATA_STRUCTURE ed;     // we copy the received data to the data structure     // to be able to access the data structure     memcpy(&ed, r_data, sizeof(ed));     // here we could talk about ed.temperature and ed.moisture access those data     //sent by the sender       //now we set the values with the data from the Sensor     ed.temperature = temperature;     ed.dampness = dampness;     // we copy the data into a memory block and send it back to the sender     uint8_t s_data[sizeof(ed)]; memcpy(s_data, &ed, sizeof(ed));     esp_now_send(Mac, s_data, sizeof(s_data));        };
 

void setup() {   Serial.begin(115200); Serial.println();   // Configuration of the Access point   WiFi.fashion(WIFI_AP);   configDeviceAP();    // Initialize ESOP-Now     if (esp_now_init()!=0) {     Serial.println("Protocol ESP - now not initialized...");     ESP.restart();     delay(1);   }     // * * * Mac Addressb for Info ***//   Serial.print("AP MAC: "); Serial.println(WiFi.softAPmacAddress());   Serial.print("STA MAC: "); Serial.println(WiFi.macAddress());     // ESP set role 1 = Master, 2 = Slave 3 = Master + Slave   esp_now_set_self_role(2);    // and register callback function   esp_now_register_recv_cb(on_receive_data);     }

void loop() {      // measured values from Sensor with error check   int err = SimpleDHTErrSuccess;   err = dht11.read(dataPin, &temperature, &dampness, ZERO);   if (err != SimpleDHTErrSuccess) {     Serial.print("Failed to read from DHT11. Error = ");     Serial.println(err);   }   // wait 1.5 s the DHT11 makes 1 measurement / s   delay(1500);    }




Master:

For the Master I have a ESP-32 Developmentboard used. Of course, any other ESP Board is also usable here. The Master is started in Station mode. In its main loop, it skates the available WiFi networks until it has found a network whose name begins with "Slave". If he has found the network, he determines the MAC address of the Access Point, which is used for further communication. Even if the Slave network fails in the meantime, the Master does not have to perform another Scan.

Here follows the Sketch for the Master:

 

 

/ * ESP32 as Master for an ESP-now connection
 * The ESP32 searches for a WiFi network whose name begins with the Slave
 * If he has found such a network he remembers the MAC address of the
 * Slaves and can communicate with them via ESP_Now
 */

// Integrate libraries for Esp-Now and for WiFi
#include <esp_now.houses>
#include <WiFi.houses>

// Global copy of Slave information
// and a Flag to know if the Slave has already been found
bool slave found = 0;
esp_now_peer_info_t slave;

#define CHANNEL 3

//Data structure for data exchange
struct DATA_STRUCTURE {     uint16_t temperature = 0;     uint32_t dampness = 0;
};
 

// Init ESP now with Restart if something goes wrong
void InitESPNow() {   if (esp_now_init() == ESP_OK) {     Serial.println("ESPNow Init Success");   }   else {     Serial.println("ESPNow Init Failed");     //Error so, new attempt     ESP.restart();   }
}

// We are looking for a Slave
void ScanForSlave() {   int8_t scanResults = WiFi.scan networks();   // reset on each scan   memset(&slave, 0, sizeof(slave));   Serial.println("");   if (scanResults == 0) {     Serial.println("Noka WiFi device found in AP mode");   } else {     Serial.print(scanResults); Serial.println("Devices found ");     for (int i = 0; i < scanResults; ++i) {       // Print SSID and RSSI for each device found       String SSID broadcast = WiFi.SSID broadcast(i);       int32_t RSSI = WiFi.RSSI(i);       String BSSIDstr = WiFi.BSSIDstr(i);       // Check if the network name starts with 'Slave'       if (SSID broadcast.indexOf("Slave") == 0) {         // Yes, then we found a Slave         Serial.println("Slave found.");         Serial.print(i + 1); Serial.print(": "); Serial.print(SSID broadcast); Serial.print(" ["); Serial.print(BSSIDstr); Serial.print("]"); Serial.print(" ("); Serial.print(RSSI); Serial.print(")"); Serial.println("");         // Get MAC address from BSSID SES Slaves and save it in Slave info structure         int Mac[6];         if ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x%c",  &Mac[0], &Mac[1], &Mac[2], &Mac[3], &Mac[4], &Mac[5] ) ) {           for (int II = 0; II < 6; ++II ) {             slave.peer_addr[II] = (uint8_t) Mac[II];           }         }         slave.channel = CHANNEL; // pick a channel         slave.encrypt = 0; // no encryption         slave found = 1;         // Without this break you could also connect to more than one Slave         /If no encryption is used up to 20 Slaves are possible         break;       }     }   }   // clean up ram   WiFi.scan delete();
}

// Check whether a Slave is already paired
// Otherwise, the Slave is paired with the Master
bool manage slave() {   if (slave.channel == CHANNEL) {     const esp_now_peer_info_t *peer = &slave;     const uint8_t *peer_addr = slave.peer_addr;     // check if the peer exists     bool exists = esp_now_is_peer_exist(peer_addr);     if ( !exists) {       // Slave not paired, attempt pair       Serial.print("Slave Status: ");       esp_err_t addStatus = esp_now_add_peer(peer);       if (addStatus == ESP_OK) {         // Pair success         Serial.println("Pair success");         return true;       } else if (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {         // How did we get so far!!         Serial.println("ESPNOW Not Init");         return false;       } else if (addStatus == ESP_ERR_ESPNOW_ARG) {         Serial.println("Invalid Argument");         return false;       } else if (addStatus == ESP_ERR_ESPNOW_FULL) {         Serial.println("Peer list full");         return false;       } else if (addStatus == ESP_ERR_ESPNOW_NO_MEM) {         Serial.println("Out of memory");         return false;       } else if (addStatus == ESP_ERR_ESPNOW_EXIST) {         Serial.println("Peer Exists");         return true;       } else {         Serial.println("Not sure what happened");         return false;       }     }   } else {     // No slave found to process     Serial.println("No Slave found to process");     return false;   }
}

// send data to Slave
void sendData() {
 DATA_STRUCTURE ed;       //Since we ignore the data in this example, in the Slave     // does it matter what we send                        ed.temperature = 0;     ed.dampness = 0;     // we copy the data structure into a memory block     uint8_t data[sizeof(ed)]; memcpy(data, &ed, sizeof(ed));     const uint8_t *peer_addr = slave.peer_addr;     //We send the data and check the Status   Serial.print("Sending: ");   esp_err_t result = esp_now_send(peer_addr, data, sizeof(data));   Serial.print("Send Status: ");   if (result == ESP_OK) {     Serial.println("Success");   } else if (result == ESP_ERR_ESPNOW_NOT_INIT) {     // How did we get so far!!     Serial.println("ESPNOW not Init.");   } else if (result == ESP_ERR_ESPNOW_ARG) {     Serial.println("Invalid Argument");   } else if (result == ESP_ERR_ESPNOW_INTERNAL) {     Serial.println("Internal Error");   } else if (result == ESP_ERR_ESPNOW_NO_MEM) {     Serial.println("ESP_ERR_ESPNOW_NO_MEM");   } else if (result == ESP_ERR_ESPNOW_NOT_FOUND) {     Serial.println("Peer not found.");   } else {     Serial.println("Not sure what happened");   }
}

// callback when the data was sent to the Slave
// here you can see if the Slave was not reachable
void on_data_sent(const uint8_t *mac_addr, esp_now_send_status_t status) {   char macStr[18];   snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",            mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);   Serial.print("Last Packet Sent to: "); Serial.println(macStr);   Serial.print("Last Packet Send Status: "); Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}


// callback when we get data from the Slave
void on_data_recv(const uint8_t *mac_addr, const uint8_t *data, int data_len) {   char macStr[18];   // MAC address of the slave for Info   snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",            mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);   DATA_STRUCTURE ed;   // we copy the data into the data structure     memcpy(&ed, data, sizeof(ed));     // and display them     Serial.print("Receiving of "); Serial.println(macStr);     Serial.print("Temperature: "); Serial.print(ed.temperature); Serial.println("°C");     Serial.print("Dampness   : "); Serial.print(ed.dampness); Serial.println(" %");
}

void setup() {   Serial.begin(115200);   // Set device in STA mode to begin with   WiFi.fashion(WIFI_STA);   WiFi.disconnect();   Serial.println("ESPNow ESP32 as a Master");   // this is the mac address of the Master   Serial.print("STA MAC: "); Serial.println(WiFi.macAddress());   // Init ESPNow with a fallback logic   InitESPNow();   //We register the Callback function at the end of the transmission process,   esp_now_register_send_cb(on_data_sent);   //We register the Callback function for the reception   esp_now_register_recv_cb(on_data_recv);
}

void loop() {   // If we haven't found a Slave yet, we're looking for more   if (!slave found) ScanForSlave();   if (slave found) {     // if we have a Slave he must be paired     // if this has not yet happened     bool isPaired = manage slave();     if (isPaired) {       // If Master and Slave are paired, we can send       sendData();     } else {       // slave pair failed       Serial.println("Slave pair failed!");     }   }   else {     // No slave found to process   }   // Wait 5 seconds   delay(5000);
}

  Tip:

You can edit more than one Board at the same time from a PC with the Arduino IDE. To do this , it is only necessary to start the IDE in two instances, not several windows of the same instance. Then Board type and Port number can be set separately.

Test:

We start the Master first: the serial Monitor will indicate that the Master does not find a suitable network. If we now start the Slave, The Master should find the network and establish a connection. The Master should then display the temperature and humidity it receives from the Slave.

If we turn off the Slave, The Master will continue to try to reach the Slave, but this ends in an error. As soon as we turn on the Slave again, the Master can successfully send and receive data again.

We will also use ESP-now in the Home-Control project.

Have fun experimenting.

 

 

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

21 comments

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

Leave a comment

All comments are moderated before being published