Guía Completa del controlador ESP32 Wemos D1 R32

Introducción

El WeMos D1 R32 es una placa de desarrollo basada en el chip ESP32-WROOM-32 de Espressif Systems, diseñada para ser compatible con el formato y las placas de expansión (shields) de Arduino UNO. Esta placa combina la potencia del procesador ESP32 con conectividad WiFi y Bluetooth integrada, todo en un formato compacto que facilita su uso en proyectos de IoT (Internet de las Cosas), domótica y electrónica embebida.

Con un precio accesible y capacidades avanzadas, el Wemos D1 R32 se ha convertido en una de las opciones más populares entre makers, desarrolladores y estudiantes que buscan una alternativa potente y económica a las placas Arduino tradicionales.

Índice

1. Especificaciones Técnicas
2. Características Principales
3. Pinout y Diagrama de Pines
4. Diferencias con Arduino UNO
5. Configuración del Entorno de Desarrollo
6. Instalación de Drivers
7. Ejemplos de Código
8. Proyectos Prácticos
9. Consideraciones de Alimentación
10. Modos de Bajo Consumo
11. Bibliotecas Recomendadas
12. Solución de Problemas
13. Recursos Adicionales

Especificaciones Técnicas

Características Principales

Procesador Dual Core

El ESP32 cuenta con un procesador doble núcleo Tensilica Xtensa LX6 de 32 bits, que puede operar a 160 MHz o ser overclockeado hasta 240 MHz. Esta arquitectura permite ejecutar tareas simultáneas de manera eficiente, ideal para aplicaciones que requieren multitarea o procesamiento en tiempo real.

Conectividad Inalámbrica Integrada

• WiFi 802.11 b/g/n: Soporta modos Station, SoftAP y Station+AP simultáneamente
• Bluetooth 4.2: Incluye tanto Bluetooth Classic (BR/EDR) como Bluetooth Low Energy (BLE)
• Antena integrada: Antena de trazas PCB en formato F inverted (PIFA)

Gestión de Energía Avanzada

El ESP32 ofrece múltiples modos de bajo consumo:

Periféricos Integrados

• Conversores ADC: 18 canales de 12 bits (0-3.3 V)
• Conversores DAC: 2 canales de 8 bits
• Sensores capacitivos: 10 pines con detección táctil
• Sensor de efecto Hall: Integrado en el chip
• Interfaz IR: Control remoto infrarrojo (TX/RX, hasta 8 canales)

Pinout y Diagrama de Pines

Distribución de Pines

El Wemos D1 R32 tiene una distribución de pines similar a Arduino UNO, facilitando la compatibilidad con shields existentes.

Pines Digitales Principales

Pines Analógicos

Nota Importante: Los pines ADC3 (GPIO34, GPIO35, GPIO36, GPIO39) son solo de entrada (input only) y no tienen buffers internos.

Pines No Recomendados para Uso General

Diferencias con Arduino UNO

Consideraciones de Voltaje

⚠️ Importante: El Wemos D1 R32 opera a 3.3 V, no a 5 V como Arduino UNO. Conectar directamente dispositivos de 5 V a los pines GPIO puede dañar la placa. Utilice convertidores de nivel lógico cuando sea necesario.

Configuración del Entorno de Desarrollo

Instalación del Arduino IDE

1. Descargue el Arduino IDE desde arduino.cc
2. Instale la versión más reciente (recomendado Arduino IDE 2.x)
3. Abra el Arduino IDE

Configuración del Gestor de Placas ESP32

Paso 1: Agregar URL del Board Manager

1. Vaya a Archivo → Preferencias
2. En el campo "URLs adicionales para el gestor de tarjetas", pegue:

   https://dl.espressif.com/dl/package_esp32_index.json
   

3. Haga clic en OK

Paso 2: Instalar el Soporte ESP32

1. Vaya a Herramientas → Placa → Gestor de tarjetas
2. Busque "ESP32"
3. Instale el paquete "esp32" por Espressif Systems
4. La versión recomendada es 2.0.x o superior

Paso 3: Seleccionar la Placa

1. Vaya a Herramientas → Placa
2. Seleccione "ESP32 Dev Module" o "DOIT ESP32 DEVKIT V1"

Paso 4: Configuración Recomendada

Instalación de Drivers

Controlador CH340G

El Wemos D1 R32 utiliza el chip CH340G para la conversión USB a serie. Este controlador puede no estar instalado por defecto en algunos sistemas.

Windows

1. Descargue el controlador CH340 desde: WCH CH340 Driver
2. Ejecute SETUP.EXE como administrador
3. Reinicie el sistema si es necesario
4. Verifique en el Administrador de Dispositivos que aparezca "USB-SERIAL CH340"

macOS

1. Descargue el controlador desde: WCH macOS Driver
2. Descomprima y ejecute el instalador
3. Puede requerir permitir la instalación en Preferencias del Sistema → Seguridad y Privacidad

Linux

El controlador CH340 está incluido en el kernel de Linux moderno. Simplemente conecte la placa y debería funcionar automáticamente. Verifique con:

dmesg | grep tty

Ejemplos de Código

Hola Mundo con Multitarea

Este ejemplo demuestra el uso de las tareas del ESP32 para ejecutar código concurrentemente:

void setup() {
  Serial.begin(115200);
  pinMode(2, OUTPUT);
  vTaskDelay(1000 / portTICK_PERIOD_MS);
  
  // Crear dos tareas simultáneas
  xTaskCreate(task1, "task1", 2048, NULL, 1, NULL);
  xTaskCreate(task2, "task2", 2048, NULL, 1, NULL);
}

void loop() {
  vTaskDelay(1000 / portTICK_PERIOD_MS);
}

void task1(void *parameter) {
  while(1) {
    Serial.println("Hello World desde Task 1!");
    vTaskDelay(1000 / portTICK_PERIOD_MS);
  }
}

void task2(void *parameter) {
  while(1) {
    digitalWrite(2, HIGH);
    vTaskDelay(500 / portTICK_PERIOD_MS);
    digitalWrite(2, LOW);
    vTaskDelay(500 / portTICK_PERIOD_MS);
  }
}

WiFi Scan - Escaneo de Redes

Este ejemplo escanea las redes WiFi disponibles en el área:

#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  Serial.println();
  Serial.println("Iniciando escaneo WiFi...");
}

void loop() {
  Serial.println("\nEscaneando redes WiFi...");
  
  int numNetworks = WiFi.scanNetworks();
  
  if (numNetworks == 0) {
    Serial.println("No se encontraron redes WiFi");
  } else {
    Serial.printf("Se encontraron %d redes:\n", numNetworks);
    
    for (int i = 0; i < numNetworks; i++) {
      Serial.printf("%d. SSID: %s\n", i + 1, WiFi.SSID(i).c_str());
      Serial.printf("   RSSI: %d dBm\n", WiFi.RSSI(i));
      Serial.printf("   Encriptación: %s\n", 
        WiFi.encryptionType(i) == WIFI_AUTH_OPEN ? "Abierta" : "Protegida");
    }
  }
  
  vTaskDelay(5000 / portTICK_PERIOD_MS);
}

Conexión WiFi a Red

#include <WiFi.h>

const char* ssid = "NOMBRE_DE_TU_RED";
const char* password = "TU_CONTRASEÑA";

void setup() {
  Serial.begin(115200);
  
  Serial.print("Conectando a ");
  Serial.println(ssid);
  
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("");
  Serial.println("WiFi conectado!");
  Serial.println("Dirección IP: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  // Código principal
}

Web Server Básico

#include <WiFi.h>
#include <WebServer.h>

const char* ssid = "NOMBRE_DE_TU_RED";
const char* password = "TU_CONTRASEÑA";

WebServer server(80);

void handleRoot() {
  String html = "<!DOCTYPE html><html><head>";
  html += "<meta name='viewport' content='width=device-width, initial-scale=1'>";
  html += "<title>ESP32 Web Server</title></head><body>";
  html += "<h1>Hola desde el ESP32!</h1>";
  html += "<p>Dirección IP: " + WiFi.localIP().toString() + "</p>";
  html += "</body></html>";
  server.send(200, "text/html", html);
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("\nWiFi conectado!");
  Serial.println(WiFi.localIP());
  
  server.on("/", handleRoot);
  server.begin();
  Serial.println("Servidor HTTP iniciado en puerto 80");
}

void loop() {
  server.handleClient();
}

Lectura de Sensor Analógico

// Configuración de atenuación ADC
#define ADC_ATTEN ADC_11db  // Rango 0-3.3V

void setup() {
  Serial.begin(115200);
  
  // Configurar pin analógico
  analogReadResolution(12);  // 12 bits (0-4095)
  analogSetAttenuation(ADC_ATTEN);
}

void loop() {
  // Leer pin A0 (GPIO36)
  int sensorValue = analogRead(A0);
  
  // Convertir a voltaje
  float voltage = sensorValue * (3.3 / 4095.0);
  
  Serial.print("Valor ADC: ");
  Serial.print(sensorValue);
  Serial.print(" | Voltaje: ");
  Serial.print(voltage, 2);
  Serial.println(" V");
  
  delay(500);
}

Uso de I²C (Ejemplo con sensor)

#include <Wire.h>

#define SDA_PIN 21  // GPIO21
#define SCL_PIN 22  // GPIO22

void setup() {
  Serial.begin(115200);
  
  // Inicializar I²C
  Wire.begin(SDA_PIN, SCL_PIN);
  
  Serial.println("I²C iniciado");
  
  // Escanear dispositivos I²C
  Serial.println("Escaneando bus I²C...");
  int count = 0;
  for (byte i = 1; i < 127; i++) {
    Wire.beginTransmission(i);
    if (Wire.endTransmission() == 0) {
      Serial.printf("Dispositivo encontrado en 0x%02X\n", i);
      count++;
    }
  }
  Serial.printf("Total: %d dispositivos\n", count);
}

void loop() {
  // Código principal
  delay(1000);
}

Proyectos Prácticos

1. Estación Meteorológica WiFi

Conecte un sensor DHT22 o BME280 para medir temperatura, humedad y presión, y envíe los datos a un servidor o visualícelos en una página web.

Componentes necesarios:

• Wemos D1 R32
• Sensor DHT22 o BME280
• Resistencia de 10kΩ (para DHT22)
• Cableado y protoboard

2. Controlador IoT para Relés

Cree un sistema para controlar dispositivos eléctricos a través de WiFi usando relés y una interfaz web.

Componentes necesarios:

• Wemos D1 R32
• Módulo de relé de 1 o 4 canales
• Fuente de alimentación adecuada
• Carga a controlar (luz, ventilador, etc.)

3. Monitor de Consumo Energético

Utilice el sensor ACS712 o PZEM-004T para medir el consumo eléctrico y envíe los datos a la nube.

4. Sistema de Riego Automático

Combine sensores de humedad de suelo con control de bombas de agua y conectividad WiFi para monitoreo remoto.

5. Bot de Telegram

Cree un bot de Telegram que controle dispositivos conectados al ESP32 y envíe notificaciones.

Consideraciones de Alimentación

Fuentes de Alimentación

Regulador de Voltaje

El Wemos D1 R32 incluye un regulador de tensión que convierte 5 V a 3.3 V. Este regulador puede proporcionar hasta aproximadamente 500 mA, suficiente para la placa y algunos periféricos.

Consumo Típico

Recomendación: Use una fuente de alimentación de al menos 500 mA para garantizar una operación estable, especialmente cuando el WiFi esté activo.

Modos de Bajo Consumo

Deep Sleep

El modo Deep Sleep es ideal para proyectos alimentados por batería:

#include <esp_sleep.h>

// Configurar wake up por temporizador (10 segundos)
esp_sleep_enable_timer_wakeup(10 * 1000000);  // en microsegundos

// O alternativamente, wake up por botón en GPIO0
// esp_sleep_enable_ext0_wakeup(GPIO_NUM_0, 1);

void setup() {
  Serial.begin(115200);
  Serial.println("Entrando en Deep Sleep...");
  
  // Guardar datos en RTC memory si es necesario
  rtc_gpio_init(GPIO_NUM_2);
  
  // Entrar en deep sleep
  esp_deep_sleep_start();
}

void loop() {
  // Este código no se ejecuta en deep sleep
}

Light Sleep

En Light Sleep, la CPU se suspende pero WiFi/Bluetooth pueden mantenerse activos:

void enterLightSleep() {
  WiFi.setSleep(true);  // Habilitar modo sleep de WiFi
  esp_light_sleep_start();
}

Configuración de Modos Sleep

// Configurar consumo en deep sleep
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_SLOW_MEM, ESP_PD_OPTION_OFF);
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_FAST_MEM, ESP_PD_OPTION_ON);

Bibliotecas Recomendadas

Bibliotecas Oficiales Espressif

Bibliotecas de Terceros Populares

Instalación de Bibliotecas

1. Abra Arduino IDE
2. Vaya a Sketch → Incluir biblioteca → Administrar bibliotecas
3. Busque el nombre de la biblioteca
4. Haga clic en Instalar

Solución de Problemas

Problema: "Failed to connect to ESP32"

Causas posibles:

1. Driver CH340 no instalado
2. Puerto COM incorrecto seleccionado
3. Pin GPIO0 no en estado correcto
4. Cable USB defectuoso (solo carga, no datos)

Soluciones:

• Verifique el Administrador de Dispositivos en Windows
• Seleccione el puerto COM correcto en Herramientas → Puerto
• Mantenga GPIO0 en HIGH durante la carga
• Pruebe con otro cable USB

Problema: "Brownout detector was triggered"

Causa: Alimentación insuficiente

Soluciones:

• Use una fuente de alimentación de al menos 500 mA
• Conecte directamente por USB durante desarrollo
• Reduzca el número de periféricos conectados

Problema: "Flash download failed"

Causas:

• Modo Flash incorrecto seleccionado
• Tamaño de Flash incorrecto

Soluciones:

• Verifique Herramientas → Modo Flash (QIO recomendado)
• Verifique Herramientas → Tamaño Flash (4MB)

Problema: ADC readings inconsistentes

Causa: El ADC del ESP32 tiene características no lineales

Soluciones:

• Use calibración o bibliotecas como ADC_Calibration
• Considere usar amplificador operacional para señales pequeñas
• Use atenuación adecuada (ADC_11db para rango completo)

Problema: WiFi se desconecta frecuentemente

Soluciones:

// Aumentar potencia de transmisión
WiFi.setTxPower(WIFI_POWER_19_5dBm);

// Configurar modo de sleep
WiFi.setSleep(false);  // Deshabilitar sleep para mejor estabilidad

// Usar canal fijo si hay interferencia
WiFi.setChannel(6, WIFI_CHANNEL_2437);

Recursos Adicionales

Documentación Oficial

• Documentación Espressif ESP32
• Arduino ESP32 Core
• Datasheet ESP32

Comunidades y Foros

• Foro Arduino ESP32
• Espressif Forum
• Reddit r/ESP32

Proyectos de Ejemplo

• Arduino ESP32 Examples
• ESP32 Projects en GitHub

Tutoriales en Video

• Canal oficial Espressif en YouTube
• Channels especializados en IoT y Arduino

Conclusión

El Wemos D1 R32 representa una excelente opción para proyectos de IoT y electrónica embebida, ofreciendo capacidades avanzadas a un precio accesible. Su compatibilidad con Arduino IDE facilita la transición para usuarios familiarizados con Arduino, mientras que las características del ESP32 abren posibilidades mucho más amplias en términos de conectividad y rendimiento.

Ya sea que esté creando una estación meteorológica, un sistema de domótica, o cualquier proyecto que requiera conectividad inalámbrica, el Wemos D1 R32 proporciona la plataforma ideal para materializar sus ideas.

Última actualización: Julio 2026