Cómo controlar un carácter I2C LCD con Arduino

Este artículo incluye todo lo que necesitas saber sobre el uso de un LCD I2C de caracteres con Arduino. He incluido un diagrama de cableado y muchos códigos de ejemplo para ayudarle a empezar.

The first part of this article covers the basics of displaying text and numbers. In the second half, I will go into more detail on how to display custom characters and how you can use the other functions of the LiquidCrystal_I2C library.

Una vez que sepa cómo mostrar texto y números en la pantalla LCD, le sugiero que eche un vistazo a los artículos siguientes. En estos tutoriales, aprenderá a medir y mostrar los datos del sensor en la pantalla LCD.

Artículos recomendados

• Cómo utilizar un sensor de distancia ultrasónico HC-SR04 con Arduino
• Cómo utilizar los sensores DHT11 y DHT22 con Arduino
• Tutorial de sensor de temperatura analógico LM35 con Arduino
• Tutorial del sensor de temperatura analógico TMP36 con Arduino

(I also have an article on How To Control A Character I2C LCD with ESP32 if you want to work with an ESP32 microcontroller instead).

Suministros

Componentes de hardware

	LCD I2C de 16×2 caracteres	× 1	Amazon
	LCD I2C de 20×4 caracteres (alternativa)	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Cables de puente (macho a hembra)	× 4	Amazon
	Cable USB tipo A/B	× 1	Amazon

Herramientas

Destornillador pequeño

Amazon

Software

Arduino IDE

Makerguides.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to products on Amazon.com. As an Amazon Associate we earn from qualifying purchases.

Fundamentos de I2C LCD

This guide is part of our hub of articles on Arduino Displays. This type of LCD is ideal for displaying text and numbers, hence the name ‘character LCD’.

The I2C LCD that we are using in this tutorial comes with a small add-on circuit mounted on the back of the module. This module features a PCF8574 chip (for I2C communication) and a potentiometer to adjust the LED backlight.

The advantage of an I2C LCD is that the wiring is very simple. You only need two data pins to control the LCD. Standard LCDs typically require around 12 connections, which can be a problem if you do not have many GPIO pins available.

Por suerte, también puedes comprar el circuito complementario I2C por separado en Amazon, así que también puedes actualizar fácilmente una pantalla LCD estándar.

Para un tutorial y un diagrama de cableado para LCDs de caracteres estándar, por favor vea el siguiente artículo:

• Cómo utilizar una pantalla LCD de 16×2 caracteres con Arduino

If you look closely at the LCD, you can see the small rectangles that form the individual characters of the LCD. Each rectangle is made up of a grid of 5×8 pixels. Later in this tutorial, I will show you how you can control the individual pixels to display custom characters on the LCD.

Especificaciones

The specifications of the 16×2, 20×4, and other sized LCDs are mostly the same. They all use the same HD44780 Hitachi LCD controller, so you can easily swap them. You will only need to change the size specifications in your Arduino code.

Las especificaciones de una pantalla I2C típica de 16×2 se pueden encontrar en la siguiente tabla.

Especificaciones del LCD 16×2 I2C

Tensión de funcionamiento	5 V
Controlador	Controlador LCD Hitachi HD44780
Dirección por defecto	0x27
Resolución de la pantalla	2 líneas × 16 caracteres
Resolución del carácter	5 × 8 píxeles
Dimensiones del módulo	80 × 36 × 12 mm
Dimensiones de la zona de visión	64,5 × 16,4 mm
Coste	Comprobar el precio

Para más información, puede consultar las hojas de datos que aparecen a continuación.

Las hojas de datos de 16×2 y 20×4 incluyen las dimensiones de la pantalla LCD y puede encontrar más información sobre el controlador LCD de Hitachi en la hoja de datos del HD44780.

El chip PCF8574 se utiliza en el módulo I2C de la parte posterior del LCD.

Cómo conectar el LCD I2C a Arduino UNO

The wiring diagram below shows you how to connect the I2C LCD to the Arduino. Wiring an I2C LCD is a lot easier than connecting a standard LCD. You only need to connect 4 pins instead of 12.

Las conexiones también se indican en la tabla siguiente.

Conexiones I2C LCD

LCD de caracteres I2C	Arduino
GND	GND
VCC	5 V
SDA	A4
SCL	A5

Si no estás usando un Arduino Uno, los pines SDA y SCL pueden estar en una ubicación diferente.

Ten en cuenta que un Arduino Uno con la disposición R3 (pinout 1.0) también tiene las cabeceras de los pines SDA (línea de datos) y SCL (línea de reloj) cerca del pin AREF. Consulte la tabla siguiente para obtener más detalles.

Junta	SDA	SCL
Arduino Uno	A4	A5
Arduino Nano	A4	A5
Arduino Micro	2	3
Arduino Mega 2560	20	21
Arduino Leonardo	2	3
Arduino Due	20	21

Ajuste del contraste de la pantalla LCD

Después de haber cableado la pantalla LCD, tendrá que ajustar el contraste de la pantalla. En el módulo I2C, encontrarás un potenciómetro que puedes girar con un pequeño destornillador.

Plug in the USB connector of the Arduino to power the LCD. You should see the backlight light up. Now rotate the potentiometer until one (16×2 LCD) or 2 rows (20×4 LCD) of rectangles appear. You can tweak the contrast later if needed.

Una vez hecho esto, podemos empezar a programar el LCD.

Instalación de la biblioteca LiquidCrystal_I2C Arduino

En este tutorial, usaré la librería LiquidCrystal_I2C. Esta biblioteca tiene muchas funciones incorporadas que hacen que la programación del LCD sea bastante fácil.

La última versión de esta biblioteca se puede encontrar aquí en GitHub o haga clic en el botón de descarga a continuación.

Make sure that you have this exact library installed and delete any other libraries that have the same name (LiquidCrystal_I2C). Other libraries will probably work as well but might use slightly different names for the different functions.

La librería LiquidCrystal_I2C funciona en combinación con la librería Wire.h que permite comunicarse con dispositivos I2C. Esta librería viene preinstalada con el IDE de Arduino.

Para instalar esta biblioteca, vaya a Herramientas > Gestionar Bibliotecas (Ctrl + Shift + I en Windows) en el IDE de Arduino. El Administrador de Bibliotecas se abrirá y actualizará la lista de bibliotecas instaladas.

Ahora busca 'liquidcrystal_i2c' y busca la biblioteca de Frank de Brabander. Selecciona la última versión y haz clic en Instalar.

The library does include some examples that you can use, but you will have to modify them to match your hardware setup. I have included many example codes below that you can use with the wiring setup I have shown earlier.

Primero le mostraré un código de ejemplo básico y luego le explicaré las funciones con más detalle.

¿Cómo encontrar la dirección I2C de mi LCD?

Most I2C LCDs ship with the default address ‘0x27’, but it can be different depending on the batch/manufacturer. If this is the case, you will need to find the actual address of the LCD before you can start using it. On the Arduino website, you can find a simple example sketch that scans the I2C-bus for devices. If a device is found, it will display the address in the serial monitor.

/*I2C_scanner
  This sketch tests standard 7-bit addresses.
  Devices with higher bit address might not be seen properly.
*/
  
#include "Wire.h"

void setup() {
  Wire.begin();

  Serial.begin(9600);
  while (!Serial);
  Serial.println("\nI2C Scanner");
}

void loop() {
  byte error, address;
  int nDevices;

  Serial.println("Scanning...");

  nDevices = 0;
  for (address = 1; address < 127; address++ ) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.print(address, HEX);
      Serial.println("  !");

      nDevices++;
    }
    else if (error == 4) {
      Serial.print("Unknown error at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.println(address, HEX);
    }
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");

  delay(5000);
}

Si subes este sketch al Arduino y lo ejecutas, deberías ver la siguiente salida en el Monitor Serial (Ctrl + Shift + M).

Anote la dirección que encuentre, la necesitará más tarde cuando programe el LCD.

Código básico de ejemplo de Arduino para LCD I2C

Puedes cargar el siguiente código de ejemplo en el Arduino utilizando el IDE de Arduino.

For this tutorial, I used this 16×2 I2C character LCD display, but you can use other I2C LCDs of different sizes as well. This example sketch will display the classic ‘Hello World!’ on the first line of the LCD and ‘LCD tutorial’ on the second line.

A continuación, explicaré cómo funciona el código.

/* I2C LCD with Arduino example code. More info: https://www.makerguides.com */

#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD

// Wiring: SDA pin is connected to A4 and SCL pin to A5.
// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered)
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.

void setup() {
  // Initiate the LCD:
  lcd.init();
  lcd.backlight();
}

void loop() {
  // Print 'Hello World!' on the first line of the LCD:
  lcd.setCursor(2, 0); // Set the cursor on the third column and first row.
  lcd.print("Hello World!"); // Print the string "Hello World!"
  lcd.setCursor(2, 1); //Set the cursor on the third column and the second row (counting starts at 0!).
  lcd.print("LCD tutorial");
}

Debería ver la siguiente salida en la pantalla LCD:

Cómo funciona el código

First, the required libraries are included. As mentioned earlier we need both the Wire.h and the LiquidCrystal_I2C library. In the rest of this tutorial, I will cover more of the built-in functions of this library.

*Cuando se utiliza la última versión de la librería LiquidCrystal_I2C ya no es necesario incluir la librería wire.h en tu boceto. La otra librería importa wire.h automáticamente.

#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD

The next step is to create an LCD object with the LiquidCrystal_I2C class and specify the address and dimensions. For this, we use the function LiquidCrystal_I2C(address, columns, rows).

This is where you will need to change the default address to the address you found earlier if it happens to be different. When using a 20×4 LCD, change this line to LiquidCrystal_I2C(0x27,20,4);

Note that we have called the display ‘lcd’. You can give it a different name if you want like ‘menu_display’. You will need to change ‘lcd’ to the new name in the rest of the sketch.

// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered)
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.

Setup

En la configuración, la pantalla LCD se inicia con lcd.init() y la luz de fondo se enciende con lcd.backlight().

void setup() {
  // Initiate the LCD:
  lcd.init();
  lcd.backlight();
}

Loop

En la sección de bucle del código, el cursor se sitúa en la tercera columna y la primera fila de la pantalla LCD con lcd.setCursor(2,0).

Tenga en cuenta que el conteo comienza en 0 y el primer argumento especifica la columna. Así que lcd.setCursor(2,1) coloca el cursor en la tercera columna y en la segunda fila.

A continuación se imprime la cadena "¡Hola Mundo!" con lcd.print("Hello World!"). Tenga en cuenta que debe colocar comillas (" ") alrededor del texto, ya que estamos imprimiendo un cadena de texto.

Si desea imprimir números, no es necesario poner comillas. Por ejemplo lcd.print(12345).

void loop() {
  lcd.setCursor(2, 0); // Set the cursor on the third column and first row.
  lcd.print("Hello World!"); // Print the string "Hello World!".
  lcd.setCursor(2, 1); //Set the cursor on the third column and the second row.
  lcd.print("LCD tutorial"); // Print the string "LCD tutorial".
}

Si quieres ver un ejemplo para mostrar (cambiar) las variables en la pantalla LCD, echa un vistazo a mi tutorial para el sensor de distancia ultrasónico HC-SR04:

• Cómo utilizar un sensor de distancia ultrasónico HC-SR04 con Arduino

Otras funciones útiles de la biblioteca LiquidCrystal_I2C

El ejemplo anterior le muestra los fundamentos de la visualización de texto en el LCD. Ahora echaremos un vistazo a las otras funciones de la librería LiquidCrystal_I2C.

clear()

Borra la pantalla LCD y coloca el cursor en la esquina superior izquierda (primera fila y primera columna) de la pantalla. Puede utilizar esta función para mostrar diferentes palabras en un bucle.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
}

void loop() {
  lcd.clear();
  lcd.print("Monday");
  delay(2000);
  lcd.clear();
  lcd.print("13:45");
  delay(2000);
}

casa()

Posiciona el cursor en la esquina superior izquierda de la pantalla. Utilice clear() si también quieres borrar la pantalla.

cursor()

Muestra el cursor de la pantalla LCD: un guión bajo (línea) en la posición del siguiente carácter a imprimir.

noCursor()

Oculta el cursor del LCD. El siguiente ejemplo crea un cursor parpadeante al final de "¡Hola Mundo!".

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("Hello World!");
}

void loop() {
  lcd.cursor();
  delay(500);
  lcd.noCursor();
  delay(500);
}

parpadeo()

Crea un cursor LCD estilo bloque parpadeante: un rectángulo parpadeante en la posición del siguiente carácter a imprimir.

noBlink()

Desactiva el cursor LCD de estilo bloque. El siguiente ejemplo muestra el cursor parpadeante durante 5 segundos y luego lo desactiva durante 2 segundos.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("blink() example");
}

void loop() {
  lcd.blink();
  delay(5000);
  lcd.noBlink();
  delay(2000);
}

mostrar()

Esta función enciende la pantalla LCD y muestra el texto o los cursores que se han impreso en la pantalla.

noDisplay()

Esta función desactiva cualquier texto o cursor impreso en la pantalla LCD. El texto/los datos no se borran de la memoria del LCD.

Esto significa que se mostrará de nuevo cuando la función display() se llama.

El siguiente ejemplo crea un efecto de texto parpadeante.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("Blinking text");
}

void loop() {
  lcd.display();
  delay(2000);
  lcd.noDisplay();
  delay(2000);
}

escribir()

Esta función se puede utilizar para escribir un carácter en la pantalla LCD. Consulte la sección sobre la creación y visualización de caracteres personalizados más abajo para obtener más información.

scrollDisplayLeft()

Desplaza el contenido de la pantalla (texto y cursor) un espacio hacia la izquierda.

Puede utilizar esta función en la sección de bucle del código en combinación con delay(500)para crear una animación de texto en movimiento.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("Hello World!");
}

void loop() {
  lcd.scrollDisplayLeft();
  delay(500);
}

scrollDisplayRight()

Desplaza el contenido de la pantalla (texto y cursor) un espacio hacia la derecha.

autoscroll()

Esta función activa el desplazamiento automático de la pantalla LCD. Esto hace que cada carácter emitido en la pantalla desplace los caracteres anteriores un espacio.

Si la dirección actual del texto es de izquierda a derecha (por defecto), la pantalla se desplaza hacia la izquierda, si la dirección actual es de derecha a izquierda, la pantalla se desplaza hacia la derecha.

Esto tiene el efecto de emitir cada nuevo carácter en el mismo lugar de la pantalla LCD.

El siguiente ejemplo de sketch habilita el desplazamiento automático e imprime el carácter 0 a 9 en la posición (16,0) de la LCD. Cambie esto a (20,0) para una LCD de 20×4.

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
}

void loop() {
  lcd.autoscroll();
  lcd.setCursor(16, 0);
  for (int x = 0; x < 10; x++) {
    lcd.print(x);
    delay(500);
  }
  lcd.clear();
}

noAutoscroll()

Desactiva el desplazamiento automático de la pantalla LCD.

leftToRight()

Esta función hace que el texto fluya hacia la derecha desde el cursor, como si la pantalla estuviera justificada a la izquierda (por defecto).

rightToLeft()

Esta función hace que el texto fluya hacia la izquierda desde el cursor, como si la pantalla estuviera justificada a la derecha.

¿Cómo se crean y se muestran los caracteres personalizados?

Con la función createChar() it is possible to create and display custom characters on the LCD. This is especially useful if you want to display a character that is not part of the standard ASCII character set.

CGROM y CGRAM

Las pantallas LCD que se basan en el controlador LCD Hitachi HD44780 tienen dos tipos de memoria: CGROM y CGRAM (ROM y RAM del generador de caracteres).

CGROM genera todos los patrones de caracteres de 5 x 8 puntos a partir de los códigos de caracteres estándar de 8 bits. CGRAM puede generar patrones de caracteres definidos por el usuario.

Para pantallas de 5 x 8 puntos, CGRAM puede escribir hasta 8 caracteres personalizados y para pantallas de 5 x 10 puntos 4. Para más información, consulte la hoja de datos.

Código de ejemplo de caracteres personalizados

The following example sketch creates and displays eight custom characters (numbered 0 – 7). You can copy the code by clicking on the button in the top right corner of the code field.

/* Arduino example code to display custom characters on I2C character LCD. More info: www.www.makerguides.com */

// Include the library:
#include "LiquidCrystal_I2C.h"

// Create lcd object of class LiquidCrystal_I2C:
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

byte Bell[] = {
  B00100,
  B01110,
  B01110,
  B01110,
  B11111,
  B00000,
  B00100,
  B00000
};

byte Alien[] = {
  B11111,
  B10101,
  B11111,
  B11111,
  B01110,
  B01010,
  B11011,
  B00000
};

byte Check[] = {
  B00000,
  B00001,
  B00011,
  B10110,
  B11100,
  B01000,
  B00000,
  B00000
};

byte Speaker[] = {
  B00001,
  B00011,
  B01111,
  B01111,
  B01111,
  B00011,
  B00001,
  B00000
};

byte Sound[] = {
  B00001,
  B00011,
  B00101,
  B01001,
  B01001,
  B01011,
  B11011,
  B11000
};

byte Skull[] = {
  B00000,
  B01110,
  B10101,
  B11011,
  B01110,
  B01110,
  B00000,
  B00000
};

byte Lock[] = {
  B01110,
  B10001,
  B10001,
  B11111,
  B11011,
  B11011,
  B11111,
  B00000
};

void setup() {
  // Initialize LCD and turn on the backlight:
  lcd.init();
  lcd.backlight();

  // Create new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

  // Clear the LCD screen:
  lcd.clear();

  // Print a message to the lcd:
  lcd.print("Custom Character");
}

// Print all the custom characters:
void loop() {
  lcd.setCursor(0, 1);
  lcd.write(0);

  lcd.setCursor(2, 1);
  lcd.write(1);

  lcd.setCursor(4, 1);
  lcd.write(2);

  lcd.setCursor(6, 1);
  lcd.write(3);

  lcd.setCursor(8, 1);
  lcd.write(4);

  lcd.setCursor(10, 1);
  lcd.write(5);

  lcd.setCursor(12, 1);
  lcd.write(6);

  lcd.setCursor(14, 1);
  lcd.write(7);
}

Debería ver la siguiente salida en la pantalla LCD:

Cómo funciona el código

After including the library and creating the LCD object, the custom character arrays are defined. Each array consists of 8 bytes (only 5 bits are considered). There is 1 byte for each row of the 5 x 8 led matrix. In this example, 8 custom characters are created.

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

When looking closely at the array, you will see the following. Each row consists of 5 numbers corresponding to the 5 pixels in a 5 x 8 dot character. A 0 means pixel off and a 1 means pixel on. The prefix ‘B’ is the Arduino specific binary formatter.

It is possible to edit each row by hand, but I recommend using this visual tool on GitHub. This application automatically creates the character array and you can click on the pixels to turn them on or off.

En la configuración, los caracteres personalizados se crean con lcd.createChar(num, data). The first argument in this function is the number of the custom character (0-7) and the second argument is the character array that we created.

  // Create new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

En el bucle, todos los caracteres se muestran con lcd.write(). Como argumento, utilizamos el número del carácter personalizado que queremos mostrar.

  lcd.setCursor(0, 1);
  lcd.write(0);

Conclusión

En este artículo, le he mostrado cómo utilizar una pantalla LCD I2C de caracteres con Arduino.

Espero que te haya resultado útil e informativo. Si lo has hecho, ¡compártelo con un amigo al que también le guste la electrónica y hacer cosas!

Me encantaría saber qué proyectos planeas construir (o ya has construido) con estos LCDs. Si tienes alguna pregunta, sugerencia o si crees que faltan cosas en este tutorial, por favor deja un comentario abajo.

Tenga en cuenta que los comentarios son retenidos por la moderación para evitar el spam.