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.

¿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ística | Valor |
|---|---|
| Chip | ESP8266EX, 32 bits, 80/160 MHz |
| Flash | 4 MB (D1 mini Pro: 16 MB) |
| RAM | 80 KB de memoria de datos (unos 40–50 KB libres con Wi-Fi activo) |
| Wi-Fi | 802.11 b/g/n, solo 2,4 GHz |
| Pines digitales | 11 (D0–D8, TX, RX) |
| Entrada analógica | 1 (A0, 0–3,2 V, 10 bits) |
| Nivel lógico | 3,3 V (se alimenta por USB o por el pin 5V) |
| Chip USB-serie | Casi siempre CH340 |
| Tamaño | 34,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.
| Etiqueta | GPIO | Función especial | Nota de uso |
|---|---|---|---|
| TX | GPIO 1 | UART TX (Monitor Serie) | Envía datos al arrancar; déjalo libre si usas Serial |
| RX | GPIO 3 | UART RX | En HIGH al arrancar; déjalo libre si usas Serial |
| D0 | GPIO 16 | Despertar del deep sleep (unido a RST) | Sin PWM, interrupciones ni I2C; en HIGH al arrancar |
| D1 | GPIO 5 | I2C SCL | Seguro; pin por defecto del shield relé |
| D2 | GPIO 4 | I2C SDA | Seguro |
| D3 | GPIO 0 | FLASH, pull-up de 10 kΩ | Si está en LOW al arrancar, entra en modo programación |
| D4 | GPIO 2 | LED integrado (lógica invertida), pull-up de 10 kΩ | Si está en LOW al arrancar, la placa no inicia; pin del shield DHT |
| D5 | GPIO 14 | SPI SCK | Seguro |
| D6 | GPIO 12 | SPI MISO | Seguro |
| D7 | GPIO 13 | SPI MOSI | Seguro |
| D8 | GPIO 15 | SPI CS, pull-down de 10 kΩ | Si está en HIGH al arrancar, la placa no inicia; CS del shield SD |
| A0 | ADC0 | Entrada analógica | 0–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 V | Alimenta aquí tus sensores |
| 5V | - | 5 V del USB / entrada externa de 5 V | Con USB es salida; si no, entrada de alimentación |
| G | - | GND | Tierra común |
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
- 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.
- Busca esp8266 en el Gestor de placas e instala el paquete de ESP8266 Community.
- Elige LOLIN(WEMOS) D1 R2 & mini en Herramientas > Placa > ESP8266 Boards.
- Si no aparece el puerto, instala el driver CH340 y usa un cable USB de datos, no uno que solo carga.
- 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:
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}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 A0 | Llega al chip | analogRead() (aprox.) |
|---|---|---|
| 0 V | 0 V | 0 |
| 1,0 V | 0,31 V | 320 |
| 1,65 V | 0,52 V | 527 |
| 3,2 V | 1,0 V | 1023 |
| 3,3 V | 1,03 V | 1023 (saturado) |
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}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:
| Shield | Pin que usa | Nota |
|---|---|---|
| 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 SHT30 | D1, 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 SD | D5, D6, D7, D8 (CS) | SPI; D8 debe quedar en LOW al arrancar |
| Shield de batería | No usa pines | Carga 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:
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:
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.
| Estado | Consumo aproximado |
|---|---|
| Enviando datos por Wi-Fi | 70–170 mA |
| Wi-Fi conectado, en reposo (modem sleep) | 15–20 mA |
| Light sleep | Alrededor 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) |
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.
¿Wemos D1 mini, NodeMCU o D1 mini ESP32?
| Placa | Chip | Lo que la destaca | ¿Cuándo elegirla? |
|---|---|---|---|
| Wemos D1 mini | ESP8266 | Muy chica, sistema de shields | Sensores Wi-Fi pequeños, proyectos con shields |
| NodeMCU V3 | ESP8266 | Más grande, pines rotulados | Prototipos cómodos en la protoboard |
| D1 mini ESP32 (MiniKit) | ESP32-WROOM-32 | Distribución D1 mini + fila interior extra | Bluetooth, más canales ADC y más memoria |
| LOLIN S2 mini / C3 mini | ESP32-S2 / ESP32-C3 | Tamaño D1 mini y compatible con shields | USB 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íntoma | Causa probable | Solución |
|---|---|---|
| No aparece el puerto | Falta el driver CH340 o el cable solo carga | Instala el driver, usa un cable de datos |
| Responde el pin equivocado | En el código dice 4 en vez de D4 | Usa las constantes D o el GPIO de la tabla |
| La placa no arranca, el código no corre | Un circuito en D3, D4 o D8 altera el nivel de arranque | Pasa el circuito a pines seguros (D1, D2, D5–D7) |
| El Wi-Fi se corta seguido | analogRead() sin pausa o alimentación débil | Pon una pausa entre lecturas, usa una buena fuente de 5 V |
| No despierta del deep sleep | D0 no está unido a RST | Une D0 con RST con un cable, una resistencia o un diodo |
| El relé y la OLED no funcionan juntos | Los dos usan D1 | Cambia el pin del relé o conéctalo con cable a otro pin |
| El LED funciona al revés | El LED integrado enciende en LOW | Invierte la lógica: LOW = encendido, HIGH = apagado |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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.

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.

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.

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).

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.

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.

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/.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

