Componentes · 9 min de lectura

ESPDuino-32 pines: equivalencias con el Uno, shields y Wi-Fi

Pines del ESPDuino-32: tabla de equivalencias con el Arduino Uno, la trampa de 3,3 V, qué shields no funcionan, la placa en el IDE de Arduino y un primer Wi-Fi.

El ESPDuino-32 es una placa de desarrollo que lleva un ESP32 al tamaño y a la distribución de pines de un Arduino Uno: por fuera parece un Uno, pero tiene un procesador de doble núcleo a 240 MHz, Wi-Fi y Bluetooth. Es un diseño de DOIT y una placa casi idéntica se vende como WEMOS D1 R32. En esta guía relacionamos uno por uno los pines del ESPDuino-32 con los del Uno, vemos qué shields del Uno funcionan y cuáles no, y explicamos cómo elegir la placa en el IDE de Arduino.

Su gran atractivo es que puedes montar los shields del Uno que ya tienes y sumarle Wi-Fi a tu proyecto. Pero hay una trampa importante: el Uno trabaja a 5 V, mientras que todos los pines de señal del ESPDuino-32 trabajan a 3,3 V y no toleran 5 V. Los shields y los sensores no conocen esa diferencia, y con una conexión equivocada puedes quemar un pin o incluso la placa entera. Conozcamos primero la placa.

Placa de desarrollo ESPDuino-32
ESPDuino-32: un módulo ESP32-WROOM-32 en una placa del tamaño del Uno, con chip USB-serie, conector DC (jack) y los headers en el mismo lugar que en el Uno.

¿Qué es el ESPDuino-32? Comparación con el Uno y el ESP32 DevKit

En el corazón del ESPDuino-32 está el módulo ESP32-WROOM-32, el mismo de las placas ESP32 clásicas. En cuanto al software es un ESP32 común y corriente: todos los sketches y librerías escritos para el ESP32 funcionan en él. La diferencia está en el diseño de la placa: los pines llegan a headers con el formato del Uno y se suman un conector DC, un regulador de 3,3 V y un conversor USB-serie (casi siempre un CH340). Si nunca usaste un ESP32, tienes lo básico en ¿Qué es el ESP32?

CaracterísticaArduino Uno R3ESPDuino-32ESP32 DevKit
ProcesadorATmega328P, 8 bits, 16 MHzESP32, doble núcleo, 240 MHzESP32, doble núcleo, 240 MHz
RAM2 KB520 KB520 KB
Flash32 KB4 MB4 MB
Nivel lógico5 V3,3 V3,3 V
InalámbricoNoWi-Fi + BluetoothWi-Fi + Bluetooth
Entradas analógicas6 canales, 10 bits6 canales en el header del Uno, 12 bitsHasta 18 canales, 12 bits
Tamaño y shields68,6 × 53,4 mm, shields del UnoMismo tamaño que el Uno, acepta shieldsEntra en la protoboard, sin shields
Chip USBATmega16U2Casi siempre CH340CP2102 o CH340

¿Cuál te conviene comprar? Si tienes shields del Uno, quieres atornillar la placa en una caja usando los agujeros del Uno o sigues un libro o curso pensado para el Uno, el ESPDuino-32 te facilita la vida. Si trabajas en protoboard, necesitas pines del ESP32 que no llegan al header del Uno, como GPIO 32 y 33, o el tamaño del equipo importa, el ESP32 DevKit clásico es mejor opción. El código es el mismo en las dos; solo cambian los números de pin.

Pines del ESPDuino-32: ¿qué GPIO hay detrás de cada pin del Uno?

Aunque la placa está rotulada D2, D3, A0 como un Uno, en el código casi siempre tienes que escribir el número de GPIO. La tabla muestra el GPIO del ESP32 que corresponde a cada pin del Uno y qué cuidar al usarlo. También puedes consultar la lista completa de pines del ESP32 en la herramienta Pinout.

Pin del UnoGPIO del ESP32EstadoNota
D0 (RX)GPIO 3No usarLínea serie del USB
D1 (TX)GPIO 1No usarLínea serie del USB
D2GPIO 26SeguroTambién sirve como salida DAC2
D3GPIO 25SeguroTambién sirve como salida DAC1
D4GPIO 17SeguroTambién se usa como TX de Serial2
D5GPIO 16SeguroTambién se usa como RX de Serial2
D6GPIO 27SeguroEntrada táctil (T7)
D7GPIO 14Con cuidadoSaca una señal PWM breve al arrancar
D8GPIO 12Con cuidadoPin de arranque: si está en HIGH al encender, la placa no arranca
D9GPIO 13SeguroEntrada y salida de uso general
D10GPIO 5Con cuidadoSPI SS; saca una señal PWM breve al arrancar
D11GPIO 23SeguroSPI MOSI
D12GPIO 19SeguroSPI MISO
D13GPIO 18SeguroSPI SCK; a diferencia del Uno, no tiene LED
A0GPIO 2Con cuidadoADC2 (no lee con Wi-Fi encendido), LED integrado, pin de arranque
A1GPIO 4Con cuidadoADC2 (no lee con Wi-Fi encendido)
A2GPIO 35Solo entradaADC1, funciona junto con el Wi-Fi
A3GPIO 34Solo entradaADC1, funciona junto con el Wi-Fi
A4GPIO 36 (VP)Solo entradaADC1; no es SDA como en el Uno
A5GPIO 39 (VN)Solo entradaADC1; no es SCL como en el Uno
SDAGPIO 21SeguroLínea de datos I2C
SCLGPIO 22SeguroLínea de reloj I2C
Aquí A4 y A5 no son I2C. En el Uno, A4 y A5 son también SDA y SCL; en el ESPDuino-32 van a GPIO 36 y 39 y solo funcionan como entradas. Para pantallas y sensores I2C usa los pines separados SDA (GPIO 21) y SCL (GPIO 22) que están junto a AREF.

En la parte analógica hay dos trampas más. La primera: A0 (GPIO 2) y A1 (GPIO 4) pertenecen a la unidad ADC2 del ESP32, que no puede leer mientras el Wi-Fi está encendido; en proyectos con Wi-Fi conecta los sensores analógicos a A2–A5 (ADC1). La segunda: el ADC del ESP32 es de 12 bits, así que analogRead() devuelve 0–4095 en lugar de 0–1023, y la escala completa es de unos 3,3 V, no de 5 V. Las cuentas tipo "valor × 5,0 / 1023" de los sketches del Uno tienen que cambiar; mejor todavía, usa analogReadMilliVolts(), que entrega un resultado calibrado en milivoltios.

La trampa de 3,3 V: ¿funcionan los shields del Uno en el ESPDuino-32?

Que un shield encaje no quiere decir que funcione. Un shield da problemas en el ESPDuino-32 de tres maneras: manda una señal de 5 V al ESP32 y daña el pin, espera lógica de 5 V y no siempre toma 3,3 V como HIGH, o deja en los pines A2–A5, que son solo de entrada, una tarea que necesita una salida. Como el pin 5V de la placa entrega 5 V igual que el Uno, el shield sí se alimenta; los problemas aparecen siempre en los pines de señal. Así les va a los shields más comunes:

Shield controlador de motores L293D
Shield de motores L293D: su registro de desplazamiento 74HC595 trabaja a 5 V, así que apenas reconoce las señales de 3,3 V del ESPDuino-32.
ShieldEstadoPor qué
CNC Shield V3 (A4988 / DRV8825)Casi siempre funcionaSTEP y DIR caen en GPIO que pueden ser salidas; las versiones de GRBL para ESP32 traen un mapa de pines listo para esta placa
Shield de relés (módulo relé)Casi siempre funcionaLos relés se alimentan del pin 5V y el transistor que los maneja conduce también con una señal de 3,3 V
Shield data logger (tarjeta SD + RTC)En parteUna SD en D10–D13 funciona, porque esos son los pines SPI del ESP32; el RTC falla si su I2C solo llega a A4/A5
Shield de motores L293DInestableEl 74HC595 a 5 V apenas lee entradas de 3,3 V y su línea de datos está en D8 (GPIO 12), que además puede impedir el arranque
Shield LCD KeypadRiesgosoLos botones llegan a A0 por una escalera de resistencias conectada a 5 V, así que GPIO 2 recibe 5 V cuando no hay botón presionado
Shield TFT paralelo de 2,4 pulgadasNo funcionaSus líneas de control están en A0–A4; A2, A3 y A4 son solo de entrada y no pueden manejar la pantalla
Shields viejos que toman el I2C solo de A4/A5No funcionaEn el ESPDuino-32 el I2C está en los pines SDA/SCL separados (GPIO 21/22)
Para saber si un shield es compatible, mira su esquema y hazte dos preguntas: ¿manda una señal de 5 V a algún pin? ¿Usa alguno de los pines A2–A5 como salida? Si las dos respuestas son no, lo más probable es que funcione. Si una sola línea manda 5 V, intercala un divisor de voltaje o un conversor de nivel lógico.

Pines de arranque (strapping): cuidado con D8 y A0

Al encender, el ESP32 revisa el nivel de algunos pines para decidir cómo arrancar. En el ESPDuino-32 dos de ellos llegan al header del Uno. Si D8 (GPIO 12) está en HIGH al arrancar, el ESP32 intenta iniciar su memoria flash con el voltaje equivocado y la placa no arranca. A0 (GPIO 2) tiene que estar al aire o en LOW mientras subes el código. Si conectaste a D8 un módulo o shield con pull-up y la placa no arranca, ese es tu primer sospechoso. D7 (GPIO 14) y D10 (GPIO 5) también sacan una señal PWM breve al arrancar, así que un relé en esos pines puede hacer un clic corto al encender.

Instalación del ESPDuino-32 y elección de placa en el IDE de Arduino

  1. Instala en el IDE de Arduino el paquete de placas esp32 de Espressif; los pasos están en ¿Qué es el ESP32?
  2. Conecta la placa por USB. Si no aparece el puerto, instala el driver de su chip USB (casi siempre un CH340) y verifica que tu cable sea de datos.
  3. En Herramientas > Placa > esp32 elige WEMOS D1 R32: en esta definición los nombres D2–D13 y A0–A5 coinciden exactamente con lo rotulado en la placa. DOIT ESPduino32 o ESP32 Dev Module también funcionan, pero entonces tienes que usar solo números de GPIO.
  4. Elige el puerto de la placa; si la carga falla con Upload Speed en 921600, bájala a 115200.
  5. Pulsa Subir y abre el Monitor Serie a 115200 baudios. Si la placa no entra en modo de carga, revisa las soluciones de ESP32 Failed to Connect.
La placa que elijas cambia lo que significa A0. Con ESP32 Dev Module seleccionada, el A0 de tu código apunta a GPIO 36, es decir, al pin que en el ESPDuino-32 dice A4; con DOIT ESPduino32, según la versión del núcleo, A0 puede no estar definido y el compilador se detiene con un error. La forma más fácil de evitar la confusión es usar siempre números de GPIO en el código.

Primera prueba: LED integrado, D13 y una lectura analógica

El LED azul integrado de la placa está en GPIO 2, no en D13 como en el Uno. El sketch de abajo enciende por turnos el LED integrado y un LED conectado a D13 (GPIO 18) con una resistencia de 220 Ω, y muestra en el Monitor Serie el valor de un potenciómetro conectado a A2 (GPIO 35). Conecta las patas extremas del potenciómetro a 3V3 y GND, no a 5V; la pata central va a A2.

C++ (Arduino IDE)
1// ESPDuino-32: Uno adları yerine GPIO numaraları / GPIO numbers instead of Uno pin names
2const int ONBOARD_LED = 2;    // kart üstü mavi LED (A0 ile aynı pin) / onboard blue LED (same pin as A0)
3const int LED_D13 = 18;       // Uno D13 = GPIO 18
4const int POT_A2 = 35;        // Uno A2 = GPIO 35 (ADC1, yalnız giriş / input only)
5
6void setup() {
7  Serial.begin(115200);
8  pinMode(ONBOARD_LED, OUTPUT);
9  pinMode(LED_D13, OUTPUT);
10  analogReadResolution(12);                      // 0–4095 (varsayılan / default)
11}
12
13void loop() {
14  int raw = analogRead(POT_A2);                  // 0–4095, Uno'daki gibi 0–1023 değil / not 0–1023 like the Uno
15  int mv = analogReadMilliVolts(POT_A2);         // kalibre edilmiş mV / calibrated millivolts
16  Serial.printf("A2 ham / raw: %d  gerilim / voltage: %d mV\n", raw, mv);
17
18  digitalWrite(ONBOARD_LED, HIGH);               // LED'ler sırayla / LEDs take turns
19  digitalWrite(LED_D13, LOW);
20  delay(500);
21  digitalWrite(ONBOARD_LED, LOW);
22  digitalWrite(LED_D13, HIGH);
23  delay(500);
24}

Primer proyecto Wi-Fi: controlar un LED desde el celular

Ahora veamos lo que de verdad diferencia a esta placa del Uno. El sketch de abajo conecta el ESPDuino-32 a la red de tu casa y levanta un pequeño servidor web. Escribe la IP que aparece en el Monitor Serie en el navegador de un celular conectado a la misma red y verás un botón que enciende y apaga el LED de D13 y la lectura del potenciómetro de A2 en milivoltios. Pusimos el potenciómetro en A2 a propósito: con el Wi-Fi encendido, A0 y A1 no pueden leer valores analógicos.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
5const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
6
7const int LED_PIN = 18;                   // Uno D13 = GPIO 18
8const int POT_PIN = 35;                   // Uno A2 = GPIO 35 (ADC1: Wi-Fi ile çalışır / works with Wi-Fi)
9
10WebServer server(80);
11bool ledOn = false;
12
13String page() {
14  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
15  html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
16  html += "<title>ESPDuino-32</title></head>";
17  html += "<body style='font-family:sans-serif;text-align:center'><h1>ESPDuino-32</h1>";
18  html += "<p>LED (D13): <b>" + String(ledOn ? "ON" : "OFF") + "</b></p>";
19  html += "<p><a href='/toggle'><button style='font-size:24px;padding:12px 32px'>LED</button></a></p>";
20  html += "<p>A2: " + String(analogReadMilliVolts(POT_PIN)) + " mV</p>";
21  html += "</body></html>";
22  return html;
23}
24
25void handleRoot() {
26  server.send(200, "text/html", page());
27}
28
29void handleToggle() {
30  ledOn = !ledOn;
31  digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
32  server.sendHeader("Location", "/");      // ana sayfaya dön / back to the main page
33  server.send(303);
34}
35
36void setup() {
37  Serial.begin(115200);
38  pinMode(LED_PIN, OUTPUT);
39
40  WiFi.mode(WIFI_STA);
41  WiFi.begin(WIFI_SSID, WIFI_PASS);
42  Serial.print("Baglaniyor / Connecting");
43  while (WiFi.status() != WL_CONNECTED) {  // bağlanana kadar bekle / wait until connected
44    delay(500);
45    Serial.print(".");
46  }
47  Serial.println();
48  Serial.print("IP: ");
49  Serial.println(WiFi.localIP());          // bu adresi telefonda aç / open this address on your phone
50
51  server.on("/", handleRoot);
52  server.on("/toggle", handleToggle);
53  server.begin();
54}
55
56void loop() {
57  server.handleClient();                   // gelen istekleri işle / handle incoming requests
58}

El sketch define dos direcciones: / envía la página principal y /toggle cambia el estado del LED y redirige el navegador de vuelta a la página principal. Cada vez que recargas la página, el potenciómetro se vuelve a leer. Para una interfaz que se actualice en vivo sin recargar, usa el método de ESP32 Async Web Server y WebSocket. Si la placa no se conecta, comprueba que tu red sea de 2,4 GHz; el ESP32 no ve redes de 5 GHz.

Alimentación: USB, conector DC y pin 3V3

FuenteVoltajeNota
USB5 VSuficiente para desarrollo y circuitos pequeños
Conector DC (jack)Normalmente 7–12 V (revisa lo impreso en tu placa)El regulador se calienta; con 9 V trabaja más frío que con 12 V
Pin VINEl voltaje del conector DCPara alimentar la placa con una fuente externa
Pin 5VSalida de 5 VAlimenta shields y módulos de 5 V; acuérdate de bajar sus señales a 3,3 V
Pin 3V3Salida de 3,3 VPara sensores; no conectes motores ni tiras LED largas

Cuando transmite por Wi-Fi, el ESP32 puede pedir picos de casi 250 mA. Un cable o un puerto USB flojos dejan caer el voltaje en esos momentos y la placa se reinicia con "Brownout detector was triggered". Si te pasa, usa un cable corto y de buena calidad o alimenta la placa por el conector DC; los detalles están en ESP32 Brownout y Guru Meditation.

Errores comunes y cómo solucionarlos

  • Un sketch del Uno no funciona: los números de pin están pensados para el Uno. pinMode(13, OUTPUT) en el ESPDuino-32 maneja GPIO 13, que es D9 y no D13; busca el número de GPIO en la tabla.
  • analogRead da siempre 4095 o siempre 0: el sensor está alimentado con 5 V y su salida pasa de 3,3 V, o el sensor está en un pin ADC2 (A0, A1) con el Wi-Fi encendido.
  • La pantalla I2C no aparece: está conectada a A4/A5; pasa los cables a los pines SDA/SCL (GPIO 21/22).
  • La placa no arranca o se reinicia una y otra vez: algo conectado a D8 (GPIO 12) pone el pin en HIGH al encender; pasa esa pieza a otro pin.
  • Con el shield puesto se calienta la placa o alguna pieza: el shield está mandando 5 V a un pin; desconecta la placa de inmediato y baja esa línea con un divisor o un conversor de nivel.
  • SoftwareSerial o la librería Servo no compilan: en lugar de las librerías exclusivas de AVR usa sus equivalentes para ESP32: el puerto serie por hardware Serial2 y ESP32Servo.

El ESPDuino-32 es el camino más familiar para pasar del Uno al ESP32: el mismo tamaño y los mismos headers, pero con una frecuencia de reloj 15 veces mayor y conexión inalámbrica. Ten a mano Pines del Arduino Uno para recordar las diferencias. Todos los proyectos ESP32 de la app BlueGrays funcionan también en esta placa, así que puedes armar paso a paso el LED, el semáforo, la conexión Wi-Fi y el servidor web con su diagrama de circuito y su código; solo tienes que relacionar los pines con la tabla de arriba.

Preguntas frecuentes

¿El ESPDuino-32 es lo mismo que el WEMOS D1 R32?

En la práctica, sí. Los dos montan un módulo ESP32-WROOM-32 en una placa del tamaño del Uno y comparten la misma asignación de pines en los headers. El IDE de Arduino tiene una definición para cada uno, y la de WEMOS D1 R32 es más cómoda porque relaciona los rótulos D y A de la placa con los GPIO correctos.

¿Puedo usar shields del Arduino Uno en el ESPDuino-32?

Encajan físicamente, pero que funcionen depende del shield. Los que no mandan señales de 5 V al ESP32, no usan A2–A5 como salidas y no toman el I2C solo de A4/A5 suelen funcionar; los shields LCD Keypad y TFT paralelo no funcionan sin modificaciones.

¿El ESPDuino-32 funciona con 5 V?

La placa se alimenta con 5 V por USB o por el pin 5V, y también acepta un voltaje mayor por el conector DC. Sus pines de señal, en cambio, trabajan a 3,3 V y no toleran 5 V, así que los sensores con salida de 5 V necesitan un divisor de voltaje o un conversor de nivel.

¿En qué pin está el LED integrado del ESPDuino-32?

El LED azul integrado está conectado a GPIO 2, que en la placa aparece también como A0. A diferencia del Uno, en D13 no hay ningún LED, y la constante LED_BUILTIN vale 2.

¿Qué placa elijo en el IDE de Arduino para el ESPDuino-32?

Elige WEMOS D1 R32 si quieres usar en el código los rótulos del Uno, como D2 o A0. DOIT ESPduino32 o ESP32 Dev Module suben el código igual de bien, pero con ellas tienes que escribir los pines como números de GPIO.

¿Por qué no funciona analogRead en mi ESPDuino-32?

Lo más común es que el sensor esté en A0 o A1 con el Wi-Fi encendido; esos pines pertenecen al ADC2, que no puede leer mientras el Wi-Fi está activo. Pasa el sensor a A2–A5 (ADC1) y recuerda que el resultado va de 0 a 4095 con una escala completa de unos 3,3 V.

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
ESP32 Semáforo
ES-5Principiante

ESP32 Semáforo

Simulación de un semáforo real con 3 LED rojo-amarillo-verde. Los tiempos se aproximan a la lógica del tráfico real: rojo largo, amarillo corto, verde largo. Ejemplo clásico de control GPIO secuencial.

4.4(22)
45
Lectura de la intensidad luminosa con el módulo LDR del ESP32
ES-11Principiante

Lectura de la intensidad luminosa con el módulo LDR del ESP32

Visualización en tiempo real en el monitor serie del valor bruto del ADC del módulo LDR y del porcentaje relativo de luz calculado a partir de referencias de oscuridad y claridad. Este porcentaje no es una medición en lux. Explica el funcionamiento de la calibración del módulo. Es recomendable realizarlo antes del Proyecto 10, ya que se utiliza para determinar el valor umbral.

4.6(36)
55
Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
ES-13Intermedio
Premium

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)

En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

4.5(19)
32
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
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