Nesta postagem, 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 alfanumérica.

“como usar o controlador pid ”

Hardware para este projeto

Vamos utilizar o teclado 4x4, que consiste em 0 a 9 valores decimais, dois caracteres especiais ‘#’ e ‘*’ e alfabetos de A a D. A combinação desses caracteres pode ser usada como senha.

O Arduino é o cérebro do sistema, um relé é conectado ao Arduino para ativar e desativar, quando a senha correta for 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 4x4, consulte o meu artigo anterior, que foi amplamente discutido noções básicas do teclado de matriz 4x4

O projeto proposto tem um design de hardware bastante minimalista. Ele consiste apenas em 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, o código é fornecido neste projeto. O programa deve ser escrito de forma que seja à prova de idiotas e nenhum sequestrador possa hackear o sistema.

Mas, tome cuidado se você expor o hardware ou se o hardware deste projeto for facilmente acessível, 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 fornecidas abaixo com atenção, a fim de operar o circuito.

Diagrama de circuito

Circuito de bloqueio de segurança de senha Arduino usando teclado 4x4

Aqui estão as duas ilustrações de como fazer a interface do teclado e do Arduino:

Resultados do teste de bloqueio de segurança de senha do Arduino

• Quando o circuito é ligado, ele pede uma senha, você pode ver no monitor serial (o monitor serial não é obrigatório, mas pode ser usado para fins de teste).

• Insira a senha que você inseriu 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. Quando isso é feito, o LED verde se apaga e o relé é desativado. Nenhuma outra chave pode desativar o relé.

• Se a senha digitada pelo usuário estiver incorreta, o LED vermelho acende e o usuário deve aguardar 30 segundos para inserir a próxima tentativa. Quando os 30 segundos terminam, o LED vermelho se apaga, informando ao usuário que o sistema está pronto para receber a entrada do usuário.

“qual é o caminho que a corrente alternada ”

• Quando o relé é desativado após a ativação bem-sucedida, a fim de ativar o relé novamente, o usuário precisa inserir 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 como 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, só então 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

“soma da expressão booleana dos produtos ”

}
}
outro
{
ir para o despejo
}
PARA:
key2 = keypad.waitForKey ()
if (key2 == pass [1])
{
digitalWrite (verde, ALTO)
atraso (100)
digitalWrite (verde, BAIXO)
{
z = 2
Serial.print ('*')
vá para B
}
}
outro
{
ir para o despejo
}
B:
key3 = keypad.waitForKey ()
if (key3 == pass [2])
{
digitalWrite (verde, ALTO)
atraso (100)
digitalWrite (verde, BAIXO)
{
z = 3
Serial.print ('*')
vá para C
}
}
outro
{
ir para o despejo
}
C:
key4 = keypad.waitForKey ()
if (key4 == pass [3])
{
digitalWrite (verde, ALTO)
atraso (100)
digitalWrite (verde, BAIXO)
{
z = 4
Serial.print ('*')
ir para D
}
}
outro
{
ir para o despejo
}
D:
key5 = keypad.waitForKey ()
if (key5 == pass [4])
{
digitalWrite (verde, ALTO)
atraso (100)
digitalWrite (verde, BAIXO)
{
z = 5
Serial.print ('*')
vá para E
}
}
outro
{
ir para o despejo
}
É:
key6 = keypad.waitForKey ()
if (key6 == pass [5])
{
digitalWrite (verde, ALTO)
atraso (100)
digitalWrite (verde, BAIXO)
{
z = 6
Serial.print ('*')
vá para ok
}
}
outro
{
ir para o despejo
}
OK:
keyOK = keypad.waitForKey ()
if (keyOK == ok [0])
{
digitalWrite (OP, HIGH)
digitalWrite (verde, ALTO)
Serial.println ('')
Serial.println ('Relé ativado, pressione' C 'para desativar.n')
}
outro
{
Serial.println ('')
Serial.println ('Pressione' D 'para entrar')
vá para ok
}
desligado:
offkey = keypad.waitForKey ()
if (offkey == off [0])
{
digitalWrite (OP, LOW)
digitalWrite (verde, BAIXO)
Serial.println ('Relay Deactivated.n')
ir para o topo
}
outro
{
Serial.println ('Pressione' C 'para desativar')
vá embora
}
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 ('*')
ir para o erro
}
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 ('*')
ir para o erro
}
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 ('*')
ir para o erro
}
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 ('*')
ir para o erro
}
if (z == 4)
{
digitalWrite (verde, ALTO)
atraso (100)
digitalWrite (verde, BAIXO)
Serial.print ('*')
dumpkey = keypad.waitForKey ()
Serial.print ('*')
dumpkey = keypad.waitForKey ()
Serial.print ('*')
ir para o erro
}
if (z == 5)
{
digitalWrite (verde, ALTO)
atraso (100)
digitalWrite (verde, BAIXO)
Serial.print ('*')
dumpkey = keypad.waitForKey ()
Serial.print ('*')
ir para o erro
}
erro:
Serial.println ('')
Serial.print ('Senha errada, aguarde 30 segundos.')
digitalWrite (vermelho, ALTO)
atraso (10000)
atraso (10000)
atraso (10000)
digitalWrite (vermelho, BAIXO)
ir para o topo
}
// --------------------------------- Programa desenvolvido por R.Girish --------- ----------------- //

NOTA: Para definir a senha: char pass [] = '123ABC' // senha de 6 dígitos apenas (nem menos nem mais)
Troque “123ABC” por sua própria senha, entre aspas.

Certifique-se de que a senha definida no programa seja APENAS 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 por senha explicado, fique à vontade para postá-las por meio de seus comentários

Anterior: Circuito LED do Simulador Sunrise Sunset Próximo: Circuito do controlador de motor Bluetooth