Componentes · 10 min de lectura

Wemos D1 mini pines: D0–D8 y GPIO, A0, shields y deep sleep

Pines del Wemos D1 mini (ESP8266): equivalencia D0–D8 y GPIO, pines que impiden el arranque, límite de 3,2 V en A0, shields relé, DHT y OLED, deep sleep D0–RST.

El Wemos D1 mini mete el chip Wi-Fi ESP8266 en una placa de 34 × 26 mm que se programa directo por USB y se amplía con shields apilables, y por eso es una de las mini placas de desarrollo más populares. Es chica, barata y compatible con el Arduino IDE, así que es la primera opción para sensores Wi-Fi, enchufes inteligentes y controladores de tiras LED. El detalle es que las etiquetas D0–D8 de la placa no son números de GPIO y algunos pines, mal usados, hacen que la placa ni siquiera arranque; por eso lo primero es tener claros los pines del Wemos D1 mini.

En esta guía reunimos todos los pines del Wemos D1 mini en una sola tabla con el GPIO de cada uno. Con código de ejemplo veremos qué pines son peligrosos en el arranque (boot), por qué la entrada analógica A0 llega solo hasta 3,2 V, qué pines usan los shields de relé, DHT y OLED y por qué hay que unir D0 con RST para usar el deep sleep. Al final repasamos rápido a sus hermanos con ESP32.

Placa de desarrollo Wemos D1 mini ESP8266
Wemos D1 mini: módulo ESP-12 (ESP8266, 4 MB de flash), conversor USB-serie CH340, botón RESET y dos filas de 8 pines.

¿Qué es el Wemos D1 mini? Características

El D1 mini lo diseñó Wemos (hoy LOLIN) y, como su esquema es abierto, lo copiaron muchísimos fabricantes. Dentro del módulo ESP-12 con blindaje metálico están el procesador ESP8266EX y 4 MB de flash; la placa suma un conversor USB-serie, un regulador que baja de 5 V a 3,3 V y el botón RESET. Lo más común es encontrar la versión v3 con micro-USB y la v4 con USB-C; la distribución de pines es la misma en todas.

CaracterísticaValor
ChipESP8266EX, 32 bits, 80/160 MHz
Flash4 MB (D1 mini Pro: 16 MB)
RAM80 KB de memoria de datos (unos 40–50 KB libres con Wi-Fi activo)
Wi-Fi802.11 b/g/n, solo 2,4 GHz
Pines digitales11 (D0–D8, TX, RX)
Entrada analógica1 (A0, 0–3,2 V, 10 bits)
Nivel lógico3,3 V (se alimenta por USB o por el pin 5V)
Chip USB-serieCasi siempre CH340
Tamaño34,2 × 25,6 mm

Pines del Wemos D1 mini: D0–D8 y su GPIO equivalente

El error más común es escribir la etiqueta de la placa como número en el código. Si en el Arduino IDE pones pinMode(4, OUTPUT), la placa no usa D4 sino GPIO 4, que es D2. En el código usa las constantes de etiqueta como D4 (existen si elegiste D1 mini como placa) o el número de GPIO de la tabla. También puedes ver el mapa de tu placa en la herramienta Pinout.

EtiquetaGPIOFunción especialNota de uso
TXGPIO 1UART TX (Monitor Serie)Envía datos al arrancar; déjalo libre si usas Serial
RXGPIO 3UART RXEn HIGH al arrancar; déjalo libre si usas Serial
D0GPIO 16Despertar del deep sleep (unido a RST)Sin PWM, interrupciones ni I2C; en HIGH al arrancar
D1GPIO 5I2C SCLSeguro; pin por defecto del shield relé
D2GPIO 4I2C SDASeguro
D3GPIO 0FLASH, pull-up de 10 kΩSi está en LOW al arrancar, entra en modo programación
D4GPIO 2LED integrado (lógica invertida), pull-up de 10 kΩSi está en LOW al arrancar, la placa no inicia; pin del shield DHT
D5GPIO 14SPI SCKSeguro
D6GPIO 12SPI MISOSeguro
D7GPIO 13SPI MOSISeguro
D8GPIO 15SPI CS, pull-down de 10 kΩSi está en HIGH al arrancar, la placa no inicia; CS del shield SD
A0ADC0Entrada analógica0–3,2 V; divisor 220 kΩ / 100 kΩ en la placa
RST-Reset (activo en LOW)Se une a D0 para el deep sleep
3V3-Salida de 3,3 VAlimenta aquí tus sensores
5V-5 V del USB / entrada externa de 5 VCon USB es salida; si no, entrada de alimentación
G-GNDTierra común
Al encender, D3 (GPIO 0) y D4 (GPIO 2) deben estar en HIGH y D8 (GPIO 15) en LOW. Un botón en D3 que quede presionado al energizar, un módulo que tire D4 a LOW o un sensor que ponga D8 en HIGH impiden el arranque: el LED azul no enciende, el Monitor Serie muestra caracteres raros y tu código nunca corre. Usa esos tres pines solo con circuitos que no alteren su nivel de arranque.

En resumen, los pines que puedes usar para cualquier cosa sin miedo son D1, D2, D5, D6 y D7. D0 sirve para salidas simples y para despertar del deep sleep, pero no tiene PWM ni interrupciones. D3 y D4 sirven para botones (mientras no estén presionados al arrancar) y LEDs. Todos los pines salvo D0 tienen resistencia pull-up interna (INPUT_PULLUP); D0 solo tiene pull-down interna. En la versión 3.x del core ESP8266, analogWrite() trabaja por defecto de 0 a 255 y a 1 kHz. Cada pin entrega como mucho unos 12 mA, así que para un módulo relé, motores o tiras LED largas usa un transistor o un driver.

Instalar el Wemos D1 mini en el Arduino IDE

  1. En Archivo > Preferencias, agrega http://arduino.esp8266.com/stable/package_esp8266com_index.json en "Gestor de URLs adicionales de tarjetas"; si ya hay otras, sepáralas con una coma.
  2. Busca esp8266 en el Gestor de placas e instala el paquete de ESP8266 Community.
  3. Elige LOLIN(WEMOS) D1 R2 & mini en Herramientas > Placa > ESP8266 Boards.
  4. Si no aparece el puerto, instala el driver CH340 y usa un cable USB de datos, no uno que solo carga.
  5. Si la carga falla a 921600, baja Upload Speed a 115200.

Primer programa: hacer parpadear el LED integrado

El pequeño LED azul del módulo ESP-12 está conectado al GPIO 2 (D4) y funciona con lógica invertida: se enciende cuando el pin está en LOW y se apaga en HIGH. LED_BUILTIN vale 2 en el D1 mini, así que este código funciona sin tocar nada:

C++ (Arduino IDE)
1// D1 mini dahili LED: D4 = GPIO 2, LOW'da yanar / onboard LED: D4 = GPIO 2, lights on LOW
2void setup() {
3  pinMode(LED_BUILTIN, OUTPUT);     // LED_BUILTIN = 2 (D4)
4}
5
6void loop() {
7  digitalWrite(LED_BUILTIN, LOW);   // LED yanar (ters mantık) / LED on (inverted logic)
8  delay(500);
9  digitalWrite(LED_BUILTIN, HIGH);  // LED söner / LED off
10  delay(500);
11}
En el código, digitalWrite(D4, LOW) y digitalWrite(2, LOW) hacen lo mismo, mientras que digitalWrite(4, LOW) maneja D2. Las constantes D solo existen si elegiste D1 mini en Herramientas > Placa. El NodeMCU usa la misma equivalencia de etiquetas y GPIO que el D1 mini, así que los programas pasan de una placa a otra sin cambios.

La entrada analógica A0: el límite de 3,2 V y cómo medir voltaje

El único conversor analógico-digital (ADC) del ESP8266 en realidad mide solo de 0 a 1,0 V con 10 bits (0–1023). El D1 mini pone detrás del pin A0 un divisor de voltaje de 220 kΩ y 100 kΩ: al ADC llega Vin × 100 / (220 + 100), es decir, 3,2 V en A0 llegan al chip como 1,0 V. Por eso la fórmula para pasar el valor crudo a voltios es V = crudo × 3,2 / 1023. Para medir un voltaje mayor, agrega una resistencia en serie antes de A0: con 100 kΩ extra la parte de arriba del divisor suma 320 kΩ y el fondo de escala sube a 1,0 × (320 + 100) / 100 = 4,2 V, justo el voltaje de una celda de litio cargada. Puedes calcular otras relaciones con la herramienta Divisor de tensión.

Voltaje en A0Llega al chipanalogRead() (aprox.)
0 V0 V0
1,0 V0,31 V320
1,65 V0,52 V527
3,2 V1,0 V1023
3,3 V1,03 V1023 (saturado)
C++ (Arduino IDE)
1// A0: kartta 220k/100k bölücü, 0–3,2 V → 0–1023 / on-board 220k/100k divider, 0–3.2 V → 0–1023
2const float FULL_SCALE = 3.2;      // ek 100 kΩ seri dirençle 4.2 olur / 4.2 with an extra 100 kΩ in series
3
4void setup() {
5  Serial.begin(115200);
6}
7
8void loop() {
9  long sum = 0;
10  for (int i = 0; i < 16; i++) {   // 16 ölçümün ortalaması / average of 16 readings
11    sum += analogRead(A0);
12    delay(10);                     // Wi-Fi'ye zaman bırak / leave time for Wi-Fi
13  }
14  float raw = sum / 16.0;
15  float volts = raw * FULL_SCALE / 1023.0;
16  Serial.print("A0 ham / raw: ");
17  Serial.print(raw, 0);
18  Serial.print("  gerilim / voltage: ");
19  Serial.print(volts, 2);
20  Serial.println(" V");
21  delay(1000);
22}
No pongas más de 3,3 V en A0; conectar directo la salida de un sensor de 5 V arruina la medición y a la larga puede dañar el chip. Llamar a analogRead() sin pausa dentro de un bucle con el Wi-Fi activo puede cortar la conexión, así que espera al menos unos milisegundos entre lecturas. Además, si tu código tiene ADC_MODE(ADC_VCC), A0 queda desactivado y el ADC lee el voltaje de alimentación de la placa.

Shields del Wemos D1 mini: relé, DHT, OLED y otros

Lo mejor del D1 mini es que los shields del mismo tamaño se enchufan directo arriba o abajo de la placa gracias a los conectores hembra. Sin soldar ni cablear; pero como cada shield usa un pin fijo, tienes que asegurarte de que los shields que apilas no compartan pines. Estos son los más comunes y sus pines:

ShieldPin que usaNota
Shield reléD1 (GPIO 5)Contactos normalmente de 10 A / 250 V AC; choca con el SCL de I2C
Shield DHT (DHT11 o DHT22 Pro)D4 (GPIO 2)Mismo pin que el LED integrado; el sensor recibe el calor de la placa
Shield SHT30D1, D2 (I2C)Más preciso que un DHT; dirección I2C 0x45
Shield OLED 0,66"D1 (SCL), D2 (SDA)64×48 píxeles, controlador SSD1306, dirección 0x3C
Shield Micro SDD5, D6, D7, D8 (CS)SPI; D8 debe quedar en LOW al arrancar
Shield de bateríaNo usa pinesCarga una batería LiPo y alimenta la placa por el pin 5V

La tabla muestra la trampa más grande: el shield relé usa D1 por defecto, y ese pin también es la línea de reloj de I2C. Si apilas el relé con el shield OLED o SHT30, ninguno funciona bien. Algunas versiones del shield relé permiten cambiar el pin con un puente de soldadura en la parte de atrás; si la tuya no, conecta el relé con un cable a D5–D7. Si pones el shield DHT directo sobre la placa, el calor del ESP8266 hace que marque 1–3 °C de más; aléjalo con una base doble (dual base) o un cable corto. Este código usa juntos el shield DHT y el shield relé como un termostato simple para un ventilador:

C++ (Arduino IDE)
1#include <DHT.h>
2
3const uint8_t DHT_PIN = 2;       // D4 = GPIO 2 (DHT shield)
4const uint8_t RELAY_PIN = 5;     // D1 = GPIO 5 (röle shield / relay shield)
5const float ON_ABOVE = 28.0;     // bunun üstünde fan açılır / fan on above this
6const float OFF_BELOW = 26.5;    // bunun altında kapanır (histerezis) / off below this (hysteresis)
7
8DHT dht(DHT_PIN, DHT11);         // DHT Pro shield için DHT22 / DHT22 for the DHT Pro shield
9bool fanOn = false;
10
11void setup() {
12  Serial.begin(115200);
13  pinMode(RELAY_PIN, OUTPUT);
14  digitalWrite(RELAY_PIN, LOW);  // röle kapalı başlasın / start with the relay off
15  dht.begin();
16}
17
18void loop() {
19  float t = dht.readTemperature();
20  if (!isnan(t)) {                                // hatalı ölçümü atla / skip failed readings
21    if (!fanOn && t > ON_ABOVE) fanOn = true;
22    if (fanOn && t < OFF_BELOW) fanOn = false;
23    digitalWrite(RELAY_PIN, fanOn ? HIGH : LOW);  // HIGH = röle çeker / HIGH = relay on
24    Serial.print(t, 1);
25    Serial.println(fanOn ? " C  fan ON" : " C  fan OFF");
26  }
27  delay(2000);
28}

Los dos umbrales del código (prende a 28 °C, apaga a 26,5 °C) forman una histéresis: con un solo umbral, el relé haría clic cada segundo mientras la temperatura oscila entre 28,0 y 28,1, y se gastarían el relé y el ventilador. Para conectar un relé con seguridad, mira ¿Qué es un módulo relé?. El shield OLED es una pantalla SSD1306 diminuta de 64×48 píxeles; la librería estándar Adafruit SSD1306 no soporta ese tamaño, así que lo más fácil es usar la librería U8g2. Este ejemplo muestra el voltaje de A0 como número y como barra:

C++ (Arduino IDE)
1#include <Wire.h>
2#include <U8g2lib.h>
3
4// 0,66" OLED shield: 64×48, I2C D1 (SCL) / D2 (SDA) / 0.66" OLED shield: 64×48, I2C on D1/D2
5U8G2_SSD1306_64X48_ER_F_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
6
7void setup() {
8  oled.begin();
9}
10
11void loop() {
12  float volts = analogRead(A0) * 3.2 / 1023.0;      // A0 → volt
13  oled.clearBuffer();
14  oled.setFont(u8g2_font_6x10_tf);
15  oled.drawStr(0, 10, "D1 mini");
16  oled.setCursor(0, 28);
17  oled.print(volts, 2);
18  oled.print(" V");
19  oled.drawFrame(0, 36, 64, 10);                    // çubuk çerçevesi / bar frame
20  oled.drawBox(2, 38, (int)(volts / 3.2 * 60), 6);  // gerilim çubuğu / voltage bar
21  oled.sendBuffer();
22  delay(500);
23}

Deep sleep: el puente D0–RST y el uso con baterías

En deep sleep el ESP8266 apaga por completo el procesador y el Wi-Fi; solo sigue andando su temporizador RTC interno. Cuando se cumple el tiempo, el RTC pone GPIO 16 (D0) en LOW por un instante. Si D0 está unido al pin RST, ese pulso reinicia el chip y tu código vuelve a empezar desde setup(). Sin el puente, la placa nunca despierta. Como despertar es un reinicio, las variables normales se pierden; los datos chicos, como un contador de lecturas, puedes guardarlos en los 512 bytes de memoria de usuario del RTC. Cada siesta dura como máximo unas 3,5 horas; para periodos más largos, vuelve a dormir la placa varias veces seguidas.

EstadoConsumo aproximado
Enviando datos por Wi-Fi70–170 mA
Wi-Fi conectado, en reposo (modem sleep)15–20 mA
Light sleepAlrededor de 1 mA
Deep sleep (solo el chip ESP8266)Alrededor de 20 µA
Deep sleep (toda la placa D1 mini)80–200 µA (por el regulador y el chip USB-serie)
C++ (Arduino IDE)
1// D0 (GPIO 16) ile RST arasına kablo tak / wire D0 (GPIO 16) to RST
2const uint64_t SLEEP_US = 10ULL * 60 * 1000000;   // 10 dakika, mikrosaniye / 10 minutes in µs
3
4void setup() {
5  Serial.begin(115200);
6  delay(100);
7  float volts = analogRead(A0) * 3.2 / 1023.0;     // ölç / measure
8  Serial.print("A0: ");
9  Serial.print(volts, 2);
10  Serial.println(" V");
11  // Wi-Fi ile gönderim burada yapılır / send the reading over Wi-Fi here
12  Serial.println("10 dk uyku / sleeping 10 min");
13  ESP.deepSleep(SLEEP_US);                         // uyanınca setup() baştan başlar / wakes up into setup()
14}
15
16void loop() {
17  // buraya hiç gelinmez / never reached
18}

La duración de la batería se puede estimar con una cuenta rápida. Supón que la placa despierta cada 10 minutos, consume en promedio 80 mA durante 5 segundos mientras envía datos y duerme a 0,15 mA los 595 segundos restantes. Cada ciclo gasta 5 × 80 = 400 mAs más 595 × 0,15 ≈ 89 mAs; en total 489 mAs, o sea un promedio de 0,82 mA en 600 segundos. Una pila 18650 de 2000 mAh dura entonces 2000 / 0,82 ≈ 2440 horas, aproximadamente 100 días. Haz la cuenta con tus propios valores en la herramienta Duración de la batería, y mira la versión ESP32 del tema en ESP32 Deep Sleep.

Con el puente D0–RST puesto, algunas placas dan problemas para cargar el código; si la carga falla, saca el cable un momento. En lugar de un cable directo, una resistencia de 470 Ω–1 kΩ o un diodo Schottky (cátodo del lado de D0) hacen que el botón RESET y la carga automática funcionen sin problemas. Mientras uses deep sleep, no uses D0 para ninguna otra cosa.

¿Wemos D1 mini, NodeMCU o D1 mini ESP32?

PlacaChipLo que la destaca¿Cuándo elegirla?
Wemos D1 miniESP8266Muy chica, sistema de shieldsSensores Wi-Fi pequeños, proyectos con shields
NodeMCU V3ESP8266Más grande, pines rotuladosPrototipos cómodos en la protoboard
D1 mini ESP32 (MiniKit)ESP32-WROOM-32Distribución D1 mini + fila interior extraBluetooth, más canales ADC y más memoria
LOLIN S2 mini / C3 miniESP32-S2 / ESP32-C3Tamaño D1 mini y compatible con shieldsUSB nativo (S2), BLE y bajo consumo (C3)

En las placas D1 mini ESP32, las filas de pines exteriores coinciden con los shields del D1 mini, así que puedes poner el shield relé u OLED tal cual. Eso sí, en el ESP32 las etiquetas D corresponden a otros GPIO; los pines I2C, por ejemplo, son D1 = GPIO 22 y D2 = GPIO 21. En el código usa WiFi.h en lugar de ESP8266WiFi.h y cambia los números de pin según el mapa de la placa. La versión ESP32 lee las entradas analógicas con 12 bits (0–4095), tiene Bluetooth y mucha más memoria. Si no sabes cuál elegir, compara ¿Qué es el ESP32? con NodeMCU ESP8266.

Ideas de proyectos con el Wemos D1 mini

  • Termómetro Wi-Fi a batería: Con un shield SHT30 o DHT, el shield de batería y deep sleep, envía una lectura cada 10 minutos.
  • Enchufe inteligente: Prende una lámpara desde el celular con el shield relé; para un cableado seguro, lee la guía del módulo relé.
  • Controlador de tira LED: Instala WLED y maneja una tira WS2812B desde el celular.
  • Sensor de puerta: Manda un aviso cuando se abre la puerta con un reed switch.
  • Mini pantalla de escritorio: Muestra la hora, el clima o pequeñas gráficas en el shield OLED, igual que en una pantalla OLED más grande.
  • Sensor para casa inteligente: Envía los valores a Home Assistant por MQTT.

Errores comunes y soluciones

SíntomaCausa probableSolución
No aparece el puertoFalta el driver CH340 o el cable solo cargaInstala el driver, usa un cable de datos
Responde el pin equivocadoEn el código dice 4 en vez de D4Usa las constantes D o el GPIO de la tabla
La placa no arranca, el código no correUn circuito en D3, D4 o D8 altera el nivel de arranquePasa el circuito a pines seguros (D1, D2, D5–D7)
El Wi-Fi se corta seguidoanalogRead() sin pausa o alimentación débilPon una pausa entre lecturas, usa una buena fuente de 5 V
No despierta del deep sleepD0 no está unido a RSTUne D0 con RST con un cable, una resistencia o un diodo
El relé y la OLED no funcionan juntosLos dos usan D1Cambia el pin del relé o conéctalo con cable a otro pin
El LED funciona al revésEl LED integrado enciende en LOWInvierte la lógica: LOW = encendido, HIGH = apagado
Si la placa se reinicia una y otra vez, abre el Monitor Serie a 74880 baudios. El cargador de arranque del ESP8266 escribe a esa velocidad las líneas "rst cause" y "boot mode"; rst cause:2, por ejemplo, indica el botón RESET o un despertar del deep sleep, y rst cause:4 un reinicio por watchdog, así encuentras rápido el origen del problema.

Por su tamaño mínimo, su sistema de shields y su Wi-Fi, el Wemos D1 mini es una de las puertas más fáciles a la domótica y a los proyectos con sensores. Si tienes presente la tabla de pines y las reglas de arranque, casi cualquier ejemplo de ESP8266 te va a funcionar a la primera. En la app BlueGrays encontrarás diagramas y código paso a paso en los proyectos ESP (parpadeo de LED, conexión Wi-Fi, servidor web, OTA y deep sleep), y puedes probarlos también en el D1 mini adaptando los pines con esta tabla.

Preguntas frecuentes

¿Qué GPIO es D4 en el Wemos D1 mini?

D4 es el GPIO 2, y ahí está conectado también el LED azul integrado. En el código puedes escribir pinMode(D4, OUTPUT) o pinMode(2, OUTPUT); en cambio, pinMode(4, OUTPUT) selecciona D2. El LED funciona con lógica invertida, así que enciende en LOW.

¿El Wemos D1 mini funciona con 5 V?

Sí, la placa se puede alimentar con 5 V por USB o por el pin 5V; el regulador los baja a 3,3 V. Pero los pines GPIO trabajan con lógica de 3,3 V, así que los sensores con salida de 5 V conviene conectarlos con un divisor de tensión o un conversor de nivel.

¿Cuántos voltios lee el pin A0 del Wemos D1 mini?

Gracias al divisor de 220 kΩ / 100 kΩ de la placa, el pin A0 lee de 0 a 3,2 V como 0–1023. El chip ESP8266 solo, sin divisor, mide apenas de 0 a 1,0 V. Si agregas una resistencia de 100 kΩ en serie antes de A0, el rango sube a 4,2 V y puedes leer una batería de litio.

¿Por qué el Wemos D1 mini no despierta del deep sleep?

Para despertar, el ESP8266 necesita el pulso de reset que el RTC saca por D0 (GPIO 16). Si no unes D0 con RST mediante un cable, una resistencia de 470 Ω–1 kΩ o un diodo Schottky, la placa se queda dormida. Revisa también que el tiempo esté en microsegundos.

¿Qué diferencia hay entre el Wemos D1 mini y el NodeMCU?

Los dos usan el mismo chip ESP8266 y sus etiquetas D0–D8 corresponden a los mismos GPIO, así que los programas funcionan sin cambios. El D1 mini es mucho más chico y admite shields apilables; el NodeMCU es más grande y más cómodo en la protoboard.

¿El Wemos D1 mini tiene Bluetooth?

No, el ESP8266 solo tiene Wi-Fi. Si necesitas Bluetooth, usa un D1 mini ESP32 o la LOLIN C3 mini con ESP32-C3, que tienen el mismo tamaño y también aceptan los shields del D1 mini.

Ver todos los proyectos
LED Parpadeante con ESP32
ES-1Principiante

LED Parpadeante con ESP32

Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

4.7(37)
108
Parpadeo del LED interno del ESP32
ES-4Principiante

Parpadeo del LED interno del ESP32

Parpadeo del LED azul incorporado en el ESP32 DevKit V1. ¡No se necesitan componentes externos! El primer proyecto que debe probar cuando compra un ESP32. GPIO 2 está conectado al LED interno.

4.8(29)
54
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
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
Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
ES-33Avanzado
Premium

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)

El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

4.3(10)
16
Actualización OTA del ESP32 — Instalación inalámbrica del firmware (con pantalla LCD)
ES-30Avanzado
Premium

Actualización OTA del ESP32 — Instalación inalámbrica del firmware (con pantalla LCD)

Aprenderás a cargar un firmware nuevo en el ESP32 por Wi-Fi, sin cable USB. Con la biblioteca ArduinoOTA, el ESP32 se hace visible en la red y aparece automáticamente como bluegrays-ota en la pestaña "Network port" del Arduino IDE. La primera carga se hace por USB; después, todas las actualizaciones son inalámbricas, algo clave para los dispositivos instalados sobre el terreno.

4.6(14)
22
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
Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
ES-37Avanzado
Premium

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)

Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.

4.3(6)
11