Sistema de Alarme Codificado com Arduino, Display 16×2 e Sensor de Vibração SW-420

Sistemas de segurança estão cada vez mais presentes em nosso cotidiano, são eles Alarmes, Cercas Elétricas, câmeras de monitoramento entre outras muitas tecnologias que estão em desenvolvimento para garantir a segurança de quem está disposto a investir nesses equipamentos. Neste tutorial vamos montar um sistema de monitoramento de segurança por alarme sonoro com desarme mediante senha, utilizando um Arduino UNO, um Sensor de Vibração SW-420 e um Display 16×2.

Montando o projeto

Para o desenvolvimento desse projeto será necessária uma placa de desenvolvimento Arduino Uno, onde ela será responsável por receber os sinais do Módulo Sensor de Vibração SW-420 e controlar o microcontrolador para o disparo sonoro com o Buzzer e do Led Vermelho 5mm quando o alarme for ativado.

Quando necessária a senha, o programa mapeará os botões pressionados no teclado e apresentará ao usuário através do display LCD. Para este protótipo o alarme sonoro é realizado por um Buzzer, mas para cada aplicação este dispositivo sonoro pode ser alterado, adaptando buzinas ou sirenes (nestes casos realizando os acionamentos por relé).

Componentes Utilizados:
Arduino Uno
Módulo Sensor de Vibração SW-420
Teclado Matricial 4×4
Display LCD 16×2 BackLight Azul
Buzzer
Resistor 480 ohms
Led Vermelho 5mm

A montagem do protótipo pode ser observada pela figura abaixo:

 
 

 
 
 
 
 
 

Inicialmente vamos ligar o display LCD aos pinos do Arduino conforme imagem acima, os pinos digitais de 2 ao 7 são de controle do LCD (demonstrados com fios de cor amarela), Alimentação 5V e GND são ligados em comum ao Arduino. O display também necessita de um potenciômetro de 10k para ajuste de contraste conforme demonstrado acima.

O teclado matricial deve ser conectado como demonstra a ilustração (fios de cor laranja), como se trata de apenas contatos, o teclado não necessita de alimentação.

O sensor de vibração é alimentado por 5V e o pino que envia o sinal D0 é conectado na entrada analógica A3 do Arduino. O Buzzer e LED são ligados respectivamente no pino 9 e A4, a saída de sinal para o Buzzer é modulada por PWM, por isso o pino 9 foi o escolhido por ser um pino com saída PWM no Arduino UNO.

Abaixo também temos na prática a montagem do protótipo:

 

 

O vídeo demonstrando o funcionamento desse projeto pode ser acessado pela  página no Instagram:
Laboratório dos Fundos
https://www.instagram.com/laboratorio_dosfundos/

 

Desenvolvendo o código

Após montagem do hardware, prosseguimos para o código onde receberá os sinais do sensor de vibração controlando assim o teclado matricial e display LCD.
O Código como pode ser observado abaixo, será carregado para o microcontrolador ATMEGA do Arduino:

#include <Keypad.h&amp>// inclui a biblioteca do teclado matricial 4x4
#include <LiquidCrystal.h> // inclui a biblioteca para o display Lcd 16x2
#define buzzer 9 // define o pino 9 para o buzzer
#define sinal_sensor A2 // define o pino A2 para a entrada de sinal
#define led_alarme A4 // define o pino A4 para o led rgb de alarme
#define button_desativador A1 // define o pino A1 como desativador alternativo
int ativa_alarme; // Cria uma variavel int de nome ativa_alarme
int desliga_alarme; // cria uma variavel int de nome desliga_alarme
int leitura_sensor; // cria uma variavel int de nome leitura_sensor
byte pinosLinhas[] = {8,A3,10,11}; // cria um vetor de 4 colunas
byte pinosColunas[] = {A0,A5,12,13}; // cria um vetor de 4 colunas
char senha[4] = {'5','9','3','8'}; // cria um vetor char de nome senha de 4 colunas com caracteres definidos 
char vetor[4]; // cria um vetor char para armazenar os digitos do teclado
int i; // cria uma variavel de nome i
char teclas[4][4] = {{'1','2','3','A'}, // matriz 4x4 com caracteres definidos
                     {'4','5','6','B'},
                     {'7','8','9','C'},
                     {'*','0','#','D'}};

Keypad teclado1 = Keypad( makeKeymap(teclas), pinosLinhas, pinosColunas, 4, 4); // cria a variavel de nome teclado1 para armazenar os caracteres
LiquidCrystal lcd ( 7, 6, 5, 4, 3, 2); // define os pinos para comunicação com o display lcd

void setup() {
pinMode(buzzer, OUTPUT); // define o pino buzzer como saída
pinMode(sinal_sensor,INPUT); // define o pino de sinal do sensor de vibrações como entrada
pinMode(led_alarme, OUTPUT); // define o pino do led como saída
pinMode(button_desativador,INPUT); //define o desativador alternativo como entrada
lcd.begin(16,2); // inicia a comunicação com o display lcd
lcd.setCursor(0,0); lcd.print("ALARME");} // escreve ALARME no display na posição (0,0)

void loop() {
lcd.setCursor(8,0); lcd.print("OFF"); // indica que o alarme está desabiitado no display
digitalWrite (led_alarme ,LOW); // deixa o led de alarme desligado
char tecla_pressionada = teclado1.getKey(); //  verifica se alguma tecla foi pressionada 
       if (tecla_pressionada == '#' ) { // se # for pressionado executa o codigo abaixo
lcd.setCursor(8,0); lcd.print("ON "); // indica no display que o alarme está ativo
digitalWrite (buzzer, HIGH); delay(50);  // sonorização
       while ( tecla_pressionada != '*') { // enquanto * não for pressionado o programa executa no laço abaixo
leitura_sensor = digitalRead(sinal_sensor); // realiza a leitura de sinal advindo do sensor de vibrações
tecla_pressionada = teclado1.getKey(); // verifica se alguma tecla foi pressionada

//******************************************ALARME
       if (leitura_sensor == HIGH) { // se receber sinais do sensor de vibração, executa o codigo abaixo
analogWrite (buzzer, 130); delay(100); // sonorizaão alarme inicial
analogWrite (buzzer, 150); delay(200); // sonorização alarme inicial
analogWrite (buzzer, 255); delay(100); // sonorização alarme inicial 
analogWrite (buzzer, 100); delay(300); // sonorização alarme inicial
       while ( desliga_alarme != HIGH){ // enquanto o botão de desativador alternativo não for ativo, executa o laço abaixo
desliga_alarme = digitalRead(button_desativador); // realiza a leitura do botao alternativo
digitalWrite (led_alarme ,HIGH); // liga o led rgb de alarme
digitalWrite (buzzer, HIGH); delay(100); // Alarme 
digitalWrite (buzzer, LOW); delay(100); // Alarme
tecla_pressionada = teclado1.getKey(); // verifica se alguma tecla foi pressionada
//******************************************SENHA
       if (tecla_pressionada){ // se alguma tecla for pressionada executa abaixo
vetor[i] = tecla_pressionada; // armazena no vetor[4] as teclas pressionadas
lcd.setCursor(i,1); lcd.print(tecla_pressionada); // indica no display a tecla pressionada
i++; // contador para definir que a senha seja de 4 digitos
       if(i==4){ // se o ultimo digito da senha for pressionado, executa abaixo
       if(vetor[0] == senha[0] &amp;amp;&amp;amp; 
          vetor[1] == senha[1] &amp;amp;&amp;amp;
          vetor[2] == senha[2] &amp;amp;&amp;amp;
          vetor[3] == senha[3]){ // compara o vetor das teclas pressionadas com a senha pré definida
lcd.setCursor(7,1); lcd.print("OK"); delay(1000); // indica que a senha digitada foi correta
lcd.setCursor(0,1); lcd.print("                "); // limpa o display
lcd.setCursor(6,0); lcd.print("                "); // limpa o display
i=0; // zera o contador
return 0;} // desativa o alarme retornando o codigo para o inicio
        else { // se a senha não for correta, executa abaixo
lcd.setCursor(0,1); lcd.print("SENHA INVALIDA  "); digitalWrite (buzzer, HIGH); delay(1000); // indica no display que a senha digitada não é correta
lcd.setCursor(0,1); lcd.print("                "); //limpa o display
i=0;} //zera o contador
}}}}    
//******************************************FIM DO ALARME
else { analogWrite(buzzer,0); // caso o alarme não estiver ativo, garante o buzzer desativado
}}}}

Você pode consultar, baixar, modificar e compartilhar o código deste tutorial em nosso repositório do GitHub! E lá você encontra todos os códigos já publicados aqui no blog! Vamos compartilhar conhecimento!

Mergulhando no projeto

Software

Inicialmente iremos instalar a biblioteca KEYPAD, esta biblioteca pode ser encontrada facilmente na web para download. Já no sketch incluímos a biblioteca posteriormente instalada  <Keypad.h> e do LCD <LiquidCrystal.h>.

Logo após, são nomeados os pinos do LED, Buzzer, entrada de sinal e botão desativador. Variáveis do tipo ‘’int’’ são criadas para controle e recebimento de dados do sensor e vetores ‘’Byte’’ para mapeamento dos pinos do teclado byte pinosLinhas[], byte pinosColunas[] . Um vetor ‘’Char’’ criado para pré-definir a senha e outro para armazenar os dígitos no momento de alarme para comparação entre eles no programa, char teclas[4][4] indica os caracteres de cada tecla.

Uma variável de nome teclado1 é criada na biblioteca Keypad para armazenar o caractere pressionado no teclado. Essa série de definições e inclusões termina com o mapeamento dos pinos
utilizados no display LCD LiquidCrystal lcd ( 7, 6, 5, 4, 3, 2).

Função Setup

Na função setup iremos definir as portas onde conectados o Buzzer e LED de alarme como saídas digitais:

pinMode (led_alarme, OUTPUT)

E os sinais do sensor de vibração e o botão desativador como entradas:

PinMode(sinal_sensor, INPUT)

Em

 lcd.begin(16,2)

inicia-se a comunicação com o display LCD e escreve na linha 1 do display a palavra “ALARME” com:

lcd.print("ALARME")

 

Função Loop

Alarme

A função Loop se inicia escrevendo no display a palavra OFF:

 lcd.setCursor(8,0); lcd.print("OFF")

indicando que o alarme está no momento desativado. A variável char tecla_pressionada monitora e armazena as teclas pressionadas no teclado:

 tecla_pressionada = teclado1.getKey()

Caso a tecla ‘’#’’ for pressionada, o programa entra para realizar os comandos do bloco IF que ativando o alarme escrevendo ON no display.Neste estágio do programa, o sistema monitora o sensor de vibrações constantemente mas esta ação ainda pode ser revertida ao pressionar a tecla‘’*’’.

Enquanto a tecla ‘’*’’ não for pressionada ou o sensor de vibrações if (leitura_sensor == HIGH) não enviar o comando para o Arduino, o programa roda dentro do laço while:

while( tecla_pressionada != *&amp;amp;)

No momento que o Arduino recebe o sinal HIGH do sensor, ele interpreta que uma vibração foi detectada e que o alarme deve ser disparado:

if (leitura_sensor == HIGH)

 

Com o alarme ativo o programa desce uma sequencia de sonorização e cai no  laço while:

while ( desliga_alarme != HIGH)

que dispara o aviso sonoro do Buzzer intermitente. Para desativar o alarme e sair deste laço o programa tem duas opções, ou o botão desativador de emergência seja acionado levando a variável desliga_alarme para nível LOW ou por senha.

O botão desativador no nosso protótipo está diretamente ligado ao nível alto HIGH, deixando assim a opção de desativar o alarme somente por senha. Já com o alarme ativo e o aviso sonoro intermitente o programa e o display aguardam a senha correta ser digitada para a desativação do sistema. A senha foi definida inicialmente mas pode ser alterada de acordo com a
preferência do usuário em:

char senha[4] = {'5', '9', '3', '8'} //um vetor de 4 posições

 

Senha

Se alguma tecla for pressionada if (tecla_pressionada), o programa armazena está tecla em:

vetor[i] = tecla_pressionada;

O contador i++ auxilia até o preenchimento por completo da senha de 4 dígitos. Após o preenchimento da senha digitada por completo ele é comparado com a senha pré-definida:

if(vetor[0] == senha[0] && vetor[1] == senha[1] && vetor[2] == senha[2] && vetor[3] == senha[3])

O programa interpreta que a senha é correta quando está comparação acima seja verdadeira. Caso a comparação for verdadeira o alarme é desativado desabilitando o Buzzer, e escreve OK no display e por fim zera o contador i++ .

Caso a senha for esteja incorreta escreve no display :

lcd.print("SENHA INVALIDA")

e retorna o programa para o laço de alarme com o Buzzer emitindo som intermitente zerando também o contador i++ para uma nova tentativa de senha.

 

Hardware

Módulo Sensor de Vibração SW-420

 

 

 

 

 

 

O módulo SW-420 foi desenvolvido para detecção de vibrações, através do trimpot na PCI é possível ajustar a sua sensibilidade de acordo com sua aplicação.

Quando houverem vibrações na superfície onde instalado o sensor, um nível alto HIGH será aplicado no pino D0 no mesmo instante também ascenderá o LED verde na PCI sinalizando a captação de vibração. As aplicações para este tipo de sensor são inúmeras.

Pinagem:

– VCC: 3,3 – 5V

– GND: GND

– D0: Saída Digital

 

Teclado Matricial 4×4

O teclado matricial 4×4 como o nome diz é uma matriz de contatos que quando algum digito é pressionando o contato se fecha de um pino para outro. O esquema de contatos pode ser observado abaixo, linhas e colunas com 8 pinos. Exemplo:
Quando a tecla 1 é pressionada os pinos 1 e 5 se fecham (linha 1, Coluna 1).

Pinagem:

– 1 – Linha 1

– 2 – Linha 2

– 3 – Linha 3

– 4 – Linha 4

– 5 – Coluna 1

– 6 – Coluna 1

– 7 – Coluna 1

– 8 – Coluna 1

 

Display LCD 16×2 BackLight Azul

 

O Display LCD 16×2 possibilita e interação do programa com o usuário. As mensagens podem ser enviadas simultaneamente com o processamento no programa possibilitando assim o envio de dados, texto e sinais lidos nas entradas do microprocessador.
O LCD possui 16 colunas e 2 linhas com luz de fundo azul e escrita branca.

Confira também o nosso tutorial sobre o Módulo I2C, que ajuda bastante na conectividade do Display 16×2 com o Arduino!

Conclusão

Através deste protótipo podemos conhecer e controlar diversos tipos de componentes e módulos como o display LCD 16×2, teclado matricial 4×4, sensor de vibração e um Buzzer. Com esses componentes deixamos em aberto a vastas aplicações com o Arduino.O Sistema de monitoramento apresentado pode ser implementado com vários outros tipos de sensores, aumentando assim seu grau de segurança. Deixem suas sugestões e perguntas, compartilhe conhecimento!

 

Referências

Datasheet Display LCD 16×2

Avatar
Sobre Pedro Pereira 8 artigos
Engenheiro Eletricista, Técnico em Eletrônica e Entusiasta na área de Sistemas Embarcados. https://www.instagram.com/laboratorio_dosfundos/

Seja o primeiro a comentar

Deixe uma resposta

O seu endereço de email não será publicado.


*