Como usar um LCD de 16×2 caracteres com Arduino

Este tutorial inclui tudo o que precisa de saber sobre como controlar um LCD de caracteres com Arduino. Incluí um diagrama de ligação e vários exemplos de código. Estes ecrãs são ótimos para mostrar dados de sensores ou texto e são também bastante económicos.

A primeira parte deste artigo cobre o básico de como mostrar texto e números. Na segunda parte, vou detalhar como exibir caracteres personalizados e como pode usar as outras funções da LiquidCrystal biblioteca Arduino.

Como verá, precisa de bastantes ligações para controlar estes ecrãs. Por isso, gosto de os usar com um módulo I2C interface montado na parte de trás. Com este módulo I2C, só precisa de duas ligações para controlar o LCD. Veja o tutorial abaixo se também quiser usar um módulo I2C:

Fornecimentos

Componentes de hardware

	16×2 character LCD	× 1	Amazon
	20×4 character LCD	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Breadboard	× 1	Amazon
	Jumper wires	~ 10	Amazon
	10 kΩ potentiometer	× 1	Amazon
	USB cable type A/B	× 1	Amazon

Software

Arduino IDE

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.

Visão geral do hardware

Estes LCDs estão disponíveis em vários tamanhos (16×2 1602, 20×4 2004, 16×1, etc.), mas todos usam o mesmo HD44780 chip controlador LCD com interface paralela da Hitachi. Isto significa que pode facilmente trocá-los. Só precisará de alterar as especificações de tamanho no seu código Arduino.

Especificações do LCD 16×2

Tensão de funcionamento	5 V
Controlador	Controlador LCD Hitachi HD44780
Resolução do ecrã	2 linhas x 16 caracteres
Resolução dos caracteres	5 x 8 pixels
Dimensões do módulo	80 x 36 x 12 mm
Dimensões da área de visualização	64,5 x 16,4 mm
Custo	Check price

Para mais informações, pode consultar as folhas de dados abaixo. As folhas de dados do 16×2 e 20×4 incluem as dimensões do LCD e na folha de dados do HD44780 encontra mais informações sobre o driver LCD da Hitachi.

Pinout do LCD 16×2

O LCD tem 16 pinos de ligação, numerados de 1 a 16 da esquerda para a direita.

O pinout de um LCD HD44780 padrão está na tabela abaixo:

Nº do pino	Símbolo	Ligação	Função
1	VSS	GND Arduino	Terra do sinal
2	VDD	5 V Arduino	Alimentação lógica do LCD
3	V0	Potenciômetro de 10 kΩ	Ajuste de contraste
4	RS	Pino 2 Arduino	Sinal de seleção de registo
5	R/W	GND Arduino	Sinal de seleção leitura/escrita
6	E	Pino 3 Arduino	Sinal de ativação da operação
7 – 14	D0 – D7	–	Linhas do barramento de dados usadas no modo 8 bits
11 – 14	D4 – D7	Pinos 4 – 7 Arduino	Linhas do barramento de dados usadas no modo 4 bits
15	A (LED+)	5 V Arduino	Ânodo do backlight do LCD
16	K (LED-)	GND Arduino	Cátodo do backlight do LCD

Testar o LCD e ajustar o contraste

Para testar o ecrã, precisa de fazer as ligações conforme mostrado na figura abaixo.

A maioria dos LCDs tem um resistor em série incorporado para o backlight LED. Deve encontrá-lo na parte de trás do LCD ligado ao pino 15 (Ânodo). Se o seu ecrã não incluir um resistor, terá de adicionar um entre os 5 V e o pino 15. Deve ser seguro usar um resistor de 220Ω, mas este valor pode deixar o ecrã um pouco fraco. Pode consultar a folha de dados para a corrente máxima do backlight e usar essa informação para escolher um resistor adequado.

Depois de ligar o LCD, terá de ajustar o contraste do ecrã. Isto faz-se rodando o potenciômetro de 10 kΩ no sentido horário ou anti-horário.

Ligue o Arduino via USB para alimentar o LCD. Deve ver o backlight acender. Agora rode o potenciômetro até aparecer uma linha (LCD 16×2) ou duas linhas (LCD 20×4) de retângulos.

Pode ajustar o contraste mais tarde, se necessário.

Como ligar o LCD ao Arduino UNO

Para controlar o LCD e mostrar caracteres, precisa de adicionar algumas ligações extra. Veja o diagrama de ligações abaixo e a tabela de pinout da introdução deste artigo.

Vamos usar o LCD em modo 4 bits, o que significa que não precisa de ligar nada aos pinos D0-D3. O pino R/W está ligado ao terra, o que o coloca em nível BAIXO e define o LCD para o modo ESCRITA.

Depois de ligar tudo, podemos começar a programar o LCD.

Exemplo de código Arduino para LCD de caracteres

Para controlar o LCD vamos usar a LiquidCrystal biblioteca. Esta biblioteca já vem pré-instalada no Arduino IDE. Pode encontrá-la indo a Sketch > Include Library > LiquidCrystal.

A biblioteca LiquidCrystal tem muitas funções incorporadas e torna o controlo de LCDs de caracteres muito fácil.

O código de exemplo abaixo mostra como exibir uma mensagem no LCD. A seguir, vou explicar como o código funciona e como pode usar as outras funções da biblioteca LiquidCrystal.

/* Basic Arduino example code for displaying text 
  on 16x2, 20x4 etc. character LCDs. 
  www.www.makerguides.com */

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

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

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

Deve ver a seguinte saída no LCD:

Como o código funciona

Depois de incluir a biblioteca, o próximo passo é criar uma nova instância da classe LiquidCrystal. Isto é feito com a função LiquidCrystal(rs, enable, d4, d5, d6, d7). Como parâmetros usamos os pinos do Arduino aos quais ligámos o ecrã. Note que chamámos ao ecrã ‘lcd’. Pode dar outro nome, como ‘menu_display’. Terá de alterar ‘lcd’ para o novo nome no resto do sketch.

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

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

No setup() o LCD é iniciado com a função begin(cols,rows). Ao usar um LCD 20×4, altere esta linha para lcd.begin(20,4);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

No loop() o cursor é colocado na terceira coluna e primeira linha do LCD com lcd.setCursor(2,0). Note que a contagem começa em 0, e o primeiro argumento especifica a coluna. Se não especificar a posição do cursor, o texto será impresso na posição inicial padrão (0,0) se o ecrã estiver vazio, ou atrás do último caractere impresso.

De seguida, a string ‘Hello World!’ é impressa com lcd.print("Hello World!"). Note que deve colocar aspas (” “) em volta do texto. Para imprimir números ou variáveis, não são necessárias aspas.

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

Se quiser ver um exemplo de como mostrar (alterar) variáveis no LCD, veja o meu tutorial sobre How to use a HC-SR04 Ultrasonic Distance Sensor with Arduino.

No exemplo usei um ecrã LCD I2C, mas o código após o setup é o mesmo para ambos.

Outras funções da biblioteca LiquidCrystal

A biblioteca LiquidCrystal do Arduino tem muitas outras funções incorporadas que podem ser úteis. Pode encontrar uma visão geral delas abaixo com explicações e alguns exemplos de código.

clear()

Limpa o ecrã do LCD e posiciona o cursor no canto superior esquerdo (primeira linha e primeira coluna) do ecrã. Pode usar esta função para mostrar palavras diferentes em loop.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
}

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

cursor()

Mostra o cursor do LCD: um sublinhado (linha) na posição do próximo caractere a imprimir.

noCursor()

Esconde o cursor do LCD. O exemplo seguinte cria um cursor a piscar no fim de “cursor()”.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("cursor()");
}

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

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

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  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 ecrã.

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

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  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 criar e mostrar caracteres personalizados abaixo para mais informações.

scrollDisplayLeft()

Desloca o conteúdo do ecrã (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.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("scrollDisplayLeft() example");
}

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

scrollDisplayRight()

Desloca o conteúdo do ecrã (texto e cursor) um espaço para a direita.

autoscroll()

Esta função ativa o scroll automático do LCD. Isto faz com que cada caractere enviado para o ecrã 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 ecrã desloca-se para a esquerda; se for da direita para a esquerda, o ecrã desloca-se para a direita. O efeito é que cada novo caractere é mostrado na mesma posição do LCD.

O sketch de exemplo seguinte ativa o scroll 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.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
}

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 scroll automático do LCD.

leftToRight()

Esta função faz o texto fluir para a direita a partir do cursor, como se o ecrã estivesse alinhado à esquerda (padrão).

rightToLeft()

Esta função faz o texto fluir para a esquerda a partir do cursor, como se o ecrã estivesse alinhado à direita.

Como criar e mostrar caracteres personalizados?

Com a função createChar() é possível criar e mostrar caracteres personalizados no LCD. Isto é especialmente útil se quiser mostrar um caractere que não faz parte do conjunto ASCII padrão.

Informação técnica: LCDs baseados no controlador Hitachi HD44780 têm dois tipos de memória: CGROM e CGRAM (Character Generator ROM e RAM). A CGROM gera todos os padrões de caracteres 5 x 8 pontos a partir dos códigos de caracteres padrão de 8 bits. A CGRAM pode gerar padrões de caracteres definidos pelo utilizador.

Para ecrãs 5 x 8 pontos, a CGRAM pode escrever até 8 caracteres personalizados e para ecrãs 5 x 10 pontos 4. Para mais informações consulte a folha de dados.

Exemplo de código Arduino para caracteres personalizados

O sketch de exemplo seguinte cria e mostra oito caracteres personalizados (numerados de 0 a 7).

/* Example sketch to create and display custom characters on 
   character LCD with Arduino and LiquidCrystal library. 
   For more info see www.www.makerguides.com */

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

// 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() {
  // Specify the LCD's number of columns and rows:
  lcd.begin(16, 2);

  // Create a 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);

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

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

void loop() {
  // Print all the custom characters:
  lcd.setCursor(0, 1);
  lcd.write(byte(0));
  lcd.setCursor(2, 1);
  lcd.write(byte(1));
  lcd.setCursor(4, 1);
  lcd.write(byte(2));
  lcd.setCursor(6, 1);
  lcd.write(byte(3));
  lcd.setCursor(8, 1);
  lcd.write(byte(4));
  lcd.setCursor(10, 1);
  lcd.write(byte(5));
  lcd.setCursor(12, 1);
  lcd.write(byte(6));
  lcd.setCursor(14, 1);
  lcd.write(byte(7));
}

Deve 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, 1 byte para cada linha. Neste exemplo são criados 8 caracteres personalizados.

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

Ao olhar de perto para a matriz, verá o seguinte. Cada linha consiste em 5 números correspondentes aos 5 pixels num caractere 5 x 8 pontos. Um 0 significa pixel desligado e um 1 significa pixel ligado.

É possível editar cada linha manualmente, mas recomendo usar esta visual tool no GitHub. 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 a 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);

No loop() todos os caracteres são mostrados com lcd.write(). Como parâmetro usamos o número do caractere que reservámos.

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

Conclusão

Neste artigo mostrei como usar um LCD alfanumérico com Arduino. Espero que tenha sido útil e informativo. Se tiver alguma dúvida, sugestão, ou achar que falta algo neste tutorial, por favor deixe um comentário abaixo.

Boas experiências 😉