Conectar una pantalla a tu ESP32 es el paso definitivo para transformar un proyecto ciego de IoT en un dispositivo interactivo. En esta guía rápida vas a aprender cómo cablear una pantalla LCD (16×2 o 20×4) con adaptador I2C a tu microcontrolador, cómo definir pines personalizados en el código y cómo estructurar un proyecto real usando, además, el avanzado Sensor BME680.
¿Por qué usar el protocolo I2C con el ESP32?
El protocolo I2C es el método más eficiente para conectar periféricos a microcontroladores. A diferencia de las conexiones tradicionales que requieren hasta 6 o 12 cables para controlar una pantalla, I2C solo necesita dos cables de datos (SDA y SCL), además de la alimentación eléctrica. Esto te deja pines libres en el ESP32 para conectar relés, motores u otros sensores analógicos.
Pines I2C por Defecto en ESP32
El protocolo I2C solo necesita dos cables de datos (además de la alimentación). Por norma general, si no especificas nada en el código, el ESP32 utiliza los siguientes pines de fábrica:
- SDA (Datos): GPIO 21
- SCL (Reloj): GPIO 22
Sin embargo, una de las grandes ventajas de la arquitectura del ESP32 es su matriz de pines intercambiables (pin mapping): puedes asignar el protocolo I2C a casi cualquier pin digital mediante software utilizando la librería nativa Wire.h.
Diagrama de conexión: Pantalla LCD y Sensor BME680
Cuando se diseña un circuito complejo (como una estación meteorológica doméstica), los pines por defecto pueden chocar con otros componentes críticos o con pines reservados para el arranque (boot pins).
En este esquema práctico, redefinimos los pines para trabajar de forma más cómoda. Dado que I2C permite conectar múltiples dispositivos en el mismo bus (siempre que tengan direcciones diferentes), conectaremos la pantalla LCD y el sensor ambiental BME680 en paralelo a los mismos cables:
| Componente | Pin de la Pantalla / Sensor | Pin asignado en ESP32 |
|---|---|---|
| Pantalla LCD / BME680 | SDA (Datos) | GPIO 13 |
| Pantalla LCD / BME680 | SCL (Reloj) | GPIO 14 |
| Alimentación | VCC | 5V o 3V3 (Según modelo) |
| Tierra | GND | GND |
Nota técnica: La pantalla LCD suele venir configurada de fábrica en la dirección 0x27, mientras que el sensor BME680 de Adafruit utiliza por defecto la dirección 0x76. Al tener identificadores distintos, el ESP32 sabe exactamente con quién habla en cada milisegundo.
Librerías necesarias en Arduino IDE
Para que el proyecto compile sin errores, necesitas instalar tres librerías esenciales desde el Gestor de Librerías de tu Arduino IDE 2.3:
LiquidCrystal_I2C(de Frank de Brabander) para el control de la pantalla.Adafruit_BME680para la gestión del sensor de calidad de aire.Adafruit_Sensor(Biblioteca unificada que requiere Adafruit para sus sensores).
Código fuente: Estación meteorológica con LCD e I2C personalizado
A continuación, dispones del código fuente listo para compilar en tu Arduino IDE. Este programa lee la temperatura, humedad, presión atmosférica y calidad del aire desde el sensor BME680, muestra los datos en tiempo real en la pantalla LCD I2C y, de forma paralela, envía las métricas mediante HTTP POST a un servidor web.
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME680.h>
// Configuración de pines personalizados
#define SDA_PIN 13
#define SCL_PIN 14
Adafruit_BME680 bme;
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup() {
Serial.begin(115200);
Wire.begin(SDA_PIN, SCL_PIN); // Inicializar I2C personalizado
lcd.init();
lcd.backlight();
if (!bme.begin(0x76)) { // Dirección del BME680
Serial.println("Error al iniciar el sensor");
while (1);
}
}
void loop() {
if (bme.performReading()) {
// Mostrar en LCD
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Temp: " + String(bme.temperature) + "C");
lcd.setCursor(0, 1);
lcd.print("Hum: " + String(bme.humidity) + "%");
}
delay(2000);
}
Conclusión y Siguiente Paso
Al usar Wire.begin(SDA, SCL) con pines personalizados, liberas el bus I2C estándar del ESP32. Para un análisis más profundo sobre la integración del BME680 con servidores Node.js/MariaDB, visita nuestra guía detallada: Monitorización Ambiental con ESP32.
Preguntas frecuentes sobre conexiones I2C en ESP32
¿Cuáles son los pines I2C por defecto del ESP32?
Por norma general, en las placas ESP32 clásicas de 30 y 38 pines, los pines asignados de fábrica para la comunicación I2C son el GPIO 21 para la línea de datos (SDA) y el GPIO 22 para la línea de reloj (SCL). Si utilizas modelos más recientes como el ESP32-S3, los pines predeterminados suelen cambiar al GPIO 8 (SDA) y GPIO 9 (SCL). No obstante, recuerda que gracias al multiplexor interno del chip puedes redefinir estos pines por software a los pines que mejor te convengan utilizando el comando Wire.begin(SDA, SCL).
¿Cómo conectar varios dispositivos I2C al ESP32?
Para conectar múltiples periféricos I2C (como una pantalla LCD y un sensor BME680) al ESP32, debes conectarlos todos en paralelo a los mismos pines SDA y SCL. El protocolo I2C es un bus serie compartido, lo que significa que el microcontrolador se comunica con cada componente de forma individual utilizando una dirección hexadecimal única (por ejemplo, 0x27 para la pantalla y 0x76 para el sensor). Solo asegúrate de que dos dispositivos no compartan exactamente la misma dirección en el circuito para evitar colisiones de datos.
¿Qué hacer si la pantalla LCD I2C no muestra texto?
Si la pantalla se enciende pero no muestra ningún carácter, el fallo más común suele ser el contraste. Gira suavemente el pequeño potenciómetro que se encuentra en la placa mochila negra soldada detrás de la pantalla hasta que aparezcan las letras. Si el problema persiste, verifica con un escáner I2C que la dirección configurada en tu código (normalmente 0x27 o 0x3F) coincida exactamente con el hardware de tu pantalla.
Como conectar DHT11 en ESP32 con salida a LCD1602
En esta entrada os mostraremos Como conectar DHT11 en ESP32 con salida a LCD1602. El DHT11 es un sensor de temperatura y humedad que es comúnmente utilizado en proyectos de electrónica y prototipos de IoT (Internet de las cosas). El ESP32 es un microcontrolador de bajo costo y bajo consumo de energía que es ampliamente utilizado en proyectos de IoT debido a su capacidad de conectividad Wi-Fi y Bluetooth.
Cuando conectas un sensor DHT11 a un ESP32 y lo programas adecuadamente, el microcontrolador puede leer los datos de temperatura y humedad del sensor. Luego, esos datos pueden ser enviados a una pantalla LCD1602 para su visualización.
Aquí hay una descripción básica de cada componente:
ESP32: Es un microcontrolador de bajo costo y bajo consumo de energía con conectividad Wi-Fi y Bluetooth integrada. Puede ser programado utilizando el lenguaje de programación Arduino o mediante el uso de herramientas de desarrollo específicas para ESP32.
DHT11: Es un sensor de temperatura y humedad digital. Utiliza un sensor capacitivo para medir la humedad relativa en el aire y un termistor para medir la temperatura ambiente. Proporciona datos digitales a través de un solo pin de datos.
LCD1602: Es una pantalla LCD alfanumérica de 16×2 caracteres. Esto significa que puede mostrar hasta 16 caracteres en dos líneas. Se comunica con el ESP32 a través de un protocolo de comunicación como I2C o paralelo.
Cuando se combinan estos componentes en un proyecto, el ESP32 se encarga de leer los datos del sensor DHT11 y luego los muestra en la pantalla LCD1602. Este tipo de configuración es comúnmente utilizada en estaciones meteorológicas caseras, termostatos inteligentes y otros dispositivos que requieren monitoreo de temperatura y humedad en tiempo real.
Código para conectar DHT11 en ESP32 con salida a LCD1602
Para realizar la lectura del sensor DHT11 y mostrar los datos en una pantalla LCD1602 con un ESP32, necesitarás utilizar las siguientes librerías:
- Para el sensor DHT11:
- DHT Sensor Library: Esta biblioteca te permitirá interactuar con el sensor DHT11. Puedes encontrar esta biblioteca en el administrador de bibliotecas de Arduino. Simplemente busca «DHT sensor library» e instálala.
- Para la pantalla LCD1602:
- LiquidCrystal_I2C: Esta biblioteca te permite controlar la pantalla LCD1602 utilizando la interfaz I2C, lo que simplifica las conexiones y el uso de pines en el ESP32. También puedes encontrar esta biblioteca en el administrador de bibliotecas de Arduino. Busca «LiquidCrystal_I2C» e instálala.
Estas dos bibliotecas son las principales que necesitarás para este proyecto. Después de instalarlas, puedes utilizarlas en tu código para interactuar con el sensor DHT11 y la pantalla LCD1602 de manera sencilla y eficiente. Recuerda que puedes encontrar ejemplos de uso de estas bibliotecas en la documentación oficial o en otros recursos en línea para ayudarte a comenzar con tu proyecto.
El código necesario
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <DHTesp.h>
DHTesp dht; // Define el objeto DHT
int dhtPin = 4; // Define el pin del sensor DHT
LiquidCrystal_I2C lcd_i2c(0x27, 16, 2); // Dirección I2C 0x27, 16 columnas y 2 filas
void setup() {
Serial.begin(115200);
dht.setup(dhtPin, DHTesp::DHT11); // Inicializa el pin y el objeto DHT
Wire.begin();
lcd_i2c.init(); // Inicializa el LCD
lcd_i2c.backlight();
}
void loop() {
delay(2000);
TempAndHumidity newValues = dht.getTempAndHumidity(); // Obtiene la temperatura y humedad
if (dht.getStatus() != 0) { // Verifica si se leyó el valor correcto
return; // Si hay un error, sale del bucle
}
lcd_i2c.clear(); // Borra la pantalla
lcd_i2c.setCursor(0, 0); // Mueve el cursor a (0, 0)
lcd_i2c.print("Temp: "); // Imprime la etiqueta de temperatura
lcd_i2c.print(newValues.temperature); // Imprime el valor de temperatura
lcd_i2c.print(" C"); // Imprime la unidad de temperatura
lcd_i2c.setCursor(0, 1); // Mueve el cursor a (0, 1)
lcd_i2c.print("Hum: "); // Imprime la etiqueta de humedad
lcd_i2c.print(newValues.humidity); // Imprime el valor de humedad
lcd_i2c.print(" %"); // Imprime la unidad de humedad
delay(1000);
}
Y aquí tenemos el resultado, lo siguiente será mostrarlo en tu navegador y guardar los dados en una base de dados.
