- Controlador de LCD de matriz de pontos 16x2 IC HD44780:
- Exibindo um caractere personalizado no LCD 16x2:
- Explicação de programação e trabalho:
- Conexões de circuito e testes:
Em nosso tutorial anterior, aprendemos como fazer a interface de um LCD 16 * 2 com um microcontrolador PIC. Recomendamos que você passe por isso antes de prosseguir, se você for iniciante em microcontroladores PIC. Anteriormente, também aprendemos os fundamentos do PIC usando o programa piscando do LED e os temporizadores no microcontrolador PIC. Você pode verificar aqui todos os tutoriais sobre como aprender microcontroladores PIC usando o compilador MPLABX e XC8.
Neste tutorial, vamos torná-lo mais interessante, criando nossos próprios caracteres personalizados e exibindo-os em nossa tela LCD usando o microcontrolador PIC PIC16F877A. Além disso, existem alguns caracteres personalizados predefinidos usados principalmente fornecidos pelo próprio IC HD44780A, também veremos como podemos usá-los. Conforme explicado em nosso tutorial anterior, nosso LCD tem um controlador Hitachi HD44780 embutido que nos ajuda a exibir os personagens. Cada caractere que exibimos já está pré-definido dentro da ROM do IC HD44780. Aprenderemos sobre o controlador de LCD IC HD44780, antes de exibir caracteres no LCD.
Controlador de LCD de matriz de pontos 16x2 IC HD44780:
Para exibir um caractere personalizado, precisamos de alguma forma informar ao IC como será a aparência do caractere personalizado. Para fazer isso, devemos saber sobre os três tipos de memórias presentes dentro do IC controlador de LCD HD44780:
Character Generator ROM (CGROM): É a memória só de leitura que, como dito anteriormente, contém todos os padrões dos caracteres pré-definidos dentro dela. Esta ROM varia de acordo com cada tipo de interface IC, e alguns podem ter alguns caracteres personalizados predefinidos com eles.
Display Data RAM (DDRAM): Esta é uma memória de acesso aleatório. Cada vez que exibimos um caractere, seu padrão será obtido do CGROM e transferido para a DDRAM e, em seguida, será colocado na tela. Para simplificar, a DDRAM terá os padrões de todos os caracteres que estão sendo exibidos na tela LCD. Desta forma, para cada ciclo, o IC não precisa buscar dados do CGROM e ajuda a obter uma frequência de atualização curta
RAM gerador de caracteres (CGRAM): Esta também é uma memória de acesso aleatório, para que possamos escrever e ler dados a partir dela. Como o nome indica, essa memória será aquela que pode ser usada para gerar o caractere personalizado. Temos que formar um padrão para o personagem e escrevê-lo no CGRAM, esse padrão pode ser lido e exibido na Tela quando necessário.
Agora, já temos uma compreensão básica dos tipos de memória presentes na interface IC HD44780. Vamos dar uma olhada em sua folha de dados para entender um pouco mais.
Como, a ficha técnica indica, o IC HD44780 forneceu 8 locais para armazenar nossos padrões personalizados no CGRAM, também à direita podemos ver que existem alguns caracteres pré-definidos que também podem ser exibidos em nossa tela LCD. Vamos ver como podemos fazer isso.
Exibindo um caractere personalizado no LCD 16x2:
Para exibir um caractere personalizado, devemos primeiro gerar um padrão para ele e depois salvá-lo no CGRAM. Como já temos as funções da biblioteca conosco, deve ser fácil fazer isso com alguns comandos simples. Aqui está a Biblioteca para funções de LCD, mas aqui copiamos e colamos todas as funções da Biblioteca no próprio programa, portanto, não há necessidade de incluir este arquivo de cabeçalho em nosso programa. Verifique também este artigo para ver o funcionamento do LCD básico e seus pinouts.
A primeira etapa é gerar um padrão ou caractere personalizado. Como sabemos, cada caractere é uma combinação de 5 * 8 pontos. Temos que selecionar qual ponto (pixel) deve ficar alto e qual deve ficar baixo. Simplesmente desenhe uma caixa como a abaixo e sombreie as regiões com base no seu personagem. Meu personagem aqui é um homem de pau (espero que pareça um). Depois de sombreado, escreva simplesmente o valor binário equivalente de cada byte conforme mostrado abaixo.
Basta colocar um '1' na região sombreada e um '0' na região não sombreada para cada byte, e é isso que nosso padrão personalizado está pronto. Da mesma forma, fiz 8 códigos de padrões personalizados para nossos 8 espaços de memória e apresentei no CGROM. Eles estão listados na tabela abaixo.
|
S.NO: |
Personagem Personalizado |
Código Padrão |
|
1 |
|
0b01110, 0b01110, 0b00100, 0b01110, 0b10101, 0b00100, 0b01010, 0b01010 |
|
2 |
|
0b00000, 0b00000, 0b01010, 0b00100, 0b00100, 0b10001, 0b01110, 0b00000 |
|
3 |
|
0b00100, 0b01110, 0b11111, 0b11111, 0b01110, 0b01110, 0b01010, 0b01010 |
|
4 |
|
0b01110, 0b10001, 0b10001, 0b11111, 0b11011, 0b11011, 0b11111, 0b00000 |
|
5 |
|
0b01110, 0b10000, 0b10000, 0b11111, 0b11011, 0b11011, 0b11111, 0b00000 |
|
6 |
|
0b00000, 0b10001, 0b01010, 0b10001, 0b00100, 0b01110, 0b10001, 0b00000 |
|
7 |
|
0b00000, 0b00000, 0b01010, 0b10101, 0b10001, 0b01110, 0b00100, 0b00000 |
|
8 |
|
0b11111, 0b11111, 0b10101, 0b11011, 0b11011, 0b11111, 0b10001, 0b11111 |
Nota: Não é obrigatório carregar todos os 8 espaços previstos no CGRAM.
Explicação de programação e trabalho:
Agora que nossos códigos padrão estão prontos, só temos que carregá-los no CGRAM do LCD e exibi-los usando o microcontrolador PIC. Para carregá-los no CGRAM, podemos formar um array 5 * 8 de elementos e carregar cada byte usando um ' for loop '. A matriz do código padrão é mostrada abaixo:
const unsigned short Custom_Char5x8 = {0b01110,0b01110,0b00100,0b01110,0b10101,0b00100,0b01010,0b01010, // Código para espaço de memória CGRAM 1 0b00000,0b00000,0b01010,0b00100,0b00100,0b10001,0b01110,0b00000, // Código para Espaço de memória CGRAM 2 0b00100,0b01110,0b11111,0b11111,0b01110,0b01110,0b01010,0b01010, // Código para espaço de memória CGRAM 3 0b01110,0b10001,0b10001,0b11111,0b11011,0b11011,0b111,0 Código de memória CGRAM, // espaço 4 0b01110,0b10000,0b10000,0b11111,0b11011,0b11011,0b11111,0b00000, // Código para espaço de memória CGRAM 5 0b00000,0b10001,0b01010,0b10001,0b00100,0b01110,0b10001,0b00000, // Código para espaço de memória CGRAM 6 0b00000,0b00000,0b01010,0b10101,0b10001,0b01110,0b00100,0b00000, // Código para espaço de memória CGRAM 7 0b11111,0b11111,0b10101,0b11011,0b11011,0b11111,0b10001,0b11111 // Código para espaço de memória CGRAM 8;
Cada espaço de memória é carregado com seu padrão de caractere respeitado. Para carregar este padrão no IC HD44780, a folha de dados do HD44780 deve ser consultada, mas são apenas linhas de comando que podem ser usadas para definir o endereço do CGRAM
// *** Carrega o caractere personalizado no CGROM *** ////// Lcd_Cmd (0x04); // Definir endereço CGRAM Lcd_Cmd (0x00); //.. definir o endereço CGRAM para (i = 0; i <= 63; i ++) Lcd_Print_Char (Custom_Char5x8); Lcd_Cmd (0); // Voltar para a página inicial Lcd_Cmd (2); //.. return to Home // *** Carregando caractere personalizado completo *** //////
Aqui, dentro do ' loop for', cada valor binário é carregado no CGROM. Uma vez que o padrão é carregado, os caracteres personalizados podem ser exibidos simplesmente chamando a localização do padrão usando a função void Lcd_Print_Char (dados char) como mostrado abaixo.
Lcd_Print_Char (0); // Exibir caractere personalizado 0 Lcd_Print_Char (1); // Exibir caractere personalizado 1 Lcd_Print_Char (2); // Mostra o caractere personalizado 2 Lcd_Print_Char (3); // Exibe o caractere personalizado 3 Lcd_Print_Char (4); // Exibe o caractere personalizado 4 Lcd_Print_Char (5); // Exibe o caractere personalizado 5 Lcd_Print_Char (6); // Exibe o caractere personalizado 6 Lcd_Print_Char (7); // Exibir caractere personalizado 7
Imprimir caractere especial predefinido:
O HD44780 IC possui alguns caracteres especiais predefinidos armazenados no DDROM. Esses caracteres podem ser impressos diretamente na tela, referindo-se ao seu valor binário na folha de dados.
Por exemplo: O valor binário do caractere "ALPHA" é 0b11100000. Como obtê-lo pode ser entendido na figura abaixo, da mesma forma você pode obter valor para qualquer caractere especial que esteja pré-definido no IC.
Uma vez que o valor binário é conhecido, o caractere correspondente pode ser impresso na tela simplesmente usando a função void Lcd_Print_Char (dados char) conforme mostrado abaixo, Lcd_Print_Char (0b11100000); // valor binário de alfa da planilha de dados
O código completo deste projeto é fornecido abaixo na seção Código, verifique também a explicação detalhada do Vídeo no final deste tutorial.
Conexões de circuito e testes:
Este projeto não tem nenhum requisito de hardware adicional, simplesmente usamos as mesmas conexões do tutorial de interface LCD anterior e usamos a mesma placa que criamos no Tutorial de LED piscando. Como sempre, vamos simular o programa usando Proteus para verificar nossa saída.
Assim que tivermos a simulação rodando conforme o esperado, vamos gravar o código diretamente em nossa configuração de hardware. A saída do programa deve ser algo assim:
É assim que você pode exibir qualquer caractere personalizado no LCD 16x2 usando o microcontrolador PIC com compilador MPLABX e XC8. Verifique também nossa Série de aprendizado de microcontroladores PIC completa aqui.