TECLADO MATRICIAL

Universidade Tecnolgica Federal do Paran - UTFPR

Sistemas Microcontrolados
Monitor da disciplina: Lus Paulo Custdio

Introduo

Teclados so geralmente utilizados em aplicaes na qual o usurio precisa interagir com

um sistema, como computadores, calculadoras, controles remotos entre outros. Utilizando um
teclado com 64 botes, caso cada boto fosse ligado diretamente a um pino do microcontrolador,
seriam gastos 64 pinos o que tornaria a implementao impossvel para a maioria dos
microcontroladores. Para evitar este problema, as teclas so conectadas no formato de matriz 88
ocupando apenas 16 pinos. Essa tcnica chamada de multiplexao, para realizar a leitura das
teclas.

O Teclado Matricial

Este teclado como o nome indica formado de botes organizados em linhas e colunas de
modo a formar uma matriz. Quando pressionado um boto, conecta a linha com a coluna na qual
est ligado. A figura a seguir ilustra a ligao matricial.
O teclado matricial (neste caso) possui a seguinte pinagem (da esquerda para a direita):

Pino 1 Primeira Linha (L1)

Pino 2 Segunda Linha (L2)
Pino 3 Terceira Linha (L3)
Pino 4 Quarta Linha (L4)
Pino 5 Primeira Coluna (C1)
Pino 5 Segunda Coluna (C2)
Pino 5 Terceira Coluna (C3)
Pino 8 Quarta Coluna (C4)

A Multiplexao

Essa tcnica consiste no compartilhamento do mesmo barramento por vrios dispositivos,

entretanto apenas um deles utilizar o barramento por vez. No caso do teclado matricial, os
barramentos sero as linhas do teclado e os dispositivos as colunas. Permite-se que apenas uma
coluna se ligue as linhas por vez. Para desconectar as colunas que no devem ser lidas deve-se
configur-las como entradas (alta impedncia).
No incio os pinos conectados s linhas ou s colunas sero configurados como entradas
com pull up ou pull down e as colunas ou linhas como entradas (alta impedncia). Isso depender
da lgica de acionamento utilizada no cdigo do programa. A varredura consiste em ativar uma
coluna por vez (sada em nvel lgico alto ou baixo) e checar se houve uma alterao nas linhas.
Esta a forma mais usada de varredura por colunas. Caso uma alterao em uma linha seja
identificada, o bounce da tecla deve ser devidamente tratado para que possa finalmente afirmar
que o boto foi pressionado.

Pressionando vrias teclas

Quando pressionadas 3 ou mais teclas um efeito conhecido como tecla fantasma pode
ocorrer. Caso a tecla fantasma seja pressionada e em seguida uma das teclas anteriores for solta,
a tecla que foi solta ainda ser considerada como pressionada. Para solucionar este problema
deve-se adicionar um diodo em cada boto para evitar que estes caminhos indesejados sejam
formados, como mostra a figura abaixo.

Biblioteca do MikroC

Esta biblioteca j vem pronta para usar o teclado matricial de 4x3 ou 4x4 (linhas x colunas)
do MikroC PRO (algumas mudanas foram feitas em relao ao cdigo original do programa).
Apenas verificar as portas de conexo do teclado (no exemplo est no PORTB) e do display LCD
(RS no pino RE0 e E no pino RE1, D4 a D7 nos pinos RD4 a RD7).
Este cdigo simplesmente mostra o valor digitado em formato ASCII e mostra tambm
quantas vezes este valor foi digitado.
 Esta biblioteca est codificada para teclados matriciais de 4x3 e 4x4, portanto, para teclados
maiores, necessrio um cdigo diferente.

// Incio do cdigo

unsigned short kp, cnt, oldstate = 0;

char txt[6];

// Conexes do teclado matricial no PORTB

char keypadPort at PORTB;

// Conexes do display LCD

sbit LCD_RS at RE0_bit;
sbit LCD_EN at RE1_bit;
sbit LCD_D4 at RD4_bit;
sbit LCD_D5 at RD5_bit;
sbit LCD_D6 at RD6_bit;
sbit LCD_D7 at RD7_bit;

sbit LCD_RS_Direction at TRISE0_bit;

sbit LCD_EN_Direction at TRISE1_bit;
sbit LCD_D4_Direction at TRISD4_bit;
sbit LCD_D5_Direction at TRISD5_bit;
sbit LCD_D6_Direction at TRISD6_bit;
sbit LCD_D7_Direction at TRISD7_bit;

void main() {
ADCON1 = 0X06; // E/S digital
cnt = 0; // Reseta o contador
Keypad_Init(); // Inicializa a funo Keypad
Lcd_Init(); // Inicializa o LCD
Lcd_Cmd(_LCD_CLEAR); // Limpa o display
Lcd_Cmd(_LCD_CURSOR_OFF); // Desliga o cursor
Lcd_Out(1, 1, "1"); // Escreve no LCD na linha 1 e coluna 1
Lcd_Out(1, 1, "Key :"); // Escreve o valor digitado no LCD
Lcd_Out(2, 1, "Times:"); // Escreve quantas vezes o valor foi digitado no LCD

do {
kp = 0; // Reseta a varivel kp

// Aguarda at alguma tecla ser pressionada

do

// Estas duas funes tm a mesma funo, a diferena est que a Key_Press no trava a
varredura enquanto uma tecla est pressionada

// kp = Keypad_Key_Press(); // Armazena a tecla pressionada na varivel kp

kp = Keypad_Key_Click(); // Armazena a tecla pressionada na varivel kp

while (!kp);
// Prepara o valor para sada e transforma a tecla pressionada em valor ASCII

switch (kp) {

// Descomente este bloco de funes se o teclado for de 4x3

 //case 10: kp = 42; break; // '*'
//case 11: kp = 48; break; // '0'
//case 12: kp = 35; break; // '#'
//default: kp += 48;

// Descomente este bloco de funes se o teclado for de 4x4

case 1: kp = 49; break; // 1
case 2: kp = 50; break; // 2
case 3: kp = 51; break; // 3
case 4: kp = 65; break; // A
case 5: kp = 52; break; // 4
case 6: kp = 53; break; // 5
case 7: kp = 54; break; // 6
case 8: kp = 66; break; // B
case 9: kp = 55; break; // 7
case 10: kp = 56; break; // 8
case 11: kp = 57; break; // 9
case 12: kp = 67; break; // C
case 13: kp = 42; break; // *
case 14: kp = 48; break; // 0
case 15: kp = 35; break; // #
case 16: kp = 68; break; // D

if (kp != oldstate) { // Se for pressionada uma tecla diferente da anterior

cnt = 1; // Contador muda de valor
oldstate = kp; // A tecla anterior passa a ser a atual
}
else { // Se a tecla for a mesma que a anterior
cnt++; // Incrementa na varivel contador
}

Lcd_Chr(1, 10, kp); // Mostra o valor pressionado em ASCII no LCD

if (cnt == 255) { // Se a varivel contador chegar a 255, ela estoura

cnt = 0; // Reseta contador
Lcd_Out(2, 10, " ");
}

WordToStr(cnt, txt); // Transforma o valor do contador em string

Lcd_Out(2, 10, txt); // Mostra o valor do contador no LCD
} while (1); // Lao infinito para outras aes
}

// Fim do cdigo
 Os resistores de pull down no so necessrios para a simulao no Proteus, porm na
montagem fsica do circuito, talvez seja necessrio coloc-los para evitar que o teclado mostre
teclas que no foram realmente pressionadas no display LCD. Valores de 4,7k a 10k so
apropriados. As conexes do teclado matricial podem variar dependendo do modelo utilizado,
portanto, verifique quais sadas so correspondentes s linhas e s colunas.

Algoritmo de exemplo

Este exemplo foi retirado do site:

https://www.youtube.com/watch?v=ZKJ4wM3690I&list=PLZ8dBTV2_5HQTv6DRKZTp9L0iRReXis
0q&index=25

Acesse-o para melhores explicaes do funcionamento deste cdigo e do circuito.

#define S2 RA0_bit
#define S1 RA1_bit
#define led2 RA2_bit
#define led1 RA3_bit

#define col_1 RB1_bit

#define col_2 RB2_bit
#define col_3 RB3_bit
#define row_A RB4_bit
#define row_B RB5_bit
#define row_C RB6_bit
#define row_D RB7_bit
void pulse(char number); //Funo para pulsar o led1

char control = 0x01;

void interrupt()
{
if(T0IF_bit) //Houve estouro do Timer0?
{ //Sim...

T0IF_bit = 0x00; //Limpa a flag

TMR0 = 0x6C; //Reinicia o timer0

if(col_1 && control == 0x01) //Coluna 1 em nvel high? Control igual 1?

{ //Sim...
control = 0x02;
col_1 = 0x00; //Apenas a coluna 1 em nvel baixo
col_2 = 0x01;
col_3 = 0x01;

if(!row_A) pulse(1);
else if(!row_B) pulse(4);
else if(!row_C) pulse(7);
else if(!row_D) pulse(11);

}
else if(col_2 && control == 0x02) //Coluna 2 em nvel high? Control igual 2?
{ //Sim...
control = 0x03;
col_1 = 0x01; //Apenas a coluna 2 em nvel baixo
col_2 = 0x00;
col_3 = 0x01;

if(!row_A) pulse(2);
else if(!row_B) pulse(5);
else if(!row_C) pulse(8);
else if(!row_D) pulse(10);

}
else if(col_3 && control == 0x03) //Coluna 3 em nvel high? Control igual 3?
{ //Sim...
control = 0x01;
col_1 = 0x01; //Apenas a coluna 3 em nvel baixo
col_2 = 0x01;
col_3 = 0x00;

if(!row_A) pulse(3);
else if(!row_B) pulse(6);
else if(!row_C) pulse(9);
else if(!row_D) pulse(12);

}
 }

} //end interrupt

// --- Funo Principal

void main()
{
CMCON = 0x07; //Desabilita os comparadores
OPTION_REG = 0x86; //Timer0 incrementa com ciclo de instruo, prescaler 1:128
GIE_bit = 0x01; //Habilita interrupo global
PEIE_bit = 0x01; //Habilita interrupo por perifricos
T0IE_bit = 0x01; //Habilita interruo do Timer0

TMR0 = 0x6C; //Inicia o timer0

TRISA = 0x03; //Entrada em RA0 e RA1

TRISB = 0xF0; //Nibble mais significativo do PORTB ser entrada
PORTA = 0x03; //RA0 e RA1 iniciam em high
PORTB = 0xFF; //Nibble mais significativo inicia em high.

while(1) //Loop Infinito

{

} //end while

} //end main

void pulse(char number)

{
char i; //varivel de iteraes

for(i=0;i<number;i++)
{
led1 = 0x01;
delay_ms(200);
led1 = 0x00;
delay_ms(200);

}
}
 Neste exemplo, o circuito mostra o funcionamento do teclado matricial e quando pressionado
o nmero correspondente no teclado, o LED1 pisca este nmero de vezes. Por exemplo, se
pressionado a tecla correspondente ao nmero 5, o LED1 ir piscar 5 vezes. A varredura do circuito
feita a cada estouro do TIMER0 acionando pela condio lgica se e comparando com a varivel
de controle control para ligar e desligar cada coluna por vez. Diferente do exemplo utilizado pelo
MikroC, a lgica outra, funcionando com nvel alto nas linhas, e quando pressionado alguma tecla,
identifica nvel baixo nas portas do PIC, por isso a necessidade de utilizar resistores de pull up. J
a funo pulse() determina o nmero de vezes que a sada referente ao LED1 deve ficar alternando
entre nvel alto e baixo, ou seja, quantas vezes o led ir piscar. Os valores referentes a * 0 # do
teclado foram arbitrados como respectivamente: 11 10 12. Portanto, possvel modificar qualquer
valor no teclado atravs do cdigo.
O osciloscpio conectado nas sadas do PIC, referente s colunas, mostra o tempo que as
colunas ficam em nvel baixo em determinado perodo.
Referncias:

http://www.embarcados.com.br/
https://www.youtube.com/watch?v=ZKJ4wM3690I&list=PLZ8dBTV2_5HQTv6DRKZTp9L0iRReXis
0q&index=25