Guías · 9 min de lectura

Controlar servo con ESP32 por WiFi: slider web desde el celular

Controlar un servo con ESP32 por WiFi desde el celular: librería ESP32Servo, slider web con fetch, pines, alimentación y GND común, sin temblores y pan-tilt.

La forma más divertida de controlar un servo con ESP32 por WiFi es moverlo en tiempo real con un slider en el celular: deslizas el dedo y el servo gira, sin instalar ninguna app en el teléfono. En esta guía convertimos el ESP32 en un servidor web, enviamos el valor del slider de la página que se abre en el navegador con el comando fetch de JavaScript y llevamos el servo a ese ángulo con la librería ESP32Servo.

Además del código, explicamos en detalle la parte de hardware, porque la mayoría de los proyectos de servos con WiFi no fallan por el software sino por la alimentación: el servo tiembla, el ESP32 se reinicia o se cae la conexión. Vas a ver paso a paso qué pin elegir, con qué alimentar el servo, por qué la tierra común (GND) es obligatoria, cómo evitar los temblores y, al final, cómo armar un mecanismo pan-tilt con dos servos.

Micro servo SG90
Micro servo SG90: gira de 0 a 180 grados, se alimenta con 4,8–6 V y se posiciona según el ancho del pulso de una señal PWM de 50 Hz.

¿Cómo funciona? El camino del slider al servo

  1. El navegador del celular abre la IP del ESP32 y el ESP32 le envía una pequeña página HTML con un slider.
  2. Al mover el slider, el JavaScript de la página manda el ángulo con fetch a una dirección como /set?angle=120; la página no se recarga.
  3. El servidor web del ESP32 recibe la petición, lee el ángulo y lo limita al rango 0–180.
  4. La librería ESP32Servo convierte el ángulo en ancho de pulso: unos 500 µs para 0 grados y 2400 µs para 180 grados, enviados 50 veces por segundo.
  5. La placa de control dentro del servo lee el pulso, lleva el motor a ese ángulo y lo mantiene ahí.

Cómo funciona un servo y la relación entre ancho de pulso y ángulo lo explicamos en detalle en ¿Qué es un servomotor? Lo que necesitas saber aquí es esto: en el ESP32 no funciona la librería Servo estándar de Arduino, porque el ESP32 genera el PWM con otro hardware (LEDC). Por eso usamos la librería ESP32Servo, que ofrece los mismos comandos attach() y write() y es compatible con los núcleos 2.x y 3.x del ESP32.

Materiales necesarios

  • Placa de desarrollo ESP32 (DevKit, NodeMCU-32S o similar)
  • Servo SG90 o MG90S (para el pan-tilt, dos servos y un soporte pan-tilt)
  • Fuente externa de 5 V: un adaptador de al menos 2 A o un portapilas para 4 pilas AA
  • Capacitor electrolítico de 470–1000 µF (de al menos 10 V)
  • Protoboard y cables dupont
  • El paquete de placas ESP32 instalado en el IDE de Arduino y la librería ESP32Servo instalada desde el Gestor de librerías

Elección del pin: ¿a qué GPIO conectar el servo?

Casi todos los pines de salida del ESP32 pueden generar PWM, pero no todos sirven igual para un servo. Algunos sacan señales cortas durante el arranque y hacen que el servo dé un tirón cada vez que enciendes la placa; otros son solo de entrada. Puedes ver el mapa completo de pines de tu placa en la herramienta Pinout:

PinesPara el servoPor qué
GPIO 13, 25, 26, 27, 32, 33RecomendadosNo sacan señal al arrancar y todos pueden generar PWM (LEDC)
GPIO 4, 16, 17, 18, 19, 21, 22, 23SirvenPines de uso general seguros; si usas I2C (21, 22) o SPI (18, 19, 23), déjalos libres
GPIO 2, 5, 12, 14, 15EvítalosSon pines de arranque (strapping) o sacan PWM al arrancar; el servo puede dar tirones o la placa no arrancar
GPIO 34–39No sirvenSon solo de entrada y no pueden generar PWM
GPIO 6–11No sirvenEstán conectados a la memoria flash interna
GPIO 1 y 3No sirvenSon la línea serie del USB (TX, RX)

Alimentación del servo y GND común

Un SG90 en reposo consume unos 10 mA, pero en el momento en que arranca o mientras sostiene una carga la corriente se dispara a 500–700 mA. El ESP32, a su vez, pide picos de unos 250 mA cuando transmite por WiFi. Si alimentas los dos desde la misma línea USB débil, el voltaje se cae y el ESP32 se reinicia con el mensaje "Brownout detector was triggered". La solución es alimentar el servo con una fuente de 5 V aparte y unir las tierras (GND) de los dos circuitos:

Cable del servoConexiónNota
Café o negro (GND)Negativo de la fuente externa y pin GND del ESP32La tierra común es obligatoria: es la referencia de la señal
Rojo (V+)Fuente externa de 5 V (4,8–6 V)Nunca lo conectes al pin 3V3 del ESP32
Naranja o amarillo (señal)GPIO 13La señal de 3,3 V alcanza para el SG90 y el MG90S
No olvides la tierra común. La señal del servo es un voltaje medido respecto del GND del ESP32. Si no conectas el negativo de la fuente externa al pin GND del ESP32, el servo se mueve al azar o no responde. Y nunca alimentes el servo desde el pin 3V3 del ESP32: el regulador de la placa no aguanta esa corriente y el ESP32 se reinicia una y otra vez.
MontajeFuente recomendadaNota
1 SG90, prueba sin cargaPin 5V (VIN) de la placa ESP32, desde el USBSolo para pruebas cortas; con WiFi puede aparecer el brownout
2 SG90 (pan-tilt)Adaptador de 5 V y al menos 2 AAgrega un capacitor de 470–1000 µF en la fuente
1–2 MG996R5–6 V y al menos 3 ALa corriente con el eje bloqueado puede llegar a 2,5 A por servo
Proyecto portátil4 pilas AA (alcalinas, 6 V)Las recargables NiMH dan 4,8 V, que también alcanza

Paso 1: primera prueba con ESP32Servo

Antes de pasar al WiFi, asegúrate de que el servo y la alimentación funcionan bien. Busca ESP32Servo en el Gestor de librerías, instala la de Kevin Harrington y John K. Bennett y luego sube el código de abajo. El servo debería ir y venir despacio entre 0 y 180 grados; si no lo hace, el problema no está en el software sino en el cableado o la alimentación.

C++ (Arduino IDE)
1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 13;                  // açılışta sessiz, güvenli pin / quiet at boot, safe pin
4Servo servo;
5
6void setup() {
7  servo.setPeriodHertz(50);                // standart servo 50 Hz / standard servo, 50 Hz
8  servo.attach(SERVO_PIN, 500, 2400);      // 0° = 500 µs, 180° = 2400 µs (SG90)
9}
10
11void loop() {
12  for (int a = 0; a <= 180; a += 2) {      // 0 → 180°
13    servo.write(a);
14    delay(15);
15  }
16  for (int a = 180; a >= 0; a -= 2) {      // 180 → 0°
17    servo.write(a);
18    delay(15);
19  }
20}
Los dos números de la línea attach(pin, 500, 2400) son el ancho de pulso de 0 y de 180 grados, en microsegundos. La mayoría de los clones del SG90 trabajan en ese rango. Si el servo zumba en los extremos o llega a su tope mecánico, achica el rango (por ejemplo, 600 y 2300) o mantén el ángulo entre 5 y 175 grados.

Paso 2: controlar el servo con un slider en la página web

Ahora sí, vamos al proyecto principal. El código de abajo conecta el ESP32 a la red de tu casa, sirve una página con un slider y escribe en el servo el ángulo que llega a la dirección /set. La página HTML va dentro del código como texto crudo (raw string), así que no necesitas subir ningún archivo aparte. Escribe el nombre y la contraseña de tu WiFi, sube el código y abre en el navegador del celular la IP que aparece en el Monitor Serie.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
7const int SERVO_PIN = 13;
8
9WebServer server(80);
10Servo servo;
11int currentAngle = 90;                    // açılışta ortada / centred at start
12
13// Telefonda açılan sayfa / page opened on the phone
14const char PAGE[] PROGMEM = R"rawliteral(
15<!DOCTYPE html><html><head><meta charset="utf-8">
16<meta name="viewport" content="width=device-width,initial-scale=1">
17<title>ESP32 Servo</title>
18<style>
19body{font-family:sans-serif;text-align:center;margin-top:40px}
20input{width:85%;height:40px}
21#v{font-size:56px;font-weight:bold}
22</style></head><body>
23<h2>ESP32 Servo</h2>
24<p><span id="v">%ANGLE%</span>°</p>
25<input type="range" id="s" min="0" max="180" value="%ANGLE%">
26<script>
27const s = document.getElementById('s');
28const v = document.getElementById('v');
29let last = 0, timer = null;
30function send() {
31  fetch('/set?angle=' + s.value);          // açıyı gönder / send the angle
32  last = Date.now();
33}
34s.addEventListener('input', () => {
35  v.textContent = s.value;
36  clearTimeout(timer);
37  if (Date.now() - last > 100) send();     // en fazla 10 istek/sn / at most 10 requests/s
38  else timer = setTimeout(send, 100);      // son değer mutlaka gider / the last value always goes out
39});
40</script></body></html>
41)rawliteral";
42
43void handleRoot() {
44  String html = PAGE;
45  html.replace("%ANGLE%", String(currentAngle));   // slider doğru yerde başlar / slider starts at the right spot
46  server.send(200, "text/html", html);
47}
48
49void handleSet() {
50  if (!server.hasArg("angle")) {
51    server.send(400, "text/plain", "angle?");
52    return;
53  }
54  int angle = constrain(server.arg("angle").toInt(), 0, 180);   // güvenli aralık / safe range
55  if (angle != currentAngle) {             // aynı açıyı tekrar yazma / don't rewrite the same angle
56    servo.write(angle);
57    currentAngle = angle;
58  }
59  server.send(200, "text/plain", String(currentAngle));
60}
61
62void setup() {
63  Serial.begin(115200);
64  servo.setPeriodHertz(50);
65  servo.attach(SERVO_PIN, 500, 2400);
66  servo.write(currentAngle);
67
68  WiFi.mode(WIFI_STA);
69  WiFi.begin(WIFI_SSID, WIFI_PASS);
70  while (WiFi.status() != WL_CONNECTED) {  // bağlanana kadar bekle / wait until connected
71    delay(500);
72    Serial.print(".");
73  }
74  Serial.println();
75  Serial.print("IP: ");
76  Serial.println(WiFi.localIP());          // bu adresi telefonda aç / open this address on your phone
77
78  server.on("/", handleRoot);
79  server.on("/set", handleSet);
80  server.begin();
81}
82
83void loop() {
84  server.handleClient();
85}

El código tiene dos puntos clave. El primero: el JavaScript no manda una petición cada vez que el slider se mueve; espera al menos 100 ms entre una petición y otra, y cuando levantas el dedo siempre manda el último valor. Un slider puede generar 60 eventos por segundo; mandarlos todos satura el servidor web del ESP32 y hace que el servo se mueva a tirones. El segundo: del lado del servidor, constrain() limita el ángulo al rango 0–180, así que aunque alguien escriba un valor equivocado en la barra de direcciones, el servo no se fuerza.

Cada vez que se abre la página, el marcador %ANGLE% se reemplaza por el ángulo actual del servo, así que aunque cierres y vuelvas a abrir el navegador del celular, el slider arranca en la posición correcta. Se pueden conectar varios celulares a la vez y vale el último ángulo enviado. Si quieres una interfaz en vivo que se actualice al instante en todos los teléfonos, pásate al método de ESP32 Async Web Server y WebSocket.

Sin router: que el ESP32 cree su propia red WiFi

Si vas a usar el proyecto en una feria de ciencias, en el patio o en un lugar sin red WiFi, pon el ESP32 en modo punto de acceso (AP). Reemplaza dentro de setup() las líneas WiFi.mode y WiFi.begin y el bucle que espera la conexión por estas líneas; después solo tienes que conectar el celular a la red ESP32-Servo y abrir 192.168.4.1 en el navegador:

C++ (Arduino IDE)
1// Router yoksa: ESP32 kendi ağını kurar / No router: the ESP32 creates its own network
2WiFi.softAP("ESP32-Servo", "12345678");    // şifre en az 8 karakter / password, at least 8 characters
3Serial.print("IP: ");
4Serial.println(WiFi.softAPIP());           // genellikle 192.168.4.1 / usually 192.168.4.1

Cómo evitar que el servo tiemble

  • Alimentación aparte y GND común: la causa número uno de los temblores es una alimentación débil; alimenta el servo con una fuente de 5 V de al menos 2 A y une las tierras.
  • Capacitor: pon un capacitor electrolítico de 470–1000 µF en los cables de alimentación, cerca del servo; suaviza la caída de voltaje del arranque. Puedes descifrar los códigos impresos en los capacitores con la herramienta código de capacitores.
  • Limita las peticiones: no mandes cada evento del slider; el límite de 100 ms del código alivia tanto a la red como al servo.
  • No escribas dos veces el mismo ángulo: la comprobación if (angle != currentAngle) del código evita escrituras innecesarias.
  • Rango de pulso correcto: si el servo zumba en los extremos, está llegando a su tope mecánico; achica el rango de attach() o los límites de ángulo.
  • Cable de señal corto: con cables de más de 30 cm, lleva la señal y GND juntos, de preferencia trenzados.
  • Último recurso, detach(): si llamas a detach() cuando el servo llega a su posición, se corta la señal y el temblor desaparece, pero el servo deja de sostener la carga.

Si el problema sigue, revisa Servo que tiembla: soluciones, donde explicamos con mediciones todas las causas del temblor. Si usas pilas, puedes estimar de antemano cuánto van a durar con la calculadora de duración de batería.

Paso 3: versión pan-tilt con dos servos

Un mecanismo pan-tilt tiene dos servos: el de abajo gira en horizontal (pan) y el de arriba en vertical (tilt). Si le montas una cámara, un láser o un sensor ultrasónico, tienes un ojo que puedes apuntar a distancia. Conecta el servo pan a GPIO 13 y el servo tilt a GPIO 27, y alimenta los dos desde la misma fuente externa de 5 V. Esta versión trae dos novedades: la página tiene dos sliders, y los servos no saltan de golpe al nuevo ángulo sino que avanzan un grado cada 10 ms hasta llegar. Eso hace el movimiento más fluido y evita que los dos servos pidan mucha corriente al mismo tiempo.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
7const int PAN_PIN = 13;                   // yatay servo / pan servo
8const int TILT_PIN = 27;                  // dikey servo / tilt servo
9
10WebServer server(80);
11Servo pan, tilt;
12int panTarget = 90, tiltTarget = 90;      // hedef açılar / target angles
13int panNow = 90, tiltNow = 90;            // anlık açılar / current angles
14unsigned long lastStep = 0;
15
16const char PAGE[] PROGMEM = R"rawliteral(
17<!DOCTYPE html><html><head><meta charset="utf-8">
18<meta name="viewport" content="width=device-width,initial-scale=1">
19<title>ESP32 Pan-Tilt</title>
20<style>body{font-family:sans-serif;text-align:center}input{width:85%;height:40px}</style>
21</head><body>
22<h2>ESP32 Pan-Tilt</h2>
23<p>Pan: <b id="pv">%PAN%</b>°</p>
24<input type="range" id="pan" min="0" max="180" value="%PAN%">
25<p>Tilt: <b id="tv">%TILT%</b>°</p>
26<input type="range" id="tilt" min="20" max="160" value="%TILT%">
27<script>
28const pan = document.getElementById('pan');
29const tilt = document.getElementById('tilt');
30let last = 0, timer = null;
31function send() {
32  fetch('/set?pan=' + pan.value + '&tilt=' + tilt.value);   // iki açı tek istekte / both angles in one request
33  last = Date.now();
34}
35function changed() {
36  document.getElementById('pv').textContent = pan.value;
37  document.getElementById('tv').textContent = tilt.value;
38  clearTimeout(timer);
39  if (Date.now() - last > 100) send();
40  else timer = setTimeout(send, 100);
41}
42pan.addEventListener('input', changed);
43tilt.addEventListener('input', changed);
44</script></body></html>
45)rawliteral";
46
47void handleRoot() {
48  String html = PAGE;
49  html.replace("%PAN%", String(panTarget));
50  html.replace("%TILT%", String(tiltTarget));
51  server.send(200, "text/html", html);
52}
53
54void handleSet() {
55  if (server.hasArg("pan"))  panTarget  = constrain(server.arg("pan").toInt(), 0, 180);
56  if (server.hasArg("tilt")) tiltTarget = constrain(server.arg("tilt").toInt(), 20, 160);   // braket sınırı / bracket limit
57  server.send(200, "text/plain", "OK");
58}
59
60// Her 10 ms'de hedefe 1 derece yaklaş: yumuşak hareket, düşük akım
61// Step 1 degree toward the target every 10 ms: smooth motion, lower current peaks
62void moveSmoothly() {
63  if (millis() - lastStep < 10) return;
64  lastStep = millis();
65  if (panNow != panTarget) {
66    panNow += (panTarget > panNow) ? 1 : -1;
67    pan.write(panNow);
68  }
69  if (tiltNow != tiltTarget) {
70    tiltNow += (tiltTarget > tiltNow) ? 1 : -1;
71    tilt.write(tiltNow);
72  }
73}
74
75void setup() {
76  Serial.begin(115200);
77  pan.setPeriodHertz(50);
78  tilt.setPeriodHertz(50);
79  pan.attach(PAN_PIN, 500, 2400);
80  tilt.attach(TILT_PIN, 500, 2400);
81  pan.write(panNow);
82  tilt.write(tiltNow);
83
84  WiFi.mode(WIFI_STA);
85  WiFi.begin(WIFI_SSID, WIFI_PASS);
86  while (WiFi.status() != WL_CONNECTED) {
87    delay(500);
88    Serial.print(".");
89  }
90  Serial.println();
91  Serial.print("IP: ");
92  Serial.println(WiFi.localIP());
93
94  server.on("/", handleRoot);
95  server.on("/set", handleSet);
96  server.begin();
97}
98
99void loop() {
100  server.handleClient();                   // istekleri işle / handle requests
101  moveSmoothly();                          // servoları hedefe taşı / move the servos toward their targets
102}

El eje tilt quedó limitado a 20–160 grados, porque en la mayoría de los soportes pan-tilt de plástico el servo de arriba choca con la base cuando llega a los extremos. En tu propio montaje, lleva el servo despacio hacia los extremos, anota el ángulo justo antes del choque y ajusta con eso tanto los valores min y max del slider como los límites de constrain() en el código. Si vas a usar más servos, en lugar de los pines del ESP32 conviene pasar a la placa controladora de servos PCA9685 de 16 canales, que simplifica mucho el cableado y la alimentación.

Errores comunes y cómo solucionarlos

  • El servo no se mueve nada: las tierras no están unidas, el servo está conectado a 3V3 o el cable de señal está en uno de los GPIO 34–39, que son solo de entrada.
  • El ESP32 se reinicia cuando el servo se mueve: la alimentación no alcanza; alimenta el servo con una fuente de 5 V aparte y agrega un capacitor.
  • Error "This library only supports boards with an AVR...": la librería Servo de Arduino no es compatible con el ESP32; usa #include <ESP32Servo.h>.
  • La página no abre: el celular y el ESP32 no están en la misma red, el celular pasó a datos móviles o la red es de 5 GHz; el ESP32 solo se conecta a redes de 2,4 GHz. Para otros problemas de conexión, mira El ESP32 no se conecta al WiFi.
  • El servo sigue al slider con retraso: se están acumulando demasiadas peticiones; respeta el límite de 100 ms del JavaScript o súbelo a 150 ms.
  • El servo da un tirón cada vez que enciendes la placa: la señal está en un pin que saca PWM al arrancar (GPIO 2, 5, 12, 14, 15); pásala a GPIO 13, 25–27 o 32–33.

Controlar un servo desde el celular con un slider es la base de muchos proyectos: brazos robóticos, cámaras orientables, cerraduras inteligentes y tapas que se abren a distancia. Si vas a usar un servo más potente, haz la cuenta de la alimentación con Servo MG996R. En la app BlueGrays encuentras paso a paso, con diagrama de circuito y código, el control de un servo con potenciómetro en el ESP32, la cerradura RFID con servo y los proyectos de servidor web con ESP32.

Preguntas frecuentes

¿Cómo se controla un servomotor con ESP32?

Instala la librería ESP32Servo, conecta el cable de señal del servo a un pin seguro como GPIO 13, inicialízalo con servo.attach(13, 500, 2400) y después usa servo.write(ángulo). Alimenta el servo con una fuente externa de 5 V, no desde el ESP32, y une las tierras.

¿Por qué no funciona Servo.h en el ESP32?

La librería Servo estándar de Arduino está escrita para procesadores como AVR y SAMD y no reconoce el hardware PWM del ESP32 (LEDC). La librería ESP32Servo ofrece los mismos comandos y funciona en los núcleos 2.x y 3.x del ESP32.

¿La señal de 3,3 V del ESP32 alcanza para un servo?

La mayoría de los servos comunes, como el SG90, el MG90S y el MG996R, reconocen sin problema una señal de 3,3 V. El problema casi nunca está en la señal sino en la alimentación: el cable rojo del servo tiene que ir a una fuente de 5–6 V que entregue suficiente corriente.

¿Cuántos servos se pueden conectar a un ESP32?

La unidad LEDC del ESP32 clásico tiene 16 canales PWM, así que en teoría puedes manejar hasta 16 servos. En la práctica antes se acaban los pines adecuados o la alimentación; para más de cuatro servos, una placa controladora PCA9685 por I2C es una solución más limpia.

¿Se puede controlar un servo con ESP32 sin router?

Sí. Si pones el ESP32 en modo punto de acceso con WiFi.softAP(), crea su propia red WiFi. Conectas el celular a esa red, abres 192.168.4.1 en el navegador y usas la misma página con el slider.

¿Por qué tiembla el servo conectado al ESP32?

Las causas más comunes son una alimentación insuficiente, la falta de tierra común y mandar demasiados comandos por segundo. Alimenta el servo con una fuente de 5 V aparte, agrega un capacitor de 470–1000 µF y limita las peticiones de la página web a una cada 100 ms.

Ver todos los proyectos
Servomotor ESP32 (control mediante potenciómetro)
ES-16Intermedio
Premium

Servomotor ESP32 (control mediante potenciómetro)

En este proyecto controlamos un servomotor SG90 mediante un potenciómetro. Ajustamos el ángulo del servo asignando el valor analógico leído en el potenciómetro al rango de 0 a 180 grados. La biblioteca ESP32Servo genera señales de servo en los GPIO adecuados del ESP32 que admiten salida; en este proyecto se utiliza GPIO 18. Este es un método de control básico para brazos robóticos, cardanes de cámara y mecanismos de puertas automáticas.

4.3(29)
42
Cerradura RFID ESP32 (RC522 + servo + OLED + zumbador + LED)
ES-35Avanzado
Premium

Cerradura RFID ESP32 (RC522 + servo + OLED + zumbador + LED)

Construimos una cerradura inteligente con un ESP32, un módulo RFID RC522, un servo SG90, una pantalla OLED SSD1306, un zumbador activo y 2 LED. Al pasar una tarjeta, su UID se compara con las autorizadas definidas en el código; si coincide, el servo abre (LED verde + 2 pitidos cortos) y vuelve a cerrar a los 5 segundos. Con una tarjeta no autorizada se enciende el LED rojo, suenan 3 pitidos rápidos y la OLED muestra su UID.

4.8(9)
16
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
ES-28Avanzado
Premium

Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)

En este proyecto, dos botones conectados al ESP32 (GPIO 5 suma, GPIO 4 resta) cambian un contador. El valor se actualiza al instante en una pantalla LCD I2C de 16x2 y, gracias al soporte WebSocket de ESPAsyncWebServer, en todos los navegadores conectados sin recargar la página. En lugar del sondeo HTTP se usa una única conexión persistente y el ESP32 envía el nuevo valor a todos con ws.textAll().

4.5(14)
23
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)

En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

4.4(21)
38
ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
ES-29Avanzado
Premium

ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)

Añadimos un servicio mDNS (Multicast DNS) al ESP32 para que accedas a él con un nombre de host legible como bluegrays-esp.local en lugar de una dirección IP. Aunque cambie la IP que asigna el DHCP, el dispositivo siempre responde al mismo nombre. Un pequeño servidor web en la placa te permite controlar el LED desde el navegador en http://bluegrays-esp.local/.

4.8(14)
23
Servocontrol con joystick
AR-60Intermedio
Premium

Servocontrol con joystick

Controla dos motores con un joystick, igual que si giraras una cámara de seguridad.

4.7(42)
58