Interface do teclado de matriz 4X4 com microcontrolador pic

Os teclados são dispositivos de entrada amplamente usados em vários projetos eletrônicos e incorporados. Eles são usados para receber entradas na forma de números e alfabetos e alimentá-los no sistema para processamento posterior. Neste tutorial, faremos a interface de um teclado de matriz 4x4 com PIC16F877A.

Antes de entrar na lógica de detalhes e aprender como usar o teclado, precisaremos saber algumas coisas.

Por que precisamos do teclado 4x4:

Normalmente usamos um único pino de E / S de uma unidade de microcontrolador para ler o sinal digital, como uma entrada de switch. Em algumas aplicações em que 9, 12, 16 chaves são necessárias para fins de entrada, se adicionarmos cada chave em uma porta do microcontrolador, acabaremos usando 16 portas de E / S. Essas 16 portas de E / S não são apenas para leitura de sinais de E / S, mas também podem ser usadas como conexões periféricas, como suportes ADC, I2C, conexões SPI também são suportadas por esses pinos de E / S. Como esses pinos estão conectados com os interruptores / chaves, não podemos usá-los, mas apenas como portas de E / S. Isso não faz sentido algum. Então, como reduzir a contagem de pinos? A resposta é: usando um teclado hexadecimal ou teclado de matriz; podemos reduzir a contagem de alfinetes, que associam chaves de matriz 4x4. Ele usará 8 pinos dos quais 4 conectados em linhas e 4 conectados em colunas, economizando 8 pinos do microcontrolador.

Como funciona o teclado de matriz 4x4:

Na imagem superior, um módulo de teclado de matriz é mostrado à esquerda. À direita, a conexão interna é mostrada, bem como a conexão da porta. Se virmos a porta, há 8 pinos, os primeiros 4 da esquerda para a direita são X1, X2, X3 e X4 são as linhas e os últimos 4 da esquerda para a direita são Y1, Y2, Y3, Y4 são quatro colunas. Se fizermos 4 linhas ou o lado X como saída e torná-los lógicos baixos ou 0, e fizermos as 4 colunas como entrada e lermos as teclas, leremos a tecla pressionada quando o Y correspondente chegar a 0.

A mesma coisa acontecerá na matriz nxn, onde n é o número. Isso pode ser 3x3, 6x6 etc.

Agora, pense que 1 está pressionado. Então, o 1 está situado na linha X1 e na coluna Y1. Se X1 for 0, então Y1 será 0. Da mesma forma, podemos sentir cada chave na linha X1, detectando as colunas Y1, Y2, Y3 e Y4. Isso acontece para cada switch e vamos ler a posição dos switches na matriz.

Cada círculo verde é o interruptor e ambos estão conectados da mesma maneira.

Neste tutorial, faremos a interface do teclado com as seguintes especificações-

Usaremos pull up interno
Vamos adicionar a opção de eliminação de chave

Mas não quando as chaves são pressionadas precisamos fazer a Y1, Y2, Y3 e Y4 como alta ou 1. Caso contrário não podemos detectar as mudanças de lógica quando a chave está sendo pressionada. Mas não poderíamos fazer isso por códigos ou programa porque esses pinos são usados como entrada, não saída. Portanto, usaremos um registro de operação interno no microcontrolador e operaremos esses pinos como modo de pull up fraco ativado. Ao usar isso, haverá um modo de habilitação alto lógico quando estiver no estado padrão.

Além disso, quando pressionamos a tecla, há picos ou ruídos são gerados com os contatos da chave e, devido a essa pressão múltipla, ocorre o que não era esperado. Portanto, primeiro detectaremos o pressionamento do interruptor, esperamos alguns milissegundos, novamente verificar se o interruptor ainda está pressionado ou não e se o interruptor ainda estiver pressionado, aceitaremos o pressionamento do interruptor, caso contrário, não. Isso é chamado de de-bouncing dos switches.

Vamos implementar tudo isso em nosso código e fazer a conexão no breadboard.

Verifique também como fazer a interface do teclado 4x4 com outros microcontroladores:

Interface de teclado com Arduino Uno
Interface de teclado de matriz 4x4 com microcontrolador 8051
Interface de teclado 4x4 com microcontrolador ATmega32
Raspberry Pi Digital Code Lock na breadboard

Material necessário:

Tábua de pão
Pic-kit 3 e ambiente de desenvolvimento em seu PC, ou seja, MPLABX
Fios e conectores
Character LCD 16x2
20Mhz Cristal
Tampa do disco de cerâmica 33pF com 2 peças.
Resistor de 4,7k
Predefinição de 10k (resistor variável)
Teclado de matriz 4x4
Um adaptador de 5 V

Diagrama de circuito:

Vamos conectar os cristais e o resistor nos pinos associados. Além disso, conectaremos o LCD no modo de 4 bits através do PORTD. Conectamos o teclado hexadecimal ou teclado de matriz na porta RB4.

Se você é novo no PIC, comece com Introdução ao Microcontrolador PIC: Introdução ao PIC e MPLABX

Explicação de programação:

O código completo para interface do teclado matricial com o microcontrolador PIC é fornecido no final. O código é fácil e autoexplicativo. A biblioteca do teclado é a única coisa a ser entendida no código. Aqui temos usado keypad.h e lcd.h biblioteca de interface do teclado e 16x2 LCD. Então, vamos ver o que está acontecendo dentro disso.

Dentro do keypad.h veremos que usamos o cabeçalho xc.h que é a biblioteca de registro padrão, a frequência do cristal é definida para o uso do atraso usado no arquivo kepad.c. Definimos as portas do teclado no registro PORTRB e definimos pinos individuais como linha (X) e colunas (Y).

Também usamos duas funções, uma para a inicialização do teclado que redirecionará a porta como saída e entrada, e uma varredura de pressionamento de interruptor que retornará o status de pressionamento de interruptor quando chamado.

#incluir #define _XTAL_FREQ 200000000 // cristal de freqüência, utilizada em atraso #define X_1 RB0 #define X_2 RB1 #define X_3 RB2 #define X_4 RB3 #define y_1 RB4 #define Y_2 RB5 #define Y_3 RB6 #define Y_4 RB7 #define Keypad_PORT PORTB #define Keypad_PORT_Direction TRISB void InitKeypad (void); char switch_press_scan (void);

No keypad.c, veremos que a função abaixo retornará o pressionamento de tecla quando a função de scanner do teclado não retornar 'n'.

char switch_press_scan (void) // Obter a chave do usuário { char key = 'n'; // Presume que nenhuma tecla foi pressionada enquanto (key == 'n') // Espere até que uma tecla seja pressionada key = keypad_scanner (); // Escaneia as chaves novamente e novamente return key; // quando a tecla é pressionada, retorna seu valor }

Abaixo está a função de leitura do teclado. Em cada etapa, faremos as linhas X1, X2, X3 e X4 como 0 e leremos o status Y1, Y2, Y3 e Y4. O retardo é usado para o efeito debounce, quando a chave ainda está pressionada retornaremos o valor associado a ela. Quando nenhum botão for pressionado, retornaremos 'n'.

char keypad_scanner (vazio) { X_1 = 0; X_2 = 1; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); enquanto (Y_1 == 0); return '1'; } if (Y_2 == 0) {__delay_ms (100); enquanto (Y_2 == 0); return '2'; } if (Y_3 == 0) {__delay_ms (100); enquanto (Y_3 == 0); retornar '3'; } if (Y_4 == 0) {__delay_ms (100); enquanto (Y_4 == 0); return 'A'; } X_1 = 1; X_2 = 0; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); enquanto (Y_1 == 0); retornar '4'; } if (Y_2 == 0) {__delay_ms (100); enquanto (Y_2 == 0); retornar '5'; } if (Y_3 == 0) {__delay_ms (100); enquanto (Y_3 == 0); retornar '6'; } if (Y_4 == 0) {__delay_ms (100); enquanto (Y_4 == 0); return 'B'; } X_1 = 1; X_2 = 1; X_3 = 0; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); enquanto (Y_1 == 0); retornar '7'; } if (Y_2 == 0) {__delay_ms (100); enquanto (Y_2 == 0); retornar '8'; } if (Y_3 == 0) {__delay_ms (100); enquanto (Y_3 == 0); retornar '9'; } if (Y_4 == 0) {__delay_ms (100); enquanto (Y_4 == 0); return 'C'; } X_1 = 1; X_2 = 1; X_3 = 1; X_4 = 0; if (Y_1 == 0) {__delay_ms (100); enquanto (Y_1 == 0); Retorna '*'; } if (Y_2 == 0) {__delay_ms (100); enquanto (Y_2 == 0); return '0'; } if (Y_3 == 0) {__delay_ms (100); enquanto (Y_3 == 0); Retorna '#'; } if (Y_4 == 0) {__delay_ms (100); enquanto (Y_4 == 0); return 'D'; } return 'n'; }

Também definiremos o pull-up fraco nos últimos quatro bits e também definiremos a direção das portas como as últimas 4 entradas e as 4 primeiras como saída. O OPTION_REG & = 0x7F; é usado para definir o modo de pull up fraco nos últimos pinos.

void InitKeypad (void) { Keypad_PORT = 0x00; // Define os valores dos pinos da porta do teclado zero Keypad_PORT_Direction = 0xF0; // Entrada dos últimos 4 pinos, saída dos primeiros 4 pinos OPTION_REG & = 0x7F; }

No programa PIC principal (fornecido abaixo), definimos primeiro os bits de configuração e incluímos algumas bibliotecas necessárias. Então, nas funções void system_init, inicializamos o teclado e o LCD. E, finalmente, em no principal função lemos o teclado chamando o switch_press_scan () função e retornando o valor de lcd.

Baixe o código completo com os arquivos de cabeçalho aqui e confira o vídeo de demonstração abaixo.