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.