En el mundo de la tecnología IoT, la comunicación inalámbrica entre dispositivos es esencial. En este artículo, exploraremos cómo establecer una comunicación WiFi cliente-servidor entre dos placas ESP8266 (NodeMCU). Descubre cómo configurar y programar estas placas para lograr una conexión estable y eficiente. ¡Sigue leyendo para adentrarte en el fascinante mundo de la comunicación inalámbrica con ESP8266!
Aprenda a establecer comunicación Wi-Fi (HTTP) entre dos placas ESP8266 NodeMCU para intercambiar datos sin necesidad de conexión a Internet (no necesita un enrutador).
Configura un ESP8266 como punto de acceso (servidor) y otro ESP8266 como estación (cliente). Luego, el servidor y el cliente intercambian datos (valores de sensores) a través de solicitudes HTTP. Programamos las placas ESP8266 con Arduino IDE.
En este ejemplo estamos enviando valores del sensor BME280 de una placa a otra. El receptor muestra los valores en una pantalla OLED.
Si tienes una placa ESP32, puedes leer esta guía específica: Comunicación WiFi Cliente-Servidor ESP32.
Mira el vídeo de demostración
Para ver cómo funciona el proyecto, puedes ver el siguiente vídeo demostrativo:
Descripción del proyecto
Para comprender mejor cómo funciona todo, mire el diagrama a continuación.
- El servidor ESP8266 crea su propia red inalámbrica (punto de acceso suave ESP8266). Esto permite que otros dispositivos Wi-Fi se conecten a esta red (SSID: punto de acceso ESP8266, Contraseña: 123456789).
- El cliente ESP8266 está configurado como una estación. Esto le permite conectarse a la red inalámbrica del servidor ESP8266.
- El cliente puede realizar solicitudes HTTP GET al servidor para solicitar datos del sensor u otra información. Todo lo que necesita hacer es usar la dirección IP del servidor para realizar una solicitud en una ruta específica: /Temperatura, /Humedad o /Presión.
- El servidor espera las solicitudes entrantes y envía una respuesta adecuada con los valores medidos.
- El cliente recibe los valores medidos y los muestra en la pantalla OLED.
Por ejemplo, el cliente ESP8266 solicita temperatura, humedad y presión del servidor realizando solicitudes a la dirección IP del servidor seguida de /Temperatura, /Humedad Y /Presióno (OBTENER HTTP).
El servidor ESP8266 monitorea estas rutas y envía los valores del sensor correspondientes a través de una respuesta HTTP cuando se realiza una solicitud.
Piezas requeridas
Para este tutorial necesitarás las siguientes partes:
- 2x placas de desarrollo ESP8266 – leer Comparación de las mejores placas ESP8266
- Sensor BME280
- Pantalla OLED I2C SSD1306
- Cables de puente
- tabla para cortar pan
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Instalación de bibliotecas
Para este tutorial necesita instalar las siguientes bibliotecas:
Bibliotecas de servidor web asíncrono
Usamos las siguientes bibliotecas para procesar solicitudes HTTP:
- ESPAsyncWebServer Biblioteca (Descarga la biblioteca ESPAsyncWebServer)
- ESPAsync TCP Biblioteca (Descargar la biblioteca ESPAsyncTCP)
Estas bibliotecas no se pueden instalar a través del administrador de bibliotecas. Por lo tanto, debe descomprimir las bibliotecas y moverlas a la carpeta de bibliotecas de instalación del IDE de Arduino.
Alternativamente puedes Bosquejo > incluir biblioteca > Agregar biblioteca .ZIP… y seleccione las bibliotecas que acaba de descargar.
También te puede interesar: Servidor web asíncrono DHT11/DHT22 con ESP8266
Bibliotecas BME280
Las siguientes bibliotecas se pueden instalar a través de Arduino Library Manager. Ir a Bosquejo > incluir biblioteca> Administrar bibliotecas y busque el nombre de la biblioteca.
También te puede interesar: Instrucciones para BME280 con ESP8266
Bibliotecas OLED I2C SSD1306
Para conectarse a la pantalla OLED necesita las siguientes bibliotecas. Estos se pueden instalar a través del Administrador de biblioteca Arduino. Ir a Bosquejo > incluir biblioteca> Administrar bibliotecas y busque el nombre de la biblioteca.
También te puede interesar: Guía completa para pantalla OLED SSD1306 con ESP8266
Servidor #1 ESP8266 (punto de acceso)
El servidor ESP8266 es un punto de acceso (AP) que escucha solicitudes en el /Temperatura, /Humedad Y /Presión URL. Cuando se reciben solicitudes a estas URL, envía las últimas lecturas del sensor BME280.
Para las pruebas utilizamos un sensor BME280, pero también puedes utilizar cualquier otro sensor cambiando algunas líneas de código (por ejemplo, DHT11/DHT22 o DS18B20).
Representación esquemática
Conecte el ESP8266 al sensor BME280 como se muestra en el diagrama de cableado a continuación.
BME280 | ESP8266 |
Número de chasis/VCC | 3,3 V |
Dimensiones | Dimensiones |
SCL | GPIO5 (D1) |
ASD | GPIO4 (D2) |
Bosquejo de Arduino para el servidor ESP8266 n.° 1
Sube el siguiente código a tu tablero.
/*
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp8266-nodemcu-client-server-wi-fi/
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*/
// Import required libraries
#include <ESP8266WiFi.h>
#include "ESPAsyncWebServer.h"
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
// Set your access point network credentials
const char* ssid = "ESP8266-Access-Point";
const char* password = "123456789";
/*#include <SPI.h>
#define BME_SCK 18
#define BME_MISO 19
#define BME_MOSI 23
#define BME_CS 5*/
Adafruit_BME280 bme; // I2C
//Adafruit_BME280 bme(BME_CS); // hardware SPI
//Adafruit_BME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); // software SPI
// Create AsyncWebServer object on port 80
AsyncWebServer server(80);
String readTemp() {
return String(bme.readTemperature());
//return String(1.8 * bme.readTemperature() + 32);
}
String readHumi() {
return String(bme.readHumidity());
}
String readPres() {
return String(bme.readPressure() / 100.0F);
}
void setup(){
// Serial port for debugging purposes
Serial.begin(115200);
Serial.println();
// Setting the ESP as an access point
Serial.print("Setting AP (Access Point)…");
// Remove the password parameter, if you want the AP (Access Point) to be open
WiFi.softAP(ssid, password);
IPAddress IP = WiFi.softAPIP();
Serial.print("AP IP address: ");
Serial.println(IP);
server.on("/temperature", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readTemp().c_str());
});
server.on("/humidity", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readHumi().c_str());
});
server.on("/pressure", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readPres().c_str());
});
bool status;
// default settings
// (you can also pass in a Wire library object like &Wire2)
status = bme.begin(0x76);
if (!status) {
Serial.println("Could not find a valid BME280 sensor, check wiring!");
while (1);
}
// Start server
server.begin();
}
void loop(){
}
Así es como funciona el código
Comience por incluir las bibliotecas necesarias. atar esos ESP8266WiFi.h biblioteca y el ESPAsyncWebServer.h Biblioteca para procesar solicitudes HTTP entrantes.
#include <ESP8266WiFi.h>
#include "ESPAsyncWebServer.h"
Incluya las siguientes bibliotecas para interactuar con el sensor BME280.
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
Defina las credenciales de red de su punto de acceso en las siguientes variables:
const char* ssid = "ESP8266-Access-Point";
const char* password = "123456789";
Configuramos el SSID Punto de acceso ESP8266pero puedes darle cualquier otro nombre que quieras. También puedes cambiar la contraseña. Por defecto está activado 123456789.
Cree una instancia para el sensor BME280 denominada bme.
Adafruit_BME280 bme;
Cree un servidor web asíncrono en el puerto 80.
AsyncWebServer server(80);
Luego cree tres funciones que devuelvan la temperatura, la humedad y la presión como variables de cadena.
String readTemp() {
return String(bme.readTemperature());
//return String(1.8 * bme.readTemperature() + 32);
}
String readHumi() {
return String(bme.readHumidity());
}
String readPres() {
return String(bme.readPressure() / 100.0F);
}
En el configuración()inicialice el monitor serie para fines de demostración.
Serial.begin(115200);
Configure su ESP8266 como punto de acceso con el nombre SSID y la contraseña que definió anteriormente.
WiFi.softAP(ssid, password);
Luego administre las rutas en las que el ESP8266 escucha las solicitudes entrantes.
Por ejemplo, si el servidor ESP8266 realiza una solicitud en el /Temperatura URL desde la que envía la temperatura leerTemp() Funcionar como un personaje (por eso usamos el cadena_c() Método.
server.on("/temperature", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readTemp().c_str());
});
Lo mismo sucede cuando el ESP realiza una solicitud al /Humedad Y /Presión URL.
server.on("/humidity", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readHumi().c_str());
});
server.on("/pressure", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readPres().c_str());
});
Las siguientes líneas inicializan el sensor BME280.
bool status;
// default settings
// (you can also pass in a Wire library object like &Wire2)
status = bme.begin(0x76);
if (!status) {
Serial.println("Could not find a valid BME280 sensor, check wiring!");
while (1);
}
Finalmente, inicie el servidor.
server.begin();
Dado que es un servidor web asíncrono, no hay nada en el Cinta().
void loop(){
}
Probando el servidor ESP8266
Sube el código a tu placa y abre el monitor serie. Deberías obtener algo como esto:
Esto significa que el punto de acceso se ha configurado correctamente.
Para asegurarse de que responda a los requisitos de temperatura, humedad y presión, ahora debe conectarse a su red.
Vaya a la configuración de Wi-Fi en su teléfono inteligente y conéctese Punto de acceso ESP8266. La contraseña es 123456789.
Abra su navegador mientras está conectado al punto de acceso e ingrese 192.168.4.1/Temperatura
Deberías obtener el valor de temperatura en tu navegador:
Pruebe esta ruta URL para la humedad 192.168.4.1/Humedad:
Finalmente, ve a 192.168.4.1/Imprimir URL:
Si obtiene lecturas válidas, significa que todo está funcionando correctamente. Ahora necesita preparar la otra placa ESP8266 (cliente) para realizar estas solicitudes por usted y mostrarlas en la pantalla OLED.
#2 Cliente ESP8266 (estación)
El cliente ESP8266 es una estación Wi-Fi que se conecta al servidor ESP8266. El cliente solicita temperatura, humedad y presión al servidor realizando solicitudes HTTP GET al servidor. /Temperatura, /HumedadY /Presión Rutas URL. A continuación, los valores medidos se muestran en la pantalla OLED.
Representación esquemática
Conecte una pantalla OLED a su placa ESP8266 como se muestra en el siguiente esquema.
Bolígrafo | ESP8266 |
vino | 3,3 V |
Dimensiones | Dimensiones |
SCL | GPIO5 (D1) |
ASD | GPIO4 (D2) |
Bosquejo de Arduino para el cliente ESP8266 n.° 2
Cargue el siguiente código en el otro ESP8266 (el cliente):
/*
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp8266-client-server-wi-fi/
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*/
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>
#include <ESP8266WiFiMulti.h>
ESP8266WiFiMulti WiFiMulti;
const char* ssid = "ESP8266-Access-Point";
const char* password = "123456789";
//Your IP address or domain name with URL path
const char* serverNameTemp = "http://192.168.4.1/temperature";
const char* serverNameHumi = "http://192.168.4.1/humidity";
const char* serverNamePres = "http://192.168.4.1/pressure";
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
String temperature;
String humidity;
String pressure;
unsigned long previousMillis = 0;
const long interval = 5000;
void setup() {
Serial.begin(115200);
Serial.println();
// Address 0x3C for 128x64, you might need to change this value (use an I2C scanner)
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F("SSD1306 allocation failed"));
for(;;); // Don't proceed, loop forever
}
display.clearDisplay();
display.setTextColor(WHITE);
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("Connected to WiFi");
}
void loop() {
unsigned long currentMillis = millis();
if(currentMillis - previousMillis >= interval) {
// Check WiFi connection status
if ((WiFiMulti.run() == WL_CONNECTED)) {
temperature = httpGETRequest(serverNameTemp);
humidity = httpGETRequest(serverNameHumi);
pressure = httpGETRequest(serverNamePres);
Serial.println("Temperature: " + temperature + " *C - Humidity: " + humidity + " % - Pressure: " + pressure + " hPa");
display.clearDisplay();
// display temperature
display.setTextSize(2);
display.setCursor(0,0);
display.print("T: ");
display.print(temperature);
display.print(" ");
display.setTextSize(1);
display.cp437(true);
display.write(248);
display.setTextSize(2);
display.print("C");
// display humidity
display.setTextSize(2);
display.setCursor(0, 25);
display.print("H: ");
display.print(humidity);
display.print(" %");
// display pressure
display.setTextSize(2);
display.setCursor(0, 50);
display.print("P:");
display.print(pressure);
display.setTextSize(1);
display.setCursor(110, 56);
display.print("hPa");
display.display();
// save the last HTTP GET Request
previousMillis = currentMillis;
}
else {
Serial.println("WiFi Disconnected");
}
}
}
String httpGETRequest(const char* serverName) {
WiFiClient client;
HTTPClient http;
// Your IP address with path or Domain name with URL path
http.begin(client, serverName);
// Send HTTP POST request
int httpResponseCode = http.GET();
String payload = "--";
if (httpResponseCode>0) {
Serial.print("HTTP Response code: ");
Serial.println(httpResponseCode);
payload = http.getString();
}
else {
Serial.print("Error code: ");
Serial.println(httpResponseCode);
}
// Free resources
http.end();
return payload;
}
Así es como funciona el código
Incluya las bibliotecas necesarias para la conexión Wi-Fi y realizar solicitudes HTTP:
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>
#include <ESP8266WiFiMulti.h>
tienes que tener uno WLANMulti Ejemplo.
ESP8266WiFiMulti WiFiMulti;
Ingrese las credenciales de red del servidor ESP8266. Si ha cambiado las credenciales de red predeterminadas en el servidor ESP8266, debe cambiarlas en consecuencia aquí.
const char* ssid = "ESP8266-Access-Point";
const char* password = "123456789";
Luego guarde las URL donde el cliente realizará solicitudes HTTP. El servidor ESP8266 tiene la dirección IP 192.168.4.1 y enviaremos solicitudes al /Temperatura, /Humedad Y /Presión URL.
const char* serverNameTemp = "http://192.168.4.1/temperature";
const char* serverNameHumi = "http://192.168.4.1/humidity";
const char* serverNamePres = "http://192.168.4.1/pressure";
Agregue las bibliotecas para interactuar con la pantalla OLED:
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
Establezca el tamaño de la pantalla OLED:
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
Crear un… Anuncio Objeto con el tamaño previamente definido y con protocolo de comunicación I2C.
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
Inicialice variables de cadena que contengan los valores de temperatura, humedad y presión recuperados del servidor.
String temperature;
String humidity;
String pressure;
Establezca el intervalo de tiempo entre cada solicitud. Por defecto son 5 segundos, pero puedes cambiarlo a cualquier otro intervalo.
const long interval = 5000;
En el configuración()inicializar la pantalla OLED:
// Address 0x3C for 128x64, you might need to change this value (use an I2C scanner)
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F("SSD1306 allocation failed"));
for(;;); // Don't proceed, loop forever
}
display.clearDisplay();
display.setTextColor(WHITE);
Nota: Si su pantalla OLED no funciona, verifique su dirección I2C con un Bosquejo del escáner I2C y cambie el código en consecuencia.
Conecte el cliente ESP8266 a la red del servidor ESP8266.
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("Connected to WiFi");
En el Cinta() es donde realizamos las solicitudes HTTP GET. Tenemos una función llamada httpGETRequest() el cual acepta como argumento la ruta URL donde queremos realizar la solicitud y la respuesta como Cadena.
Puede utilizar la siguiente función en sus proyectos para simplificar su código:
String httpGETRequest(const char* serverName) {
WiFiClient client;
HTTPClient http;
// Your IP address with path or Domain name with URL path
http.begin(client, serverName);
// Send HTTP POST request
int httpResponseCode = http.GET();
String payload = "--";
if (httpResponseCode>0) {
Serial.print("HTTP Response code: ");
Serial.println(httpResponseCode);
payload = http.getString();
}
else {
Serial.print("Error code: ");
Serial.println(httpResponseCode);
}
// Free resources
http.end();
return payload;
}
Usamos esta función para obtener los valores de temperatura, humedad y presión del servidor.
temperature = httpGETRequest(serverNameTemp);
humidity = httpGETRequest(serverNameHumi);
pressure = httpGETRequest(serverNamePres);
Imprima estas lecturas para depurar en el monitor serie.
Serial.println("Temperature: " + temperature + " *C - Humidity: " + humidity + " % - Pressure: " + pressure + " hPa");
A continuación, la temperatura se muestra en la pantalla OLED:
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,0);
display.print("T: ");
display.print(temperature);
display.print(" ");
display.setTextSize(1);
display.cp437(true);
display.write(248);
display.setTextSize(2);
display.print("C");
Humedad:
display.setTextSize(2);
display.setCursor(0, 25);
display.print("H: ");
display.print(humidity);
display.print(" %");
Finalmente, el valor de la presión:
display.setTextSize(2);
display.setCursor(0, 50);
display.print("P:");
display.print(pressure);
display.setTextSize(1);
display.setCursor(110, 56);
display.print("hPa");
display.display();
Usamos temporizadores en lugar de retrasos para realizar una solicitud cada x segundos. Por eso los tenemos anteriorMillis, actualMillis variables y utilizar el milisegundos() Función. Tenemos un artículo que muestra la diferencia entre temporizadores y retrasos que puede resultarle útil (o lea ESP8266 Timers).
Sube el boceto al #2 ESP8266 (cliente) para probar si todo funciona correctamente.
Probando el cliente ESP8266
Si ambas placas están lo suficientemente juntas y tienen energía, puede ver que el ESP n.° 2 recibe nuevas lecturas de temperatura, humedad y presión del ESP n.° 1 cada 5 segundos.
Esto es lo que debería ver en el Monitor serie del cliente ESP8266.
Los valores del sensor también se muestran en la pantalla OLED.
¡Eso es todo! Sus dos placas ESP8266 se comunican entre sí.
Envolver
En este tutorial, le mostramos cómo enviar datos de una placa ESP8266 a otra mediante solicitudes HTTP. Este proyecto puede resultar muy útil cuando necesitas configurar la comunicación inalámbrica entre dos o más tarjetas y no tienes un enrutador cerca.
A modo de demostración, hemos mostrado cómo enviar los valores del sensor BME280, pero puede utilizar cualquier otro sensor o enviar otros datos. Otros sensores recomendados:
- ESP8266 DHT11 o DHT22 (Instrucciones)
- ESP8266 DS18B20 (Instrucciones)
- DHT11 frente a DHT22 frente a DS18B20 frente a BME280
Tenemos un tutorial similar para el ESP32 que puede resultarle útil:
- Comunicación WiFi cliente-servidor ESP32 entre dos placas
Esperamos que hayas disfrutado de este tutorial. Estamos preparando más tutoriales como este. ¡Así que estad atentos y suscríbete a nuestro blog!
Gracias por leer.
Comunicación WiFi cliente-servidor ESP8266 entre dos placas (NodeMCU)
Aprende a establecer una comunicación Wi-Fi (HTTP) entre dos placas ESP8266 NodeMCU para intercambiar datos sin necesidad de conectarse a Internet (no necesitas un enrutador).
Inspiración
En este proyecto, aprenderás a configurar un ESP8266 como Punto de Acceso (Servidor) y otro ESP8266 como Estación (Cliente). Luego, el servidor y el cliente intercambiarán datos (lecturas de sensores) mediante solicitudes HTTP. Programaremos las placas ESP8266 utilizando el IDE de Arduino.
En este ejemplo, enviaremos lecturas de sensor BME280 de una placa a la otra. El receptor mostrará las lecturas en una pantalla OLED.
Si tienes una placa ESP32, puedes leer esta guía dedicada: Comunicación Wi-Fi Cliente-Servidor ESP32.
Preguntas Frecuentes
- ¿Cuáles son las partes necesarias para este proyecto?
- ¿Cómo instalar las bibliotecas necesarias?
- ¿Cómo configurar el ESP8266 como servidor?
- ¿Cómo configurar el ESP8266 como cliente?
- ¿Cómo probar la comunicación entre las dos placas ESP8266?
Partes Necesarias
Para este tutorial, necesitarás las siguientes partes:
- 2 placas de desarrollo ESP8266
- Sensor BME280
- Pantalla OLED SSD1306 I2C
- Cables puente
- Protoboard
Puedes encontrar todas las partes para tus proyectos al mejor precio en MakerAdvisor.
Instalación de Bibliotecas
Para este tutorial, necesitas instalar las siguientes bibliotecas:
Librerías de Servidor Web Asíncrono
Descarga la librería ESPAsyncWebServer y la librería ESPAsyncTCP.
Estas bibliotecas no están disponibles para instalar a través del Administrador de bibliotecas. Por lo tanto, debes descomprimir las bibliotecas y moverlas a la carpeta de instalación de bibliotecas de Arduino.
Alternativamente, ve a Sketch > Include Library > Add .ZIP library… y selecciona las bibliotecas que acabas de descargar.
Librerías BME280
Para interactuar con el sensor BME280, instala las siguientes bibliotecas a través del Administrador de bibliotecas de Arduino:
- Adafruit_BME280
- Adafruit unified sensor
Librerías OLED SSD1306 I2C
Para interfaz con la pantalla OLED, instala las siguientes bibliotecas a través del Administrador de bibliotecas de Arduino:
- Adafruit SSD1306
- Adafruit GFX Library
¡Esperamos que te haya gustado este tutorial!
¡Qué chévere! Me encanta la idea de poder conectar las placas NodeMCU a través de Wifi. Muy útil para proyectos de Internet de las Cosas. ¡Gracias por compartir!
Interesante artículo, me parece genial que se pueda comunicar las placas entre sí. ¡Buena información!