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

---

Projeto108 - Como usar um Teclado Matricial 4x4 com Arduino (Com Biblioteca Keypad)

Angelo Luis Ferreira | 25/04/2025 Acessos: 300

Objetivo

Este projeto tem como objetivo apresentar o uso da biblioteca "Keypad" para facilitar a leitura de um teclado matricial de membrana 4x4 com Arduino. Por meio dessa biblioteca, a identificação das teclas pressionadas torna-se mais simples e eficiente, eliminando a necessidade de implementar manualmente a lógica de varredura multiplexada das linhas e colunas.

Ao pressionar uma tecla, o Arduino reconhece seu valor de forma automática e o exibe em tempo real no monitor serial e em um display LCD. O projeto demonstra como configurar e utilizar a biblioteca "Keypad", proporcionando uma abordagem prática e direta para quem deseja implementar interfaces com teclado em projetos Arduino, com maior agilidade no desenvolvimento e menos complexidade no código.

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.

f. A biblioteca Keypad do Arduino automatiza esse processo por meio de uma varredura multiplexada das linhas e colunas. Ela configura dinamicamente os pinos como entrada ou saída e verifica, em alta velocidade, as conexões entre linhas e colunas para identificar qual tecla foi pressionada. Isso elimina a necessidade de escrever manualmente toda a lógica de detecção, tornando o código mais simples, legível e confiável.

Como o Arduino detecta a tecla pressionada:

Se você deseja entender em detalhes como o Arduino detecta uma tecla pressionada em um teclado matricial 4x4 sem utilizar bibliotecas, recomendo a leitura do artigo completo no site da Squids:​

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

Neste tutorial, você encontrará uma explicação detalhada sobre o funcionamento de teclados matriciais, incluindo a estrutura de linhas e colunas, o processo de varredura multiplexada e como implementar a leitura das teclas diretamente no código do Arduino, sem depender de bibliotecas externas. O artigo também aborda conceitos fundamentais de controle de hardware em baixo nível e gerenciamento de entradas digitais, proporcionando uma compreensão aprofundada do tema.

Referências

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

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.

Incluindo a biblioteca Keypad

Para facilitar o uso do Teclado Matricial de Membrana 4x4, utilizaremos a biblioteca Keypad, que automatiza o processo de detecção das teclas pressionadas. Com ela, não é necessário lidar diretamente com os detalhes da varredura multiplexada, pois toda a lógica de leitura da matriz de linhas e colunas é gerenciada internamente pela biblioteca, tornando o desenvolvimento mais simples e eficiente.

Instalação da biblioteca

1. No IDE do Arduino, acesse a aba Sketch (Rascunho), selecione [Incluir Biblioteca] e depois [Gerenciar Bibliotecas...].

2.  No campo de pesquisa digite Keypad. Localizada a biblioteca Keypad (por Mark Stanley, Alexander) clique no botão [Instalar].

3. Após a instalação, observe que aparecerá a informação que a biblioteca foi instalada.

Código do Projeto (Sketch)

1. Faça o download e abra o arquivo projeto108.ino no IDE do Arduino: DOWNLOAD - projeto108.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 108: Usando o Teclado Matricial 4X4 (keypad) - com biblioteca Keypad
*               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
#include <Keypad.h>                 //biblioteca para usar o Teclado Matricial

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

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

Keypad teclado = Keypad(makeKeymap(keys), rowPins, colPins, rows, cols); // Inicia teclado

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

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

}

void loop() {
  char tecla = teclado.getKey();              //atribui a variavel a leitura do teclado

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

}

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.

Explicando o código

Cabeçalho

/*******************************************************************************
*
*          Projeto 108: Usando o Teclado Matricial 4X4 (keypad) - com biblioteca Keypad
*               http://squids.com.br/arduino
*
*******************************************************************************/

➡ Comentário de cabeçalho que identifica o projeto.

Inclusão das bibliotecas

#include <Wire.h>                   // Biblioteca para comunicação I2C
#include <LiquidCrystal_I2C.h>      // Biblioteca para controle do LCD via I2C
#include <Keypad.h>                 // Biblioteca para uso do teclado matricial

➡ Essas bibliotecas são necessárias para:

• Wire.h: comunicação com dispositivos I2C.

• LiquidCrystal_I2C.h: exibir texto no LCD via I2C.

• Keypad.h: facilitar a leitura do teclado 4x4.

Definições do teclado

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

➡ Define o teclado como uma matriz 4x4, com 4 linhas e 4 colunas.

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

➡ Matriz que representa as teclas dispostas no teclado físico. Cada tecla corresponde a uma posição (linha, coluna).

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

➡ Define os pinos digitais usados para conectar as linhas e colunas do teclado no Arduino.

Inicialização dos objetos

LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE);

➡ Cria o objeto lcd, informando o endereço I2C (0x27) e os pinos internos do módulo I2C (dependem do modelo).
Obs: Essa forma de instanciar o LCD é comum com displays baseados no chip PCF8574.

Keypad teclado = Keypad(makeKeymap(keys), rowPins, colPins, rows, cols);

➡ Cria o objeto teclado que usará a matriz keys, os pinos de linha e coluna, e as dimensões definidas.
A função makeKeymap() converte a matriz de caracteres para o formato aceito pela biblioteca.

Função setup()

void setup() {
  lcd.begin (16,2);       // Inicializa o LCD com 16 colunas e 2 linhas
  lcd.setBacklight(HIGH); // Liga o backlight
  lcd.clear();            // Limpa o LCD
  lcd.setCursor(0,0);     // Move o cursor para a primeira linha
  lcd.print("-- Digite --"); // Exibe mensagem inicial
}

➡ Configura o display LCD e mostra uma mensagem para o usuário.

Função loop()

void loop() {
  char tecla = teclado.getKey();  // Lê a tecla pressionada

  if(tecla) {                     // Se uma tecla foi pressionada (diferente de null)
    lcd.clear();                  // Limpa o display
    lcd.setCursor(0,0);           // Cursor na posição inicial
    lcd.print("Tecla: ");         // Escreve “Tecla: ”
    lcd.print(tecla);             // Mostra o caractere da tecla pressionada
  }
}

➡ Fluxo principal:

• Usa teclado.getKey() para verificar se alguma tecla foi pressionada.

• Se sim, exibe no LCD qual foi a tecla.

• Como não há delay, o LCD atualizará a cada nova tecla pressionada.

✅ Conclusão

Este código é simples, eficiente e didático, ideal para quem está começando a usar o teclado matricial com Arduino.
Graças à biblioteca Keypad, todo o processo de varredura multiplexada é automatizado, facilitando a leitura das teclas com poucas linhas de código.

Comentários