Início
/
Projetos Arduino
/
Projetos Squids
/
Básico
/
Projeto110 -Tranca Eletrônica com Arduino, Teclado Matricial, LCD I2C e LED RGB com Alteração Segura de Senha
Projeto110 -Tranca Eletrônica com Arduino, Teclado Matricial, LCD I2C e LED RGB com Alteração Segura de Senha
Angelo Luis Ferreira | 01/05/2025
Acessos: 268
Básico - Projeto 110
Simulação de uma Tranca Eletrônica com Arduino, Teclado Matricial, LCD I2C e LED RGB com senha permanente e segura
Objetivo
O objetivo deste tutorial é desenvolver uma simulação de uma tranca eletrônica com Arduino, utilizando um teclado matricial 4x4 para digitação de senha, um display LCD com interface I2C para exibir mensagens ao usuário, e um LED RGB para indicar visualmente o estado da tranca, que permanece vermelha enquanto fechada e verde quando aberta. Além disso, o sistema permite a alteração segura da senha, com armazenamento permanente na EEPROM, garantindo a persistência dos dados mesmo após desligar o equipamento:
O programa simula uma tranca eletrônica digital com senha, utilizando um teclado matricial 4x4 como interface de entrada.
Um LED RGB indica o estado da tranca: vermelho para fechada e verde para aberta.
Um display LCD com I2C exibe mensagens que orientam o usuário durante o uso do sistema.
A senha padrão pode ser modificada de forma segura, exigindo a senha atual antes de permitir a troca.
A senha é armazenada na EEPROM, garantindo que ela seja preservada mesmo após desligar o Arduino.
O sistema garante um controle de acesso simples e seguro, ideal para simulações de fechaduras eletrônicas.
Definições
Teclado Matricial
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.
Memória EEPROM no Arduino
EEPROM no Arduino: A EEPROM (Electrically Erasable Programmable Read-Only Memory) é uma memória não volátil presente em muitos modelos de Arduino (como o Uno, Nano, Mega), usada para armazenar dados que permanecem mesmo após desligar o dispositivo.
No Arduino Uno, por exemplo, a EEPROM possui 1.024 bytes de capacidade.
Utilização no Arduino: A EEPROM é acessada pela biblioteca EEPROM.h e permite gravar e ler dados byte a byte (valores de 0 a 255). Pode ser usada para armazenar:
Lógica de leitura e gravação
Cuidados ao usar a EEPROM:
-
Ciclo de gravação limitado:
A EEPROM suporta cerca de 100.000 ciclos de escrita por célula. Evite gravar repetidamente o mesmo endereço em intervalos curtos (ex.: dentro do loop()), pois isso pode desgastar a memória.
-
Verificação antes de gravar:
Sempre verifique se o valor a ser gravado já está presente antes de escrever, para evitar escritas desnecessárias:
- Ou de forma mais simples, mais limpa e segura:
EEPROM.update(addr, valor);
-
Gerenciamento de espaço:
Organize os dados na EEPROM com cuidado para não sobrescrever informações importantes.
-
Salvar somente quando necessário:
Por exemplo, ao confirmar a alteração de uma senha, e não a cada digitação.
-
Não usar como RAM:
A EEPROM é lenta e não apropriada para leitura e gravação em tempo real contínuas.
Referências
Projeto108 - Como usar um Teclado Matricial 4x4 com Arduino (Com Biblioteca Keypad)
Projeto107 - Como usar um Teclado Matricial 4x4 com Arduino (Sem Biblioteca)
Projeto 48a - Como controlar um display LCD com o módulo I2C (LiquidCrystal_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)
Projeto 23 - Criando efeito de cores com um LED RGB
Aplicação
Para fins didáticos e em projetos reais de controle de acesso, como fechaduras eletrônicas para portas, cofres ou gavetas (quando acoplado a solenóides ou motores para acionamento físico da tranca). Também é aplicável em sistemas de restrição de uso de equipamentos, como impressoras, bancadas de laboratório e painéis elétricos ou eletrônicos, além de poder integrar soluções de segurança em ambientes residenciais ou comerciais.
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)
|
| Led RGB |
Led RGB 5mm |
1 |
 |
Você poderá utilizar um LED RGB ânodo ou cátodo.
Você poderá utilizar também um LED RGB difuso ou de alto brilho.
|
| 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.
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)
| Pinos do Teclado Matricial |
Pinos Digitais do Arduino |
| L1 |
9 |
| L2 |
8 |
| L3 |
7 |
| L4 |
6 |
| C1 |
5 |
| C2 |
4 |
| C3 |
3 |
| C4 |
2 |
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 48a - Como controlar um display LCD com o módulo I2C (LiquidCrystal_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. Lembre-se que existem 2 tipos de LED RGB, o ânodo comum e o cátodo comum. Observe que para cada uma das cores existe um terminal, e além disso o quarto terminal (maior) deverá ser conectado ao polo positivo (ânodo comum) e ao polo negativo (cátodo comum).
4.1. No projeto usamos um LED RGB ânodo comum, portanto conectamos o terminal mais longo no 5Vcc (polo positivo do Arduino).
4.2. ATENÇÃO: Caso tenha um LED RGB cátodo comum, conecte o terminal mais longo no GND (polo negativo do Arduino).
4.3. Para saber mais sobre LED RGB leia: Projeto 23 - Criando efeito de cores com um LED RGB.
4.2. Leia também: Led RGB anodo comum ou o Led RGB catodo comum? Como identificar e usar com Arduino (circuito e programação).
5. 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.
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.
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 LiquidCrystal_I2C. Localizada a biblioteca LiquidCrystal_I2C (por Frank de Brabander) clique no botão [Instalar].
3. Após a instalação, observe que aparecerá a informação que a biblioteca foi instalada.
Para saber detalhes desta biblioteca clique aqui.
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 projeto110.ino no IDE do Arduino: DOWNLOAD - projeto110.ino
Obs. 1: Nos casos em que módulo I2C estiver configurado com uma faixa de endereços diferente do endereço 0X27 altere a alinha de programação -> LiquidCrystal_I2C lcd(0x27,16,2); com o endereço correto.
Obs. 2: Se estiver utilizando um display de LCD 20 X 4, altere para LiquidCrystal_I2C lcd(0x27,20,4);
Obs. 3: 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. 4: 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 110: Tranca eletrônica com Arduino e teclado matricial
http://squids.com.br/arduino
* Autor: Angelo Luis Ferreira
*
*******************************************************************************/
#include <Keypad.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>
// --- LCD via I2C ---
LiquidCrystal_I2C lcd(0x27, 16, 2); // Endereço 0x27 é o mais comum
// --- Teclado ---
const byte linhas = 4, colunas = 4;
char keys[linhas][colunas] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[linhas] = {9, 8, 7, 6};
byte colPins[colunas] = {5, 4, 3, 2};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, linhas, colunas);
// --- LED RGB ---
const int redPin = A0;
const int greenPin = A1;
const int bluePin = A2;
// --- Controle de senha ---
const int MAX_SENHA = 6;
int senhaEnd = 0;
String senhaAtual = "";
bool modoConfig = false;
String buffer = "";
// --- Funções EEPROM ---
String lerSenhaEEPROM() {
byte len = EEPROM.read(senhaEnd);
String s = "";
for (int i = 1; i <= len; i++) {
s += char(EEPROM.read(senhaEnd + i));
}
return s;
}
void salvarSenhaEEPROM(const String &s) {
byte len = s.length();
EEPROM.update(senhaEnd, len); // Usa update para gravar apenas se necessário
for (int i = 0; i < len; i++) {
EEPROM.update(senhaEnd + 1 + i, s[i]);
}
}
// --- LED ---
void setColor(int r, int g, int b) {
digitalWrite(redPin, r);
digitalWrite(greenPin, g);
digitalWrite(bluePin, b);
}
// --- Setup ---
void setup() {
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
lcd.init();
lcd.backlight();
senhaAtual = lerSenhaEEPROM();
if (senhaAtual.length() < 1 || senhaAtual.length() > MAX_SENHA) {
senhaAtual = "1234";
salvarSenhaEEPROM(senhaAtual);
}
setColor(0, 255, 255); // vermelho = trancado
lcd.clear();
lcd.print("Tranca fechada");
delay(2000);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Digite senha:");
}
// --- Loop ---
void loop() {
char key = keypad.getKey();
if (!key) return;
if (!modoConfig) {
if (key == '*') {
modoConfig = true;
buffer = "";
lcd.clear();
lcd.print("Nova senha:");
}
else if (key != '#') {
buffer += key;
lcd.setCursor(buffer.length(), 1);
lcd.print('*');
if (buffer.length() >= senhaAtual.length()) {
delay(200);
if (buffer == senhaAtual) {
abrirTranca();
} else {
lcd.clear();
lcd.print("Senha incorreta");
delay(1000);
reiniciar();
}
}
}
} else {
if (key == '#') {
if (buffer.length() >= 4) {
salvarSenhaEEPROM(buffer);
senhaAtual = buffer;
lcd.clear();
lcd.print("Senha alterada!");
delay(1000);
} else {
lcd.clear();
lcd.print("Min 4 digitos");
delay(1000);
}
reiniciar();
} else if (key == '*') {
reiniciar();
} else {
if (buffer.length() < MAX_SENHA) {
buffer += key;
lcd.setCursor(buffer.length(), 1);
lcd.print('*');
}
}
}
}
// --- Funções auxiliares ---
void abrirTranca() {
setColor(255, 0, 255);
lcd.clear();
lcd.print("Acesso liberado");
delay(2000);
reiniciar();
}
void reiniciar() {
modoConfig = false;
buffer = "";
setColor(0, 255, 255);
lcd.clear();
lcd.print("Tranca fechada");
delay(2000);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Digite senha:");
}
Vídeo
Como o projeto deve funcionar
5. Teclas de Operação: Cada tecla especial do teclado 4x4 tem uma função definida:
-
Ao pressionar a tecla "*", o sistema entra no modo de configuração de senha.
-
Ao pressionar "#" no modo de configuração de senha, a nova senha é gravada na EEPROM (memória permanente do Arduino).
Explicando o código do projeto
Estrutura geral
Esse projeto implementa uma tranca eletrônica com:
-
Teclado matricial 4x4 → para digitar a senha.
-
LCD 16x2 via I2C → para mostrar mensagens ao usuário.
-
LED RGB → indicando se a tranca está fechada (vermelho) ou aberta (verde).
-
EEPROM → para salvar a senha de forma permanente (mesmo desligando a placa).
1. Inclusão de bibliotecas
#include <Keypad.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>
-
Keypad → facilita a leitura de teclas no teclado matricial.
-
Wire → usada pela comunicação I2C.
-
LiquidCrystal_I2C → controla o LCD com apenas 2 fios (SDA/SCL).
-
EEPROM → grava/ler dados permanentes, como a senha.
2. Configuração do hardware
LiquidCrystal_I2C lcd(0x27, 16, 2);
- Inicializa o LCD com endereço I2C
0x27, comum na maioria dos módulos.
const byte linhas = 4, colunas = 4;
char keys[linhas][colunas] = { ... };
byte rowPins[linhas] = {9, 8, 7, 6};
byte colPins[colunas] = {5, 4, 3, 2};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, linhas, colunas);
const int redPin = A0;
const int greenPin = A1;
const int bluePin = A2;
3. Controle de senha
const int MAX_SENHA = 6;
int senhaEnd = 0;
String senhaAtual = "";
bool modoConfig = false;
String buffer = "";
-
const int MAX_SENHA → limite de caracteres da senha.
-
int senhaEnd → posição inicial onde a senha será gravada na EEPROM.
-
String senhaAtual → guarda a senha que está salva.
- No Arduino, "
String" (com 'S' maiúsculo) antes de um nome de variável significa que você está declarando uma variável do tipo classe String, usada para armazenar e manipular sequências de texto (cadeias de caracteres) como palavras e frases. Este tipo é uma classe poderosa que oferece funções extras para trabalhar com texto, tornando-o uma maneira mais simples de lidar com texto em comparação com o uso de arrays de caracteres (char). Leia Projeto 46 - Mostrando texto digitado pelo computador no display LCD com scroll e contador de caracteres
-
bool modoConfig → controla se o sistema está no modo normal ou de alterar senha.
-
String buffer → armazena temporariamente os dígitos digitados pelo usuário.
- O
buffer é uma área de memória temporária usada para armazenar dados, principalmente na comunicação serial, antes de serem lidos ou processados pelo microcontrolador. Quando o Arduino recebe dados via comunicação serial (por exemplo, do teclado matricial), esses dados são primeiro armazenados num "buffer", que é como uma fila de espera.
4. Funções EEPROM
Função lerSenhaEEPROM()
String lerSenhaEEPROM() {
byte len = EEPROM.read(senhaEnd);
String s = "";
for (int i = 1; i <= len; i++) {
s += char(EEPROM.read(senhaEnd + i));
}
return s;
}
-
O primeiro byte da memória (endereço senhaEnd) não guarda parte da senha em si, mas sim o comprimento da senha (quantos caracteres ela tem).
-
Cria a String s vazia que será usada para ir montando a senha.
-
Percorre cada posição da EEPROM onde os caracteres da senha estão armazenados.
-
Converte o valor lido (byte) em caractere (char) e acrescenta na String s.
-
O primeiro caractere está em senhaEnd + 1, porque senhaEnd foi usado para salvar o comprimento.
O anúncio abaixo ajuda a manter o Squids Arduino funcionando
Comentários
