Componentes · 11 min de lectura

Conectar LCD 16x2 a Arduino sin I2C: modo 4 bits y contraste

Cómo conectar una LCD 16x2 a Arduino sin módulo I2C: los 16 pines, modo 4 bits, contraste, LiquidCrystal, solución a los cuadros negros y la LCD 20x4.

Cuando conectas una LCD 16x2 a Arduino sin módulo I2C, usas 12 de los 16 pines de la pantalla: seis van a pines digitales del Arduino y el resto a la alimentación, el contraste y la retroiluminación. Parecen muchos cables, pero esta conexión te enseña de verdad cómo funciona la pantalla, te ahorra buscar direcciones I2C, es más rápida que el I2C y no detiene tu proyecto si no tienes un módulo I2C. Además, la mayoría de las LCD de los kits de inicio de Arduino vienen sin módulo I2C.

En esta guía aprenderás la función de cada uno de los 16 pines, por qué solo usamos 4 líneas de datos (modo de 4 bits), cómo conectar el potenciómetro de contraste y los comandos de la biblioteca LiquidCrystal. Después diseñarás caracteres personalizados para una barra que se llena con un potenciómetro, pasarás a una LCD 20x4 y usarás la misma pantalla con un ESP32 y una Raspberry Pi Pico. En las últimas secciones encontrarás cómo resolver los problemas más comunes, como los "cuadros negros" y la "pantalla en blanco", y cuándo conviene pasar a un módulo I2C.

Pantalla LCD de caracteres 16x2
LCD 16x2: caracteres de 5 × 8 píxeles en 16 columnas y 2 filas. Los 16 pines del borde superior se conectan directamente, sin módulo I2C.

¿Cómo funciona una LCD 16x2?

El chip negro en forma de gota de la parte trasera es el controlador HD44780 (o un clon exacto), el idioma común de casi todas las LCD de caracteres. Arduino le envía dos tipos de bytes: comandos (borrar la pantalla, llevar el cursor a una posición, encender la pantalla) y caracteres (el código de la letra que se mostrará). El pin RS indica cuál se envía: con RS en LOW el byte es un comando y con RS en HIGH, un carácter. El pin E (enable) es la señal de "dato listo, léelo ahora": tras poner un byte en las líneas de datos, E pasa brevemente a HIGH y el chip lee el byte en el flanco de bajada. Dentro del chip hay una memoria de pantalla de 80 caracteres (DDRAM), una ROM con 208 caracteres incorporados y una pequeña memoria (CGRAM) para los 8 caracteres personalizados que diseñarás.

CaracterísticaValor
Chip controladorHD44780 o compatible (KS0066, SPLC780)
Pantalla16 columnas × 2 filas, cada carácter de 5 × 8 píxeles
Alimentación4,5–5,5 V (también hay versiones especiales de 3,3 V)
Corriente lógicaUnos 1–2 mA
Corriente de retroiluminaciónUnos 15–30 mA (LED, según el modelo)
Bus de datosParalelo de 8 o 4 bits
Caracteres personalizados8 (CGRAM)
Tiempo por comandoLa mayoría 37 µs, clear() y home() unos 1,5 ms

La función de los 16 pines

PinNombreFunciónConexión
1VSSMasaGND
2VDDAlimentación lógica5V
3V0 (VO, VEE)Ajuste de contrasteCursor de un potenciómetro de 10 kΩ
4RSSelección de comando (LOW) o carácter (HIGH)Arduino D12
5RWLectura (HIGH) o escritura (LOW)GND (solo escribiremos)
6EPulso de dato válidoArduino D11
7–10D0–D3Bits de datos bajosLibres en modo de 4 bits
11D4Bit de datos 4Arduino D5
12D5Bit de datos 5Arduino D4
13D6Bit de datos 6Arduino D3
14D7Bit de datos 7Arduino D2
15A (LED+)Ánodo de la retroiluminación5V a través de 220 Ω
16K (LED−)Cátodo de la retroiluminaciónGND
En algunas LCD el orden de los pines es distinto, o los pines de retroiluminación 15 y 16 están al principio. Antes de conectar, revisa las etiquetas de la placa y la marca del pin 1. No conectes la retroiluminación directamente a 5 V sin resistencia: si el módulo no tiene resistencia en serie, el LED consume demasiado y se degrada. En la parte trasera suele haber una resistencia de unos 100 Ω marcada como R8 o R9; si no estás seguro, añade igualmente la de 220 Ω. Puedes calcular el valor adecuado con la calculadora de resistencia para LED.

Modo de 4 bits: ¿por qué 4 líneas de datos y no 8?

El HD44780 puede recibir un byte de una vez por 8 líneas de datos (modo de 8 bits) o en dos mitades por las líneas D4–D7 (modo de 4 bits). En modo de 4 bits se envía primero la mitad alta del byte y luego la baja, con un pulso en E para cada mitad. Tarda el doble, pero en la práctica no se nota: escribir un carácter sigue costando unos 50 µs y refrescar toda la pantalla lleva menos de 2 ms. A cambio, quedan libres cuatro pines del Arduino. La biblioteca LiquidCrystal elige el modo de 4 bits automáticamente cuando pasas seis pines al constructor; dejar D0–D3 sin conectar es seguro porque el chip tiene resistencias pull-up internas en ellos.

El potenciómetro de contraste

Potenciómetro de 10 kΩ
Para el contraste basta un potenciómetro de 10 kΩ: patas laterales a 5V y GND y la central al V0 de la LCD.

La tensión del pin V0 decide si el texto se ve o no. Lo que gira el cristal líquido es la diferencia entre VDD y V0; en los módulos estándar de 5 V la mejor imagen suele conseguirse con V0 entre 0,3 y 1 V aproximadamente. Cuando V0 se acerca a 0 V también se oscurece el fondo de los caracteres y las celdas vacías aparecen como cuadros negros; cuando se acerca a 5 V el texto desaparece por completo. Por eso, para el primer montaje lo más práctico es un potenciómetro: una pata lateral a 5V, la otra a GND y la central a V0, y gíralo despacio hasta que el texto se vea nítido. Una vez encontrado el punto, puedes cambiar el potenciómetro por una resistencia fija: entre 1 y 2,2 kΩ de V0 a GND funciona bien en la mayoría de módulos.

Paso a paso: tu primer texto con Arduino

  1. Suelda una tira de 16 pines macho a la LCD y pincha la pantalla en la protoboard; en una protoboard larga queda sitio para cables a ambos lados.
  2. Lleva el 5V y el GND del Arduino a las líneas de alimentación de la protoboard. Conecta los pines 1 (VSS) y 16 (K) de la LCD a GND, el pin 2 (VDD) a 5V y el pin 15 (A) a 5V a través de 220 Ω. Al conectar el Arduino al USB, la retroiluminación debe encenderse.
  3. Conecta el potenciómetro y gíralo. Incluso antes de cargar código deberían aparecer 16 cuadros negros en la línea superior; eso indica que la pantalla y el contraste funcionan.
  4. Conecta el pin 5 (RW) a GND. Después conecta RS a D12, E a D11 y D4–D7 a D5, D4, D3 y D2 respectivamente.
  5. Comprueba en el Gestor de Bibliotecas que LiquidCrystal está instalada (viene con el Arduino IDE) y carga el código de abajo.
  6. Cuando desaparezcan los cuadros y aparezca el texto, ajusta por última vez el contraste con el potenciómetro.
C++ (Arduino IDE)
1// 16x2 LCD, I2C modülü olmadan (4-bit mod) / 16x2 LCD without an I2C module (4-bit mode)
2// RS -> D12, E -> D11, D4 -> D5, D5 -> D4, D6 -> D3, D7 -> D2, RW -> GND, V0 -> pot
3#include <LiquidCrystal.h>
4
5const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
6LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
7
8void setup() {
9  lcd.begin(16, 2);              // 16 sütun, 2 satır / 16 columns, 2 rows
10  lcd.print(F("Merhaba Arduino!"));
11  lcd.setCursor(0, 1);           // sütun 0, satır 1 / column 0, row 1
12  lcd.print(F("Sure:"));
13}
14
15void loop() {
16  unsigned long s = millis() / 1000;
17  lcd.setCursor(6, 1);
18  lcd.print(s);
19  lcd.print(F(" sn   "));      // eski haneleri boşlukla sil / overwrite old digits with spaces
20  delay(200);
21}

El código tiene dos costumbres pequeñas pero importantes. La primera: antes de escribir el valor que cambia, va a esa posición con setCursor() en lugar de llamar a clear(), y añade unos espacios tras el número. clear() es un comando pesado que tarda unos 1,5 ms y, usado en el bucle, hace parpadear la pantalla; además no hace falta borrar y reescribir toda la pantalla. Los espacios evitan que quede en pantalla una cifra antigua cuando el número se acorta (por ejemplo, de 100 a 99). La segunda: los textos fijos se escriben con la macro F(), así se guardan en la memoria de programa y no en la RAM. En una pantalla 16x2 caben como máximo 16 caracteres por línea; un texto más largo se sale por la derecha y no se ve.

ComandoQué hace
lcd.begin(16, 2)Inicia la pantalla e indica columnas y filas
lcd.print(valor)Escribe texto, un entero o un decimal; lcd.print(3.14159, 2) muestra dos decimales
lcd.setCursor(columna, fila)Elige dónde escribir; se cuenta desde 0
lcd.clear()Borra la pantalla y lleva el cursor al inicio (tarda 1,5 ms)
lcd.cursor() / lcd.noCursor()Muestra u oculta el cursor de subrayado
lcd.blink() / lcd.noBlink()Activa o desactiva el cursor de bloque parpadeante
lcd.display() / lcd.noDisplay()Enciende o apaga la imagen sin borrar la memoria
lcd.scrollDisplayLeft()Desplaza toda la pantalla una columna a la izquierda
lcd.createChar(n, matriz)Carga un carácter personalizado en la posición 0–7
lcd.write(byte(n))Escribe un carácter personalizado o un código de la ROM

Caracteres personalizados: una barra que se llena con un potenciómetro

Cada celda de carácter es una cuadrícula de 5 columnas y 8 filas de píxeles. Para definir un carácter personalizado escribes cada fila como un número de 5 bits: 1 es un píxel encendido y 0 uno apagado. El HD44780 permite 8 caracteres personalizados a la vez. El ejemplo siguiente usa cinco de esas posiciones para bloques con 1, 2, 3, 4 y 5 columnas llenas desde la izquierda. Con 16 celdas × 5 columnas obtienes una barra de 80 pasos que se llena y se vacía con suavidad al girar un potenciómetro; ideal para volumen, nivel de batería o un porcentaje de un sensor. En el artículo sobre la LCD I2C explicamos cómo diseñar letras turcas (ş, ğ, ı, ç); el mismo comando createChar funciona exactamente igual con la conexión en paralelo.

C++ (Arduino IDE)
1// Özel karakterlerle 80 adımlık çubuk grafik / 80-step bar graph with custom characters
2// Potansiyometre orta ucu -> A0 / potentiometer wiper -> A0
3#include <LiquidCrystal.h>
4
5LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
6
7byte bars[5][8];                       // 1..5 sütun dolu bloklar / blocks with 1..5 columns filled
8
9void buildBars() {
10  for (int n = 0; n < 5; n++) {
11    byte row = 0;
12    for (int c = 0; c <= n; c++) row |= (0b10000 >> c);   // soldan doldur / fill from the left
13    for (int r = 0; r < 8; r++) bars[n][r] = row;
14    lcd.createChar(n, bars[n]);        // karakter 0 = 1 sütun ... 4 = 5 sütun / char 0 = 1 column ... 4 = 5 columns
15  }
16}
17
18void setup() {
19  lcd.begin(16, 2);
20  buildBars();
21  lcd.setCursor(0, 0);                 // createChar sonrası konum ayarla / set position after createChar
22  lcd.print(F("Seviye / Level"));
23}
24
25void loop() {
26  int raw = analogRead(A0);
27  int steps = map(raw, 0, 1023, 0, 80);  // 16 hücre x 5 sütun / 16 cells x 5 columns
28  int percent = map(raw, 0, 1023, 0, 100);
29
30  lcd.setCursor(12, 0);
31  if (percent < 100) lcd.print(' ');
32  if (percent < 10) lcd.print(' ');
33  lcd.print(percent);
34  lcd.print('%');
35
36  lcd.setCursor(0, 1);
37  for (int cell = 0; cell < 16; cell++) {
38    int fill = steps - cell * 5;       // bu hücreye düşen sütun / columns in this cell
39    if (fill >= 5) lcd.write(byte(4));
40    else if (fill > 0) lcd.write(byte(fill - 1));
41    else lcd.print(' ');
42  }
43  delay(50);
44}

El comando createChar lleva el cursor de la memoria de pantalla a la de caracteres, por eso, tras cargar los caracteres personalizados, hay que llamar a setCursor() antes de escribir; si no, puede que el primer texto no aparezca. Los caracteres solo se guardan en la CGRAM y se pierden al quitar la alimentación, así que se vuelven a cargar en setup() en cada arranque. Si cambias la definición de un carácter mientras está en pantalla, todas las celdas que lo muestran cambian a la vez; las pequeñas animaciones se hacen justo con este truco.

LCD 20x4: la misma conexión, más pantalla

Las LCD de 20 columnas y 4 filas usan el mismo chip HD44780 y los mismos 16 pines; la conexión es idéntica y en el código solo tienes que poner lcd.begin(20, 4). Su retroiluminación consume algo más (40–60 mA), así que no reduzcas la resistencia en serie para no forzar la línea de 5V del Arduino en un uso prolongado. La única rareza que debes conocer es el orden de las filas: en la memoria de pantalla, el final de la fila 1 continúa en la fila 3 y el de la fila 2, en la fila 4. Por eso, si escribes un texto largo sin setCursor(), pasa de la fila 1 a la 3 y no a la 2. Llamar a setCursor(0, fila) al principio de cada fila elimina el problema por completo.

C++ (Arduino IDE)
1// 20x4 LCD: aynı bağlantı, begin(20, 4) / 20x4 LCD: same wiring, begin(20, 4)
2#include <LiquidCrystal.h>
3
4LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
5
6void setup() {
7  lcd.begin(20, 4);
8  for (int row = 0; row < 4; row++) {
9    lcd.setCursor(0, row);             // her satırı açıkça seç / select every row explicitly
10    lcd.print(F("Satir / Row "));
11    lcd.print(row + 1);
12  }
13}
14
15void loop() {
16  lcd.setCursor(15, 3);
17  lcd.print(millis() / 1000 % 100000);  // 5 haneye sığsın / fit in 5 digits
18  delay(500);
19}

LCD en paralelo con ESP32

Una LCD 16x2 estándar no da suficiente contraste si no se alimenta a 5 V, mientras que los pines del ESP32 son de 3,3 V. La buena noticia: mientras RW esté a GND, la LCD nunca pone tensión en las líneas, solo escucha. Como la entrada mínima que el HD44780 considera HIGH a 5 V ronda los 2,2 V, las señales de 3,3 V del ESP32 bastan y no hace falta un convertidor de nivel. Conecta el VDD de la LCD al pin VIN de la placa ESP32 (5 V del USB). La biblioteca LiquidCrystal funciona igual en el ESP32; solo evita los pines con funciones especiales al arrancar, como GPIO 0, 2, 12 y 15.

C++ (Arduino IDE)
1// ESP32 + 16x2 LCD (paralel, 4-bit) / ESP32 + 16x2 LCD (parallel, 4-bit)
2// RS -> GPIO 22, E -> GPIO 21, D4 -> 19, D5 -> 18, D6 -> 26, D7 -> 25
3// VDD -> VIN (5 V), RW -> GND, V0 -> pot, A -> 220 ohm -> VIN
4#include <LiquidCrystal.h>
5
6LiquidCrystal lcd(22, 21, 19, 18, 26, 25);
7
8void setup() {
9  lcd.begin(16, 2);
10  lcd.print("ESP32 + LCD");
11}
12
13void loop() {
14  lcd.setCursor(0, 1);
15  lcd.print("Heap: ");
16  lcd.print(ESP.getFreeHeap() / 1024);   // boş bellek (KB) / free memory (KB)
17  lcd.print(" KB   ");
18  delay(1000);
19}

LCD en paralelo con Raspberry Pi Pico (MicroPython)

Con la Raspberry Pi Pico la lógica es la misma: alimenta la LCD con 5 V desde VBUS (pin 40), conecta RW a GND y lleva las señales directamente a pines GP. MicroPython no trae una biblioteca LiquidCrystal, así que abajo tienes un pequeño controlador que gestiona él mismo el modo de 4 bits. Sigue la secuencia de inicio de la hoja de datos del HD44780: espera 50 ms tras el encendido, fuerza tres veces el modo de 8 bits, después pasa a 4 bits y enciende la pantalla. Cada carácter se envía en dos mitades (nibbles), con un breve pulso en E tras cada una.

MicroPython
1# Raspberry Pi Pico: I2C'siz 16x2 LCD sürücüsü (4-bit) / 16x2 LCD driver without I2C (4-bit)
2# RS -> GP16, E -> GP17, D4 -> GP18, D5 -> GP19, D6 -> GP20, D7 -> GP21
3# VDD -> VBUS (pin 40, 5 V), RW -> GND, V0 -> pot
4from machine import Pin
5import time
6
7
8class LCD4:
9    def __init__(self, rs, e, d4, d5, d6, d7):
10        self.rs = Pin(rs, Pin.OUT, value=0)
11        self.e = Pin(e, Pin.OUT, value=0)
12        self.data = [Pin(p, Pin.OUT, value=0) for p in (d4, d5, d6, d7)]
13        time.sleep_ms(50)                 # güç geldikten sonra bekle / wait after power-up
14        for _ in range(3):
15            self._nibble(0x03)            # 8-bit moda zorla / force 8-bit mode
16            time.sleep_ms(5)
17        self._nibble(0x02)                # 4-bit moda geç / switch to 4-bit mode
18        self.command(0x28)                # 4 bit, 2 satır, 5x8 / 4-bit, 2 lines, 5x8
19        self.command(0x0C)                # ekran açık, imleç kapalı / display on, cursor off
20        self.clear()
21        self.command(0x06)                # soldan sağa yaz / write left to right
22
23    def _nibble(self, value):
24        for i, pin in enumerate(self.data):
25            pin.value((value >> i) & 1)
26        self.e.value(1)                   # E darbesi / E pulse
27        time.sleep_us(1)
28        self.e.value(0)
29        time.sleep_us(50)                 # komut süresi (37 µs) / command time (37 µs)
30
31    def _write(self, value, rs):
32        self.rs.value(rs)
33        self._nibble(value >> 4)          # önce üst yarı / upper half first
34        self._nibble(value & 0x0F)
35
36    def command(self, cmd):
37        self._write(cmd, 0)
38
39    def clear(self):
40        self.command(0x01)
41        time.sleep_ms(2)                  # clear yaklaşık 1,5 ms / clear takes about 1.5 ms
42
43    def move_to(self, col, row):
44        offsets = (0x00, 0x40, 0x14, 0x54)   # 16x2 ve 20x4 satır adresleri / row addresses
45        self.command(0x80 | (offsets[row] + col))
46
47    def putstr(self, text):
48        for ch in text:
49            self._write(ord(ch), 1)
50
51
52lcd = LCD4(rs=16, e=17, d4=18, d5=19, d6=20, d7=21)
53lcd.move_to(0, 0)
54lcd.putstr("Merhaba Pico!")
55count = 0
56while True:
57    lcd.move_to(0, 1)
58    lcd.putstr("Sayac: {:<9d}".format(count))
59    count += 1
60    time.sleep(1)

Cuadros negros, pantalla en blanco y otros problemas

Casi todos los problemas de una LCD en paralelo se parecen a uno de unos pocos síntomas, y la propia pantalla te dice dónde buscar. La pista más importante es esta: si ves 16 cuadros negros solo en la fila superior, la alimentación y el contraste están bien, pero el chip nunca se ha inicializado. Al encenderse, el HD44780 arranca en modo de una línea y solo activa la primera; mientras el código no consiga inicializar la pantalla, la imagen no cambiará. En ese caso el problema casi siempre está en los cables RS, E o D4–D7 o en el orden de pines del constructor. Si ves cuadros tenues en las dos filas, la pantalla funciona y simplemente el contraste está demasiado alto.

SíntomaCausa probableSolución
16 cuadros negros solo en la fila superiorPantalla sin inicializar: cables RS, E, D4–D7 u orden de pines del constructor incorrectos, o código sin cargarRevisa los cables con la tabla y el orden LiquidCrystal lcd(RS, E, D4, D5, D6, D7)
Cuadros tenues en las dos filasContraste demasiado alto (V0 muy cerca de GND)Gira el potenciómetro
La retroiluminación se enciende pero no se ve nadaContraste demasiado bajo o V0 sin conectarComprueba que el cursor del potenciómetro va a V0 y gíralo
La retroiluminación no se enciendePines 15 y 16 sin conectar, invertidos o sin resistenciaConecta A a 5V con 220 Ω y K a GND
Caracteres sin sentido o que se desplazanUn cable de datos suelto, D4–D7 intercambiados, ruido de motores o relésAsegura los cables, añade 100 µF en la alimentación y reinicia con lcd.begin() si hace falta
El texto parpadeaSe usa lcd.clear() en el bucleSobrescribe con setCursor() y borra las cifras viejas con espacios
Queda una cifra antigua al acortarse el númeroEl valor nuevo es más corto que el anteriorAñade espacios tras el valor
No aparece texto tras un carácter personalizadocreateChar llevó el cursor a la memoria de caracteresLlama a setCursor() después de createChar
En proyectos con motores, relés o servos, la LCD a veces empieza a mostrar basura al cabo de unas horas: una caída de tensión ha dejado el chip en un estado indefinido. Llamar a lcd.begin(16, 2) cada cierto tiempo, por ejemplo una vez por minuto, y volver a dibujar la pantalla lo soluciona sin que el usuario lo note.

¿Conviene pasar a un módulo I2C?

Módulo I2C para LCD (PCF8574)
El módulo I2C basado en PCF8574 se suelda detrás de la LCD y reduce los 16 pines a solo cuatro cables.

Gracias al chip PCF8574 de su parte trasera, el módulo I2C lleva todas las señales de la LCD por dos cables (SDA y SCL); el potenciómetro de contraste y el transistor de la retroiluminación también están en la placa. A medida que crece tu proyecto, esa comodidad importa: un Uno solo tiene 20 pines digitales y analógicos y una LCD en paralelo ocupa seis por sí sola. Por otro lado, la conexión en paralelo es más rápida, no tiene conflictos de dirección I2C y no necesita módulo. La tabla resume cuándo conviene cada una; para el montaje con módulo I2C, consulta el artículo sobre la pantalla LCD I2C.

CaracterísticaParalelo (4 bits)Con módulo I2C
Pines de Arduino usados62 (A4, A5)
Número de cables12 (incluida alimentación y potenciómetro)4
Refresco de toda la pantallaMenos de 2 msUnos 20–30 ms a 100 kHz
Ajuste de contrastePotenciómetro externoTrimmer en el módulo
Apagar la retroiluminación por softwareRequiere un transistor extralcd.noBacklight()
BibliotecaLiquidCrystal (incluida en el IDE)LiquidCrystal I2C (se instala aparte)
Problemas típicosMaraña de cables, conexiones flojasDirección (0x27 / 0x3F) y pull-up

Ideas de proyectos con una LCD 16x2

  • Termómetro digital: Muestra en grande la temperatura y la humedad de un NTC o un DHT11, escribiendo el símbolo de grado con lcd.write(223).
  • Cerradura con clave: Muestra con asteriscos la clave tecleada en un teclado matricial y activa un relé si es correcta.
  • Indicador de distancia: Muestra a la vez en centímetros y en una barra la distancia medida con un HC-SR04.
  • Cronómetro y cuenta atrás: Arranca, para y pon a cero con dos botones, mostrando el tiempo como minutos:segundos:centésimas.
  • Minijuego: Dibuja con caracteres personalizados un corredor y obstáculos y hazlo saltar con un botón.
  • Sistema de menús: Monta un menú que recorres y ajustas con un encoder rotativo y guarda las opciones en la EEPROM.

Conectar una LCD 16x2 sin módulo I2C puede parecer al principio un lío de cables, pero cuando entiendes cómo recibe los comandos la pantalla, puedes usar cualquier LCD de caracteres, la 20x4 e incluso otros microcontroladores con la misma lógica. En la app BlueGrays, los proyectos "Mostrar un mensaje en una LCD 16x2", "Texto que rebota en la LCD" y "Medir distancias con una LCD" te guían paso a paso por esta conexión con esquema y código listo.

Preguntas frecuentes

¿Por qué mi LCD 16x2 muestra cuadros negros?

Si los cuadros aparecen solo en la fila superior, la alimentación y el contraste están bien, pero el Arduino no ha podido inicializar la pantalla; revisa los cables RS, E y D4–D7 y el orden de pines del constructor de LiquidCrystal. Si hay cuadros tenues en las dos filas, el contraste está demasiado alto y basta con girar el potenciómetro.

¿Por qué la LCD se ilumina pero no muestra texto?

La causa más frecuente es un contraste demasiado bajo: si V0 queda cerca de 5 V, los caracteres no se ven. Comprueba que el cursor del potenciómetro está conectado a V0 y gíralo despacio. Si el contraste es correcto y aparecen cuadros en la fila superior, el problema está en los cables de datos o en el código.

¿Se puede usar una LCD 16x2 sin potenciómetro?

Sí. Una resistencia fija de 1–2,2 kΩ entre V0 y GND da buen contraste en la mayoría de módulos de 5 V. Lo más fiable es encontrar el valor una vez con un potenciómetro y luego sustituirlo por una resistencia fija. También puedes conectar V0 a un pin PWM a través de un filtro RC y ajustar el contraste por software.

¿Dónde se conecta el pin RW de la LCD?

Si solo vas a escribir en la pantalla, conecta RW (pin 5) a GND; así la LCD queda siempre en modo escritura, que es como trabaja la biblioteca LiquidCrystal. Si RW queda al aire, la pantalla puede pasar al azar a modo lectura, poner tensión en las líneas de datos y no mostrar nada. Con RW a GND también se protegen los pines de las placas de 3,3 V.

¿Qué diferencia hay entre LiquidCrystal y LiquidCrystal_I2C?

LiquidCrystal controla la LCD directamente desde pines de Arduino y viene con el Arduino IDE; se usa en la conexión en paralelo. LiquidCrystal_I2C envía los mismos comandos a través de un módulo I2C con PCF8574 y hay que instalarla aparte. La mayoría de comandos (print, setCursor, createChar) son iguales en ambas; la versión I2C añade lcd.init() para iniciar y backlight() para la retroiluminación.

¿Mi código para LCD 16x2 funciona en una 20x4?

Sí, porque la conexión y los comandos son los mismos; solo tienes que cambiar lcd.begin(16, 2) por lcd.begin(20, 4). En una pantalla 20x4 las filas siguen en memoria el orden 1, 3, 2, 4, así que lo más limpio es ir a cada fila con setCursor(0, fila). La retroiluminación consume algo más.

Ver todos los proyectos
Mostrar un mensaje en una pantalla LCD 2x16
AR-29Avanzado
Premium

Mostrar un mensaje en una pantalla LCD 2x16

Tu primer paso para escribir texto en una pantalla. La pantalla LCD de dos líneas muestra primero un mensaje de espera, luego escribe un saludo en la línea de arriba y teclea una palabra letra a…

4.6(37)
51
Texto que rebota de izquierda a derecha en LCD
AR-30Avanzado
Premium

Texto que rebota de izquierda a derecha en LCD

En la fila de arriba de la pantalla LCD, la palabra BLUEGRAYS se desliza de un borde a otro y rebota como una pelota contra la pared, una y otra vez sin parar.

4.5(29)
40
Medición de distancias mediante pantalla LCD
AR-31Avanzado
Premium

Medición de distancias mediante pantalla LCD

Un aparato que mide distancias sin regla: mueve la mano delante del sensor y mira cómo cambia el número.

4.6(45)
59
Medición de temperatura con NTC y pantalla LCD 2x16
AR-44Principiante
Premium

Medición de temperatura con NTC y pantalla LCD 2x16

Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

4.5(33)
44
Reloj RTC DS1302 con pantalla LCD
AR-46Intermedio
Premium

Reloj RTC DS1302 con pantalla LCD

Un pequeño reloj de mesa que no pierde la hora aunque se vaya la luz. El módulo de reloj DS1302 guarda la hora gracias a su propia pila diminuta; cada segundo el Arduino la lee y escribe la hora y la…

4.7(41)
51
Voltímetro digital con pantalla LCD
AR-56Intermedio
Premium

Voltímetro digital con pantalla LCD

Descubre cuánto voltaje da una pila o un adaptador con un medidor hecho por ti. Un divisor de dos resistencias baja la tensión alta a un nivel que la placa puede leer, y el Arduino calcula el valor…

4.5(27)
36
Cerradura con contraseña, teclado 4x4 y LCD
AR-64Avanzado
Premium

Cerradura con contraseña, teclado 4x4 y LCD

Una pequeña cerradura electrónica que no deja pasar a quien no sepa la clave. Pulsas la tecla de almohadilla y escribes la clave en el teclado; si es correcta, la pantalla indica acceso permitido, se…

4.8(59)
75
Juego Arduino LCD Runner
AR-96Intermedio
Premium

Juego Arduino LCD Runner

Juego endless runner de desplazamiento lateral que se ejecuta en una pantalla LCD de 16x2 caracteres. El héroe corre automáticamente, el jugador salta los obstáculos pulsando el botón. Aparecen obstáculos aleatorios en las filas superior e inferior. El zumbador pasivo reproduce la melodía de apertura, el sonido de salto, el sonido de celebración de 50 puntos y la melodía de fin de partida. La pantalla de inicio "BlueGrays - Arduino Projects" se muestra al arrancar.

4.6(32)
56