Comunicación WiFi cliente-servidor ESP32 entre dos placas

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.

Comunicación WiFi cliente-servidor ESP32 entre dos placas

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.

Comunicación WiFi cliente-servidor ESP32 entre dos placas
  • 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

Comunicación WiFi cliente-servidor ESP32 entre dos placas

Para este tutorial necesitarás las siguientes partes:

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

Comunicación WiFi cliente-servidor ESP32 entre dos placas

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:

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)

Comunicación WiFi cliente-servidor ESP32 entre dos placas

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.

Comunicación WiFi cliente-servidor ESP32 entre dos placas
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(){
  
}

Ver código sin formato

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:

Comunicación WiFi cliente-servidor ESP32 entre dos placas

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.

Comunicación WiFi cliente-servidor ESP32 entre dos placas

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:

Comunicación WiFi cliente-servidor ESP32 entre dos placas

Pruebe esta ruta URL para la humedad 192.168.4.1/Humedad:

Comunicación WiFi cliente-servidor ESP32 entre dos placas

Finalmente, ve a 192.168.4.1/Imprimir URL:

Comunicación WiFi cliente-servidor ESP32 entre dos placas

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)

Comunicación WiFi cliente-servidor ESP32 entre dos placas

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.

Comunicación WiFi cliente-servidor ESP32 entre dos placas
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;
}

Ver código sin formato

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.

Comunicación WiFi cliente-servidor ESP32 entre dos placas

Los valores del sensor también se muestran en la pantalla OLED.

Comunicación WiFi cliente-servidor ESP32 entre dos placas

¡Eso es todo! Tus dos tableros se comunican entre sí.

Comunicación WiFi cliente-servidor ESP32 entre dos placas

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.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded

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

  1. 2 placas de desarrollo ESP32
  2. Sensor BME280
  3. Pantalla OLED SSD1306 con I2C
  4. Cables jumper
  5. 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

Deja un comentario