TECLADO MATRICIAL

GOSTARIA DE UMA JUDA.
EU FIZ UM TECLADO SIMPLES DE 5 BOTOES PARA LIGAR NO PIC, MAIS NAO É MATRICIAL, UTILIZEI 5 ENTRADAS DO PIC.
SE ALGUEM SOUBER COMO LIGAR UM MATRICIAL NESSE PIC (18F4550), FICARIA MUITO GRATO. MAS MEU PROBLEMA É OUTRO:
COMO FAÇO PARA O PROGRAMA RECONHECER UM NUMERO QUE EU DIGITO NUMERO. POR EXEMPLO: EU QUERO DIGITAR O NUMERO 122, EU DIGITO 1 + 2 + 2. OK, MAS COMO EU FAÇO PRA RECONHECER O NUMERO 122 (CENTO E VITE E DOIS)? OU SEJA UNIDADE, DEZENA E CENTENA.
OBRIGADO.

Olá Davi,

O teclado matricial oferece a vantagem de usar menor número de portas do microcontrolador e o preço disto é uma complicação pequena no hardware o no firmware.
Para a parte de hardware existem teclados matriciais prontos para comprar. Caso deseje montar um em protoboard nao é complicado, basta seguir o esquemático abaixo:

Fonte: http://picmania.garcia-cuervo.net/experimentos_hard.php

Para o firmware você deve fazer o microcontrolador colocar 1 em uma das colunas e 0 nas outras. Então você faz uma varredura linha a linha olhando se alguma delas possui nivel lógico 1. Passa para próxima coluna e faz novamente a varredura pelas linhas. Ao terminar a varredura de todas linhas e colunas você saberá qual tecla está sendo apertada (caso seja).

Por exemplo: Caso voce coloque 1 na primeira coluna e 0 nas demais e na varredura de teclas a linha 3 apresente nivel lógico 1 e as demais linhas nivel lógico 0 significa que o usuário está apertando o número 7. Caso você tenha dúvidas eu detalho mais como fazer este firmware.

Sobre sua dúvida de reconhecimento dos números você mesmo quase a respondeu. Você deve informar ao programa que o primeiro dígito tem valor de unidade, o segundo de dezena, o terceiro de centena etc. Para isto, você pode declarar um inteiro numero e inicializa-lo com 0. Ao pressionar uma tecla voce multiplica o valor da tecla por 1 e soma a número. A segunda vez voce multiplica o valor da tecla por 10 e soma a numero, a terceira vez mulplica por 100 e soma a número. Abaixo um exemplo

Código:


    int numero = 0;
    int contador = 1;
while (tela_ok)
{
    if(tecla1)
    {
      Delay(); // Evitar problema de "amortecimento" da tecla.
      numero = numero + (1 * contador);
      contador = contador * 10;
    }
    if(tecla2)
    {
      Delay(); // Evitar problema de "amortecimento" da tecla.
      numero = numero + (2 * contador);
      contador = contador * 10;
    }
    if(tecla3)
    {
      Delay(); // Evitar problema de "amortecimento" da tecla.
      numero = numero + (3 * contador);
      contador = contador * 10;
    }
}
etc.


Espero ter ajudado.

CONSEGUI BRUNO, DEU CERTIM......MUITO OBRIGADO..VALEU

Encontrei um site bom falando sobre a lógica de funcionamento do teclado matricial:
http://www.arnerobotics.com.br/eletronica/Microcontrolador_PIC_pratica_5.htm
Aproveitem.

Bruno S. Avelar

ESTOU PRECISANDO DE UM EXEMPLO DE TECLADO MATRICIAL PARA PIC18F4550.

JA TENHO O TECLADO COM A SEGUINTE CONFIGURAÇÃO

5 x 3 DE 8 VIAS.

Tomei a liberdade de fundir um tópico já existente (um pouco difícil de ser encontrado) ao seu já que ele respondia sua pergunta.
Da uma olhada nas mensagens acima, caso precise de mais informações post uma mensagem que te ajudo.

Espero ter ajudado,
Bruno S. Avelar

Olá Bruno;
Eu li os tópicos acimas mas não estou conseguindo entender direito como é essa varredura e como ficará o programa.
Como fica configurado as colunas e as linhas? Todos como entrada? Ou como saída? Como fica a ligação do resistores? Não estou entendendo.
Será que vocë poderia colocar de exemplo um programa para que eu possa testar?
Abraços.

Davi,

O funcionamento do teclado matricial é relativamente simples. O desenho que coloquei abaixo mostra como funciona um teclado matricial por dentro.





Você pode perceber que quando a coluna 1 estiver em nivel lógico 1 (ou seja 5v) e as demais colunas em nível lógico 0, e a tecla '4', por exemplo, for pressionada, então, apenas a porta RB5 ficará em nível lógico 1.

As colunas devem ser definidas como saidas e as linhas como entradas.

O programa deve colocar nível lógico 1 na primeira coluna e 0 nas demais, e logo em seguida, ler cada uma das linhas, se alguma delas apresentar nivel logico 1 significa que a tecla correspondente a esse linha, na PRIMEIRA COLUNA, foi pressionada. Em seguida, coloca-se nível lógico 1 na segunda coluna e 0 nas demais, o programa lê cada uma das linhas novamente, se alguma delas apresentar nivel logico 1 significa que a tecla correspondente a esse linha, na SEGUNDA COLUNA coluna, foi pressionada. E assim sucessivamente.

Os resistores têm a função de impedir um curto circuito entre duas portas do microcontrolador pois, quando uma tecla for pressionada, uma conexão direta entre a porta conectada à linha (configurada como saía) e a porta conectada à coluna (configurada como entrada) é estabelecida. Portanto, não a segredo na ligação dos resistores, basta colocá-los como indicado na figura enviada pelo Bruno, entre cada uma das portas do microcontrolador que estão conectadas as linhas do teclado e as linhas do teclado.

Abaixo segue uma biblioteca simples para utilização de um teclado matricial.

Arquivo .h :

Código:


/******************************************************************************
 *
 *            Curso PICMINAS de Microcontroladores (PIC18F4550)
 *
 ******************************************************************************
 * Nome do Arquivo:    Teclado_16Teclas
 * Dependencias:       Veja seção INCLUDES
 * Processador:         PIC18F4550
 * Opção de Clock:      HS 20MHz (externo) - CPU: 48MHz   
 * Compilador:           C18 v3.20 ou superior
 * Empresa:           PICMINAS - Axoon - UFMG
 *
 * Plataforma:         Kit PICMINAS v2.0
 *
 * Autor:            James Hamilton Oliveira Junior
 *
 * Data:            v1 - 24/Jan/2010
 *                  v2 - 25/Jan/2010
 *                  v3 - 26/Jan/2010
 *                  v4 - 28/Jan/2010
 *
 * Descrição:           Biblioteca de funções para ler de um teclado de 16 ou 12 teclas
 *                  (4x4 ou 4x3) através de interrupções. O teclado deverá ser
 *                  conectado a porta do microcontrolador que possui interrupções
 *                  de grupo, no caso do PIC18F4550, portaB de RB4 até RB7.
 *                  
 *                  O funcionamento de um teclado do tipo matriz é simples. Sempre que
 *                  uma tecla é pressionada, a linha a coluna são conectas. Por exemplo,
 *                  pressionada, a linha 2 ficará com nivel logico 1 também.
 *                  
 *                  No uso desse teclado com o microcontrolador, conectamos suas linhas
 *                  em portas de output, e suas colunas em portas de input. As colunas
 *                  são conectas am pinos de input do microcontrolador e assume nivel
 *                  logico 1. Colocando nivel logico 0 nas linhas, podemos saber quando
 *                  uma tecla é pressionada pela variação de uma coluna. Para indentificar
 *                  a tecla, basta fazer uma busca pelo teclado, alternando o bit '0'
 *                  entre as linhas e verificando qual coluna permanece em '0'.
 *                  
 *                  As coluna do teclado devem ser conectas as portas com interrupções
 *                  ,inputs, enquanto as linhas devem ser conectas a portas configuras
 *                  como outpus. O esquema abaixo demonstra as ligações
 *                  
 *         
 *                                 C     C     C     C
 *                                 O     O     O     O
 *                                 L     L     L     L
 *                                 U     U     U     U
 *                                 N     N     N     N
 *                                 A     A     A     A
 *                                 |     |     |     |
 *                                 0     1     2     3  -> Coluna 3 não implementada
 *                                :     :     :     :
 *                                   :     :     :     :
 *                               __:    __:    __:    __:
 *                              |00|   |01|   |02|   |03|
 *                  LINHA_0   --------|__|----|__|----|__|----|__|
 *                                   :     :     :     :
 *                               __:    __:    __:    __:
 *                              |10|   |11|   |12|   |13|
 *                  LINHA_1   --------|__|----|__|----|__|----|__|
 *                                   :     :     :     :
 *                               __:    __:    __:    __:
 *                              |20|   |21|   |22|   |23|
 *                  LINHA_2   --------|__|----|__|----|__|----|__|
 *                                       :     :     :     :
 *                               __:    __:    __:    __:
 *                              |30|   |31|   |32|   |33|
 *                  LINHA_3   --------|__|----|__|----|__|----|__|            
 *      
 *      
 *      
 *                  Como queremos que os pinos de input do PIC fiquem em nivel
 *                  logico alto (1) quando desconectados (nenhuma tecla pressionada)
 *                  precisamos habilitar os resistores de pull-up internos
 *                  ou acrescentar resistores externos:
 *
 *                  Resistores de Pull-up:
 *               
 *                  /|\
 *                 /_|_\ Vcc
 *                   |
 *                   |               
 *                      _|_
 *                 |  |
 *                 | R |
 *                 |_ _|
 *                   |              ()
 *                   |                 \      |  GND
 *                 __|____              \      ||
 *                  pino  |_________()  \______|||
 *                 _______|                  |||
 *                                       ||
 *                                       |
 *
 *                  para habilitar os pull-ups da porta B: INTCON2bits.RBPU=0;
 *                  pagina 114, item 10.2 do datasheet do PIC18F4550:
 *                  
 *                  "Each of the PORTB pins has a weak internal pull-up. A
 *                  single control bit can turn on all the pull-ups. This is
 *                   performed by clearing bit, RBPU (INTCON2<7>). The
 *                  weak pull-up is automatically turned off when the port
 *                  pin is configured as an output. The pull-ups are
 *                  disabled on a Power-on Reset."               
 *                                       
 *                                                
 *****************************************************************************/
/*****************************************************************************/
//
//                       I N C L U D E S
//
//
/*****************************************************************************/

#include <p18cxxx.h>   // Biblioteca com as definições do PIC selecionado
                  //no projeto, neste caso, o modelo 18F4550.

/*****************************************************************************/
//
//                       D E F I N E S
//
//
/*****************************************************************************/                  
//  Define os pinos onde será conectado o teclado. A quarta coluna esta
//  desabilitada, portanto, o teclado so possui 12 teclas. Para habilitá-lo,
//   para 16 teclas é necessário descomentar essa linha e mais as linhas da função
//   Interrupção_Teclado, da definiçao de Matriz_Teclado e das funções
//   Limpa_Matriz_Teclado() e Teclas()

#define LINHA_0      PORTBbits.RB2
#define LINHA_1      PORTBbits.RB3
#define LINHA_2      PORTBbits.RB1
#define LINHA_3      PORTBbits.RB0

#define COLUNA_0     PORTBbits.RB5
#define COLUNA_1     PORTBbits.RB6
#define COLUNA_2     PORTBbits.RB7
//#define COLUNA_3     PORTBbits.RB4

/*****************************************************************************/
//
//                    P R O T O T I P O S
//
//
/*****************************************************************************/   

/******************************************************************************
 * Funcao:           void Interrupcao_Teclado (void)
 * Entrada:        Nenhuma (void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao a ser executada quando uma interrupcao
 *               do teclado ocorrer. Determina as teclas pressionadas
 *               por meio de uma matriz: Matriz_Teclado[][] onde o primeiro
 *               colchete representa as linhas e o segundo as colunas.
 *
 *               Essa função deve ser chamada quando a interrupção ocorrer.
 *               Ela apenas "lê" o teclado e armazena as teclas que foram
 *               pressionadas em uma matriz. A função insere um '0' nas
 *               posições da matriz onde teclas foram pressionadas.
 *               
 *               A função Interrupção_Teclado, entretanto, não evita "bounce",
 *               ficando sob responsabilidade do usuário.
 *               
 *               Uma sugestão consiste em, cada vez que uma interrupção
 *               ocorrer, desabilitar as interrupções do teclado e disparar
 *               um timer. Quando a iterrupção do timer ocorrer, as
 *               interrupções do teclado são novamente habilitadas.
 *
 *****************************************************************************/
 extern void Interrupcao_Teclado (void);
 
 /******************************************************************************
 * Funcao:           void Tecla_Pressionada (unsigned char Linha, unsigned char Coluna)
 *
 * Entrada:        unsigned char Linha  -> linha da matriz que se deseja acessar
 *               unsigned char Coluna -> coluna da matriz que se deseja acessar
 *
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que retorna o bit binario invertido contido na
 *               matriz do teclado. Se a tecla de coordendas indicadas
 *               pelas entradas da função tiver sido pressionada, será
 *               retornado o valor '1', se a tecla não tiver sido pressionada
 *               a função retorna '0'
 *
 *****************************************************************************/
 extern unsigned int Tecla_Pressionada (unsigned char Linha, unsigned char Coluna);

 /*****************************************************************************/
 /******************************************************************************
 * Funcao:           void Teclado_Escrito (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que retorna o valor do flag do teclado (Teclado_Flag).
 *               Se o valor retornado for 1, o a matriz do teclado foi escrita 
 *               pela rotina de interrupção e portanto possui informações não
 *               processadas pelo programa, se seu valor for '0', a matriz do
 *               teclado ja foi lida pelo programa e não contem informações
 *               novas.
 *
 *****************************************************************************/
 extern unsigned int Teclado_Escrito (void);

 /*****************************************************************************/ 
 /******************************************************************************
 * Funcao:           void Teclado_Lido (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que zera o valor do flag do teclado (Teclado_Flag).
 *               Dessa forma, o programa indica que a matriz do teclado já foi lida, 
 *               habilitando a rotina de interrupção a escrever na matriz caso uma
 *               nova tecla seja pressionada
 *
 *****************************************************************************/
 extern void Teclado_Lido (void);

 /*****************************************************************************/
 /******************************************************************************
 * Funcao:           unsigned int Posicao_Teclado (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que retorna a posição da primeira tecla encontrada
 *               na matriz de teclas. Se nenhuma tecla tiver sido pressionada,
 *               a função retorna '99', um código de erro.
 *
 *****************************************************************************/
 extern unsigned int Posicao_Teclado (void);

 /*****************************************************************************/   
 /******************************************************************************
 * Funcao:           void Limpa_Matriz_Teclado (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que 'limpa' todas as posições da matriz do teclado.
 *               A função percorre todas as posições atribuido o bit '1'.
 *               Ou seja, que a tecla dessa posição não foi pressionada
 *
 *****************************************************************************/
 extern void Limpa_Matriz_Teclado (void);

/*****************************************************************************/
/******************************************************************************
* Funcao:      void Inicializa_Teclado (void)
*
* Entrada:      Nenhuma(void)
* Saída:        Nenhuma (void)
* Descrição:    Funcao que iniciliza o teclado, garantido que os valores
*            lidos sejam corretos. A função limpa a matriz do teclado,
*            reseta o flag_do teclado, e coloca nas linhas (outputs) o
*            bit '0', para que qualquer tecla pressionada possa gerar
*            a primeira interrupção
*
*****************************************************************************/
extern void Inicializa_Teclado (void);

 /******************************************************************************
 * Funcao:           unsigned int Numero_Teclado (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que retorna o NUMERO da primeira tecla encontrada
 *               na matriz de teclas. Se nenhuma tecla tiver sido pressionada,
 *               a função retorna '99', um código de erro.
 *
 *****************************************************************************/
extern unsigned int Numero_Teclado (void);


/****************      F I M      D O    A R Q U I V O    *****************/
/****************************************************************************/


Arquivo .c :

Código:


/******************************************************************************
 *
 *            Curso PICMINAS de Microcontroladores (PIC18F4550)
 *
 ******************************************************************************
 * Nome do Arquivo:    Teclado_16Teclas
 * Dependencias:       Veja seção INCLUDES
 * Processador:         PIC18F4550
 * Opção de Clock:      HS 20MHz (externo) - CPU: 48MHz   
 * Compilador:           C18 v3.20 ou superior
 * Empresa:           PICMINAS - Axoon - UFMG
 *
 * Plataforma:         Kit PICMINAS v2.0
 *
 * Autor:            James Hamilton Oliveira Junior
 *
 * Data:            v1 - 24/Jan/2010
 *                  v2 - 25/Jan/2010
 *                  v3 - 26/Jan/2010
 *                  v4 - 28/Jan/2010
 *
 * Descrição:           Biblioteca de funções para ler de um teclado de 16 ou 12 teclas
 *                  (4x4 ou 4x3) através de interrupções. O teclado deverá ser
 *                  conectado a porta do microcontrolador que possui interrupções
 *                  de grupo, no caso do PIC18F4550, portaB de RB4 até RB7.
 *                  
 *                  O funcionamento de um teclado do tipo matriz é simples. Sempre que
 *                  uma tecla é pressionada, a linha a coluna são conectas. Por exemplo,
 *                  pressionada, a linha 2 ficará com nivel logico 1 também.
 *                  
 *                  No uso desse teclado com o microcontrolador, conectamos suas linhas
 *                  em portas de output, e suas colunas em portas de input. As colunas
 *                  são conectas am pinos de input do microcontrolador e assume nivel
 *                  logico 1. Colocando nivel logico 0 nas linhas, podemos saber quando
 *                  uma tecla é pressionada pela variação de uma coluna. Para indentificar
 *                  a tecla, basta fazer uma busca pelo teclado, alternando o bit '0'
 *                  entre as linhas e verificando qual coluna permanece em '0'.
 *                  
 *                  As coluna do teclado devem ser conectas as portas com interrupções
 *                  ,inputs, enquanto as linhas devem ser conectas a portas configuras
 *                  como outpus. O esquema abaixo demonstra as ligações
 *                  
 *         
 *                                 C     C     C     C
 *                                 O     O     O     O
 *                                 L     L     L     L
 *                                 U     U     U     U
 *                                 N     N     N     N
 *                                 A     A     A     A
 *                                 |     |     |     |
 *                                 0     1     2     3  -> Coluna 3 não implementada
 *                                :     :     :     :
 *                                   :     :     :     :
 *                               __:    __:    __:    __:
 *                              |00|   |01|   |02|   |03|
 *                  LINHA_0   --------|__|----|__|----|__|----|__|
 *                                   :     :     :     :
 *                               __:    __:    __:    __:
 *                              |10|   |11|   |12|   |13|
 *                  LINHA_1   --------|__|----|__|----|__|----|__|
 *                                   :     :     :     :
 *                               __:    __:    __:    __:
 *                              |20|   |21|   |22|   |23|
 *                  LINHA_2   --------|__|----|__|----|__|----|__|
 *                                       :     :     :     :
 *                               __:    __:    __:    __:
 *                              |30|   |31|   |32|   |33|
 *                  LINHA_3   --------|__|----|__|----|__|----|__|            
 *      
 *      
 *      
 *                  Como queremos que os pinos de input do PIC fiquem em nivel
 *                  logico alto (1) quando desconectados (nenhuma tecla pressionada)
 *                  precisamos habilitar os resistores de pull-up internos
 *                  ou acrescentar resistores externos:
 *
 *                  Resistores de Pull-up:
 *               
 *                  /|\
 *                 /_|_\ Vcc
 *                   |
 *                   |               
 *                      _|_
 *                 |  |
 *                 | R |
 *                 |_ _|
 *                   |              ()
 *                   |                 \      |  GND
 *                 __|____              \      ||
 *                  pino  |_________()  \______|||
 *                 _______|                  |||
 *                                       ||
 *                                       |
 *
 *                  para habilitar os pull-ups da porta B: INTCON2bits.RBPU=0;
 *                  pagina 114, item 10.2 do datasheet do PIC18F4550:
 *                  
 *                  "Each of the PORTB pins has a weak internal pull-up. A
 *                  single control bit can turn on all the pull-ups. This is
 *                   performed by clearing bit, RBPU (INTCON2<7>). The
 *                  weak pull-up is automatically turned off when the port
 *                  pin is configured as an output. The pull-ups are
 *                  disabled on a Power-on Reset."               
 *                                       
 *                                                
 *****************************************************************************/
/*****************************************************************************/
//
//                       I N C L U D E S
//
//
/*****************************************************************************/

#include "Teclado_16Teclas.h"

/*****************************************************************************/
//
//                        V A R I Á V E I S
//
//
/*****************************************************************************/

unsigned int Matriz_Teclado[4][3];      //Matriz de teclas pressionadas o primeiro
//unsigned int Matriz_Teclado[4][4];   //indice indica a linha e o segundo a coluna
                              //a matriz é 4x3, (4 linhas e 3 colunas) mas
                              //é possivel adicionar mais uma coluna, basta
                              //descomentar alguns comandos

int Teclado_Flag = 0;                //Flag, indica se o a Matriz_Teclado foi escrita
                              //pela interrupção (Teclado_Flag = 1) e/ou se ja
                              //foi lida pelo programa (Teclado_Flag = 0)
                                 
/*****************************************************************************/
//
//                       F U N Ç Õ E S
//
//
/*****************************************************************************/

/******************************************************************************
 * Funcao:           void Interrupcao_Teclado (void)
 * Entrada:        Nenhuma (void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao a ser executada quando uma interrupcao
 *               do teclado ocorrer. Determina as teclas pressionadas
 *               por meio de uma matriz: Matriz_Teclado[][] onde o primeiro
 *               colchete representa as linhas e o segundo as colunas.
 *
 *               Essa função deve ser chamada quando a interrupção ocorrer.
 *               Ela apenas "lê" o teclado e armazena as teclas que foram
 *               pressionadas em uma matriz. A função insere um '0' nas
 *               posições da matriz onde teclas foram pressionadas.
 *               
 *               A função Interrupção_Teclado, entretanto, não evita "bounce",
 *               ficando sob responsabilidade do usuário.
 *               
 *               Uma sugestão consiste em, cada vez que uma interrupção
 *               ocorrer, desabilitar as interrupções do teclado e disparar
 *               um timer. Quando a iterrupção do timer ocorrer, as
 *               interrupções do teclado são novamente habilitadas.
 *
 *****************************************************************************/
 void Interrupcao_Teclado (void)
 {
    //   if (Teclado_Flag == 0)   //enquanto o buffer não for lido pelo programa,
    //   {                     //uma nova leitura não será feita.
             LINHA_0 = 0;      
             LINHA_1 = 1;                  //seta apenas uma das linhas de cada vez, e
             LINHA_2 = 1;                  //testa as colunas, assim é possivel identificar
             LINHA_3 = 1;                  //as pressionadas   
             Matriz_Teclado[0][0] = COLUNA_0;
             Matriz_Teclado[0][1] = COLUNA_1;
             Matriz_Teclado[0][2] = COLUNA_2;
             //Matriz_Teclado[0][3] = COLUNA_3;   //coluna desativada, para ativar, basta descomentar
                                        //essa linha e a linhas dos defines no arquivo .h
                         
             LINHA_0 = 1;
             LINHA_1 = 0;
             LINHA_2 = 1;
             LINHA_3 = 1;
             Matriz_Teclado[1][0] = COLUNA_0;
             Matriz_Teclado[1][1] = COLUNA_1;
             Matriz_Teclado[1][2] = COLUNA_2;
             //Matriz_Teclado[1][3] = COLUNA_3;
             
             LINHA_0 = 1;
             LINHA_1 = 1;
             LINHA_2 = 0;
             LINHA_3 = 1;
             Matriz_Teclado[2][0] = COLUNA_0;
             Matriz_Teclado[2][1] = COLUNA_1;
             Matriz_Teclado[2][2] = COLUNA_2;
             //Matriz_Teclado[2][3] = COLUNA_3;
             
              LINHA_0 = 1;
             LINHA_1 = 1;
             LINHA_2 = 1;
             LINHA_3 = 0;
             Matriz_Teclado[3][0] = COLUNA_0;
             Matriz_Teclado[3][1] = COLUNA_1;
             Matriz_Teclado[3][2] = COLUNA_2;
             //Matriz_Teclado[3][3] = COLUNA_3;
             
             LINHA_0 = 0;            //todas as linhas são colocadas novamente
             LINHA_1 = 0;            //em '0', dessa forma, quando uma nova tecla
             LINHA_2 = 0;            //for pressionada haverá interrupção.
             LINHA_3 = 0;
             
             Teclado_Flag = 1;      //seta o flag, indicando para o programa que
                                  //o teclado foi escrito, ele não será escrito
    //   }//fim if                     //de novo ate que seja lido pelo programa
 }//fim Interrupcao_Teclado
 
 /******************************************************************************
 * Funcao:           void Tecla_Pressionada (unsigned char Linha, unsigned char Coluna)
 *
 * Entrada:        unsigned char Linha  -> linha da matriz que se deseja acessar (de 0 até 3)
 *               unsigned char Coluna -> coluna da matriz que se deseja acessar (de 0 até 2 ou 3)
 *
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que retorna o bit binario invertido contido na
 *               matriz do teclado. Se a tecla de coordendas indicadas
 *               pelas entradas da função tiver sido pressionada, será
 *               retornado o valor '1', se a tecla não tiver sido pressionada
 *               a função retorna '0'
 *
 *****************************************************************************/
 unsigned int Tecla_Pressionada (unsigned char Linha, unsigned char Coluna)
  {
     return !Matriz_Teclado[Linha][Coluna];       //retorna 1 se a tecla foi pressionada
                                      //e 0 se não foi.      
  }
 /*****************************************************************************/
 /******************************************************************************
 * Funcao:           void Teclado_Escrito (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que retorna o valor do flag do teclado (Teclado_Flag).
 *               Se o valor retornado for 1, o a matriz do teclado foi escrita 
 *               pela rotina de interrupção e portanto possui informações não
 *               processadas pelo programa, se seu valor for '0', a matriz do
 *               teclado ja foi lida pelo programa e não contem informações
 *               novas.
 *
 *****************************************************************************/
 unsigned int Teclado_Escrito (void)
  {
     return (Teclado_Flag); //retorna 1 se teclado foi escrito
  }
 /*****************************************************************************/ 
 /******************************************************************************
 * Funcao:           void Teclado_Lido (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que retorna zera o valor do flag do teclado (Teclado_Flag).
 *               Dessa forma, o programa indica que a matriz do teclado já foi lida, 
 *               habilitando a rotina de interrupção a escrever na matriz caso uma
 *               nova tecla seja pressionada
 *
 *****************************************************************************/
  void Teclado_Lido (void)
  {
     Teclado_Flag = 0;
  }
 /*****************************************************************************/
 /******************************************************************************
 * Funcao:           unsigned int Posicao_Teclado (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que retorna a posição da primeira tecla encontrada
 *               na matriz de teclas. Se nenhuma tecla tiver sido pressionada,
 *               a função retorna '99', um código de erro.
 *
 *****************************************************************************/
  unsigned int Posicao_Teclado (void)
  {
        int i, j;
        
        for (i=0; i<=3; i++)
        {
           for(j=0; j<=2; j++)             //opera apenas para teclado 12 teclas
           //for(j=0; j<=3; j++)            //descomentar essa linha e comentar a
           {                           //de cima para teclado de 16 tecals
              if (Matriz_Teclado[i][j] == 0)
              {
                 Teclado_Flag = 0;
                 return ((i*10)+j);         //retorna a posiçao da primeira tecla encontrada
              }
           }
        }   
        Teclado_Flag = 0;
        return 99;       //nenhuma tecla pressionada 'erro'
  }//fim função
 /*****************************************************************************/   
 /******************************************************************************
 * Funcao:           void Limpa_Matriz_Teclado (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que 'limpa' todas as posições da matriz do teclado.
 *               A função percorre todas as posições atribuido o bit '1'.
 *               Ou seja, que a tecla dessa posição não foi pressionada
 *
 *****************************************************************************/
void Limpa_Matriz_Teclado (void)
{   
   int i,j;
   
   for(i=0; i<=3; i++)
   {
      for (j=0; j<=2; j++)          //opera apenas para teclado 12 teclas
      //for (j=0; j<=3; j++)         //descomentar essa linha e comentar a
      {                        //de cima para teclado de 16 tecals
         Matriz_Teclado[i][j] = 1;
      }
   }      
}      
/*****************************************************************************/
/******************************************************************************
* Funcao:      void Inicializa_Teclado (void)
*
* Entrada:      Nenhuma(void)
* Saída:        Nenhuma (void)
* Descrição:    Funcao que iniciliza o teclado, garantido que os valores
*            lidos seja corretos. A função limpa a matriz do teclado,
*            reseta o flag_do teclado, e coloca nas linhas (outputs) o
*            bit '0', para que qualquer tecla pressionada possa gerar
*            a primeira interrupção
*
*****************************************************************************/
void Inicializa_Teclado (void)
{
   Limpa_Matriz_Teclado();
   Teclado_Flag = 0;       //habilita teclado para a escrita
   
   LINHA_0 = 0;            //seta as portas de output para detectar uma
    LINHA_1 = 0;            //tecla pressionada.
    LINHA_2 = 0;
    LINHA_3 = 0;
}      

 /******************************************************************************
 * Funcao:           unsigned int Numero_Teclado (void)
 *
 * Entrada:        Nenhuma(void)
 * Saída:             Nenhuma (void)
 * Descrição:      Funcao que retorna o NUMERO da primeira tecla encontrada
 *               na matriz de teclas. Se nenhuma tecla tiver sido pressionada,
 *               a função retorna '99', um código de erro.
 *
 *****************************************************************************/
unsigned int Numero_Teclado (void)
{
     int i, j;
     
     for (i=0; i<=3; i++)
     {
        for(j=0; j<=2; j++)          
        {                           
         if (Matriz_Teclado[i][j] == 0)
         {
            if (i!=3)                  //determina o numero da tecla pressionada
            {                        //os caracteres da linha 3 sao uma excessao
               Teclado_Flag = 0;
               return ((3*i+1+j));         
            }                     
            else                     //analisa os caracteres especiais da                                             
            {                        //ultima linha do teclado   
               switch(j)               
               {
                  case (0):             //caso *
                     Teclado_Flag = 0;
                     return 10;
                  break;
                  
                  case (1):             //caso 0
                     Teclado_Flag = 0;
                     return 0;
                  break;
                  
                  case (2):            //caso #
                     Teclado_Flag = 0;
                     return 11;
                  break;
               }
            }
            
           }//fim if
           
        }//fim for   
   }//fim for      
   Teclado_Flag = 0;
   return 99;             //se nehuma tecla encontrada retorna         
                     //codigo de 'erro' 99
}//fim função


//****************      F I M      D O    A R Q U I V O    *****************/
/*****************************************************************************/