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.

¿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ística | Valor |
|---|---|
| Chip controlador | HD44780 o compatible (KS0066, SPLC780) |
| Pantalla | 16 columnas × 2 filas, cada carácter de 5 × 8 píxeles |
| Alimentación | 4,5–5,5 V (también hay versiones especiales de 3,3 V) |
| Corriente lógica | Unos 1–2 mA |
| Corriente de retroiluminación | Unos 15–30 mA (LED, según el modelo) |
| Bus de datos | Paralelo de 8 o 4 bits |
| Caracteres personalizados | 8 (CGRAM) |
| Tiempo por comando | La mayoría 37 µs, clear() y home() unos 1,5 ms |
La función de los 16 pines
| Pin | Nombre | Función | Conexión |
|---|---|---|---|
| 1 | VSS | Masa | GND |
| 2 | VDD | Alimentación lógica | 5V |
| 3 | V0 (VO, VEE) | Ajuste de contraste | Cursor de un potenciómetro de 10 kΩ |
| 4 | RS | Selección de comando (LOW) o carácter (HIGH) | Arduino D12 |
| 5 | RW | Lectura (HIGH) o escritura (LOW) | GND (solo escribiremos) |
| 6 | E | Pulso de dato válido | Arduino D11 |
| 7–10 | D0–D3 | Bits de datos bajos | Libres en modo de 4 bits |
| 11 | D4 | Bit de datos 4 | Arduino D5 |
| 12 | D5 | Bit de datos 5 | Arduino D4 |
| 13 | D6 | Bit de datos 6 | Arduino D3 |
| 14 | D7 | Bit de datos 7 | Arduino D2 |
| 15 | A (LED+) | Ánodo de la retroiluminación | 5V a través de 220 Ω |
| 16 | K (LED−) | Cátodo de la retroiluminación | GND |
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

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
- 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.
- 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.
- 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.
- 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.
- Comprueba en el Gestor de Bibliotecas que LiquidCrystal está instalada (viene con el Arduino IDE) y carga el código de abajo.
- Cuando desaparezcan los cuadros y aparezca el texto, ajusta por última vez el contraste con el potenciómetro.
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.
| Comando | Qué 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.
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.
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.
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.
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íntoma | Causa probable | Solución |
|---|---|---|
| 16 cuadros negros solo en la fila superior | Pantalla sin inicializar: cables RS, E, D4–D7 u orden de pines del constructor incorrectos, o código sin cargar | Revisa los cables con la tabla y el orden LiquidCrystal lcd(RS, E, D4, D5, D6, D7) |
| Cuadros tenues en las dos filas | Contraste demasiado alto (V0 muy cerca de GND) | Gira el potenciómetro |
| La retroiluminación se enciende pero no se ve nada | Contraste demasiado bajo o V0 sin conectar | Comprueba que el cursor del potenciómetro va a V0 y gíralo |
| La retroiluminación no se enciende | Pines 15 y 16 sin conectar, invertidos o sin resistencia | Conecta A a 5V con 220 Ω y K a GND |
| Caracteres sin sentido o que se desplazan | Un cable de datos suelto, D4–D7 intercambiados, ruido de motores o relés | Asegura los cables, añade 100 µF en la alimentación y reinicia con lcd.begin() si hace falta |
| El texto parpadea | Se usa lcd.clear() en el bucle | Sobrescribe con setCursor() y borra las cifras viejas con espacios |
| Queda una cifra antigua al acortarse el número | El valor nuevo es más corto que el anterior | Añade espacios tras el valor |
| No aparece texto tras un carácter personalizado | createChar llevó el cursor a la memoria de caracteres | Llama a setCursor() después de createChar |
¿Conviene pasar a un módulo I2C?

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ística | Paralelo (4 bits) | Con módulo I2C |
|---|---|---|
| Pines de Arduino usados | 6 | 2 (A4, A5) |
| Número de cables | 12 (incluida alimentación y potenciómetro) | 4 |
| Refresco de toda la pantalla | Menos de 2 ms | Unos 20–30 ms a 100 kHz |
| Ajuste de contraste | Potenciómetro externo | Trimmer en el módulo |
| Apagar la retroiluminación por software | Requiere un transistor extra | lcd.noBacklight() |
| Biblioteca | LiquidCrystal (incluida en el IDE) | LiquidCrystal I2C (se instala aparte) |
| Problemas típicos | Maraña de cables, conexiones flojas | Direcció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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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.

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.

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…

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…

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…

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…

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

