Neste post vamos construir um circuito de bloqueio de segurança por senha, que pode ser acessado por uma senha de 6 dígitos. Para ser mais preciso, é uma senha alfa numérica.
Hardware para este projeto
Vamos utilizar o teclado 4×4, que consiste em 0 a 9 valores decimais, dois caracteres especiais ‘#’ e ‘*’ e alfabetos A a D. A combinação desses caracteres pode ser usada como senha.
O Arduino é o cérebro do sistema, um relé é interfaceado com o Arduino para ativar e desativar, quando a senha correta é comandada. Dois LEDs indicadores são utilizados aqui para indicar o status do sistema de bloqueio.
Se você não estiver familiarizado com o teclado 4×4, consulte meu artigo anterior, que discutiu de forma abrangente os conceitos básicos do teclado matricial 4×4
O projeto proposto tem um design de hardware bastante minimalista. Ele consiste apenas de um teclado, relé, arduino e alguns LEDs, até mesmo um noob no arduino pode fazer isso com facilidade.
A única parte que é um pouco difícil neste projeto é a codificação, não precisa se preocupar que o código é fornecido neste projeto. O programa deve ser escrito de tal forma que seja à prova de falhas e nenhum sequestrador possa invadir o sistema.
Mas, tome cuidado se você expor o hardware ou o hardware deste projeto é de fácil acesso, o relé pode ser hackeado com facilidade. Portanto, mantenha este projeto em chassis bem protegidos.
Como funciona
Nota: Um resistor limitador de corrente de 4,7K deve ser conectado à base do transistor, que não é mostrado no diagrama.
Agora vamos ver como funciona este circuito de bloqueio de segurança de senha do Arduino, por favor, leia as instruções abaixo com cuidado, a fim de operar o circuito.
Diagrama de circuito
Aqui estão as duas ilustrações de como fazer a interface do teclado e do Arduino:
• Quando o circuito é ligado, ele pede senha, você pode ver no monitor serial (o monitor serial não é obrigatório, mas pode ser usado para fins de teste).
• Digite a senha que você digitou no programa antes de compilá-lo.
• Enquanto você pressiona as teclas, o LED verde pisca por um décimo de segundo, indicando que alguma tecla foi pressionada pelo usuário.
• Depois de inserir a senha de 6 dígitos, pressione ‘D’ no teclado que funciona como ‘Enter’. Se sua senha estiver correta, o relé é ativado, o LED verde acende.
• Para desativar o relé, pressione ‘C’ no teclado. Feito isso, o LED verde desliga e o relé é desativado. Nenhuma outra chave pode desativar o relé.
• Se a senha digitada pelo usuário estiver incorreta, então o LED vermelho acende e o usuário tem que esperar 30 segundos para entrar na próxima tentativa. Quando os 30 segundos se esgotarem, o LED vermelho desliga, informando ao usuário que o sistema está pronto para receber a entrada do usuário.
• Quando o relé é desativado após a ativação bem-sucedida, para ativar o relé novamente, o usuário precisa digitar a senha novamente e pressionar ‘D’.
Aqui está um caso especial:
• Quando a senha correta é inserida, o relé é ativado e após a desativação bem-sucedida, quando o usuário pressiona qualquer tecla errada (não a senha inteira), o programa reconhece a senha incorreta e o usuário precisa aguardar mais 30 segundos. Se for um sequestrador, isso atrasará o número de tentativas feitas pelo sequestrador.
• Quando o pressionamento de tecla correto é pressionado na primeira tentativa, somente então ele permite inserir a próxima tecla. Isso é apenas para o primeiro pressionamento de tecla e não para todos os pressionamentos de tecla sucessivos.
• O lema do conceito explicado acima é atrasar o número de tentativas feitas pelo sequestrador.
Código do programa:
//---------------------------------Program Developed by R.Girish--------------------------//
#include
const byte ROWS = 4;
const byte COLS = 4;
char pass[] = "123ABC"; // 6 digit password only (no less or no more)
int OP=10;
int green=12;
int red=11;
char key1;
char key2;
char key3;
char key4;
char key5;
char key6;
char dumpkey;
char keyOK;
char ok[]="D";
char offkey;
char off[]="C";
int z;
char keys[ROWS][COLS] =
{
{'D','#','0','*'},
{'C','9','8','7'},
{'B','6','5','4'},
{'A','3','2','1'}
};
byte rowPins[ROWS] = {6,7,8,9}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {2,3,4,5}; //connect to the column pinouts of the keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
void setup()
{
Serial.begin(9600);
pinMode(OP,OUTPUT);
pinMode(green,OUTPUT);
pinMode(red,OUTPUT);
digitalWrite(OP,LOW);
}
void loop()
{
top:
Serial.println("");
Serial.println("[Press D = Enter]");
Serial.print("Enter the password: ");
key1=keypad.waitForKey();
if(key1 == pass[0])
{
digitalWrite(green,HIGH);
delay(100);
digitalWrite(green,LOW);
{
z=1;
Serial.print("*");
goto A;
}
}
outro
{
tem que despejar;
}
UMA:
key2=teclado.waitForKey();
if(chave2 == passar[1])
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
{
z=2;
Serial.print(“*”);
vá para B;
}
}
outro
{
tem que despejar;
}
B:
key3=teclado.waitForKey();
if(chave3 == passar[2])
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
{
z=3;
Serial.print(“*”);
vá para C;
}
}
outro
{
tem que despejar;
}
C:
key4=teclado.waitForKey();
if(chave4 == passar[3])
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
{
z=4;
Serial.print(“*”);
vá para D;
}
}
outro
{
tem que despejar;
}
D:
key5=teclado.waitForKey();
if(chave5 == passar[4])
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
{
z=5;
Serial.print(“*”);
goto E;
}
}
outro
{
tem que despejar;
}
E:
key6=teclado.waitForKey();
if(chave6 == passar[5])
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
{
z=6;
Serial.print(“*”);
vai ok;
}
}
outro
{
tem que despejar;
}
OK:
keyOK=teclado.waitForKey();
if(teclaOK ==ok[0])
{
digitalWrite(OP,HIGH);
digitalWrite(verde, ALTO);
Serial.println(“”);
Serial.println(“Relay ativado, pressione ‘C’ para desativar.n”);
}
outro
{
Serial.println(“”);
Serial.println(“Pressione ‘D’ para entrar”);
vai ok;
}
fora:
offkey=keypad.waitForKey();
if(desligado==desligado[0])
{
digitalWrite(OP,LOW);
digitalWrite(verde, BAIXO);
Serial.println(“Relay Desativado.n”);
vá para cima;
}
outro
{
Serial.println(“Pressione ‘C’ para desativar”);
desligou;
}
jogar fora:
if(z==0)
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
erro goto;
}
if(z==1)
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
erro goto;
}
if(z==2)
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
erro goto;
}
if(z==3)
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
erro goto;
}
if(z==4)
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
erro goto;
}
if(z==5)
{
digitalWrite(verde, ALTO);
atraso(100);
digitalWrite(verde, BAIXO);
Serial.print(“*”);
dumpkey=keypad.waitForKey();
Serial.print(“*”);
erro goto;
}
erro:
Serial.println(“”);
Serial.print(“Senha errada, aguarde 30 segundos.”);
digitalWrite(vermelho, ALTO);
atraso(10000);
atraso(10000);
atraso(10000);
digitalWrite(vermelho, BAIXO);
vá para cima;
}
//———————————Programa Desenvolvido por R.Girish——— ——————//
NOTA: Para definir a senha: char pass[] = “123ABC”; // Apenas senha de 6 dígitos (nem menos nem mais)
Altere “123ABC” com sua própria senha, entre aspas.
Certifique-se de que a senha definida no programa seja SOMENTE de 6 dígitos, nem menos nem mais, mas exatamente 6 dígitos. Caso contrário, o programa não funcionará corretamente.
Se você tiver mais dúvidas sobre o circuito de bloqueio de segurança de senha explicado, sinta-se à vontade para publicá-las através de seus comentários
Hashtags: #Circuito #bloqueio #segurança #por #senha #usando #teclado #Arduino
FONTE
Nota: Este conteúdo foi traduzido do Inglês para português (auto)
Pode conter erros de tradução
Olá, se tiver algum erro de tradução (AUTO), falta de link para download etc…
Veja na FONTE até ser revisado o conteúdo.
Status (Ok Até agora)
Se tiver algum erro coloque nos comentários