Início / Projetos Arduino / Projetos Squids / Básico / Projeto107 - Como usar um Teclado Matricial 4x4 com Arduino (Sem Biblioteca)

---

Projeto107 - Como usar um Teclado Matricial 4x4 com Arduino (Sem Biblioteca)

Angelo Luis Ferreira | 22/04/2025 Acessos: 152

Objetivo

Este projeto tem como objetivo demonstrar o funcionamento de um teclado matricial de membrana 4x4 (keypad) controlado por um microcontrolador Arduino, sem o uso de bibliotecas auxiliares. Ao pressionar uma tecla, o Arduino identifica o valor correspondente e o exibe em tempo real no monitor serial e em um display LCD.

A leitura das teclas é realizada por meio de varredura multiplexada das linhas e colunas do teclado, utilizando as entradas e saídas digitais do Arduino. O código implementado faz essa leitura de forma direta, permitindo uma compreensão mais aprofundada dos conceitos de leitura matricial, controle de hardware em baixo nível e gerenciamento de entradas digitais. Com isso, o projeto oferece uma base sólida para quem deseja entender e aplicar a lógica de leitura de teclados matriciais, sem abstrações automáticas fornecidas por bibliotecas externas.

Definições

Teclado Matricial De Membrana 4 X 4: O Teclado Matricial foi desenvolvido para servir como interface de entrada de dados em sistemas eletrônicos. Este teclado possui 16 teclas distribuídos em 4 linhas e 4 colunas, onde 10 delas são números (0 a 9), 4 são letras (A, B, C e D) e 2 são caracteres especiais. Também possui um terminal com 8 vias para a ligação.

Como o teclado matricial de membrana 4 X 4 trabalha:

a. O teclado possui 16 teclas, que estão dispostas em 4 linhas por 4 colunas, e ele possui 8 pinos para ligação. 

b. Abaixo de cada tecla do teclado matricial existe um pequeno interruptor de membrana. Esses interruptores estão organizados em linhas e colunas, formando uma malha de conexões. Todos os interruptores de uma mesma linha estão interligados por uma trilha condutora, e o mesmo acontece com os interruptores de uma mesma coluna. Ou seja, cada tecla está localizada na interseção de uma linha com uma coluna, o que permite identificar exatamente qual botão foi pressionado.

c. Por isso, esse tipo de teclado é chamado de teclado matricial, já que sua estrutura elétrica se baseia em uma matriz de linhas e colunas. Em um teclado 4x4, por exemplo, são utilizadas 4 linhas e 4 colunas, totalizando 8 pinos (vias) de conexão com o Arduino. A imagem abaixo ilustra essa disposição de forma mais clara.

d. O Arduino detecta qual botão foi pressionado detectando o pino de linha (R1, R2, R3 ou R4) e coluna (C1, C2, C3 ou C4) conectado ao botão.

e. Esse método é eficiente porque permite a leitura de múltiplas teclas usando uma quantidade reduzida de pinos, sem a necessidade de um fio separado para cada botão. No caso de um teclado 4x4, por exemplo, são necessários apenas 8 pinos (4 linhas + 4 colunas) para monitorar 16 teclas.

Como o Arduino detecta a tecla pressionada:

O teclado matricial funciona por meio de um processo chamado varredura multiplexada. Nesse método, o Arduino atua como um scanner: ele envia sinais sequenciais pelas linhas da matriz enquanto lê continuamente os sinais nas colunas (ou vice-versa), a fim de identificar qual tecla foi pressionada.

Esse processo consiste em ativar uma linha por vez e verificar, nas colunas, se há algum sinal indicando que um botão naquela linha e coluna foi acionado. Quando uma conexão é detectada entre uma linha ativa e uma coluna, o Arduino consegue determinar exatamente qual tecla está na interseção entre aquela linha e coluna — ou seja, qual foi pressionada.

Abaixo, mostramos como esse processo pode ser implementado no código, sem o uso de bibliotecas, utilizando apenas lógica de controle direto das portas digitais do Arduino:

1. Configuração Inicial

Primeiro é configurar todos os pinos digitais correspondentes às linhas como entradas (INPUT_PULLUP) - resistor de pull-up interno ativado - em nível lógico alto (HIGH) e os pinos correspondentes às colunas como saídas (OUTPUT), também em nível lógico alto (HIGH).

Quando nenhuma tecla está pressionada, todos os pinos de linha permanecem em nível alto, e não há corrente entre as colunas e linhas.

2. Início da Varredura

O Arduino realiza a varredura coluna por coluna. Para isso, ele coloca uma coluna por vez em nível lógico baixo (LOW), mantendo as outras colunas em HIGH, e lê o estado dos pinos de linha.

3. Detecção da Tecla Pressionada

Se uma tecla da coluna atualmente ativada (em LOW) estiver sendo pressionada, o pino da linha correspondente será "alterado" para LOW. Isso acontece porque a tecla pressionada estabelece uma conexão elétrica entre a coluna (em LOW) e a linha (originalmente em HIGH com pull-up), fazendo com que o pino da linha também vá para LOW.

4. Identificação da Linha e Coluna

Sabendo qual coluna estava ativada no momento e qual linha foi lida como LOW, o Arduino identifica exatamente qual tecla está na interseção dessa linha e coluna.

5. Leitura Concluída

O processo se repete para todas as colunas, e o Arduino detecta pressionamentos em tempo real. Assim, por exemplo, se a tecla "5" for pressionada, e ela estiver na interseção da linha 2 e coluna 2, o Arduino detectará isso durante a varredura e poderá exibir o valor correspondente.

Referências

Projeto 48 - Como controlar um display LCD com o módulo I2C

Projeto 38 - Controlando um display LCD (instalação e comandos básicos) (Caso não possua um módulo I2C e queira adaptar o projeto para usar o display LCD sem adaptador)

Aplicação

Para fins didáticos e sistemas que precisam de interação humana, como por exemplo: sistema de senha para abertura de fechadura eletrônica, menu de navegação em displays, mini calculadores e conversores de unidade, controle de robôs e dispositivos (luzes, ventilação, irrigação), jogos como quiz ou perguntas de múltiplas escolhas, temporizadores, automação residência, etc.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Teclado Matricial de Membrana	Teclado Matricial de Membrana 4 X 4 (16 teclas)	1		Teclas: 16 Conector: 8 pinos (2,54mm) Montagem: Auto-Adesivo Limites de Operação: 35VDC, 100mA Isolação: 100MΩ, 100V Tempo de contato: 5ms Durabilidade: 1 milhão de ciclos por tecla Temperatura de Funcionamento: 0-70°C
Jumpers	Kit cabos ligação macho / macho	1
Display LCD	Display LCD 16 X 2 com pinos soldados	1		LCD que utilize o controlador HD44780 (veja na descrição ou datasheet do componente) O display poderá ser de qualquer cor (fundo verde, azul ou vermelho)
Módulo I2C	Módulo I2C com CI PCF8574	1		O módulo I2C poderá vir separado ou já soldado no display LCD (datasheet)
Arduino UNO R3	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

Conecte os componentes como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito.

Fonte: Circuit Basics

Atenção

1. Verifique abaixo como devem ser as conexões do Teclado Matricial no Arduino:

Pinos de conexão do Teclado Matricial

1.1. Tabela de conexão com o Arduino (de acordo com o nosso exemplo)

2. No projeto, vamos utilizar também um display LCD 16x2 com controlador HD44780, que se adapta aos mais diversos projetos com vários modelos de placas e microcontroladores. Este display possui 16 colunas por 2 linhas com backlight (luz de fundo) verde, azul ou vermelha e tem 16 pinos para a conexão.

3. Para a montagem do display com adaptador I2C, entenda a estrutura do módulo I2C para display LCD 16x2 / 20X4:

3.1. Na lateral do adaptador encontramos 4 pinos, sendo: 2 pinos para alimentação (Vcc e GND) e 2 pinos para conexão com a interface I2C (SDA e SCL) que deverão estar conectados nos pinos analógicos A4 (SDA) e A5 (SCL) do Arduino Uno ou nos pinos A20 (SDA) e A21 (SCL) do Arduino Mega 2560. Veja a tabela abaixo com onde temos as principais placas Arduino e suas conexões com o I2C.

3.2. Para controlar o contraste do display, utilize o potenciômetro de ajuste de contraste. O jumper lateral, quando utilizado, permite que a luz do fundo (backlight) seja controlada pelo programa ou permaneça apagada.

3.3. O módulo I2C pode ser separado ou já vir soldado no próprio display LCD. Para saber todos os detalhes sobre a montagem e utilização de display LCD com módulo I2C leia: Projeto 48 - Como controlar um display LCD com o módulo I2C.

3.4. Caso não possua um módulo I2C e queira adaptar o projeto para usar o display LCD sem adaptador leia: Projeto 38 - Controlando um display LCD (instalação e comandos básicos). Depois você terá que adaptar o projeto aproveitando os 8 pinos restantes para a montagem do Teclado Matricial. Também terá que ajustar o código para essas alterações.

4. A montagem do nosso exemplo foi realizada com um display LCD com comunicação via protocolo I2C.

Incluindo a biblioteca LiquidCrystal_I2C

Atenção 1: Caso você opte pela utilização do display de LCD sem o módulo I2C, siga os procedimentos do Projeto 38 - Controlando um display LCD (instalação e comandos básicos) e não instale a biblioteca abaixo.

Atenção 2: Se estiver utilizando uma biblioteca diferente para o controle do módulo I2C, lembre-se de ajustar o código do projeto de acordo com os comandos específicos dessa biblioteca.

1. Para que o módulo I2C funcione corretamente é necessário adicionarmos a biblioteca LiquidCrystal_I2C no IDE do Arduino. Uma das grandes vantagens das placas Arduino é a diversidade de bibliotecas disponíveis que podem ser utilizadas em seus programas. Estas bibliotecas podem ser criadas para a linguagem "C" ou especificamente para o Arduino, reduzindo drasticamente o tempo gasto com programação.  Veja a tabela Coletânea de bibliotecas para módulos.

Download dos arquivos da biblioteca LiquidCrystal_I2C 

 DOWNLOAD - NewliquidCrystal_1.3.4.zip

Para saber detalhes desta biblioteca clique aqui.

2. Após fazer o download do arquivo NewliquidCrystal_1.3.4.zip com todos os arquivos da biblioteca compactados no formato zip, abra o IDE do Arduino e siga o tutorial: Como incluir uma biblioteca no IDE do Arduino.

Biblioteca Wire

1. Para realizar a comunicação via protocolo I2C (comunicação com 2 fios: clock (SCL) e dado (SDA) podemos utilizar a biblioteca Wire.h que já vem instalada por padrão no IDE do Arduino.

2. A biblioteca Wire.h é responsável por conter as funções necessárias para gerenciar a comunicação entre os dispositivos através do protocolo I2C.

3. Muitas bibliotecas específicas para módulos e sensores com comunicação I2C já tem incluído a biblioteca Wire no seu escopo. Entretanto, é recomendável utilizar sempre essa biblioteca quando utilizarmos a comunicação via protocolo I2C, afim de evitarmos possíveis erros de comunicação.

Código do Projeto (Sketch)

1. Faça o download e abra o arquivo projeto107.ino no IDE do Arduino: DOWNLOAD - projeto107.ino

Obs. 1: Nos casos em que módulo I2C estiver configurado com um endereço diferente do endereço 0X27, altere a alinha de programação -> LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE); com o endereço correto. - Veja o tutorial Projeto 48 - Como controlar um display LCD com o módulo I2C

Obs. 2: Se estiver utilizando uma biblioteca diferente para o controle do módulo I2C, ajuste o código do projeto de acordo com os comandos específicos dessa biblioteca.

Obs. 3: Se não possuir o módulo I2C utilize apenas o display LCD conforme Projeto 38 - Controlando um display LCD (instalação e comandos básicos) e ajuste o sketch para esta configuação. Lembrando que você terá que alterar a montagem do Teclado Matricial conectando-o nos pinos digitais que restarem.

2. Se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*          Projeto 107: Usando o Teclado Matricial 4X4 (keypad) - sem biblioteca
*               http://squids.com.br/arduino
*
*******************************************************************************/
#include <Wire.h>                   //biblioteca para usar comunicação I2C
#include <LiquidCrystal_I2C.h>      //biblioteca para usar display LCD com I2C

const int rows = 4;                 //número de linhas do teclado
const int cols = 4;                 //número de colunas do teclado

char keys[rows][cols] = {           //definição do teclado        
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

byte rowPins[rows] = {9, 8, 7, 6};  //pinos do Arduino - linhas do teclado
byte colPins[cols] = {5, 4, 3, 2};  //pinos do Arduino - colunas do teclado

const int debounce = 20;            //tempo de pausa para debounce
const char controle = 0;            //controle para verificar se a tecla foi pressionada

LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE); // Inicializa o display no endereco 0x27

void setup() {
  lcd.begin (16,2);                 //instancia o objeto lcd (display lcd 16X2)

  //configura as linhas como entradas com padrão em nível lógico alto
  for(int linha = 0; linha < rows; linha++) {
    pinMode(rowPins[linha], INPUT_PULLUP);
    digitalWrite(rowPins[linha], HIGH); //habilita pull-up
  }

  //configura as colunas como saídas com padrão em nível lógico alto
  for(int coluna = 0; coluna < cols; coluna++){
    pinMode(colPins[coluna], OUTPUT);
    digitalWrite(colPins[coluna], HIGH);
  }

  lcd.setBacklight(HIGH);
  lcd.clear();                                // limpa a tela do display
  lcd.setCursor(0,0);
  lcd.print("-- Digite --");

}

void loop() {
  char tecla = teclaPressionada(); //chama a função teclaPressionada() que retorna o valor da tecla digitada

  if(tecla != controle) {
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Tecla: ");
    lcd.print(tecla);
  }

}

//Função teclaPressionada() -> Determina qual tecla foi pressionada
char teclaPressionada() {
  char tecla = controle;                   //atribui o valor padrão de retorno (nenhuma tecla pressionada)
  boolean match = false;                   //inicialmente considera que nenhuma tecla foi pressionada
  for (int coluna = 0; coluna < cols; coluna++) {
    digitalWrite(colPins[coluna], LOW);                 //muda o estado do pino
    //varre as linhas procurando por uma tecla pressionada
    for(int linha = 0; linha < rows; linha++) {
      //lê linha pela primeira vez
      if(digitalRead(rowPins[linha]) == LOW) {          //tecla está pressionada
        delay(debounce);                                //insere pausa para descartar ruídos
      }
      //lê linha pela segunda vez
      if(digitalRead(rowPins[linha]) == LOW) {          //tecla continua pressionada, não é ruído
        while(digitalRead(rowPins[linha]) != HIGH);     //espera soltar o tecla
        tecla = keys[linha][coluna];                    //determina qual foi a tecla pressionada 
        match = true;                                   //uma tecla foi pressionada
        break;                                          //sai da varredura das linhas
      } 
    }
    digitalWrite(colPins[coluna], HIGH);                //retorna o pino ao seu estado inicial
    //se uma tecla foi pressionada, sai do laço for
    if(match) break;
  }
  return tecla;                            //retorna a tecla pressionada (kNADA se nenhuma foi encontrada)
}

Vídeo

Como o projeto deve funcionar

1. Ao iniciar o programa, o display LCD exibirá uma mensagem solicitando que você pressione uma tecla.

2. Quando qualquer tecla do teclado matricial de membrana for pressionada, o caractere correspondente (número, letra ou símbolo) será exibido no display LCD.

3. Este projeto tem como foco demonstrar o funcionamento básico da interface entre o teclado matricial e o display LCD, servindo como base para o desenvolvimento de aplicações que exigem interação com o usuário, como sistemas de senha, menus de navegação e automações controladas por entrada manual.

Entendendo processo varredura multiplexada do Teclado Matricial

Vamos mostrar no exemplo abaixo como funciona a varredura multiplexada utilizada para detectar uma tecla no Teclado Matricial de membrana 4 X 4. Veja o código da função teclaPressionada():

Exemplo de como o Arduino detecta a tecla pressionada (exemplo com a tecla “5”)

Estrutura do teclado 4x4

O teclado 4x4 possui:

• 4 linhas (L1 a L4)

• 4 colunas (C1 a C4)

Cada tecla está na interseção de uma linha com uma coluna.
A tecla “5” está, por exemplo, na linha 2 (L2) e coluna 2 (C2).

Configuração inicial no Arduino

• As colunas (C1 a C4) são configuradas como saídas (OUTPUT) e iniciadas em nível ALTO (HIGH).

• As linhas (L1 a L4) são configuradas como entradas com pull-up interno (INPUT_PULLUP), ou seja, também iniciadas em HIGH.

Com essa configuração, se nenhuma tecla estiver pressionada, todas as linhas permanecem em HIGH

Processo de detecção com a tecla “5” pressionada:

1. Arduino coloca a coluna 1 (C1) em nível BAIXO (LOW)

   • As colunas C2, C3 e C4 continuam em HIGH.

   • O Arduino lê os pinos das linhas (L1 a L4).

   • Nenhuma linha está em LOW, então nenhuma tecla da coluna 1 foi pressionada.

2. Arduino coloca a coluna 2 (C2)  nível BAIXO (LOW)
   

   • Agora, C1, C3 e C4 estão em HIGH; C2 está em LOW.

   • A tecla “5” está na coluna 2, e foi pressionada.

3. Tecla “5” conecta a linha 2 (L2) à coluna 2 (C2)

   • Como C2 está em LOW e o botão “5” foi pressionado, a linha 2 (L2) é "puxada" para LOW através do botão.

4. Arduino detecta que L2 está em LOW

   • Isso indica que houve uma conexão entre coluna 2 (C2) e linha 2 (L2).

   • Com essa informação, o Arduino identifica a tecla como “5”, que está nessa interseção.

5. Leitura concluída!

   • O Arduino então imprime “5” no monitor serial e/ou no display LCD.

   • Em seguida, ele volta a colocar todas as colunas em HIGH e repete o processo para novas leituras.

Comentários