Conecte ESP32 + D1 Mini a través de ESP-Now

A diferencia de la forma tradicional de conectar un controlador a otro a través de Wi-Fi, ESP-Now utiliza un protocolo especial que conecta dos microcontroladores habilitados para WLAN directamente sin pasar por un router. La conexión se realiza directamente por medio de las direcciones MAC respectivas y, por supuesto, sólo puede tener lugar dentro de una red inalámbrica (WLAN).

Este protocolo simplificado hace que la conexión sea mucho más rápida y, por lo tanto, también reduce el consumo de energía del controlador. Sin embargo, ESP-Now también tiene desventajas, la cantidad de datos por paquete está limitada a 250 bytes e Internet solo se puede alcanzar a través de un gateway.

Un maestro puede ser emparejado con hasta 20 esclavos. Si desea cifrar la red ESP-Now, el número de esclavos posibles se reduce a 10.

En nuestro ejemplo, usaremos un ESP32 como el maestro y un D1 Mini como esclavo. El esclavo se inicia como un punto de acceso suave para que el maestro pueda encontrarlo a través de un análisis de red.

A petición del maestro, el esclavo debe enviar valores medidos desde un sensor de temperatura y humedad.

Esclavo:

El esclavo es un D1 Minia través del pin D0 a GPIO 16 con el pin de datos de un Sensores de temperatura DHT11 Conectado.

El siguiente boceto anotado detallado muestra el programa utilizado. El Punto de acceso exporta la red WLAN nombrada Slave_1, la contraseña no se requiere para establecer la conexión.  :

 

/* D1 Mini con sensor de temperatura y humedad DHT11 como
 * Esclavo en una comunicación ESP-NOW
 * El esclavo genera la red WiFi Slave_1 y espera los datos del maestro
 * Cada vez que se recibe un paquete de datos, el esclavo responde con
 * los valores medidos del sensor
 */

 Bibliotecas para WiFi y para el sensor
#include <ESP8266WiFi.H>
#include <SimpleDHT.H>

Biblioteca para ESP-Now
Externos "C"{
#include <espnow.H>
}

Canal WiFi
#define Canal 1

Estructura de datos para el intercambio de datos
Estructura DATEN_STRUKTUR {     uint16_t Temperatura = 0;     uint32_t Húmedo = 0;
};

Instancia para acceder al sensor
SimpleDHT11 dht11;

Pin de datos en D1Mini - D0 es igual a GPIO16 
Const Byte dataPin = 16; Pin de datos del DHT11

variables globales para valores medidos
Byte Temperatura = 0;
Byte Húmedo = 0;

Necesitamos un punto de acceso WiFi
Vacío configDeviceAP() {   Char* Ssid = "Slave_1";   Bool Resultado = Wifi.softAP(Ssid, "Slave_1_Password", Canal, 0);   Si (!Resultado) {     Serial.println("Error en la configuración de AP.");   } Más {     Serial.println("AP Config Success. Transmisión con AP: " + Cadena(Ssid));   }
}

Función de devolución de llamada cuando se han recibido datos 
Vacío on_receive_data(uint8_t *Mac, uint8_t *r_data, uint8_t Len) {     para obtener información, convertimos la dirección MAC del remitente en una cadena y la     Char MACmaster[6];     Sprintf(MACmaster, "%02X:%02X:%02x:%02X:%02X:%02X:%02X",Mac[0],Mac[1],Mac[2],Mac[3],Mac[4],Mac[5]);     Serial.Impresión("Recibir MAC: "); Serial.Impresión(MACmaster);       DATEN_STRUKTUR Ed;     copiamos los datos recibidos en la estructura de datos     acceso a la estructura de datos     Memcpy(&Ed, r_data, Sizeof(Ed));     aquí pudimos acceder a estos datos a través de ed.temperatur y ed.feuchte     que el remitente ha enviado       ahora establecemos los valores con los datos del sensor     Ed.Temperatura = Temperatura;     Ed.Húmedo = Húmedo;     copiamos los datos en un bloque de almacenamiento y los enviamos de vuelta al remitente     uint8_t s_data[Sizeof(Ed)]; Memcpy(s_data, &Ed, Sizeof(Ed));     esp_now_send(Mac, s_data, Sizeof(s_data));        };
 

Vacío Configuración() {   Serial.Comenzar(115200); Serial.println();   Configuración del punto de acceso   Wifi.Moda(WIFI_AP);   configDeviceAP();    Inicializar ESOP-Now     Si (esp_now_init()!=0) {     Serial.println("Protocolo ESP-NOW no inicializado...");     Esp.Reiniciar();     Retraso(1);   }     Direcciones MACb para información ***/   Serial.Impresión("AP MAC:"); Serial.println(Wifi.softAPmacAddress());   Serial.Impresión("STA MAC: "); Serial.println(Wifi.macAddress());     Set ESP rol 1-Maestro, 2 - Esclavo 3 - Maestro + Esclavo   esp_now_set_self_role(2);    y registrar la función de devolución de llamada   esp_now_register_recv_cb(on_receive_data);     }

Vacío Bucle() {      valores medidos desde el sensor con comprobación de errores   Int Err = SimpleDHTErrSuccess;   Err = dht11.Leer(dataPin, &Temperatura, &Húmedo, Null);   Si (Err != SimpleDHTErrSuccess) {     Serial.Impresión("No se pudo leer el DHT11. Error á ");     Serial.println(Err);   }   esperar 1.5 s El DHT11 hace 1 medición / s   Retraso(1500);    }




Maestro:

Para el Maestro, tengo un ESP-32 Developmentboard Utilizado. Por supuesto, todos los demás tableros ESP también se pueden utilizar aquí. El maestro comienza en modo de estación. En su bucle principal, puede utilizar las redes WiFi disponibles hasta que haya encontrado una red cuyo nombre comienza con "esclavo". Si ha encontrado la red, determina la dirección MAC del Punto de acceso, que se utiliza para la comunicación adicional. Incluso si la red esclava falla mientras tanto, el maestro no tiene que realizar otro análisis.

Aquí está el croquis para el maestro:

 

 

/* ESP32 como maestro para una conexión ESP-Now
 * El ESP32 busca un WiFi Netzerk cuyo nombre comienza con el esclavo
 * Cuando ha encontrado una red de este tipo, recuerda la dirección MAC de la
 * Esclavos y pueden comunicarse con ellos a través de ESP_Now
 */

Incluir bibliotecas para Esp-Now y WiFi
#include <esp_now.H>
#include <Wifi.H>

Copia global de la información de esclavos
y una bandera para saber si el esclavo ya ha sido encontrado
Bool slaveFound = 0;
esp_now_peer_info_t Esclavo;

#define Canal 3

Estructura de datos para el intercambio de datos
Estructura DATEN_STRUKTUR {     uint16_t Temperatura = 0;     uint32_t Húmedo = 0;
};
 

Init ESP Ahora con Reiniciar en caso de que lo que salga mal
Vacío InitESPNow() {   Si (esp_now_init() == ESP_OK) {     Serial.println("ESPNow Init Success");   }   Más {     Serial.println("EsPNow Init Failed");     Error tan nuevo intento     Esp.Reiniciar();   }
}

Estamos buscando un esclavo
Vacío ScanForSlave() {   int8_t scanResults = Wifi.scanNetworks();   restablecer en cada escaneo   Memset(&Esclavo, 0, Sizeof(Esclavo));   Serial.println("");   Si (scanResults == 0) {     Serial.println("Nose encuentra ningún dispositivo WiFi en modo AP");   } Más {     Serial.Impresión(scanResults); Serial.println(" Dispositivos encontrados ");     Para (Int Ⅰ. = 0; Ⅰ. < scanResults; ++Ⅰ.) {       Imprima SSID y RSSI para cada dispositivo encontrado       Cadena Ssid = Wifi.Ssid(Ⅰ.);       int32_t Rssi = Wifi.Rssi(Ⅰ.);       Cadena BSSIDstr = Wifi.BSSIDstr(Ⅰ.);       Compruebe si el nombre de la red comienza con 'Esclavo'       Si (Ssid.Indexof("Esclavo") == 0) {         Sí, entonces encontramos un esclavo         Serial.println("Esclavo encontrado.");         Serial.Impresión(Ⅰ. + 1); Serial.Impresión(": "); Serial.Impresión(Ssid); Serial.Impresión(" ["); Serial.Impresión(BSSIDstr); Serial.Impresión("]"); Serial.Impresión(" ("); Serial.Impresión(Rssi); Serial.Impresión(")"); Serial.println("");         Determinar la dirección MAC del BSSID ses esclavos y almacenarlos en la estructura de información de esclavos         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] ) ) {           Para (Int Ⅱ. = 0; Ⅱ. < 6; ++Ⅱ. ) {             Esclavo.peer_addr[Ⅱ.] = (uint8_t) Mac[Ⅱ.];           }         }         Esclavo.Canal = Canal; elegir un canal         Esclavo.Cifrar = 0; sin cifrado         slaveFound = 1;         Sin este descanso también podría conectarse a más de un esclavo         Si no se utiliza cifrado, es posible que se utilicen hasta 20 esclavos         Romper;       }     }   }   limpiar carnero   Wifi.scanDelete();
}

Compruebe si un esclavo ya está emparejado
De lo contrario, el esclavo se empareja con el maestro
Bool manageSlave() {   Si (Esclavo.Canal == Canal) {     Const esp_now_peer_info_t *par = &Esclavo;     Const uint8_t *peer_addr = Esclavo.peer_addr;     comprobar si el par existe     Bool Existe = esp_now_is_peer_exist(peer_addr);     Si ( !Existe) {       Esclavo no emparejado, probar par       Serial.Impresión("Estado del esclavo: ");       esp_err_t addStatus = esp_now_add_peer(par);       Si (addStatus == ESP_OK) {         Tiempo de éxito en la pareja         Serial.println("Éxito de par");         devolución Verdad;       } Más Si (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {         ¿Cómo llegamos tan lejos!!         Serial.println("ESPNOW no init");         devolución Falso;       } Más Si (addStatus == ESP_ERR_ESPNOW_ARG) {         Serial.println("Argumento no válido");         devolución Falso;       } Más Si (addStatus == ESP_ERR_ESPNOW_FULL) {         Serial.println("Lista de pares llena");         devolución Falso;       } Más Si (addStatus == ESP_ERR_ESPNOW_NO_MEM) {         Serial.println("Fuera de memoria");         devolución Falso;       } Más Si (addStatus == ESP_ERR_ESPNOW_EXIST) {         Serial.println("El par existe");         devolución Verdad;       } Más {         Serial.println("No estoy seguro de lo que pasó");         devolución Falso;       }     }   } Más {     Ningún esclavo encontrado para procesar     Serial.println("No se ha encontrado ningún esclavo para procesar");     devolución Falso;   }
}

enviar datos a esclavo
Vacío sendData() {
 DATEN_STRUKTUR Ed;       Porque ignoramos los datos de este ejemplo en el esclavo     no importa lo que enviemos                        Ed.Temperatura = 0;     Ed.Húmedo = 0;     copiamos la estructura de datos en un bloque de memoria     uint8_t Datos[Sizeof(Ed)]; Memcpy(Datos, &Ed, Sizeof(Ed));     Const uint8_t *peer_addr = Esclavo.peer_addr;     Enviamos los datos y comprobamos el estado   Serial.Impresión("Enviando: ");   esp_err_t Resultado = esp_now_send(peer_addr, Datos, Sizeof(Datos));   Serial.Impresión("Estado de envío: ");   Si (Resultado == ESP_OK) {     Serial.println("El éxito");   } Más Si (Resultado == ESP_ERR_ESPNOW_NOT_INIT) {     ¿Cómo llegamos tan lejos!!     Serial.println("ESPNOW no Init.");   } Más Si (Resultado == ESP_ERR_ESPNOW_ARG) {     Serial.println("Argumento no válido");   } Más Si (Resultado == ESP_ERR_ESPNOW_INTERNAL) {     Serial.println("Error interno");   } Más Si (Resultado == ESP_ERR_ESPNOW_NO_MEM) {     Serial.println("ESP_ERR_ESPNOW_NO_MEM");   } Más Si (Resultado == ESP_ERR_ESPNOW_NOT_FOUND) {     Serial.println("No se encuentra el par.");   } Más {     Serial.println("No estoy seguro de lo que pasó");   }
}

devolución de llamada cuando los datos fueron enviados al esclavo
aquí se puede ver si el esclavo no era accesible
Vacío on_data_sent(Const uint8_t *mac_addr, esp_now_send_status_t Estado) {   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]);   Serial.Impresión("El último paquete enviado a: "); Serial.println(macStr);   Serial.Impresión("Estado de envío del último paquete: "); Serial.println(Estado == ESP_NOW_SEND_SUCCESS ? "Éxito de entrega" : "Fallo de entrega");
}


devolución de llamada cuando obtenemos datos del esclavo
Vacío on_data_recv(Const uint8_t *mac_addr, Const uint8_t *Datos, Int data_len) {   Char macStr[18];   Dirección MAC del esclavo para obtener información   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;   copiamos los datos en la estructura de datos     Memcpy(&Ed, Datos, Sizeof(Ed));     y mostrarlos     Serial.Impresión("Recepción"); Serial.println(macStr);     Serial.Impresión("Temperatura: "); Serial.Impresión(Ed.Temperatura); Serial.println("C");     Serial.Impresión("Humedad: "); Serial.Impresión(Ed.Húmedo); Serial.println(" %");
}

Vacío Configuración() {   Serial.Comenzar(115200);   Ajuste el dispositivo en modo STA para comenzar con   Wifi.Moda(WIFI_STA);   Wifi.Desconecte();   Serial.println("ESPNow ESP32 como Maestro");   esta es la dirección mac del maestro   Serial.Impresión("STA MAC: "); Serial.println(Wifi.macAddress());   Init ESPNow con una lógica de reserva   InitESPNow();   Registramos la función de devolución de llamada al final del proceso de envío   esp_now_register_send_cb(on_data_sent);   Registramos la función de devolución de llamada para recibir   esp_now_register_recv_cb(on_data_recv);
}

Vacío Bucle() {   Si aún no hemos encontrado un esclavo, todavía estamos buscando   Si (!slaveFound) ScanForSlave();   Si (slaveFound) {     tenemos un esclavo que tiene que ser emparejado     si esto aún no ha sucedido     Bool isPaired = manageSlave();     Si (isPaired) {       Si el amo y el esclavo están emparejados, podemos enviar       sendData();     } Más {       pareja de esclavos falló       Serial.println("La pareja de esclavos falló!");     }   }   Más {     Ningún esclavo encontrado para procesar   }   5 segundos para esperar   Retraso(5000);
}

Propina:

Puede editar más de una placa desde un PC con el IDE de Arduino al mismo tiempo. Para ello, solo es necesario iniciar el IDE en dos instancias, es decir, no varias ventanas de la misma instancia. A continuación, el tipo de placa y el número de puerto se pueden establecer por separado.

Prueba:

Comenzamos el maestro primero: El monitor serie indicará que el maestro no puede encontrar una red adecuada. Cuando iniciamos el esclavo, el maestro debe encontrar la red y conectarse. El maestro debe entonces mostrar la temperatura y la humedad que recibe del esclavo.

Si apagamos el esclavo, el maestro seguirá tratando de alcanzar al esclavo, pero esto terminará en un error. Tan pronto como volvamos a encender el esclavo, el maestro puede enviar y recibir datos con éxito de nuevo.

También utilizaremos ESP-Now en el proyecto Home-Control.

Diviértete experimentando.

 

 

Esp-32Precipitador electrostático - 8266Proyectos para principiantes

21 comentarios

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

Deja un comentario

Todos los comentarios son moderados antes de ser publicados

Artículos de blog

  1. Ahora instalamos el esp32 a través de la administración.
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. Transporte Aéreo - programación de ESP mediante redes locales inalámbricas