- Materiais requisitados
- Módulo de exibição LCD 16X2
- Diagrama de circuito e conexões
- Programação ARM7-LPC2148
O display é a parte necessária de uma máquina, seja ela qualquer eletrodoméstico ou industrial. O display não apenas mostra as opções de controle para operar a máquina, mas também mostra o status e a saída da tarefa executada por aquela máquina. Existem muitos tipos de visores usados em eletrônicos, como visor de 7 segmentos, visor LCD, visor de tela sensível ao toque TFT, visor LED, etc. O visor LCD 16x2 é o mais básico e também é usado em alguns equipamentos eletrônicos pequenos, fizemos muito projetos usando LCD 16x2 incluindo a interface básica com outros microcontroladores:
- Interface de LCD com microcontrolador 8051
- Interface de LCD com microcontrolador ATmega32
- Interface LCD com microcontrolador PIC
- Interface de LCD 16x2 com Arduino
- Interface de LCD 16x2 com Raspberry Pi usando Python
Neste tutorial, veremos como fazer a interface de um LCD 16x2 com o microcontrolador ARM7-LPC2148 e exibir uma mensagem de boas-vindas simples. Se você é novo no ARM7, comece com o básico do ARM7 LPC2148 e aprenda como ele pode ser programado usando o Keil uVision
Materiais requisitados
Hardware
- Placa do microcontrolador ARM7-LPC2148
- LCD (16X2)
- Potenciômetro
- IC regulador de tensão 5V
- Tábua de pão
- Fios de conexão
- Bateria 9V
- Cabo micro usb
Programas
- Keil uVision 5
- Ferramenta Magic Flash
Antes de entrar no projeto, devemos saber algumas coisas sobre os modos de operação do LCD e sobre os códigos Hex do LCD.
Módulo de exibição LCD 16X2
Um LCD 16X2 diz que tem 16 colunas e 2 linhas. Este LCD possui 16 pinos. A imagem e a tabela abaixo mostram os nomes dos pinos do display LCD e suas funções.
|
NOME |
FUNÇÃO |
|
VSS |
Pino de aterramento |
|
VDD |
+ 5V Pino de entrada |
|
VEE |
Pino de ajuste de contraste |
|
RS |
Registrar Selecione |
|
R / W |
Pin de leitura / gravação |
|
E |
Habilitar PIN |
|
D0-D7 |
Pinos de dados (8 pinos) |
|
LED A |
Pino ânodo (+ 5V) |
|
LED K |
Pino Catodo (GND) |
O LCD pode funcionar em dois modos diferentes, ou seja, o modo de 4 bits e o modo de 8 bits. No modo de 4 bits, enviamos os dados nibble por nibble, primeiro nibble superior e, em seguida, nibble inferior. Para aqueles de vocês que não sabem o que é um nibble: um nibble é um grupo de quatro bits, então os quatro bits inferiores (D0-D3) de um byte formam o nibble inferior, enquanto os quatro bits superiores (D4-D7) de um byte forma o nibble superior. Isso nos permite enviar dados de 8 bits.
Já no modo de 8 bits, podemos enviar os dados de 8 bits diretamente de uma vez, pois usamos todas as 8 linhas de dados.
Aqui neste projeto, usaremos o modo mais comumente usado, que é o modo de 4 bits. No modo de quatro bits, podemos economizar 4 pinos do microcontrolador e também reduzir a sobrecarga de fiação.
16x2 também usa código HEX para receber qualquer comando, existem muitos comandos hexadecimais para LCD, como mover o cursor, selecionar o modo, mudar o controle para a segunda linha, etc. Para saber mais sobre o Módulo de Display LCD 16X2 e comandos hexadecimais, siga o link.
Diagrama de circuito e conexões
A tabela abaixo mostra as conexões de circuito entre LCD e ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Seleção de Registro) |
|
P0.6 |
E (habilitar) |
|
P0,12 |
D4 (dados pino 4) |
|
P0.13 |
D5 (pino de dados 5) |
|
P0.14 |
D6 (pino de dados 6) |
|
P0.15 |
D7 (dados pino 7) |
Conexões do regulador de tensão com LCD e braço ARM7
A tabela abaixo mostra as conexões entre o ARM7 e o LCD com regulador de tensão.
|
Regulador de tensão IC |
Função de pino |
LCD e ARM-7 LPC2148 |
|
1. Pino esquerdo |
+ Ve da entrada de bateria 9V |
NC |
|
2. Pino central |
- Ve da bateria |
VSS, R / W, K de LCD GND de ARM7 |
|
3. Pino direito |
Saída regulada de + 5V |
VDD, A de LCD + 5V de ARM7 |
Potenciômetro com LCD
Um potenciômetro é usado para variar o contraste do display LCD. Um potenciômetro tem três pinos, o pino esquerdo (1) é conectado a + 5V e o centro (2) ao VEE ou V0 do módulo LCD e o pino direito (3) é conectado ao GND. Podemos ajustar o contraste girando o botão.
Configurações de jumpers
Um pino de jumper está presente no ARM7-Stick para que possamos alimentar e carregar o código usando USB ou usando uma entrada de 5 Vcc apenas para alimentação. Você pode ver as imagens abaixo.
A imagem abaixo mostra que o jumper está na posição DC. Isso significa que devemos alimentar a placa com uma fonte externa de 5V.
E esta imagem mostra que o jumper está conectado no modo USB. Aqui, o poder e o código são fornecidos via porta micro usb.
NOTA: Aqui neste tutorial, carregamos o código usando USB, definindo o jumper para USB e, em seguida, alteramos o jumper para o modo DC para alimentar o LPC2148 a partir da entrada de 5v do regulador. Você pode conferir isso no vídeo fornecido no final.
O circuito final para a interface do LCD 16x2 com o microcontrolador ARM7 será semelhante a este:
Programação ARM7-LPC2148
Para programar o ARM7-LPC2148, precisamos da ferramenta Keil uVision e Flash Magic. Estamos usando o cabo USB para programar o ARM7 Stick via porta micro USB. Nós escrevemos código usando Keil e criamos um arquivo hexadecimal e então o arquivo HEX é enviado para o stick ARM7 usando Flash Magic. Para saber mais sobre como instalar keil uVision e Flash Magic e como usá-los, siga o link Getting Started With ARM7 LPC2148 Microcontroller e programe-o usando Keil uVision.
O código completo para fazer a interface do LCD com o ARM 7 é fornecido no final deste tutorial, aqui estamos explicando algumas partes dele.
Em primeiro lugar, precisamos incluir os arquivos de cabeçalho necessários
#incluir
A inicialização do módulo LCD é uma etapa muito importante. Aqui, usamos certos códigos HEX, que na verdade são comandos, para informar ao LCD sobre o modo de operação (4 bits), tipo de LCD (16x2), linha de início etc.
void LCD_INITILIZE (void) // Função para preparar o LCD { IO0DIR = 0x0000FFF0; // Define os pinos P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 como OUTPUT delay_ms (20); LCD_SEND (0x02); // Inicializa o LCD no modo de operação de 4 bits LCD_SEND (0x28); // 2 linhas (16X2) LCD_SEND (0x0C); // Exibe o cursor desligado LCD_SEND (0x06); // Cursor de incremento automático LCD_SEND (0x01); // Mostra limpar LCD_SEND (0x80); // Primeira linha, primeira posição }
Para o modo de 4 bits, temos diferentes tipos de função de gravação para os pinos, ou seja, usando nibble superior e inferior. Vamos ver como é feito
void LCD_SEND (comando char) // Função para enviar comandos hexadecimais nibble by nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Envia o nibble superior do comando IO0SET = 0x00000040; // Fazendo Enable HIGH IO0CLR = 0x00000030; // Fazendo RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // Fazendo Habilitar LOW delay_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((comando & 0x0F) << 12)); // Envia o nibble inferior do comando IO0SET = 0x00000040; // ATIVAR IO0CLR HIGH = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // ATIVAR LOW delay_ms (5); }
Lógica de envio do Nibble
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((comando & 0x0F) << 12)); // Envia o nibble inferior do comando IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Envie a parte superior do comando
As duas declarações acima desempenham um papel importante neste programa. O primeiro comando envia o nibble inferior e o segundo envia o nibble superior. Isso sem afetar os outros pinos que fazemos. Vamos ver como está acontecendo antes de conhecer essa lógica primeiro
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Portanto, usamos um conceito de mascaramento e operação de mudança lógica sem afetar os outros pinos. Significa que apenas os pinos (P0.12-P0.15) são usados e nenhum outro pino como P0.4, P0.6 é afetado. Isso será feito deslocando os dados em quatro bits e colocando o nibble superior no lugar do nibble inferior e mascarando o nibble superior. E então tornamos os bits inferiores zero (0XF0) e fazemos o OR com os dados nibble para obter os dados nibble superiores na saída.
Um processo semelhante é usado para dados de nibble inferior, mas aqui não precisamos deslocar os dados.
Ao gravar dados na saída, ou seja, no modo de comando RS deve ser BAIXO e para executar a habilitação deve ser HIGH, e no modo de dados RS deve ser HIGH e para executar a habilitação deve ser HIGH.
Agora, para enviar os dados da string que devem ser impressos na saída, o mesmo princípio é usado nibble por nibble. Um passo importante aqui é REGISTER SELECT (RS) deve ser HIGH para o modo de dados.
void LCD_DISPLAY (char * msg) // Função para imprimir os caracteres enviados um a um { uint8_t i = 0; enquanto (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Envia o nibble superior IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH para imprimir os dados IO0CLR = 0x00000020; // RW LOW Atraso do modo de gravação ms (2); IO0CLR = 0x00000040; // EN = 0, RS e RW inalterados (ou seja, RS = 1, RW = 0) atraso ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Envia o nibble inferior IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; atraso ms (2); IO0CLR = 0x00000040; atraso ms (5); i ++; }
O vídeo completo de codificação e demonstração é fornecido abaixo.