Interface LCD com microcontrolador pic usando mplabx e xc8

Este é o nosso sexto tutorial em nossa série de tutoriais PIC, neste tutorial aprendemos a interface do LCD 16x2 com o microcontrolador PIC. Em nossos tutoriais anteriores, aprendemos o básico do PIC usando alguns programas com LEDs piscando e também aprendemos como usar temporizadores no microcontrolador PIC. Você pode verificar aqui todos os tutoriais sobre como aprender microcontroladores PIC usando o compilador MPLABX e XC8.

Este tutorial será interessante porque aprenderemos Como fazer a interface do LCD 16 × 2 com PIC16F877A, verifique o vídeo detalhado no final deste tutorial. Já se foram os velhos tempos em que usávamos LEDs para indicações do usuário. Vamos ver como podemos tornar nossos projetos mais interessantes e úteis usando telas de LCD. Verifique também nossos artigos anteriores sobre Interface de LCD com 8051, com Arduino, com Raspberry Pi, com AVR.

Funções para interface de LCD com microcontrolador PIC:

Para tornar as coisas mais fáceis, criamos uma pequena biblioteca que pode tornar as coisas mais fáceis ao usar este LCD com nosso PIC16F877A. O arquivo de cabeçalho "MyLCD.h" é fornecido aqui para download, contendo todas as funções necessárias para acionar o LCD usando PIC MCU. O código da biblioteca é bem explicado por linhas de comentários, mas se você ainda tiver dúvidas, entre em contato conosco através da seção de comentários. Verifique também este artigo para ver o funcionamento do LCD básico e seus pinagem.

Nota: É sempre recomendável saber o que realmente está acontecendo dentro do seu arquivo de cabeçalho porque isso o ajudará na depuração ou durante a alteração do MCU.

Agora, existem duas maneiras de adicionar esse código ao seu programa. Você pode copiar todas as linhas de código acima em MyLCD.h e colá-las antes de void main (). Ou você pode baixar o arquivo de cabeçalho usando o link e adicioná-los ao arquivo de cabeçalho do seu projeto ( #include "MyLCD.h "; ). Isso pode ser feito clicando com o botão direito do mouse no arquivo de cabeçalho e selecionando Adicionar item existente e navegando até este arquivo de cabeçalho.

Aqui, copiei e colei o código do arquivo de cabeçalho em meu arquivo C principal. Portanto, se você estiver usando nosso código, não precisará baixar e adicionar o arquivo de cabeçalho ao seu programa, apenas use o Código completo fornecido no final deste tutorial. Observe também que esta biblioteca só oferece suporte a microcontroladores PIC da série PIC16F.

Aqui estou explicando cada função dentro de nosso arquivo de cabeçalho abaixo:

void Lcd_Start (): Esta função deve ser a primeira função que deve ser chamada para começar a trabalhar com nosso LCD. Devemos chamar essa função apenas uma vez para evitar atrasos no programa.

void Lcd_Start () {Lcd_SetBit (0x00); para (int i = 1065244; i <= 0; i--) NOP (); Lcd_Cmd (0x03); __delay_ms (5); Lcd_Cmd (0x03); __delay_ms (11); Lcd_Cmd (0x03); Lcd_Cmd (0x02); // 02H é usado para Return home -> Limpa a RAM e inicializa o LCD Lcd_Cmd (0x02); // 02H é usado para Return home -> Limpa a RAM e inicializa o LCD Lcd_Cmd (0x08); // Selecione a linha 1 Lcd_Cmd (0x00); // Limpar exibição da linha 1 Lcd_Cmd (0x0C); // Selecione a linha 2 Lcd_Cmd (0x00); // Limpar exibição da linha 2 Lcd_Cmd (0x06); }

Lcd_Clear (): Esta função limpa a tela LCD e pode ser usada dentro de loops para limpar a aparência dos dados anteriores.

Lcd_Clear () {Lcd_Cmd (0); // Limpa o LCD Lcd_Cmd (1); // Mova o cursor para a primeira posição}

void Lcd_Set_Cursor (x pos, y pos): Uma vez iniciado, nosso LCD está pronto para receber comandos, podemos instruir o LCD a definir seu cursor no local de sua preferência usando esta função. Suponha que precisamos do cursor no 5º caractere da 1ª linha. Então, a função será anulada Lcd_Set_Cursor (1, 5)

void Lcd_Set_Cursor (char a, char b) {char temp, z, y; if (a == 1) {temp = 0x80 + b - 1; // 80H é usado para mover o cursor z = temp >> 4; // Menores 8 bits y = temp & 0x0F; // 8 bits superiores Lcd_Cmd (z); // Definir linha Lcd_Cmd (y); // Definir coluna} else if (a == 2) {temp = 0xC0 + b - 1; z = temp >> 4; // Menores 8 bits y = temp & 0x0F; // 8 bits superiores Lcd_Cmd (z); // Definir linha Lcd_Cmd (y); // Definir coluna}}

void Lcd_Print_Char (dados de char): Uma vez que o cursor é definido, podemos escrever um caractere em sua posição simplesmente chamando esta função.

void Lcd_Print_Char (char data) // Envia 8 bits no modo de 4 bits {char Lower_Nibble, Upper_Nibble; Lower_Nibble = dados & 0x0F; Upper_Nibble = dados & 0xF0; RS = 1; // => RS = 1 Lcd_SetBit (Upper_Nibble >> 4); // Envia a metade superior deslocando 4 EN = 1; para (int i = 2130483; i <= 0; i--) NOP (); EN = 0; Lcd_SetBit (Lower_Nibble); // Enviar metade inferior EN = 1; para (int i = 2130483; i <= 0; i--) NOP (); EN = 0; }

void Lcd_Print_String (char * a): Se um grupo de caracteres deve ser exibido, a função string pode ser usada.

void Lcd_Print_String (char * a) {int i; para (i = 0; a! = '\ 0'; i ++) Lcd_Print_Char (a); // Divida a string usando ponteiros e chame a função Char}

Cada vez que o Lcd_Print_Char (dados de char) é chamado, seus respectivos valores de caractere são enviados para as linhas de dados do LCD. Esses caracteres chegam ao HD44780U na forma de bits. Agora, este IC relaciona os bits ao caractere a ser exibido usando sua memória ROM, conforme mostrado na tabela abaixo. Você pode encontrar bits para todos os caracteres na folha de dados do controlador LCD HD44780U.

Agora, uma vez que estamos satisfeitos com nosso arquivo de cabeçalho, vamos construir o circuito e testar o programa. Verifique também o arquivo de cabeçalho completo fornecido no link fornecido acima.

Diagrama de circuito e teste:

Abaixo está o diagrama de circuito para a interface do LCD 16x2 com o microcontrolador PIC.

Não mostrei a fonte de alimentação ou a conexão ICSP no circuito acima, pois estamos usando a mesma placa que usamos no tutorial anterior, verifique aqui.

Uma coisa importante a ser observada no programa são as definições de pinos do LCD:

#define RS RD2 #define EN RD3 #define D4 RD4 #define D5 RD5 #define D6 RD6 #define D7 RD7

Essas definições de pinos podem ser alteradas de acordo com a configuração do hardware do programador. Lembre-se de alterar a configuração da porta respeitada na função principal se você alterar aqui.

O hardware para este projeto é muito simples. Vamos reutilizar o mesmo módulo PIC que usamos da última vez e conectar o módulo LCD ao nosso PIC usando fios de jumper.

A conexão pode ser entendida pela seguinte tabela:

Pin nº do LCD	Nome do pino LCD	Nome do PIN MCU	Número do pino MCU
1	Terra	Terra	12
2	VCC	+ 5V	11
3	VEE	Terra	12
4	Registrar Selecione	RD2	21
5	Ler escrever	Terra	12
6	Habilitar	RD3	22
7	Dados Bit 0	NC	-
8	Dados Bit 1	NC	-
9	Dados Bit 2	NC	-
10	Dados Bit 3	NC	-
11	Dados Bit 4	RD4	27
12	Dados Bit 5	RD5	28
13	Dados Bit 6	RD6	29
14	Dados Bit 7	RD7	30
15	LED positivo	+ 5V	11
16	LED negativo	Terra	12

Agora vamos simplesmente fazer as conexões, despejar o código em nosso MCU e verificar a saída.

Se você tiver qualquer problema ou dúvida, use a seção de comentários. Verifique também o vídeo de demonstração abaixo.