Usando o Teclado Matricial com Arduino

This tutorial is not available in English

Introdução

O Teclado Matricial 4x4 foi desenvolvido para facilitar a entrada de dados em projetos microcontrolados. Este teclado possui 16 teclas, onde 10 delas são números, 4 são letras e 2 são caracteres especiais. Com ele podemos criar uma infinidade de projetos, tais como criar controles de acesso, teclados musicais, entre outros.

Nesse tutorial iremos montar um simples projeto, assim aprendendo o funcionamento básico do teclado, de imprimir as teclas pressionadas no monitor serial. Posteriormente iremos acionar cargas, mediante a uma senha programada.

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$ 94,90 no PIX

Cabo USB AB 1.50m

R$ 10,35 no PIX

Teclado Matricial de Membrana 16 Teclas

R$ 6,17 no PIX

Conceitos Teóricos

O teclado possui 16 teclas, que estão dispostas em 4 linhas por 4 colunas, e ele possui 8 pinos para ligação. Embaixo de cada tecla há um interruptor de membrana. Cada interruptor em uma linha é conectado aos outros interruptores da mesma linha por um traço condutor sob o bloco, e da mesma forma são conectadas às colunas, onde todos os botões da coluna também estão conectados. Ou seja, todos os botões do teclado estão conectados a uma linha e a uma coluna, por isso que é chamado de teclado matricial. A imagem abaixo ilustra o circuito do teclado.

keypad-inside — Esquema de Ligação dos Botões e Terminais de Conexão
Fonte: Circuit Basics

Para identificar qual botão foi pressionado, a placa Arduino executa quatro passos. O primeiro é configurar todas as colunas da matriz como entradas em nível lógico alto (resistor de pull-up interno ativado), e todas as linhas como saídas em nível lógico baixo. Deste modo, caso o botão "5" seja pressionado, a coluna "2" passará para o nível lógico baixo, completando o segundo passo. Já no terceiro passo, o Arduino identifica a linha que foi pressionada invertendo o nível lógico anterior, ou seja, configurando as colunas para nível lógico baixo, e mantendo as linhas em nível lógico alto. Desta forma, a linha "2", em nosso exemplo, passará para o nível lógico baixo, e o microcontrolador identificará que o botão pressionado está na linha "2" e coluna "2", completando, portanto, o quarto e último passo, como na imagem abaixo.

passos-leitura — Passos para a Leitura das Teclas Pressionadas
Editado de Circuit Basics

Projeto Teclando com Arduino

Para começar a trabalhar com o teclado matricial, vamos criar um projeto simples de exibição das teclas pressionadas na tela do computador.

Circuito

Para exibir no monitor serial as teclas presionadas, monte o circuito a seguir.

Software

Biblioteca

Para que possamos começar nossos estudos sobre o teclado matricial, baixe e instale a biblioteca através do botão a seguir.

Download da Biblioteca "Keypad"

Caso você não saiba como instalar bibliotecas na Arduino IDE, siga os passos de nosso tutorial Adicionando Bibliotecas na IDE Arduino.

Código

Com a biblioteca adicionada à Arduino IDE, copie o código abaixo e carregue-o para sua BlackBoard.

/*******************************************************************************
* Teclado Matricial 16 Teclas : Primeiros Passos (v1.0)
*
* Codigo base para exibir as teclas pressionadas no monitor serial da IDE.
*
* Copyright 2020 RoboCore.
* Escrito por Matheus Cassioli (30/07/2019).
* Atualizado por Giovanni de Castro (22/01/2020).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

#include <Keypad.h> // Biblioteca do codigo

const byte LINHAS = 4; // Linhas do teclado
const byte COLUNAS = 4; // Colunas do teclado

const char TECLAS_MATRIZ[LINHAS][COLUNAS] = { // Matriz de caracteres (mapeamento do teclado)
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

const byte PINOS_LINHAS[LINHAS] = {9, 8, 7, 6}; // Pinos de conexao com as linhas do teclado
const byte PINOS_COLUNAS[COLUNAS] = {5, 4, 3, 2}; // Pinos de conexao com as colunas do teclado

Keypad teclado_personalizado = Keypad(makeKeymap(TECLAS_MATRIZ), PINOS_LINHAS, PINOS_COLUNAS, LINHAS, COLUNAS); // Inicia teclado

void setup() {
  Serial.begin(9600); // Inicia porta serial
}

void loop() {

  char leitura_teclas = teclado_personalizado.getKey(); // Atribui a variavel a leitura do teclado

  if (leitura_teclas) { // Se alguma tecla foi pressionada
    Serial.println(leitura_teclas); // Imprime a tecla pressionada na porta serial
  }
  
}

​x
 
/*******************************************************************************
* Teclado Matricial 16 Teclas : Primeiros Passos (v1.0)
*
* Codigo base para exibir as teclas pressionadas no monitor serial da IDE.
*
* Copyright 2020 RoboCore.
* Escrito por Matheus Cassioli (30/07/2019).
* Atualizado por Giovanni de Castro (22/01/2020).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/
​
#include <Keypad.h> // Biblioteca do codigo
​
const byte LINHAS = 4; // Linhas do teclado
const byte COLUNAS = 4; // Colunas do teclado
​
const char TECLAS_MATRIZ[LINHAS][COLUNAS] = { // Matriz de caracteres (mapeamento do teclado)
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
​
const byte PINOS_LINHAS[LINHAS] = {9, 8, 7, 6}; // Pinos de conexao com as linhas do teclado
const byte PINOS_COLUNAS[COLUNAS] = {5, 4, 3, 2}; // Pinos de conexao com as colunas do teclado
​
Keypad teclado_personalizado = Keypad(makeKeymap(TECLAS_MATRIZ), PINOS_LINHAS, PINOS_COLUNAS, LINHAS, COLUNAS); // Inicia teclado
​
void setup() {
  Serial.begin(9600); // Inicia porta serial
}
​
void loop() {
​
  char leitura_teclas = teclado_personalizado.getKey(); // Atribui a variavel a leitura do teclado
​
  if (leitura_teclas) { // Se alguma tecla foi pressionada
    Serial.println(leitura_teclas); // Imprime a tecla pressionada na porta serial
  }
  
}

Entendendo o Código

Logo no início, após a inclusão da biblioteca "Keypad", declaramos em variáveis a quantidade de linhas e de colunas do teclado utilizado, no nosso caso, 4 linhas e 4 colunas.

#include <Keypad.h> // Biblioteca do codigo

const byte LINHAS = 4; // Linhas do teclado
const byte COLUNAS = 4; // Colunas do teclado

xxxxxxxxxx
 
#include <Keypad.h> // Biblioteca do codigo
​
const byte LINHAS = 4; // Linhas do teclado
const byte COLUNAS = 4; // Colunas do teclado

Também criamos a matriz TECLAS_MATRIZ, responsável por armazenar as informações do nosso teclado, e onde indicamos para nosso microcontrolador, através de uma matriz, qual caractere é impresso quando um determinado botão do teclado é pressionado.

const char TECLAS_MATRIZ[LINHAS][COLUNAS] = { // Matriz de caracteres (mapeamento do teclado)
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

xxxxxxxxxx
 
const char TECLAS_MATRIZ[LINHAS][COLUNAS] = { // Matriz de caracteres (mapeamento do teclado)
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

Abaixo definimos em vetores quais pinos são responsáveis pelas linhas e pelas colunas (respectivamente PINOS_LINHAS e PINOS_COLUNAS). Posteriormente inserimos o comando Keypad teclado_personalizado, para iniciar o teclado e associar nossa matriz de acordo com o pinos estabelecidos para colunas e linhas.

const byte PINOS_LINHAS[LINHAS] = {9, 8, 7, 6}; // Pinos de conexao com as linhas do teclado
const byte PINOS_COLUNAS[COLUNAS] = {5, 4, 3, 2}; // Pinos de conexao com as colunas do teclado

Keypad teclado_personalizado = Keypad(makeKeymap(TECLAS_MATRIZ), PINOS_LINHAS, PINOS_COLUNAS, LINHAS, COLUNAS); // Inicia teclado

xxxxxxxxxx
 
const byte PINOS_LINHAS[LINHAS] = {9, 8, 7, 6}; // Pinos de conexao com as linhas do teclado
const byte PINOS_COLUNAS[COLUNAS] = {5, 4, 3, 2}; // Pinos de conexao com as colunas do teclado
​
Keypad teclado_personalizado = Keypad(makeKeymap(TECLAS_MATRIZ), PINOS_LINHAS, PINOS_COLUNAS, LINHAS, COLUNAS); // Inicia teclado

No setup do programa, inserimos o comando Serial.begin(9600), assim iniciando a porta serial em 9600 bits por segundo.

Por fim, no looping do programa, e com o comando leitura_teclas = teclado_personalizado.getKey(), atribuímos à variável leitura_teclas o caractere do botão que foi pressionado. Com essa variável, verificamos se alguma tecla foi realmente pressionada através da condição if (leitura_teclas). Caso alguma tecla tenha sido realmente pressionada, o valor da variável será diferente de "0" e a condição será verdadeira, resultando na impressão da tecla pressionada no monitor serial.

char leitura_teclas = teclado_personalizado.getKey(); // Atribui a variavel a leitura do teclado

if (leitura_teclas) { // Se alguma tecla foi pressionada
  Serial.println(leitura_teclas); // Imprime a tecla pressionada na porta serial
}

xxxxxxxxxx
 
char leitura_teclas = teclado_personalizado.getKey(); // Atribui a variavel a leitura do teclado
​
if (leitura_teclas) { // Se alguma tecla foi pressionada
  Serial.println(leitura_teclas); // Imprime a tecla pressionada na porta serial
}

O Que Deve Acontecer

Ao abrir o Monitor Serial em 9600 bps, pressione o botão desejado e o mesmo será impresso na tela, como na figura abaixo.

Projeto Controle de Acesso

Já que aprendemos o funcionamento básico do Teclado Matricial, que tal criarmos uma senha de acesso a um cofre, ou até mesmo uma liberação de uma fechadura?

Circuito

No projeto a seguir, iremos utilizar dois LEDs, sendo eles um vermelho e um verde. Os mesmos representam se a fechadura foi ou não liberada.

Software

Biblioteca

Para que possamos criar um controle de acesso através um senha pré-definida, baixe e instale a biblioteca a seguir.

Download da Biblioteca "Password"

Caso você não saiba como instalar bibliotecas na Arduino IDE, siga os passos de nosso tutorial Adicionando Bibliotecas na IDE Arduino.

Código

Após a inclusão da biblioteca, copie o código abaixo e passe-o para sua placa. Esse código foi baseado no projeto acima, porém incluindo uma nova biblioteca e adicionando alguns comandos.

/*******************************************************************************
* Teclado Matricial 16 Teclas : Controle de Acesso (v1.0)
*
* O codigo ira verificar se a senha digitada esta correta. Caso correta, o 
* acesso e liberado, caso contrario o acesso se mantem travado.
*
* Copyright 2020 RoboCore.
* Escrito por Matheus Cassioli (30/07/2019).
* Atualizado por Giovanni de Castro (22/01/2020).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
****************************************************************************/

#include <Password.h> // Biblioteca utilizada para controle de senha
#include <Keypad.h> // Biblioteca para controle do teclado de matrizes

const byte LINHAS = 4; // Linhas do teclado
const byte COLUNAS = 4; // Colunas do teclado

Password senha = Password( "8765" ); // Senha utilizada para liberacao

const int PINO_LED_VERMELHO = 11; // LED vermelho conectado ao pino 11
const int PINO_LED_VERDE = 10; // LED verde conectado ao pino 10

const char TECLAS_MATRIZ[LINHAS][COLUNAS] = { // Matriz de caracteres (mapeamento do teclado)
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

const byte PINOS_LINHAS[LINHAS] = {9, 8, 7, 6}; // Pinos de conexao com as linhas do teclado
const byte PINOS_COLUNAS[COLUNAS] = {5, 4, 3, 2}; // Pinos de conexao com as colunas do teclado

Keypad teclado_personalizado = Keypad(makeKeymap(TECLAS_MATRIZ), PINOS_LINHAS, PINOS_COLUNAS, LINHAS, COLUNAS); // Inicia teclado

void setup() {
  
  Serial.begin(9600); // Inicializa serial monitor
  
  pinMode(PINO_LED_VERMELHO, OUTPUT); // Define pino 10 como saida
  pinMode(PINO_LED_VERDE, OUTPUT); // Define pino 11 como saida

  digitalWrite(PINO_LED_VERDE, LOW); // LED Verde apagado
  digitalWrite(PINO_LED_VERMELHO, LOW); // LED Vermelho apagado
  
}

void loop() {
    
  char leitura_teclas = teclado_personalizado.getKey(); // Atribui a variavel a leitura do teclado
  
  if(leitura_teclas){ // Se alguma tecla foi pressionada

    if(leitura_teclas == 'C'){ // Se a tecla 'C' foi pressionada
      
      if(senha.evaluate()){ // Verifica se a senha digitada esta correta
        
        Serial.println("Senha confirmada!"); // Exibe a mensagem que a senha esta correta
        for(int i = 0; i < 5; i++){ // Pisca o LED 5 vezes rapidamente
          digitalWrite(PINO_LED_VERDE, HIGH);
          delay(50);
          digitalWrite(PINO_LED_VERDE, LOW);
          delay(50);
          
        }
      } else { // Caso a senha esteja incorreta
        
        Serial.println("Senha incorreta!"); // Exibe a mensagem que a senha esta errada
        for(int i = 0; i < 5; i++){ // Pisca o LED 5 vezes rapidamente
          digitalWrite(PINO_LED_VERMELHO, HIGH);
          delay(50);
          digitalWrite(PINO_LED_VERMELHO, LOW);
          delay(50);
          
        }
      }
      
      senha.reset(); // Limpa a variavel senha
      
    } else { // Caso outra tecla tenha sido pressionada
      
      Serial.println(leitura_teclas); // Exibe a tecla pressionada
      senha.append(leitura_teclas); // Salva o valor da tecla pressionada na variavel senha
      
    }
  }

}

xxxxxxxxxx
 
/*******************************************************************************
* Teclado Matricial 16 Teclas : Controle de Acesso (v1.0)
*
* O codigo ira verificar se a senha digitada esta correta. Caso correta, o 
* acesso e liberado, caso contrario o acesso se mantem travado.
*
* Copyright 2020 RoboCore.
* Escrito por Matheus Cassioli (30/07/2019).
* Atualizado por Giovanni de Castro (22/01/2020).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
****************************************************************************/
​
#include <Password.h> // Biblioteca utilizada para controle de senha
#include <Keypad.h> // Biblioteca para controle do teclado de matrizes
​
const byte LINHAS = 4; // Linhas do teclado
const byte COLUNAS = 4; // Colunas do teclado
​
Password senha = Password( "8765" ); // Senha utilizada para liberacao
​
const int PINO_LED_VERMELHO = 11; // LED vermelho conectado ao pino 11
const int PINO_LED_VERDE = 10; // LED verde conectado ao pino 10
​
const char TECLAS_MATRIZ[LINHAS][COLUNAS] = { // Matriz de caracteres (mapeamento do teclado)
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
​
const byte PINOS_LINHAS[LINHAS] = {9, 8, 7, 6}; // Pinos de conexao com as linhas do teclado
const byte PINOS_COLUNAS[COLUNAS] = {5, 4, 3, 2}; // Pinos de conexao com as colunas do teclado
​
Keypad teclado_personalizado = Keypad(makeKeymap(TECLAS_MATRIZ), PINOS_LINHAS, PINOS_COLUNAS, LINHAS, COLUNAS); // Inicia teclado
​
void setup() {
  
  Serial.begin(9600); // Inicializa serial monitor
  
  pinMode(PINO_LED_VERMELHO, OUTPUT); // Define pino 10 como saida
  pinMode(PINO_LED_VERDE, OUTPUT); // Define pino 11 como saida
​
  digitalWrite(PINO_LED_VERDE, LOW); // LED Verde apagado
  digitalWrite(PINO_LED_VERMELHO, LOW); // LED Vermelho apagado
  
}
​
void loop() {
    
  char leitura_teclas = teclado_personalizado.getKey(); // Atribui a variavel a leitura do teclado
  
  if(leitura_teclas){ // Se alguma tecla foi pressionada
​
    if(leitura_teclas == 'C'){ // Se a tecla 'C' foi pressionada
      
      if(senha.evaluate()){ // Verifica se a senha digitada esta correta
        
        Serial.println("Senha confirmada!"); // Exibe a mensagem que a senha esta correta
        for(int i = 0; i < 5; i++){ // Pisca o LED 5 vezes rapidamente
          digitalWrite(PINO_LED_VERDE, HIGH);
          delay(50);
          digitalWrite(PINO_LED_VERDE, LOW);
          delay(50);
          
        }
      } else { // Caso a senha esteja incorreta
        
        Serial.println("Senha incorreta!"); // Exibe a mensagem que a senha esta errada
        for(int i = 0; i < 5; i++){ // Pisca o LED 5 vezes rapidamente
          digitalWrite(PINO_LED_VERMELHO, HIGH);
          delay(50);
          digitalWrite(PINO_LED_VERMELHO, LOW);
          delay(50);
          
        }
      }
      
      senha.reset(); // Limpa a variavel senha
      
    } else { // Caso outra tecla tenha sido pressionada
      
      Serial.println(leitura_teclas); // Exibe a tecla pressionada
      senha.append(leitura_teclas); // Salva o valor da tecla pressionada na variavel senha
      
    }
  }
​
}

Entendendo o Código

Primeiramente, com a ajuda da biblioteca "Password", criamos a variável senha e indicamos os caracteres que irão fazer parte dela, sendo números, letras ou caracteres especiais. Além disso, declaramos as variáveis que armazenam os pinos onde os LEDs do circuito estão conectados.

#include <Password.h> // Biblioteca utilizada para controle de senha
          
Password senha = Password( "8765" ); // Senha utilizada para liberacao

const int PINO_LED_VERMELHO = 11; // LED vermelho conectado ao pino 11
const int PINO_LED_VERDE = 10; // LED verde conectado ao pino 10

xxxxxxxxxx
 
#include <Password.h> // Biblioteca utilizada para controle de senha
          
Password senha = Password( "8765" ); // Senha utilizada para liberacao
​
const int PINO_LED_VERMELHO = 11; // LED vermelho conectado ao pino 11
const int PINO_LED_VERDE = 10; // LED verde conectado ao pino 10

No setup do programa, configuramos os pinos dos LEDs (PINO_LED_VERDE e PINO_LED_VERMELHO) como saídas, em nível lógico baixo.

pinMode(PINO_LED_VERMELHO, OUTPUT); // Define pino 10 como saida
pinMode(PINO_LED_VERDE, OUTPUT); // Define pino 11 como saida

digitalWrite(PINO_LED_VERDE, LOW); // LED Verde apagado
digitalWrite(PINO_LED_VERMELHO, LOW); // LED Vermelho apagado

xxxxxxxxxx
 
pinMode(PINO_LED_VERMELHO, OUTPUT); // Define pino 10 como saida
pinMode(PINO_LED_VERDE, OUTPUT); // Define pino 11 como saida
​
digitalWrite(PINO_LED_VERDE, LOW); // LED Verde apagado
digitalWrite(PINO_LED_VERMELHO, LOW); // LED Vermelho apagado

No looping, iniciamos a repetição atribuindo à variável leitura_teclas a leitura dos botões, como no código anterior. Entretanto, neste código, após verificarmos se alguma tecla foi realmente pressionada, verificamos, através da condição if(leitura_teclas == 'C'), se a tecla "C", responsável pela confirmação da senha, foi pressionada. Caso ela tenha sido pressionada, damos continuidade para a verificação da senha digitada através da condição if(senha.evaluate()). Caso a senha digitada esteja correta, piscamos o LED verde e exibimos a mensagem que a senha foi confirmada. Caso contrário, por meio do comando else, piscamos o LED vermelho e exibimos a mensagem que a senha está incorreta. Logo após a verificação da senha, graças ao comando senha.reset(), limpamos a variável senha para que ela possa ser digitada novamente. Entretanto, caso a tecla pressionada não seja a tecla "C", a tecla que foi pressionada é impressa no monitor, e acrescentada à variável senha através do comando senha.append(leitura_teclas).

char leitura_teclas = teclado_personalizado.getKey(); // Atribui a variavel a leitura do teclado
  
if(leitura_teclas){ // Se alguma tecla foi pressionada

  if(leitura_teclas == 'C'){ // Se a tecla 'C' foi pressionada
      
    if(senha.evaluate()){ // Verifica se a senha digitada esta correta
        
      Serial.println("Senha confirmada!"); // Exibe a mensagem que a senha esta correta
      for(int i = 0; i < 5; i++){ // Pisca o LED 5 vezes rapidamente
        digitalWrite(PINO_LED_VERDE, HIGH);
        delay(50);
        digitalWrite(PINO_LED_VERDE, LOW);
        delay(50);
      }
  
    } else { // Caso a senha esteja incorreta
        
      Serial.println("Senha incorreta!"); // Exibe a mensagem que a senha esta errada
      for(int i = 0; i < 5; i++){ // Pisca o LED 5 vezes rapidamente
        digitalWrite(PINO_LED_VERMELHO, HIGH);
        delay(50);
        digitalWrite(PINO_LED_VERMELHO, LOW);
        delay(50);
      }
  
    }
      
    senha.reset(); // Limpa a variavel senha
      
  } else { // Caso outra tecla tenha sido pressionada
    
    Serial.println(leitura_teclas); // Exibe a tecla pressionada
    senha.append(leitura_teclas); // Salva o valor da tecla pressionada na variavel senha
    
  }
}

xxxxxxxxxx
 
char leitura_teclas = teclado_personalizado.getKey(); // Atribui a variavel a leitura do teclado
  
if(leitura_teclas){ // Se alguma tecla foi pressionada
​
  if(leitura_teclas == 'C'){ // Se a tecla 'C' foi pressionada
      
    if(senha.evaluate()){ // Verifica se a senha digitada esta correta
        
      Serial.println("Senha confirmada!"); // Exibe a mensagem que a senha esta correta
      for(int i = 0; i < 5; i++){ // Pisca o LED 5 vezes rapidamente
        digitalWrite(PINO_LED_VERDE, HIGH);
        delay(50);
        digitalWrite(PINO_LED_VERDE, LOW);
        delay(50);
      }
  
    } else { // Caso a senha esteja incorreta
        
      Serial.println("Senha incorreta!"); // Exibe a mensagem que a senha esta errada
      for(int i = 0; i < 5; i++){ // Pisca o LED 5 vezes rapidamente
        digitalWrite(PINO_LED_VERMELHO, HIGH);
        delay(50);
        digitalWrite(PINO_LED_VERMELHO, LOW);
        delay(50);
      }
  
    }
      
    senha.reset(); // Limpa a variavel senha
      
  } else { // Caso outra tecla tenha sido pressionada
    
    Serial.println(leitura_teclas); // Exibe a tecla pressionada
    senha.append(leitura_teclas); // Salva o valor da tecla pressionada na variavel senha
    
  }
}

O Que Deve Acontecer

Ao abrir o Monitor Serial em 9600 bps, digite a senha programada anteriormente e confirme pressionando a tecla "C". Note que o LED verde irá piscar rapidamente 5 vezes. Você também pode digitar uma senha incorreta para verificar que o LED vermelho irá piscar rapidamente 5 vezes, como nos GIFs abaixo.

Resultado Final - Senha Incorreta

Resultado Final - Senha Correta

Indo Além

Embora utilizamos a biblioteca Keypad.h neste tutorial, é possível realizar a leitura da tecla pressionada sem a utilização dos comandos da biblioteca. Para isso, basta você seguir os passos de leitura mencionados na seção Conceitos Teóricos, e verificar a linha e a coluna que estão interligados no botão pressionado.

Comments

To make comments you must be logged in. Login.

You are not registered yet? Register Now!

rafael.willian.perso
date

Sent 2023-07-05 15:09:38

Exist um CI que facilite a interação com esse componente? Por que ao meu ver parece simples um CI que recebe 8 entradas e tem 4 saídas que são um número binário de 0000 até 1111... Assim utilizaria bem menos cabos e ajudaria a usar com o LCD, que usa bastante entrada também kkkk.

luan.ferreira
date

Sent 2023-07-05 15:41:51
rafael.willian.perso

Infelizmente não trabalhamos com nenhum C.I deste tipo, por isso não temos muitas informações sobre qual C.I pode ser usado. Para o LCD,  é possível utilizar um “Módulo I2C para Display LCD” ( https://www.robocore.net/display/modulo-i2c-para-display-lcd ) para facilitar a conexão.

amaro

Sent 2024-02-17 16:26:45
rafael.willian.perso

Não sei se tem aqui na Robocore, mas eu imaginei utilizar com esse teclado um CI 4052 (Duplo Seletor 1 de 4 (MUX/DEMUX)), até para reduzir a quantidade de pinos utilizados no Arduino para a varredura das teclas, em projetos em que ele precise ser conectado a um número considerável de dispositivos.

carlos.oliveira
date

Sent 2024-02-19 08:44:16
rafael.willian.perso

Olá! Infelizmente não trabalhamos com o C.I citado, portanto, nunca testamos essa aplicação e não podemos afirmar a compatibilidade.

bigles21
date

Sent 2022-12-22 16:47:00

Consegui Luan, fiz umas alteraç~~çoes aqui e deu certo pelo menos com duas senhas, se deu com duas, dará com outras, obrigado e feliz festas!!:)

luan.ferreira
date

Sent 2022-12-23 08:05:28
bigles21

Ficamos muito felizes em saber que deu certo! Gostaríamos de desejar boas festas para você e para toda a sua família!

bigles21
date

Sent 2022-12-22 16:25:44

Obrigado

luan.ferreira
date

Sent 2022-12-22 16:31:28
bigles21

Disponha. Em caso de dúvidas ou problemas, peço que entre em contato.

bigles21
date

Sent 2022-12-22 15:11:56

fiz isso mas nao aceita a senha2. usando o trecho <Password senha = Password( "8765" );>
e quando aceitar, quero que a verificação faça outra coisa, exemplo:  
Password senha = Password( "1234" ); // Senha utilizada para liberacao
Password senha2 = Password( "4321" ); // Senha utilizada para liberacao
a senha 2 nao fucnionou, mas quando funcionar, quero q a senha faça uma coisa e a senha 2 faça outra, sem acender led nada, so acionar o rele tal com a senha e rele 2 com a senha 2

luan.ferreira
date

Sent 2022-12-22 15:58:23
bigles21

Neste caso, foi adicionado uma nova condição (<if>) para verificar a segunda senha (como <if(senha2.evaluate())>, por exemplo)? Se não, verifique se ao adicionar o condição de verificação, a senha passa a funcionar. Vale dizer que além de adicionar a verificação, também será necessário programar o que irá acontecer quando a senha for aceita. Se quiser, pode postar o seu projeto no nosso Fórum ( https://www.robocore.net/modules.php?name=Forums ), para que outros usuários mais experientes, e até que trabalhem com desenvolvimento de projetos, possam entrar em contato direto com você.

bigles21
date

Sent 2022-12-22 14:18:23

no mais o código ta funciopnando ok com outras partes de codigo q eu ja tiinha,

bigles21
date

Sent 2022-12-22 14:17:04

certo, Luan, mas nao sei como fazer, é tipo colocar senha 2 etc, mas quando eu digitar outra senha, a validação da senha 2 por exemplo, fara outra coisa. To apanhando.
Password senha = Password( "1234" ); // Senha utilizada para liberacao
Password senha = Password( "4321" ); // Senha utilizada para liberacao
const byte LINHAS = 4; // Linhas do teclado
const byte COLUNAS = 4; // Colunas do teclado
// Define the Keymap
const char TECLAS_MATRIZ[LINHAS][COLUNAS]  = {
  {&#39;A&#39;, &#39;B&#39;, &#39;C&#39;, &#39;D&#39;},
  {&#39;E&#39;, &#39;F&#39;, &#39;G&#39;, &#39;H&#39;},
  {&#39;1&#39;, &#39;2&#39;, &#39;3&#39;, &#39;4&#39;},
  {&#39;5&#39;, &#39;*&#39;, &#39;0&#39;, &#39;#&#39;}
};

bigles21
date

Sent 2022-12-21 23:15:37

Ola queridos, Preciso de uma ajuda, eu preciso colocar mais senhas pre definidas como no exemplo do código, mas s´que vou usar 2 teclas, bele, mas como faço? o que será executado em cada uma eu sei fazer, mas não sei como fazer com mais de uma senha. valeu!

luan.ferreira
date

Sent 2022-12-22 11:33:18
bigles21

Para inserir novas senhas, basta replicar (alterando o nome do objeto) o método usado para a criação de uma senha. Por exemplo, no tutorial acima, definimos uma senha usando o trecho <Password senha = Password( "8765" );>. Levando isso em consideração, para criarmos uma segunda senha, basta fazermos o mesmo, só que desta vez mudar o nome do objeto (e a senha), como <Password senha2 = Password( "1234" );>, por exemplo.

mariaeduardagarciapi
date

Sent 2022-06-20 17:18:30

outros assim: 

In file included from C:\Users\Familia\Desktop\sketch_jun20a\sketch_jun20a.ino:2:0:
C:\Users\Familia\Documents\Arduino\libraries\Keypad\src/Keypad.h:78:2: note:   initializing argument 2 of &#39;Keypad::Keypad(char*, byte*, byte*, byte, byte)&#39;
  Keypad(char *userKeymap, byte *row, byte *col, byte numRows, byte numCols);
  ^~~~~~

luan.ferreira
date

Sent 2022-06-21 08:58:35
mariaeduardagarciapi

Levamos esse comentário em consideração para responder o seu outro comentário, já que esta mensagem também é apenas um aviso. Conforme comentado abaixo, veja se o código está funcionando corretamente.

mariaeduardagarciapi
date

Sent 2022-06-20 17:17:01

Olá, o meu código está dando erros, pode me ajudar? Já verifiquei os jumpers e tudo mais, no entanto, não consigo achar o erro.

Arduino: 1.8.19 (Windows 10), Placa:"Arduino Uno"

C:\Users\Familia\Desktop\sketch_jun20a\sketch_jun20a.ino:7:35: warning: ISO C++ forbids converting a string constant to &#39;char*&#39; [-Wwrite-strings]

 Password senha = Password( "8765" ); // Senha utilizada para liberacao

                                   ^

C:\Users\Familia\Desktop\sketch_jun20a\sketch_jun20a.ino:22:110: warning: invalid conversion from &#39;const byte* {aka const unsigned char*}&#39; to &#39;byte* {aka unsigned

luan.ferreira
date

Sent 2022-06-21 08:57:34
mariaeduardagarciapi

Olá! Esta mensagem é apenas um aviso, que não deve interferir na compilação do código. Sendo assim, o código deve compilar corretamente. Aliás, você pode optar por não ver esses avisos, basta ir na sua Arduino IDE > Arquivo > Preferências > Avisos do compilador, e selecionar a opção “Nenhum”. Com isso, você não verá mais os avisos do compilador.

lorranymagalhaesribe
date

Sent 2022-05-02 19:34:33

tem como me ajudar essa programação para um server motor, quero colocar uma porta automatizada, que quando digita a senha correta ele abre de depois de período de tempo feche novamente???

luan.ferreira
date

Sent 2022-05-03 08:37:17
lorranymagalhaesribe

Para realizar esse projeto, você pode usar como base os exemplos que vem na biblioteca "Servo" da Arduino IDE (Arquivo > Exemplos > Servo). Isso lhe dará base para começar o seu projeto.

Usando o Teclado Matricial com Arduino

Introdução

Lista de Materiais

Lista completa de produtos

BlackBoard UNO R3

Cabo USB AB 1.50m

Teclado Matricial de Membrana 16 Teclas

LED 5mm Vermelho (10 unidades)

LED 5mm Verde (10 unidades)

Resistor 300Ω - Pacote com 10 unidades

Protoboard 400 Pontos

WorkPlate 400 - Preta

Jumpers Macho-Macho x40 Unidades

Conceitos Teóricos

Projeto Teclando com Arduino

Circuito

Software

Biblioteca

Código

Entendendo o Código

O Que Deve Acontecer

Projeto Controle de Acesso

Circuito

Software

Biblioteca

Código

Entendendo o Código

O Que Deve Acontecer

Indo Além