por Rodrigo Almeida em quarta-feira, 02 de abril de 2014.

Sofa-Teclado: http://www.zo-loft.com/design/

Para se realizar a leitura de uma tecla ou chave necessrio utilizar um terminal do
microcontrolador. No post sobre debounce so explicados mais detalhes deste
procedimento. Para teclados com uma quantidade maior de chaves possvel que o
microcontrolador no possua terminais disponveis em quantidade suficiente, ou que o
controlador que possua essa quantidade seja de um custo mais elevado.

A soluo padro para este problema realizar-se a multiplexao das chaves. Isto
aumenta a quantidade de chaves que pode ser lida para uma mesma quantidade de
terminais. Esta economia de hardware, no entanto, aumenta a complexidade do software
e o custo, em termos de tempo de computao.

Uma das tcnicas mais eficientes de multiplexao para leitura de teclados o arranjo em
formato matricial. Com esta configurao podemos, com N terminais, ler at (N/2)^2
chaves, ou seja, com apenas 8 terminais possvel fazer uma leitura de 16 teclas. J um
teclado alfanumrico padro de 105 teclas pode ser montado com apenas 21 terminais,
uma reduo de quase 80%.

A multiplexao a capacidade de enviar mais de um sinal utilizando um mesmo caminho,
o dividindo de algum modo, geralmente em frequncias diferentes, ou em perodos de
tempo diferentes.

Na leitura matricial dispe-se os grupos de chaves separados em colunas, de modo que
seja possvel ligar uma coluna por vez. Isto pode ser feito utilizando terminais de sada
para acionamento de cada coluna e terminais de entrada para a leitura das linhas. muito
comum utilizar resistores de pull-ups na entrada do microcontrolador ou, caso o
microcontrolador possua, pull-ups internos das prprias entradas. Para proteger o sistema
de curto entre os terminais, geralmente se utiliza resistores em srie nas sadas a serem
controladas. Um modelo deste circuito apresentado na figura 1.


Figura 1 Teclado matricial


Conforme podemos ver na Figura 1, cada chave pode ser identificada unicamente pela sua
posio (linha, coluna). A leitura realizada ento por um processo conhecido como
varredura: liga-se uma coluna por vez e verifica-se quais chaves daquela coluna esto
ligadas. O cdigo abaixo apresenta um modelo de varredura utilizando-se a porta B.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void main(void)
{
unsigned char i, j;
unsigned char chave[4][4] = {{0,0,0,0},{0,0,0,0}};
INTCON2 &= 0x7F; //habilita pull-up
TRISB = 0xF0; //4 terminais de entrada e 4 terminais de sada
for(;;)
{
for(i = 0; i < 4; i++)
{
PORTB = 0xff; //desliga todas as colunas
BitClr(PORTB,i); //liga a coluna correspondente
//tempo para estabilizao do sinal
for(j = 0; j < 100; j++);
//realiza o teste para cada chave
for(j = 0; j < 4; j++)
{
if (!BitTst(PORTB,j+4))
{
chave[i][j] = 1;
}
else
{
chave[i][j] = 0;
}
}
}
}
}

importante notar que o cdigo acima no apresenta debounce em software para as
teclas. H apenas uma pequena contagem de tempo entre os acionamentos das colunas
para permitir que as capacitncias, tanto as utilizadas como filtro nas chaves quanto as
parasitas, possam se carregar para informar corretamente o estado das chaves.

incomum utilizar uma matriz para armazenar o estado das chaves, sendo mais comum a
utilizao de um vetor de bits. Utilizando uma varivel unsigned int de 16 bits, possvel
guardar o valor de at 16 chaves. Esta varivel pode ento ser interpretada como um vetor
de 16 bits. Outra vantagem a possibilidade de realizar o debounce de todas as chaves
simultaneamente, bastando esperar que o valor da varivel estabilize durante um tempo
antes de termos certeza do estado das chaves. Juntando-se esta idia com a questo da
varredura chega-se ao cdigo abaixo.


1
2
//ltimo valor confivel, pode estar atrasado devido ao processo de debounce

3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
//define a quantidade de leituras iguais antes que o sinal seja considerado estvel
#define DEBOUNCE_TIME 10

static unsigned int valor = 0x0000;
unsigned int LerTeclas(void){
return valor;
}

//Funo para varredura e debounce, deve ser chamada peridicamente
void VarreduraDebounceTeclas(void){
unsigned char i,j;
//variveis estticas para gerenciamento do debounce
static unsigned char tempo;
static unsigned int valorNovo = 0x0000;
static unsigned int valorAntigo = 0x0000;
//inicio do processo de varredura
for(i = 0; i < 4; i++){
PORTB |= 0x0F; //desliga todas as colunas
BitClr(PORTB,(i)); //liga uma coluna
//tempo para estabilizar o sinal
for(j=0;j<100;j++);
//realiza o teste para cada bit e atualiza a varivel
for(j = 0; j < 4; j++) {
if (!BitTst(PORTB,j+4)) { //lgica invertida
BitSet(valorNovo,(i*4)+j);
}else{
BitClr(valorNovo,(i*4)+j);
}
}
}
//inicio do processo de debounce
if (valorAntigo == valorNovo){
tempo --;
}else{
tempo = DEBOUNCE_TIME;
valorAntigo = valorNovo;
}
if (tempo == 0){
valor = valorAntigo;
}
}

void InicializaTeclado(void){
TRISB = 0xF0; //quatro entradas e quatro sadas
INTCON2 &= 0x7F; //habilita pull-up
}
Para aqueles que gostariam de utilizar o sistema de modo ainda mais otimizado (com
relao ao nmero de pinos do processador) existe uma tcnica de multiplexao
conhecida como Charlieplexing. Essa tcnica foi inicialmente pensada para o acionamento
de Leds. Devido caracterstica dos leds de conduzirem apenas em um dos sentidos
possvel colocar os Leds em anti-paralelo aumentando a quantidade em duas vezes.
Adicionando-se a isto a capacidade de alguns terminais que podem ser configurados como
entrada e sada, permitindo lev-los a estados similares ao tristate, possvel colocar at
(N^2-N) leds usando apenas N terminais. Deste modo um painel com 90 leds pode ser
acionado com apenas 10 terminais do microcontrolador!

Figura 2 Relgio com 90 leds acionados via charliplexing (Wikipedia)

Para utilizar essa topologia para a leitura de teclas basta adicionar alguns diodos no
esquemtico. Isso quer dizer que possvel fazer a leitura do teclado de 16 chaves com
apenas 5 terminais! Se fosse utilizada uma topologia matricial seria necessrio 8 terminais
do microcontrolador. Um teclado inteiro de 105 teclas precisaria de apenas 11 terminais
para ser implementado. No entanto o custo de processamento, alm de questes de
segurana e confiabilidade, podem ser motivos suficientes para evitar esse modelo em
projetos mais complexos.

Para os curiosos segue o modelo de um teclado 3*4 com apenas 4 terminais retirado
doelectronicdesing.com na figura 2 (frente aos 7 terminais necessrios para uma
topologia matricial).

Figura 2 Teclado 4*3 utilizando Charlieplexing




Professor da Universidade Federal de Itajub onde leciona sobre programao embarcada,
sistemas operacionais e desenvolvimento de produtos eletrnicos. Pesquisa na rea de sistemas
crticos desenvolvendo tcnicas para melhoria de confiabilidade e segurana.

Teclado Matricial

Dentre as vrias maneiras de interagirmos com o hardware em uma IHM (Interface Homem
Mquina) uma das formas mais comuns atravs do pressionamento de chaves e botoeiras
para que o programa possa ento executar uma tarefa especfica.
Hoje vamos interfacear um teclado matricial, como o encontrado em telefones celulares e
calculadoras, onde temos vrias chaves conectadas ao microcontrolador de maneira eficiente
a fim de no despediarmos pinos do hardware.

Para efetuar a conexo de uma tecla ao microcontrolador, podemos citar a maneira mais
simples que utiliza apenas uma tecla e um resistor de Pull-up ou Pull-down conforme o nvel
de tenso que desejarmos quando ocorrer o pressionamento da tecla.

Porm nesta configurao precisamos um pino para cada tecla conectada ao
microcontrolador, o que caracteriza o desperdcio de hardware, porm isto pode ser
resolvido com implementao de uma simples matriz, onde conseguimos maximizar a
utilizao dos pinos de forma eficiente.
No esquema abaixo podemos observar a utilizao das linhas e colunas que formam a matriz.



O nmero mximo de chaves para esta implementao pode ser obtida atravs da equao
abaixo:
Nteclas = Colunas x Linhas
O funcionamento do teclado matricial consiste em energizar apenas uma nica linha por vez e
efetuar a leitura das colunas para verificar o pressionamento de alguma das teclas, quando
detectado um nvel alto em alguma das colunas durante o rastreamento se torna possvel a
identificao da tecla pressionada. Para que no haja erros de leituras durante este processo,
se faz necessrio o uso de resistores de pull-down para garantir um nvel baixo nas colunas
que no esto sendo ativas pelo pressionamento de tecla.
Funo para escaneamento de teclado
Para efetuar a leitura do teclado matricial, vamos criar uma funo que retornar o valor da
tecla pressionada em hexadecimal ou o valor 0xFF caso nenhuma tecla tenha sido
pressionada.No nosso exemplo utilizaremos um teclado matricial de [4x3] que foi adquirido
atravs do sitewww.goodluckbuy.com.
Assim que a funo chamada, colocamos um nivel alto na primeira linha e efetuamos a
leitura das quatro colunas, caso alguma coluna responda nivel alto, retornamos da funo
com o valor correspondente a matrizagem, vejamos como fica o cdigo:

#define Coluna_1 PORTD.B0
#define Coluna_2 PORTD.B1
#define Coluna_3 PORTD.B2
#define Linha_1 PORTD.B6
#define Linha_2 PORTD.B5
#define Linha_3 PORTD.B4
#define Linha_4 PORTD.B3
char Le_Teclado() // Funo que efetua a leitura do teclado matricial
{
Coluna_1 = 1;
Coluna_2 = 0;
Coluna_3 = 0;
Delay_ms(1);
if(Linha_1) return 1;
if(Linha_2) return 4;
if(Linha_3) return 7;
if(Linha_4) return 10;

Coluna_1 = 0;
Coluna_2 = 1;
Coluna_3 = 0;
Delay_ms(1);
if(Linha_1) return 2;
if(Linha_2) return 5;
if(Linha_3) return 8;
if(Linha_4) return 0;

Coluna_1 = 0;
Coluna_2 = 0;
Coluna_3 = 1;
Delay_ms(1);
if(Linha_1) return 3;
if(Linha_2) return 6;
if(Linha_3) return 9;
if(Linha_4) return 11;

return 255;
}

Este cdigo mostra como efetuar uma leitura simples do teclado matricial, porm
dependendo do hardware utilizado pode apresentar problemas de estabilidade efetuando
leituras falsas ou deixando de apresentar um pressionamento.
MikroC PRO
O compilador MikroC PRO, possui internamente uma biblioteca prpria para uso com teclados
matriciais e que torna o processo de escaneamento uma tarefa simples. Podem ser utilizadas
as configuraes [4x1] , [4x2] , [4x3] ou [4x4].
Keypad_Init()
Efetua a inicializao do teclado matricial, esta funo requer que seja declarado
anteriormente uma varivel chamada keypadPort que define o PORT onde ser conectado o
nosso hardware do teclado.
char keypadPort at PORTD;
Keypad_Key_Press()
Efetua a leitura de uma tecla pressionada, retornando o valor da tecla (1 16) ou 0 caso
nenhuma tecla seja pressionada.
Keypad_Key_Click()
Efetua a leitura de uma tecla pressionada, retornando o valor da tecla (1 16) ou 0 caso
nenhuma tecla seja pressionada, porm uma funo com propriedades de bloqueio, ou seja,
quando chamada, aguarda o pressionamento da tecla, bloqueando o processo do programa
durante a espera do pressionamento da tecla.
Notem que esta biblioteca do MikroC PRO, embora nos ajude a interfacear o teclado no
retorna o valor direto das teclas e sim a posio dela na matriz.
Vejamos como ficou o nosso cdigo completo utilizando o compilador MikroC PRO.
/******************************************************************************
JL Audio www.esquemas .org
Data: 04/2012
Autor: Jean Carlos
Projeto: Teclado Matricial
Microprocessador: PIC18F4550
Clock do processador: 48MHz
Estao de desenvolvimento: PK2Lab V 1.1
Compilador: MikroC PRO V 4.60.0.0
Verso atual: 1.0
Descrio:
Implementao de leitura de teclado matricial na
placa PK2Lab, atravs de biblioteca do MikroC PRO.
*******************************************************************************/
// Inicializao do teclado no PORTD
char keypadPort at PORTD;
// Configurao do LCD da placa PK2Lab V.1.1
sbit LCD_RS at RB2_bit;
sbit LCD_EN at RB3_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISB2_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
//******************************************************************************
// Variveis Globais
char tecla, tecla_antiga = 0;
//******************************************************************************
// Rotinas Auxiliares
//******************************************************************************
//Rotina Principal
void main()
{
TRISA = 0b00000000;
PORTA = 0b00000000;
TRISB = 0b00000000;
PORTB = 0b00000000;
TRISC = 0b00000000;
PORTC = 0b00000000;
PORTD = 0b00000000;
TRISE = 0b00000000;
PORTE = 0b00000000;
ADCON1 = 0X0F; // Entradas digitais.

Keypad_Init(); // Inicializa o Teclado Matricial
Lcd_Init();
Lcd_Cmd(_Lcd_Cursor_Off);
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1,1,"*** PK2Lab ***");
Lcd_Out(2,2,"Tecla Press:");
Delay_ms(100);
while(1)
{
tecla = Keypad_Key_Press(); // Efetua leitura do teclado

if(tecla != 0)
{
switch (tecla) // Efetua converso para impresso
{
case 1: tecla = 49; break; // 1
case 2: tecla = 50; break; // 2
case 3: tecla = 51; break; // 3
case 4: tecla = 65; break; // A
case 5: tecla = 52; break; // 4
case 6: tecla = 53; break; // 5
case 7: tecla = 54; break; // 6
case 8: tecla = 66; break; // B
case 9: tecla = 55; break; // 7
case 10: tecla = 56; break; // 8
case 11: tecla = 57; break; // 9
case 12: tecla = 67; break; // C
case 13: tecla = 42; break; // *
case 14: tecla = 48; break; // 0
case 15: tecla = 35; break; // #
case 16: tecla = 68; break; // D
}
if(tecla != tecla_antiga) // Atualiza a ultima tecla pressionada
{
tecla_antiga = tecla;
}
Lcd_Chr(2,15,tecla); // Imprime a tecla pressionada no LCD
}
}//while(1)
}//main
;****************************************************************
;Programa PICT_HEX.ASM - Teclado de 16 teclas com PIC
;Desenvolvido por Marcio Soares
;Compilador - MPASM
;Ultima alterao - 23/06/2003
;Esta verso acende leds de acordo com valor HEX da tecla - vide
tabela
;****************************************************************
;Ports
;RA0-RA3 -> Saidas p/ LEDs
;RB0-RB2 -> Saidas para scan de teclado (colunas)
;RB4-RB7 -> Entradas para scan de teclado (linhas)

radix dec
include <P16F84A.INC>
__CONFIG _CP_OFF & _PWRTE_OFF & _WDT_OFF & _XT_OSC ;configura
bits

;**********************************************
;Define registros

PICRES equ 0x00
PICINT equ 0x04
RAMINIT equ 0x0C

;**********************************************
;Variaveis j definidas em P16F84A.INC
;
;PORTA, PORTB, STATUS, PCL, DC, C, Z
;**********************************************
;Variaveis de uso do programa
;
org RAMINIT ;endereco da RAM

TEMP res 1
TECLA res 1
TECLA_L res 1
T1 res 1
T2 res 1
AUX1 res 1

org PICRES ;endereco de reset
goto inicio ;desvia p/ inicio

org PICINT ;endereco do vector de INT
retfie
;**********************************************
;inicio do programa
;seta ambiente

inicio:

movlw 0x00 ;ajuste para os bits INTCON
movwf INTCON

bsf STATUS,RP0 ;seleciona banco 1 para options e tris

movlw 0x00 ;ajusta os bits em A como saida
movwf TRISA

movlw 0xF0 ;ajusta os bits em B como saida e
entradas
movwf TRISB

bcf STATUS,RP0 ;volta ao banco 0... (padro do reset)

movlw 0x04 ;apaga leds do port A
movwf PORTA
movwf AUX1

clrf PORTB
;**********************************************
;loop principal

loop:
movlw B'11110111' ;seta em low primeira coluna
movwf TEMP ;salva

tec1:
bsf STATUS,RP0 ;seleciona banco 1
movlw 0xF0
movwf TRISB ;seta novamente o port B
bcf STATUS,RP0 ;volta ao banco 0

movf TEMP,0 ;carrega W com TEMP
movwf PORTB ;envia TEMP para B
movf PORTB,W ;Le o port B
andlw 0xF0 ;mascara para ver se houve...
xorlw 0xF0 ;mudanca no port
btfss STATUS,Z ;nao??? entao pula proximo
goto det_tecla ;sim??? entao tem tecla

tec3:
bsf STATUS,C ;seta carry
rrf TEMP,1 ;marca prxima coluna
btfsc STATUS,C ;ultima coluna??? pula proximo
goto tec1 ;senao, faz novamente
clrf TECLA ;zera tecla
decf TECLA,1 ;faz tecla igual FF

tec2:
clrf PORTB ;zera port B
bsf STATUS,RP0 ;seta banco 1
movlw 0xF0
movwf TRISB ;seta novamente portb
bcf STATUS,RP0 ;volta ao banco 0
goto led ;led 3, opera invertido

apaga:
movlw 0x04
goto led

acende:
movwf TECLA

led1:
movwf PORTA ;ativa led
call pausa

led:
movf AUX1,W ;pega ultimo valor
movwf PORTA
goto loop ;volta para inicio

det_tecla:
incf TECLA,1 ;incrementa tecla
btfss STATUS,Z ;se TECLA estava limpa, pula
goto tec2 ;senao, limpa e volta
movf PORTB,0 ;colhe tecla
iorlw B'00001111' ;operacao OR
andwf TEMP,0 ;AND do resultado com TEMP
movwf TECLA ;salva em tecla

pega_tec:
andlw B'00001111' ;pega o bit em low (coluna)
movwf TECLA_L ;grava em tecla linha
movlw 0x04 ;valor para contador
movwf TEMP ;carrega valor em TEMP

pt1:
bsf STATUS,C ;seta bit carry
rrf TECLA_L,1 ;roda a direita
btfss STATUS,C ;testa bit de carry, se 1 pula
goto pega_hi ;pega parte alta
decfsz TEMP,1 ;decrementa TEMP
goto pt1 ;loop ate zerar contador

erro_meu:
goto inicio ;retorna e inicializa

pega_hi:
decf TEMP,1 ;decrementa TEMP
swapf TECLA,0 ;troca 0 por 1 e vice-versa
andlw B'00001111' ;and do resultado com o literal
movwf TECLA_L ;salva o novo valor
movf TEMP,W ;carrega temp em W
addwf PCL,1 ;soma counter ao Program Counter
goto pega4 ;pula para cada um de acordo com PC
goto pega8
goto pega12
goto pega16

pega4:
movlw 0x04 ;seta contador com 4

pega_com:
movwf TEMP ;salva em temp

pega_c1:
bsf STATUS,C ;seta o bit de carry
rrf TECLA_L,1 ;roda a direita
btfss STATUS,C ;testa o carry
goto tabela_tec ;carry=0, vai para tabela
decfsz TEMP,1 ;decrementa temp
goto pega_c1 ;loop, testa novamente

goto erro_meu ;ERRO! forca reset

pega8:
movlw 0x08 ;carrega W com 8
goto pega_com ;testa

pega12:
movlw 0x0C ;carrega W com 12
goto pega_com

pega16:
movlw 0x10 ;carrega W com 16
goto pega_com ;testa

;**********************************************
;tabela com valores das teclas

tabela_tec:
call tabela ;chama tabela
movwf AUX1 ;salva Tecla
goto acende ;acende leds

tabela:
decf TEMP,1 ;decrementa TEMP
movf TEMP,0 ;poe temp em w
addwf PCL,F ;soma W a PC

;Led 3 opera invertido, ento tabela deve passar bit 2 para PORT A
;tambm invertido -> 0=1 e 1=0
; valor de retorno valor real e tecla

retlw 0x07 ;03 tecla 77H -> F3
retlw 0x03 ;07 tecla B7H -> F2
retlw 0x0F ;11 tecla D7H -> F1
retlw 0x0B ;15 tecla E7H -> E

retlw 0x06 ;2 tecla 7BH -> 9
retlw 0x02 ;6 tecla BBH -> 6
retlw 0x0E ;10 tecla DBH -> 3
retlw 0x0A ;14 tecla EBH -> C

retlw 0x05 ;1 tecla 7DH -> 8
retlw 0x01 ;5 tecla BDH -> 5
retlw 0x0D ;9 tecla DDH -> 2
retlw 0x09 ;13 tecla EDH -> ponto

retlw 0x04 ;0 tecla 7EH -> 7
retlw 0x00 ;4 tecla BEH -> 4
retlw 0x0C ;8 tecla DEH -> 1
retlw 0x08 ;12 tecla EEH -> 0

;**********************************************
;subrotina de temporizao

pausa:
movlw 0xff ;carrega W com 255
movwf T1 ;carrega T1 com W
car_1:
movlw 0xff ;carrega W com 255
movwf T2 ;carrega T2 com 255
dec_1:
decfsz T2,1 ;decrementa T2
goto dec_1 ;255 x T1 vezes
decfsz T1,1 ;decrementa T1
goto car_1 ;volta a carregar T2
retlw 0x00 ;retorna 0 em W

;
;**********************************************
;fim do programa
;**********************************************

end
MICROCONTROLADORES PIC PRTICA - PARTE 5
CONTROLE DE TECLADOS MATRICIAIS


TECLADO MATRICIAL
Os teclados matriciais so muito utilizados hoje em dia. Sempre que for necessrio coletar informaes em campo,
no cho de fabrica, ou mesmo passar orientaes a um pequeno rob, podemos utilizar um teclado.



A figura acima demonstra alguns tipos de teclados matriciais. Estes teclados so formados basicamente por botes
tipo normalmente abertos intercalados entre colunas e linhas. Veja a figura abaixo. Para saber qual tecla foi
pressionada necessrio ler a linha e coluna referente a tecla. Assim podemos determinar exatamente qual das
teclas na matriz foi pressionada.


Porm como saber exatamente qual linha e qual coluna devemos analisar?!? E como garantir que estaremos
analisando a linha e coluna da tecla esperada no exato momento em que ela foi pressionada?!? Para tal necessrio
realizar uma operao muito conhecida no mundo dos microcontroladores, conhecida como varredura. Observe a
figura abaixo.

Voc pode observar que forado um valor fixo nas linhas. Este valor geralmente equivale ao 1 lgico (5V).
Ento, o microcontrolador executa um loop inserindo um 0 lgico (GND) na coluna que dever ser lida e 1
lgico nas colunas que no deseja-se ler. Assim quando algum pressiona uma tecla na coluna onde existe o 0
lgico, imediatamente a linha referente tecla assume o valor 0 tambm. Por meio de uma interrupo ou mesmo
atravs da leitura direta possvel saber qual linha teve seu valor inicial alterado. Como sabemos qual coluna estava
em 0 naquele exato momento, podemos determinar atravs de uma tabela, qual tecla foi pressionada.
Voc deve estar se perguntando: Mas como garantir que a tecla pressionada era realmente a que desejvamos
ler?!?! Simples. A varredura faz isso. A varredura insere nas colunas o valor 0 com uma velocidade muito
maior que uma pessoa pressiona uma tecla. Este valor 0 inserido na primeira coluna, depois na segunda, e assim
por diante at chegar a ltima. Se nenhuma tecla for pressionada, uma nova varredura iniciada na busca de uma
tecla e assim o microcontrolador ficar em um loop eterno na busca de uma tecla.
Resumindo: foramos os valores nas linhas igual a 1 lgico, inserimos 0 lgico na primeira coluna (mantendo
todas as outras em 1) e lemos as linhas. Se nada se alterou, nenhuma tecla foi pressiona nas linhas referentes
coluna. Passamos ento a forar o 0 na prxima coluna e novamente lemos as linhas. Isso feito at que uma das
linhas seja alterada. Neste momento, verificamos uma tabela de decodificao que guarda o valor da tecla. Com este
valor possvel saber exatamente qual tecla foi pressionada.

O CIRCUITO
Nada melhor do que um pouco de prtica para uma melhor compreenso do que foi exposto. O circuito que
ser proposto a seguir demonstrar como utilizar um teclado matricial de quatro linhas e quatro colunas, tambm
conhecido como teclado matricial 4 x 4 (16 teclas).
Na figura abaixo temos o circuito eltrico para o exerccio proposto. O teclado ligado na porta B do PIC. Nesta
porta o microcontrolador realiza toda a varredura para o teclado. Na porta A esto ligados quatro LEDs que sero
utilizados para demonstrar o valor binrio da tecla pressionada. Chamaremos a tecla que fica no canto superior
esquerdo da matriz de tecla 0, na linha 1 / coluna 1. Assim teremos as prximas colunas indicadas como 2, 3 e
4. O mesmo acontecendo para as linhas. As teclas so lidas sempre como linha / coluna. A tecla na linha 4 / coluna 4
ser a tecla 15.

Na tabela abaixo, voc encontrar os valores decimais e binrio de cada tecla, podendo assim dimensionar seu
teclado para a resposta esperada nos LED's. O 1 binrio equivale ao LED aceso, o 0 equivale ao mesmo apagado.
Tabela - Tecla e seu valor decimal e binrio
Tecla Valor
Decimal
Valor
Binrio
Tecla Valor
Decimal
Valor
Binrio
Linha 1 / Coluna
1
0 0000 Linha 3 / Coluna
1
8 1000
Linha 1 / Coluna
2
1 0001 Linha 3 / Coluna
2
9 1001
Linha 1 / Coluna
3
2 0010 Linha 3 / Coluna
3
10 1010
Linha 1 / Coluna
4
3 0011 Linha 3 / Coluna
4
11 1011
Linha 2 / Coluna 4 0100 Linha 4 / Coluna 12 1100
1 1
Linha 2 / Coluna
2
5 0101 Linha 4 / Coluna
2
13 1101
Linha 2 / Coluna
3
6 0110 Linha 4 / Coluna
3
14 1110
Linha 2 / Coluna
4
7 0111 Linha 4 / Coluna
4
15 1111

O PROGRAMA
O cdigo fonte para gravar o microcontrolador pode ser obtido nesta pgina, mais abaixo, no item Downloads. E na
figura abaixo temos o fluxograma do exemplo proposto. Meu programa exemplo funciona executando
constantemente a varredura do teclado. Voc notar que entre o deslocamento de uma coluna e outra sempre feito
um delay de alguns mili segundos, para assegurar tempo suficiente para a deteco da tecla. Se isso no fosse
feito a varredura no teclado seria muito rpida e uma tecla pressionada poderia ser detectada vrias vezes durante o
seu acionamento. Tambm existe um outro delay inserido aps a tecla ter sido detectada, para segurar ainda mais
a velocidade da varredura, evitando mais uma vez o repique da tecla.

Aps a deteco e a decodificao da tecla atravs da tabela, a mesma transportada para a porta A, para
ligar/desligar os LEDs de acordo com o valor inserido na tabela. Este valor ficar exposto atravs dos LEDs at que
uma tecla diferente seja pressionada.
O cdigo fonte tambm foi extensamente comentado para facilitar a compreenso das rotinas empregadas. Com a
alterao deste cdigo fonte possvel, por exemplo, fazer a varredura de teclados telefnicos 4 x 3 (4 linhas, 3
colunas), 3 x 3 (3 linhas, 3 colunas) e at mesmo teclados maiores como os de 44 teclas (4 linhas, 11 colunas).
As aplicaes para este tipo de circuito so vastas: tranca microcontrolada, teclado para micro-terminal de dados,
operao de um rob, habilitao de processos atravs de senhas, controle de mquinas, etc.

CONCLUSO
Espero ter ajudado voc que busca por informaes sobre teclados matriciais e seu controle atravs dos
microcontroladores PIC. Mais uma vez chamo a ateno para a importncia da compreenso do conceito! As
linguagens de programao mudam, mas a aplicao de um conceito sempre a mesma, independente da
Linguagem. Tenha isso sempre em mente!

DOWNLOADS:
- Cdigo fonte


Lista de materiais
Material para o exerccio proposto

Semicondutores
CI1 PIC16F84A-04/P microcontrolador Microchip
D1, D2, D3, D4 1N4149 diodos de sinal (silcio)
D5, D6, D7, D8 Leds comuns redondos (vermelhos)

Resistores
R2, R3, R4, R5 4K7 (amarelo, viloleta, vermelho)
R1, R6, R7, R8, R9 330R (laranja, laranja, marrom)

Capacitores
C1, C2 33pF cermico
C3 100nF cermico

Diversos
Cristal 4MHz, teclado matricial 4x4 ou 16 push-buttons NA (veja texto), matriz de contatos
ou placa, fios para ligao, etc.




Copyright deste contedo reservado para Mrcio Jos Soares e protegido pela Lei de Direitos Autorais LEI N 9.610,
de 19 de Fevereiro de 1998. estritamente proibida a reproduo total ou parcial do contedo desta pgina em
outros pontos da internet, livros ou outros tipos de publicaes comerciais ou no, sem a prvia autorizao por
escrito do autor.