Os Displays LCD são muito úteis para quem pretende usar um Micro-controlador para desenvolver uma aplicação. Eles permitem uma interface visual entre homem e máquina (HMI em inglês), barata e simples de usar. No LCD você pode enviar textos, números, símbolos e até imagens que podem dar uma indicação do que o Micro-controlador esta fazendo, dos dados que podem estar sendo coletados ou transmitidos, etc. Para quem não sabe, LCD significa em inglês – Liquid Crystal Display – ou mostrador de cristal liquido. Uma grande vantagem dos LCDs é que não precisam de muita energia para funcionar. Lembram-se dos relógios digitais de LCD, há décadas atrás ? As pilhas podiam durar meses e até um ano. Mas os LCDs que estamos falando, tem LEDs atrás para que possam ser usados em ambientes com pouca ou nenhuma luz. Esses LEDs é que gastam um pouco mais. Mas se fosse usar somente os LCDs, o consumo de energia seria baixíssimo !
Os monitores dos primeiros Laptops da década de 1980 usavam a mesma tecnologia LCD ! E sem iluminação de LED.
Laptop Toshiba T1000 – foto Wikipedia
No início da era das TVs Digitais, essa tecnologia LCD também foi muito usada. Atualmente existem outras tecnologias que reproduzem as imagens com muito mais fidelidade.
O mercado de displays LCD está sempre inovando, e hoje já temos displays coloridos: azuis, vermelhos, verdes, etc, isto é, para todos os gostos. Esse Guia fará sempre referência para os LCDs azuis. Mas fique sabendo que todos tem o mesmo princípio de funcionamento. O que muda somente é a cor do LED que o ilumina.
Para o uso de Micro-controladores como o Arduino, os displays LCD mais comuns são o 16×2 (16 caracteres x 2 linhas) ou 20×4 (20 caracteres x 4 linhas).
Quando eles foram criados décadas atrás, eles não eram luminosos. Eles simplesmente deixavam passar a luz ou então a obstruíam, deixando sombras. O mostrador é formado de duas placas acrílicas transparentes. Entre essas placas está o cristal líquido. Esse cristal líquido altera o seu comportamento cristalino, dependendo da tensão aplicada entre ele. Os displays, como dá para ver, são formados de vários pontinhos. Cada pontinho pode ficar claro ou escuro, dependendo da polarização da eletricidade de cada um. Sob as placas transparentes, existem uma matriz invisível de conexões que controlam todos esses pontinhos. Quem faz isso, são os chips controladores que ficam por trás do display.
O chip controlador de LCD mais usado atualmente no mundo inteiro, é um que foi desenvolvido pela Hitachi – o HD44780, há muito tempo atrás. Ele é tão bom, que se tornou um padrão. Se quiser aprofundar os seus estudos sobre LCDs, aprendendo à usar todos os inúmeros recursos disponíveis, recomendo a leitura do datasheet.
A comunicação entre o Controlador de LCD e o Micro-controlador (por exemplo, Arduino), pode ser paralela ( 4 ou 8 bits) ou serial (I2C). Para um número limitado de portas digitais, é recomendável o uso da interface I2C.
Como curiosidade, saiba que esse chip possui uma ROM interna onde já estão gravados alguns caracteres e símbolos. E para que você possa gerar seus próprios símbolos, existe uma memória RAM interna. Muito versátil !
Veja uma parte da Tabela de caracteres gravada internamente – cada caracter é formado por uma matriz de 5 x 8 pontos:
Display LCD 16×2 azul – foto Gustavo Murta
Esse é o Datasheet bem detalhado de um Display LCD 16×2 . Veja que ele usa chips controladores compatíveis com o padrão HD44780 :
Na parte superior do Display, existem 16 furos onde podem ser soldados pinos ou cabos de comunicação e alimentação. Atenção : a ligação incorreta ou uso de tensões acima de 5V poderá danificar o display.
OBS: A pinagem do LCD 16×2 é idêntica ao LCD 20×4 !
A iluminação do LCD é feita pelo LED. O pino 15 (Anodo do LED) pode ser conectado diretamente em +5 V e o pino 16 (catodo do LED) deve ser conectado no terra (GND). Dessa forma o LED vai consumir aproximadamente 22 mA. O consumo total de corrente (LCD + LED) do LCD 16×2 Azul é de aproximadamente 23 mA (sem considerar o backlight, que pode levar o consumo para entre 40 e 120 mA).
Se deseja consumir menor corrente, use um resistor em série, por exemplo de 220 ohms (consumo 7,6 mA).
Para ajuste do contraste do LCD, a tensão no pino 3 (VO) deve ser ajustada. Use um potenciômetro de 20K ohms. Nas extremidades do POT conecte o +5V e o GND. O pino central conecte no pino 3 do LCD. No meu LCD 16×2 azul, a tensão VO foi igual a 1,0 Volts aproximadamente.
Quando esse tipo de Display LCD foi desenvolvido, os barramentos de dados dos Micro-controladores usavam 8 bits. Na era Arduino, as portas digitais disponíveis são reduzidas. Para resolver essa limitação, foi desenvolvida uma interface I2C especialmente dedicada para os LCDs. O chip usado nesse módulo é o PCF8574 .Ele é um expansor de portas paralelas, tem uma interface I2C e pode controlar até 8 bits tanto como entrada ou como saída (dependendo da configuração). A velocidade da interface I2C esta limitada a 100 KHz. A tensão de alimentação pode ser 3,3V ou 5V, o que o habilita para todos os Micro-controladores mais comuns.
Essa foto é a parte de trás do Display LCD com a Interface I2C já conectada.
LCD 16×2 com Interface I2C – foto Gustavo Murta
Para conectar com o Arduino ou outro Micro-controlador , somente quatro pinos são necessários :
O potenciômetro Azul nessa interface é usado para ajuste do contraste. Após o Display energizado e programado, ajuste-o para tornar a imagem visível. O jumper LED é usado para ativar o LED Backlight. Se não quiser usar o LED para economizar energia, retire esse jumper. O led vermelho na placa serve como indicação que ela esta energizada.
Em uma interface I2C , a comunicação é serial. Para selecionar um dispositivo, o endereço é enviado para o barramento, pois em um mesmo barramento pode-se ter vários dispositivos.
O chip PCF8574 possui alguns endereços já definidos, dependendo do modelo (identifique o chip do seu módulo):
Além do endereço básico, através de 3 pinos de endereçamento (A0, A1 e A2) o endereçamento pode ser alterado, como no caso do uso de mais de um chip no mesmo barramento . Veja no módulo, os jumpers A0, A1 e A2.
Mais um detalhe muito importante ! Para que a interface I2C funcione adequadamente, resistores de PULL UP devem ser usados nas duas linhas (SCL e SDA) . Esses resistores conectam essas linhas ao VCC . Nesse módulo I2C, esses resistores de PULL UP (4,7 K ohms) já existem. Portanto não acrescente mais resistores na interface.
Como já informei , o Display LCD pode ser conectado ao Arduino através de um barramento Paralelo ou Serial (usando o módulo I2C).
No caso do barramento paralelo para o Arduino, usa-se apenas 4 bits de dados. Mas para as linhas de controles, mais portas são necessárias ( RS, R/W e ENABLE) . Somando um total de 7 portas ! Esse tipo de comunicação deve ser evitado se não houver um número de portas disponíveis para a aplicação.
Materiais necessários para o projeto com Arduino Nano e Display LCD 16×2
Esse é o diagrama Fritzing do circuito para teste do Display LCD 16×2 com Arduino Nano :
E esse é o diagrama eletrônico do mesmo circuito – Arduino Nano com LCD 16×2:
Veja que o pino 5 (R/W) esta aterrado (nível zero) . Portanto o Display só pode receber dados (Write).
Para posicionar os caracteres no Display, existe esse endereçamento das linhas e das colunas. Veja que a contagem começa do 0 e não do 1 (Linha 0, coluna 0) ! As diferenças de um Display de 16×2 para um Display 20×4 são a quantidade de caracteres e o endereçamento. Todos os comandos são idênticos para os dois tipos de Displays.
Nessa montagem , usaremos a Biblioteca Liquid Crystal, portanto ela deve ser instalada usando o procedimento abaixo.
Para instalar a nova Biblioteca, clique em Sketch > Incluir Biblioteca > Gerenciar Bibliotecas .
Após abrir a janela do Gerenciador de Biblioteca, refine a busca digitando o nome da biblioteca. Na biblioteca selecionada, clique em More Info e depois em Instalar. Após alguns segundos, ela será automaticamente instalada. Lembre-se que o seu computador precisa estar conectado na internet. Após a instalação da biblioteca, é necessário que feche e abra novamente o programa Arduino IDE.
Usando exemplos da Biblioteca Liquid Crystal, fiz esse Sketch para testar várias funções do Display :
Para configurar o tipo de Display :
lcd.begin(16, 2); // definindo o LCD – 16 colunas e 2 linhas
lcd.begin(20, 4); // definindo o LCD – 20 colunas e 4 linhas
/* Programa de Teste de LCD
Blog Eletrogate - https://blog.eletrogate.com/guia-completo-do-display-lcd-arduino/
Arduino Nano - LCD 16/2 azul - IDE 1.8.5
Gustavo Murta 11/abril/2018
Biblioteca LiquidCrystal https://github.com/arduino-libraries/LiquidCrystal
*/
#include <LiquidCrystal.h> // usando a biblioteca LiquidCrystal
const int rs = 8, en = 9, d4 = 4, d5 = 5, d6 = 6, d7 = 7; // definicao dos pinos do Display
LiquidCrystal lcd(rs, en, d4, d5, d6, d7); // configurando os pinos
int thisChar = 0 ;
void setup()
{
lcd.begin(16, 2); // definindo o LCD - 16 colunas e 2 linhas
}
void Hello () // imprimindo mensagem
{
lcd.setCursor(0, 0); // selecionando coluna 0 e linha 0
lcd.print("Blog ELETROGATE"); // print da mensagem
lcd.setCursor(2, 1); // selecionando coluna 2 e linha 1
lcd.print("Guia do LCD"); // Print da mensagem
delay(1000); // atraso de 1 segundo
}
void Flash ()
{
lcd.noDisplay(); // desliga display
delay(1000); // atraso de meio segundo
lcd.display(); // liga display
delay(1000); // atraso de meio segundo
lcd.clear(); // limpa a tela
delay(1000); // atraso de 1 segundo
}
void Blink () // teste do cursor
{
lcd.noBlink(); // apaga cursor
delay(1000); // atraso de 1 segundo
lcd.blink(); // acende cursor
delay(1000); // atraso de 1 segundo
lcd.clear(); // limpa a tela
delay(1000); // atraso de 1 segundo
}
void AutoScroll () // teste de rolagem de mensagem
{
lcd.setCursor(16, 1); // selecionando coluna 16 e linha 1
lcd.autoscroll(); // configura rolagem automatica de mensagem
for (thisChar = 0; thisChar < 10; thisChar++) // imprime de 0 a 9
{
lcd.print(thisChar); // imprime o numero
delay(350); // atraso de 350 ms
}
lcd.noAutoscroll(); // desliga rolagem autoamtica
lcd.clear(); // limpa a tela
delay(1000); // atraso de 1 segundo
}
void dirText () // teste de direcao de mensagem
{
lcd.clear(); // limpa a tela
lcd.cursor(); // liga o cursor
lcd.setCursor(10, 0); // selecionando coluna 10 e linha 1
for (thisChar = 1; thisChar < 10; thisChar++) // imprime de 1 a 9
{
lcd.rightToLeft(); // imprime da direita para a esquerda
lcd.print(thisChar); // imprime o numero
delay(350); // atraso de 350 ms
}
for (thisChar = 1; thisChar < 10; thisChar++) // imprime de 1 a 9
{
lcd.leftToRight(); // imprime da esquerda para a direita
lcd.print(thisChar); // imprime o numero
delay(350); // atraso de 350 ms
}
lcd.noCursor(); // desliga o cursor
}
void loop()
{
Hello (); // imprimindo mensagem
Flash (); // piscando a mensagem
Blink (); // teste do cursor
AutoScroll (); // teste de rolagem de mensagem
dirText (); // teste de direcao de mensagem
delay(1000); // atraso de 1 segundo
}
Mais um recurso bem legal da Biblioteca Liquid Crystal : criar caracteres especiais ! Essa biblioteca tem um método que permite, através do controle dos pontos da matriz 5×8 de cada caracter do LCD, a criação de qualquer símbolo ou caracter especial. Use o Gerador de caracteres do link abaixo, para criar o código do Sketch. Para desenhar, clique nos pontos da matriz 5×8. Copie o código gerado e insira-o no Sketch.
Gerador de símbolos e caracteres especiais
/* Programa Gerador de Caracter Especial no LCD
Blog Eletrogate - https://blog.eletrogate.com/guia-completo-do-display-lcd-arduino/
Arduino Nano - LCD 16/2 azul - IDE 1.8.5
Gustavo Murta 12/abril/2018
Biblioteca LiquidCrystal https://github.com/arduino-libraries/LiquidCrystal
*/
#include <LiquidCrystal.h> // usando a biblioteca LiquidCrystal
const int rs = 8, en = 9, d4 = 4, d5 = 5, d6 = 6, d7 = 7; // definicao dos pinos do Display
LiquidCrystal lcd(rs, en, d4, d5, d6, d7); // configurando os pinos
byte customChar[8] = // Matriz do caracter especial
{
0b00000,
0b11011,
0b11011,
0b00100,
0b00100,
0b10001,
0b01110,
0b00000
};
void setup() // ate 8 caracteres especiais podem ser criados
{
lcd.clear(); // limpa a tela
lcd.createChar(1, customChar); // criando o caracter especial 1
lcd.begin(16, 2); // definindo o LCD - 16 colunas e 2 linhas
lcd.write((byte)1); // imprimindo o carcter especial 1
}
void loop()
{
}
Encontrei no Youtube, essa aplicação também bem interessante do uso de números grandes no Display LCD 16×2.
Biblioteca Big Crystal
A biblioteca Liquid Crystal é bem versátil ! Permite o uso de vários tipos de interface :
Como referência para consulta, esse é o link para uso da interface SPI (pouco usada):
LCD16x2 com Interface SPI – ARDUINO
Como já citei anteriormente, existe um módulo de Interface I2C especialmente projetado para o uso de Displays LCD. A grande vantagem é o número reduzido de portas usadas no Arduino – somente duas – SCL e SDA.
Arduino – Biblioteca Wire / I2C
Ligações das Portas I2C (para Arduino) :
Não se esqueça de conectar o GND da Interface I2C no GND do Arduino. O mesmo para 5V . O consumo de corrente medido por mim foi de 27,5 mA. Faça o ajuste do contraste usando o potenciômetro da Interface I2C.
Materiais necessários para o projeto com Arduino Nano e Display LCD 16×2 I2C
Esse é o diagrama Fritzing do circuito para teste do Display LCD 16×2 (Interface I2C) com Arduino Nano :
Esse é o diagrama eletrônico do mesmo circuito – Display LCD 16×2 (Interface I2C) com Arduino Nano:
O primeiro teste a ser feito, é a identificação do endereço I2C da interface. Rode o Sketch I2C Scanner. Na minha montagem, o endereço encontrado foi:
I2C scanner. Procurando …
Endereco I2C encontrado: 63 (0x3F) – esse endereço deverá ser inserido no Sketch de teste
Encontrado 1 dispositivo(s).
// I2C Scanner
// Written by Nick Gammon
// Date: 20th April 2011
#include <Wire.h>
void setup()
{
Serial.begin (9600);
Serial.println ();
Serial.println ("I2C scanner. Procurando ...");
byte count = 0;
Wire.begin();
for (byte i = 8; i < 120; i++)
{
Wire.beginTransmission (i);
if (Wire.endTransmission () == 0)
{
Serial.print ("Endereco I2C encontrado: ");
Serial.print (i, DEC);
Serial.print (" (0x");
Serial.print (i, HEX);
Serial.println (")");
count++;
delay (1);
}
}
Serial.print ("Encontrado ");
Serial.print (count, DEC);
Serial.println (" dispositivo(s).");
}
void loop() {}
Essa é a Biblioteca Liquid Crystal I2C usada nessa montagem de teste (instale-a usando o procedimento já citado anteriormente):
Usando a Biblioteca Liquid Crystal I2C, criei o programa para testar as mesmas funções do exemplo anterior (interface 4 bits) :
/* Programa de Teste de LCD - Interface I2C
Blog Eletrogate - https://blog.eletrogate.com/guia-completo-do-display-lcd-arduino/
Arduino Nano - LCD 16/2 azul - IDE 1.8.5
Gustavo Murta 13/abril/2018
Biblioteca LiquidCrystal I2C https://github.com/marcoschwartz/LiquidCrystal_I2C
*/
#include <Wire.h> // usando a biblioteca Wire
#include <LiquidCrystal_I2C.h> // usando a biblioteca LiquidCrystal I2C
LiquidCrystal_I2C lcd(0x3F, 16, 2); // Configura endereço I2C e display com 16 caracteres e 2 linhas
int thisChar = 0 ;
void setup()
{
lcd.init(); // inicializa LCD
lcd.backlight(); // ativa led de backlight
}
void Hello () // imprimindo mensagem
{
lcd.setCursor(0, 0); // selecionando coluna 0 e linha 0
lcd.print("Blog ELETROGATE"); // print da mensagem
lcd.setCursor(2, 1); // selecionando coluna 2 e linha 1
lcd.print("Guia do LCD"); // Print da mensagem
delay(1000); // atraso de 1 segundo
}
void Flash ()
{
lcd.noDisplay(); // desliga display
delay(1000); // atraso de meio segundo
lcd.display(); // liga display
delay(1000); // atraso de meio segundo
lcd.clear(); // limpa a tela
delay(1000); // atraso de 1 segundo
}
void Blink () // teste do cursor
{
lcd.noBlink(); // apaga cursor
delay(1000); // atraso de 1 segundo
lcd.blink(); // acende cursor
delay(1000); // atraso de 1 segundo
lcd.clear(); // limpa a tela
delay(1000); // atraso de 1 segundo
}
void AutoScroll () // teste de rolagem de mensagem
{
lcd.setCursor(16, 1); // selecionando coluna 16 e linha 1
lcd.autoscroll(); // configura rolagem automatica de mensagem
for (thisChar = 0; thisChar < 10; thisChar++) // imprime de 0 a 9
{
lcd.print(thisChar); // imprime o numero
delay(350); // atraso de 350 ms
}
lcd.noAutoscroll(); // desliga rolagem autoamtica
lcd.clear(); // limpa a tela
delay(1000); // atraso de 1 segundo
}
void dirText () // teste de direcao de mensagem
{
lcd.clear(); // limpa a tela
lcd.cursor(); // liga o cursor
lcd.setCursor(10, 0); // selecionando coluna 10 e linha 1
for (thisChar = 1; thisChar < 10; thisChar++) // imprime de 1 a 9
{
lcd.rightToLeft(); // imprime da direita para a esquerda
lcd.print(thisChar); // imprime o numero
delay(350); // atraso de 350 ms
}
for (thisChar = 1; thisChar < 10; thisChar++) // imprime de 1 a 9
{
lcd.leftToRight(); // imprime da esquerda para a direita
lcd.print(thisChar); // imprime o numero
delay(350); // atraso de 350 ms
}
lcd.noCursor(); // desliga o cursor
}
void loop()
{
Hello (); // imprimindo mensagem
Flash (); // piscando a mensagem
Blink (); // teste do cursor
AutoScroll (); // teste de rolagem de mensagem
dirText (); // teste de direcao de mensagem
delay(1000); // atraso de 1 segundo
}
Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!
|
A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.
Conheça a Metodologia Eletrogate e Lecione um Curso de Robótica nas Escolas da sua Região!
Rua Rio de Janeiro, 441 - Sala 1301
Centro - Belo Horizonte/MG
CEP 30160-041
*Não temos atendimento físico
Eletrogate Componentes Eletrônicos
CNPJ: 18.917.521/0001-73
