Aprender

Un LCD 20x4 en un Arduino: cuatro filas por I2C

Intermedio

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: dos LCD 20x4, uno directo y uno I2Cen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
Un LCD 20x4 directo en seis pines y un LCD 20x4 I2C en A4 y A5, controlados por un ATmega328P simulado.

Un LCD de caracteres 20x4, vendido como LCD2004, muestra cuatro filas de veinte caracteres. Es el hermano mayor del 16x2, con el mismo controlador HD44780, y viene de las mismas dos formas: con dieciséis pines directos, o con un módulo I2C que los reduce a cuatro cables.

El circuito de arriba es un Uno controlando uno de cada tipo. El panel directo imprime una línea de cuarenta caracteres de una sola vez, para mostrar la sorpresa que todo dueño de un 20x4 encuentra: el texto se sale de la fila 0 y continúa en la fila 2, no en la fila 1. El panel I2C coloca cada fila con setCursor() y cuenta los segundos. Si tienes un 16x2, la página del 16x2 I2C lo cubre.

Lo que necesitas

  • Un Arduino Uno
  • Un LCD 20x4 con módulo I2C (LCD2004 con PCF8574)
  • Para el segundo panel: un LCD 20x4 directo
  • Una protoboard y cables jumper

Cableado

Componente y pinVa aNota
GND del LCD I2CGND
VCC del LCD I2C5 V
SDA del LCD I2CA4El pin de datos I2C del Uno
SCL del LCD I2CA5El pin de reloj I2C del Uno
RS y E del LCD directoPines 2, 3
D4 a D7 del LCD directoPines 4, 5, 6, 7Modo de cuatro bits
VSS, V0 y RW del LCD directoGNDV0 a tierra es el contraste máximo
VDD del LCD directo5 V

Cuatro filas son en realidad dos líneas

El controlador HD44780 solo tiene dos líneas de memoria, de cuarenta caracteres cada una. Un 16x2 muestra los primeros dieciséis de cada una. Un 20x4 muestra cada línea dos veces: la fila 0 son los primeros veinte caracteres de la línea 1 y la fila 2 son los siguientes veinte, y las filas 1 y 3 hacen lo mismo con la línea 2.

Así que las cuatro filas comienzan en las direcciones de memoria 0x00, 0x40, 0x14 y 0x54. LiquidCrystal_I2C conoce esa tabla, por eso setCursor(0, 2) llega al inicio de la fila 2. Imprime una cadena de más de veinte caracteres sin setCursor() y sigue avanzando por la línea 1, entrando en la fila 2.

Ejecuta el circuito y el panel directo lo demuestra. Su sketch imprime "Row 0 runs off here " y luego "and on into row 2..." sin un setCursor() entre ellas, y la segunda mitad aparece en la fila 2. La fila 1 contiene "Row 1 is line 2", colocada ahí con setCursor(0, 1).

El código de ejemplo I2C

The backpack is a PCF8574 port expander soldered to the back of the panel. It turns the LCD’s pins into an I2C device at address 0x27, or 0x3F on boards with the PCF8574A chip. In the Arduino IDE install "LiquidCrystal I2C" from the Library Manager; in Mokxi it is built in.

La línea que importa para un 20x4 es el constructor: LiquidCrystal_I2C lcd(0x27, 20, 4). El 20 y el 4 le indican a la biblioteca la forma del panel, así que usa las direcciones de fila correctas. Luego init() inicia el controlador, backlight() enciende la luz, y setCursor(columna, fila) coloca cada línea donde quieras, con las filas numeradas de 0 a 3.

Ejecuta este sketch en un panel 20x4 I2C y muestra cuatro filas: "Four rows of twenty", luego "Row 1 starts at 0x40", "Row 2 starts at 0x14" y "Row 3 starts at 0x54".

Sketch de ejemplo para LCD 20x4 I2C
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 20, 4);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Four rows of twenty");
  lcd.setCursor(0, 1);
  lcd.print("Row 1 starts at 0x40");
  lcd.setCursor(0, 2);
  lcd.print("Row 2 starts at 0x14");
  lcd.setCursor(0, 3);
  lcd.print("Row 3 starts at 0x54");
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Decirle por error a la biblioteca que es 16x2

Copy a 16x2 sketch to a 20x4 and the constructor still says LiquidCrystal_I2C lcd(0x27, 16, 2). Rows 0 and 1 work, so it looks fine at first. But the library now thinks there are only two rows, so setCursor(0, 2) and setCursor(0, 3) both go to row 1.

Ejecuta el sketch de arriba con 16, 2 en el constructor y el panel muestra "Four rows of twenty" en la fila 0 y "Row 3 starts at 0x54" en la fila 1, escritos sobre el texto de las filas 1 y 2. Las filas 2 y 3 quedan vacías. Cámbialo de nuevo a 20, 4 y aparecen las cuatro filas.

Actualizar un número sin parpadeo

El panel I2C del circuito cuenta segundos en la fila 2. Su loop no borra la pantalla. Mueve el cursor a la columna 9 de la fila 2 e imprime el número nuevo sobre el anterior, cuatro veces por segundo. clear() es lento, unos 1.5 milisegundos en el controlador y mucho más por I2C, y deja la pantalla en blanco, lo que se ve como parpadeo.

Si un número puede hacerse más corto, de 10 a 9 por ejemplo, imprime un espacio después para que el dígito anterior no se quede atrás.

El panel sin módulo, y tus propios caracteres

Without a backpack, a 20x4 has the same sixteen pins as a 16x2 and wires the same way: RS, E and four data lines in four-bit mode, with RW and V0 to ground. The bare panel in the circuit uses pins 2 to 7. Its sketch uses Mokxi’s own small LCD driver, but the stock LiquidCrystal library does the same job with lcd.begin(20, 4).

Ambos tipos guardan espacio para ocho caracteres propios, de cinco puntos de ancho y ocho de alto, y así es como la gente dibuja iconos de batería, flechas y dígitos grandes a lo largo de dos filas. lcd.createChar() guarda uno, y lcd.write() con su número, de 0 a 7, lo muestra.

Errores comunes

La dirección incorrecta. Con 0x3F en el sketch y un módulo en 0x27, el controlador nunca se configura, y el panel muestra su aspecto de encendido: filas 0 y 2 llenas de bloques sólidos y filas 1 y 3 vacías. Ejecuta un escáner I2C para encontrar la dirección real.

16, 2 en el constructor de un 20x4, así que las filas 2 y 3 acaban en la fila 1.

Líneas de más de veinte caracteres, que continúan en la fila dos filas más abajo.

El ajustador de contraste del módulo girado hasta el tope, así que el cristal parece vacío con la luz de fondo encendida. Gíralo despacio hasta que aparezca el texto.

Olvidar backlight(). El texto está ahí, pero no puedes leerlo.

Abre este circuito en el editor. Arduino Uno: dos LCD 20x4, uno directo y uno I2C, conectados como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Qué biblioteca uso para un LCD 20x4 I2C?

LiquidCrystal I2C (LiquidCrystal_I2C.h), la misma que usa el 16x2. Declárala como LiquidCrystal_I2C lcd(0x27, 20, 4).

¿Cuál es la dirección I2C de un LCD 20x4?

Normalmente 0x27. Los módulos con el chip PCF8574A usan 0x3F. Un sketch de escáner I2C te dice cuál es.

¿Por qué mi texto salta de la fila 0 a la fila 2?

El controlador guarda las filas 0 y 2 como una sola línea larga. El texto que pasa de la columna 19 de la fila 0 continúa en la fila 2. Usa setCursor() para cada fila.

¿Puedo usar el código de 16x2 en una LCD de 20x4?

Sí, una vez que cambies el constructor a 20, 4. Con 16, 2 la biblioteca envía las filas 2 y 3 a la fila 1.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.