La comunicación WiFi cliente-servidor entre placas ESP32 es una herramienta poderosa y versátil que permite la transferencia de datos de manera inalámbrica. En este artículo, exploraremos cómo establecer esta conexión entre dos placas ESP32 y cómo maximizar su eficacia. ¡Descubre todo lo que necesitas saber para implementar esta tecnología en tus proyectos de forma sencilla y efectiva!
Esta guía muestra cómo configurar la comunicación HTTP entre dos placas ESP32 para intercambiar datos a través de WiFi sin una conexión a Internet (enrutador). En pocas palabras, aprenderá cómo enviar datos de una placa a otra mediante solicitudes HTTP. Las placas ESP32 están programadas con Arduino IDE.
Para fines de demostración, enviaremos los valores del sensor BME280 de una placa a otra. El receptor muestra los valores en una pantalla OLED.
Si tiene una placa ESP8266, puede leer esta guía dedicada: Comunicación WiFi cliente-servidor ESP8266 NodeMCU.
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
Una placa ESP32 actúa como servidor y la otra placa ESP32 actúa como cliente. El siguiente diagrama muestra una descripción general de cómo funciona.
- El servidor ESP32 crea su propia red inalámbrica (punto de acceso suave ESP32). Esto permite que otros dispositivos Wi-Fi se conecten a esta red (SSID: punto de acceso ESP32, Contraseña: 123456789).
- El cliente ESP32 está configurado como estación. Esto le permite conectarse a la red inalámbrica del servidor ESP32.
- 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 ESP32 solicita temperatura, humedad y presión del servidor realizando solicitudes a la dirección IP del servidor seguida de /Temperatura, /Humedad Y /Presiónrespectivamente.
El servidor ESP32 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 ESP32 – leer Revisión de las mejores placas ESP32
- 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)
- TCP asíncrono Biblioteca (Descargar la biblioteca AsyncTCP)
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 podría interesar: Crear un servidor web asíncrono con el ESP32
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 podría interesar: Conexión de BME280 a ESP32 (Instrucciones)
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: Pantalla OLED I2C SSD1306 con ESP32 (Guía)
Servidor ESP32 n.º 1 (punto de acceso)
El servidor ESP32 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 fines de demostración usamos un sensor BME280, pero puedes usar cualquier otro sensor cambiando algunas líneas de código.
Representación esquemática
Conecte el ESP32 al sensor BME280 como se muestra en el diagrama de cableado a continuación.
BME280 | ESP32 |
Número de chasis/VCC | 3,3 V |
Dimensiones | Dimensiones |
SCL | GPIO22 |
ASD | GPIO21 |
Boceto de Arduino para el servidor ESP32 n.° 1
Sube el siguiente código a tu tablero.
/*
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp32-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 "WiFi.h"
#include "ESPAsyncWebServer.h"
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
// Set your access point network credentials
const char* ssid = "ESP32-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 WiFi.h biblioteca y el ESPAsyncWebServer.h Biblioteca para procesar solicitudes HTTP entrantes.
#include "WiFi.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 = "ESP32-Access-Point";
const char* password = "123456789";
Configuramos el SSID Punto de acceso ESP32pero 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 ESP32 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 ESP32 escucha las solicitudes entrantes.
Por ejemplo, si el servidor ESP32 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 ESP32
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 ESP32. 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 ESP32 (cliente) para realizar estas solicitudes por usted y mostrarlas en la pantalla OLED.
#2 Cliente ESP32 (estación)
El cliente ESP32 es una estación Wi-Fi conectada al servidor ESP32. 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 una pantalla OLED.
Representación esquemática
Conecte el ESP32 a la pantalla OLED como se muestra en el diagrama de cableado a continuación.
OLED | ESP32 |
Número de chasis/VCC | Número de chasis |
Dimensiones | Dimensiones |
SCL | GPIO22 |
ASD | GPIO21 |
Boceto de Arduino para el cliente ESP32 n.° 2
Sube el siguiente código al otro ESP32:
/*
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp32-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 <WiFi.h>
#include <HTTPClient.h>
const char* ssid = "ESP32-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 4 // 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);
// 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);
WiFi.begin(ssid, password);
Serial.println("Connecting");
while(WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to WiFi network with IP Address: ");
Serial.println(WiFi.localIP());
}
void loop() {
unsigned long currentMillis = millis();
if(currentMillis - previousMillis >= interval) {
// Check WiFi connection status
if(WiFi.status()== 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.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");
// 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 Domain name with URL path or IP address with 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 <WiFi.h>
#include <HTTPClient.h>
Ingrese las credenciales de red del servidor ESP32. Si ha cambiado las credenciales de red predeterminadas en el servidor ESP32, debe cambiarlas en consecuencia aquí.
const char* ssid = "ESP32-Access-Point";
const char* password = "123456789";
Luego guarde las URL donde el cliente realizará solicitudes HTTP. El servidor ESP32 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 <SPI.h>
#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 ESP32 a la red del servidor ESP32.
WiFi.begin(ssid, password);
Serial.println("Connecting");
while(WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to WiFi network with IP Address: ");
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) {
HTTPClient http;
// Your IP address with path or Domain name with URL path
http.begin(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 Temporizadores ESP32).
Sube el boceto al #2 ESP32 (cliente) para probar si todo funciona correctamente.
Probando el cliente ESP32
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 ESP32.
Los valores del sensor también se muestran en la pantalla OLED.
¡Eso es todo! Tus dos tableros se comunican entre sí.
Envolver
En este tutorial, aprendió cómo enviar datos desde una placa ESP32 a otra placa ESP32 a través de WiFi mediante solicitudes HTTP sin tener que conectarse a Internet. 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:
- ESP32 DHT11 o DHT22 (Instrucciones)
- ESP32 DS18B20 (Instrucciones)
- DHT11 frente a DHT22 frente a DS18B20 frente a BME280
Tenemos un tutorial similar para el ESP8266 que puede resultarle útil:
- ESP8266 NodeMCU comunicación Wi-Fi cliente-servidor entre dos placas
Esperamos que este tutorial te haya resultado útil. 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 ESP32 entre dos placas
En este tutorial aprenderás cómo configurar una comunicación HTTP entre dos placas ESP32 para intercambiar datos a través de Wi-Fi sin necesidad de una conexión a Internet (router). En otras palabras, aprenderás cómo enviar datos de una placa a la otra utilizando solicitudes HTTP. Las placas ESP32 serán programadas utilizando el Arduino IDE.
Descripción del Proyecto
Una placa ESP32 actuará como servidor y la otra placa ESP32 actuará como cliente. El servidor ESP32 creará su propia red inalámbrica (Punto de Acceso Soft ESP32). Por lo tanto, otros dispositivos Wi-Fi pueden conectarse a esa red (SSID: ESP32-Access-Point, Contraseña: 123456789). El cliente ESP32 se configura como una estación. Por lo tanto, puede conectarse a la red inalámbrica del servidor ESP32. El cliente puede realizar solicitudes HTTP GET al servidor para solicitar datos del sensor u otra información. Solo necesita usar la dirección IP del servidor para hacer una solicitud en una ruta específica: /temperatura, /humedad o /presión. El servidor escucha las solicitudes entrantes y envía una respuesta adecuada con las lecturas. El cliente recibe las lecturas y las muestra en la pantalla OLED.
Como ejemplo, el cliente ESP32 solicita temperatura, humedad y presión al servidor mediante solicitudes en la dirección IP del servidor seguida de /temperatura, /humedad y /presión, respectivamente.
Partes Requeridas
- 2 placas de desarrollo ESP32
- Sensor BME280
- Pantalla OLED SSD1306 con I2C
- Cables jumper
- Protoboard
Puedes encontrar todas las partes necesarias para este proyecto en MakerAdvisor.com/tools a los mejores precios.
Comunicación entre Cliente y Servidor
Este proyecto implica el uso de dos placas ESP32 para configurar una comunicación inalámbrica entre un servidor y un cliente. El servidor envía las lecturas de temperatura, humedad y presión a través de HTTP GET requests, mientras que el cliente recibe y muestra esta información en una pantalla OLED.
Para ver la implementación de este proyecto, asegúrese de ver el video de demostración adjunto en la parte superior.
Para ver el diagrama de cableado y el código de programación detallado para ambos la placa ESP32 servidor y la placa ESP32 cliente, consulte el contenido completo y detallado en RandomNerdTutorials aquí: ESP32 Comunicación Wi-Fi Cliente-Servidor
Además, si tienes una placa ESP8266, puedes consultar nuestra guía dedicada para la comunicación Wi-Fi cliente-servidor entre dos placas ESP8266 NodeMCU: ESP8266 NodeMCU Cliente-Servidor