Este artigo inclui tudo o que precisa de saber sobre como usar um Display de Caracteres I2C LCD com Arduino. Incluí um diagrama de ligação e vários exemplos de código para o ajudar a começar.
A primeira parte deste artigo aborda os conceitos básicos de exibição de texto e números. Na segunda parte, irei detalhar como exibir caracteres personalizados e como pode usar as outras funções da biblioteca LiquidCrystal_I2C.
Depois de saber como exibir texto e números no LCD, sugiro que consulte os artigos abaixo. Nestes tutoriais, aprenderá a medir e mostrar dados de sensores no LCD.
Materiais necessários
Componentes de hardware
 | 16×2 character I2C LCD | × 1 | Amazon |
| 20×4 character I2C LCD (alternativa) | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Jumper wires (macho para fêmea) | × 4 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Ferramentas
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Noções básicas sobre LCD I2C
Este guia faz parte do nosso conjunto de artigos sobre Displays. Este tipo de LCD é ideal para mostrar texto e números, daí o nome ‘LCD de caracteres’.
O LCD I2C que usamos neste tutorial vem com um pequeno circuito adicional montado na parte traseira do módulo. Este módulo inclui um chip PCF8574 (para comunicação I2C) e um potenciômetro para ajustar o retroiluminado LED.
A vantagem de um LCD I2C é que a ligação é muito simples. Só precisa de dois pinos de dados para controlar o LCD. Os LCDs padrão normalmente requerem cerca de 12 ligações, o que pode ser um problema se não tiver muitos pinos GPIO disponíveis.
Felizmente, também pode comprar o circuito adicional I2C separadamente em Amazon, para que possa facilmente atualizar um LCD padrão.
Para um tutorial e diagrama de ligação para LCDs de caracteres padrão, consulte o seguinte artigo:
Se olhar atentamente para o LCD, verá pequenos retângulos que formam os caracteres individuais do LCD. Cada retângulo é composto por uma grelha de 5×8 pixels. Mais adiante neste tutorial, mostrarei como controlar os pixels individuais para exibir caracteres personalizados no LCD.
Especificações
As especificações dos LCDs 16×2, 20×4 e outros tamanhos são praticamente as mesmas. Todos usam o mesmo HD44780 Hitachi LCD controller, por isso pode trocá-los facilmente. Só precisará alterar as especificações de tamanho no seu código Arduino.
As especificações de um típico display I2C 16×2 podem ser encontradas na tabela abaixo.
Especificações do LCD I2C 16×2
| Tensão de funcionamento | 5 V |
| Controlador | Controlador LCD Hitachi HD44780 |
| Endereço padrão | 0x27 |
| Resolução do ecrã | 2 linhas × 16 caracteres |
| Resolução dos caracteres | 5 × 8 pixels |
| Dimensões do módulo | 80 × 36 × 12 mm |
| Dimensões da área de visualização | 64,5 × 16,4 mm |
| Custo | Check price |
Para mais informações, pode consultar as folhas de dados abaixo.
As folhas de dados dos modelos 16×2 e 20×4 incluem as dimensões do LCD e pode encontrar mais informações sobre o controlador Hitachi no datasheet do HD44780.
O chip PCF8574 é usado no módulo I2C na parte traseira do LCD.
Como ligar o LCD I2C ao Arduino UNO
O diagrama de ligação abaixo mostra como ligar o LCD I2C ao Arduino. Ligar um LCD I2C é muito mais fácil do que ligar um LCD padrão. Só precisa de ligar 4 pinos em vez de 12.
As ligações também estão indicadas na tabela abaixo.
Ligações do LCD I2C
| LCD de Caracteres I2C | Arduino |
|---|---|
| GND | GND |
| VCC | 5 V |
| SDA | A4 |
| SCL | A5 |
Se não estiver a usar um Arduino Uno, os pinos SDA e SCL podem estar em localizações diferentes.
Note que um Arduino Uno com layout R3 (pinout 1.0) também tem os pinos SDA (linha de dados) e SCL (linha de relógio) perto do pino AREF. Consulte a tabela abaixo para mais detalhes.
| Placa | 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 |
Ajustar o contraste do LCD
Depois de ligar o LCD, terá de ajustar o contraste do ecrã. No módulo I2C, encontrará um potenciômetro que pode rodar com uma pequena chave de fendas.
Ligue o Arduino via USB para alimentar o LCD. Deve ver o retroiluminado acender. Agora rode o potenciômetro até que uma (LCD 16×2) ou duas linhas (LCD 20×4) de retângulos apareçam. Pode ajustar o contraste mais tarde, se necessário.
Depois disso, podemos começar a programar o LCD.
Instalar a biblioteca LiquidCrystal_I2C para Arduino
Neste tutorial, vou usar a LiquidCrystal_I2C biblioteca. Esta biblioteca tem muitas funções integradas que facilitam a programação do LCD.
A versão mais recente desta biblioteca pode ser encontrada aqui:
Certifique-se de que tem esta biblioteca exata instalada e elimine quaisquer outras bibliotecas com o mesmo nome (LiquidCrystal_I2C). Outras bibliotecas provavelmente funcionarão também, mas podem usar nomes ligeiramente diferentes para as funções.
A biblioteca LiquidCrystal_I2C funciona em conjunto com a Wire.h biblioteca que permite comunicar com dispositivos I2C. Esta biblioteca já vem pré-instalada no Arduino IDE.
Para instalar esta biblioteca, vá a Tools > Manage Libraries (Ctrl + Shift + I no Windows) no Arduino IDE. O Gestor de Bibliotecas abrirá e atualizará a lista de bibliotecas instaladas.
Agora procure por ‘liquidcrystal_i2c’ e procure a biblioteca de Frank de Brabander. Selecione a versão mais recente e clique em Instalar.
A biblioteca inclui alguns exemplos que pode usar, mas terá de os modificar para corresponder à sua configuração de hardware. Incluí vários exemplos de código abaixo que pode usar com a ligação que mostrei anteriormente.
Primeiro vou mostrar-lhe um código básico de exemplo e depois explicarei as funções com mais detalhe.
Como encontrar o endereço I2C do meu LCD?
A maioria dos LCDs I2C vem com o endereço padrão ‘0x27’, mas pode ser diferente dependendo do lote/fabricante. Se for esse o caso, terá de encontrar o endereço real do LCD antes de começar a usá-lo. No site do Arduino, pode encontrar um sketch simples que faz a varredura do barramento I2C à procura de dispositivos. Se um dispositivo for encontrado, o endereço será mostrado no monitor serial.
/*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);
}
Se carregar este sketch no Arduino e o executar, deverá ver a seguinte saída no Monitor Serial (Ctrl + Shift + M).
Anote o endereço que encontrar, vai precisar dele mais tarde para programar o LCD.
Código básico de exemplo Arduino para LCD I2C
Este sketch de exemplo mostrará o clássico ‘Hello World!’ na primeira linha do LCD e ‘LCD tutorial’ na segunda linha.
/* 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");
}
Deverá ver a seguinte saída no LCD:
A seguir, explicarei como o código funciona.
Como o código funciona
Primeiro, as bibliotecas necessárias são incluídas. Como mencionado anteriormente, precisamos tanto da Wire.h como da biblioteca LiquidCrystal_I2C. No resto deste tutorial, abordarei mais funções integradas desta biblioteca.
#include "Wire.h" // Library for I2C communication #include "LiquidCrystal_I2C.h" // Library for LCD
O próximo passo é criar um objeto LCD com a classe LiquidCrystal_I2C e especificar o endereço e as dimensões. Para isso, usamos a função LiquidCrystal_I2C(address, columns, rows).
Aqui terá de alterar o endereço padrão para o endereço que encontrou anteriormente, caso seja diferente. Ao usar um LCD 20×4, altere esta linha para LiquidCrystal_I2C(0x27,20,4);
Note que chamámos ao display ‘lcd’. Pode dar-lhe outro nome, como ‘menu_display’. Terá de substituir ‘lcd’ pelo novo nome no resto do 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
No setup, o LCD é iniciado com lcd.init() e o retroiluminado é ligado com lcd.backlight().
void setup() {
// Initiate the LCD:
lcd.init();
lcd.backlight();
}
Loop
Na secção loop do código, o cursor é colocado na terceira coluna e na primeira linha do LCD com lcd.setCursor(2,0).
Note que a contagem começa em 0 e o primeiro argumento especifica a coluna. Assim, lcd.setCursor(2,1) posiciona o cursor na terceira coluna e na segunda linha.
De seguida, a string ‘Hello World!’ é impressa com lcd.print("Hello World!"). Note que deve colocar aspas (” “) em torno do texto, pois estamos a imprimir uma text string.
Quando quiser imprimir números, não são necessárias aspas. Por exemplo 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".
}
Se quiser ver um exemplo para exibir (alterar) variáveis no LCD, consulte o meu tutorial para o sensor de distância ultrassónico HC-SR04:
Outras funções úteis da biblioteca LiquidCrystal_I2C
O sketch de exemplo acima mostra o básico de exibir texto no LCD. Agora vamos ver as outras funções da biblioteca LiquidCrystal_I2C.
clear()
Limpa o ecrã do LCD e posiciona o cursor no canto superior esquerdo (primeira linha e primeira coluna) do display. Pode usar esta função para mostrar palavras diferentes em loop.
#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);
}
home()
Posiciona o cursor no canto superior esquerdo do LCD. Use clear() se também quiser limpar o display.
cursor()
Mostra o cursor do LCD: um sublinhado (linha) na posição do próximo caractere a ser impresso.
noCursor()
Esconde o cursor do LCD. O exemplo seguinte cria um cursor a piscar no fim de “Hello World!”.
#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);
}
blink()
Cria um cursor do LCD em estilo bloco a piscar: um retângulo a piscar na posição do próximo caractere a ser impresso.
noBlink()
Desativa o cursor em estilo bloco do LCD. O exemplo seguinte mostra o cursor a piscar durante 5 segundos e depois desativa-o por 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);
}
display()
Esta função liga o ecrã do LCD e mostra qualquer texto ou cursor que tenha sido impresso no display.
noDisplay()
Esta função desliga qualquer texto ou cursor impresso no LCD. O texto/dados não são apagados da memória do LCD.
Isto significa que serão mostrados novamente quando a função display() for chamada.
O exemplo seguinte cria um efeito de texto a piscar.
#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);
}
write()
Esta função pode ser usada para escrever um caractere no LCD. Veja a secção sobre criação e exibição de caracteres personalizados abaixo para mais informações.
scrollDisplayLeft()
Desloca o conteúdo do display (texto e cursor) um espaço para a esquerda.
Pode usar esta função na secção loop do código em combinação com delay(500), para criar uma animação de texto a rolar.
#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()
Desloca o conteúdo do display (texto e cursor) um espaço para a direita.
autoscroll()
Esta função ativa o deslocamento automático do LCD. Isto faz com que cada caractere enviado para o display empurre os caracteres anteriores um espaço para o lado.
Se a direção atual do texto for da esquerda para a direita (padrão), o display desloca-se para a esquerda; se a direção for da direita para a esquerda, o display desloca-se para a direita.
Isto tem o efeito de imprimir cada novo caractere na mesma posição do LCD.
O sketch de exemplo seguinte ativa o deslocamento automático e imprime os caracteres de 0 a 9 na posição (16,0) do LCD. Altere para (20,0) para um LCD 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()
Desativa o deslocamento automático do LCD.
leftToRight()
Esta função faz com que o texto flua para a direita a partir do cursor, como se o display estivesse alinhado à esquerda (padrão).
rightToLeft()
Esta função faz com que o texto flua para a esquerda a partir do cursor, como se o display estivesse alinhado à direita.
Como criar e exibir caracteres personalizados?
Com a função createChar() é possível criar e exibir caracteres personalizados no LCD. Isto é especialmente útil se quiser mostrar um caractere que não faz parte do ASCII character set.
CGROM e CGRAM
Os LCDs baseados no controlador Hitachi HD44780 têm dois tipos de memória: CGROM e CGRAM (Character Generator ROM e RAM).
O CGROM gera todos os padrões de caracteres 5 x 8 pontos a partir dos códigos padrão de 8 bits. O CGRAM pode gerar padrões de caracteres definidos pelo utilizador.
Para displays 5 x 8 pontos, o CGRAM pode armazenar até 8 caracteres personalizados e para displays 5 x 10 pontos, 4. Para mais informações, consulte o datasheet.
Exemplo de código para caracteres personalizados
O sketch de exemplo seguinte cria e exibe oito caracteres personalizados (numerados de 0 a 7). Pode copiar o código clicando no botão no canto superior direito do campo de código.
/* 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);
}
Deverá ver a seguinte saída no LCD:
Como o código funciona
Depois de incluir a biblioteca e criar o objeto LCD, são definidas as matrizes dos caracteres personalizados. Cada matriz consiste em 8 bytes (apenas 5 bits são considerados). Há 1 byte para cada linha da matriz LED 5 x 8. Neste exemplo, são criados 8 caracteres personalizados.
// Make custom characters:
byte Heart[] = {
B00000,
B01010,
B11111,
B11111,
B01110,
B00100,
B00000,
B00000
};
Ao olhar atentamente para a matriz, verá o seguinte. Cada linha consiste em 5 números correspondentes aos 5 pixels de um caractere 5 x 8 pontos. Um 0 significa pixel desligado e um 1 significa pixel ligado. O prefixo ‘B’ é o formatador binário específico do Arduino.
É possível editar cada linha manualmente, mas recomendo usar esta ferramenta online LCD Custom Character Generator. Esta aplicação cria automaticamente a matriz do caractere e pode clicar nos pixels para os ligar ou desligar.
No setup, os caracteres personalizados são criados com lcd.createChar(num, data). O primeiro argumento desta função é o número do caractere personalizado (0-7) e o segundo argumento é a matriz do caractere que criámos.
// 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);
Na loop, todos os caracteres são exibidos com lcd.write(). Como argumento, usamos o número do caractere personalizado que queremos mostrar.
lcd.setCursor(0, 1); lcd.write(0);
Conclusão
Neste artigo, mostrei-lhe como usar um LCD de caracteres I2C com Arduino. Também temos um artigo sobre How To Control A Character I2C LCD with ESP32, se quiser trabalhar com um microcontrolador ESP32 em vez disso.
Se tiver alguma dúvida, sugestão ou achar que falta algo neste tutorial, por favor deixe um comentário abaixo.
