PIT- LAB DE HARDWARE - FATEC

Prévia do material em texto

CENTRO PAULA SOUZA 
FATEC INDAIATUBA - FACULDADE DE TECNOLOGIA DE 
INDAIATUBA DR. ARCHIMEDES LAMMOGLIA 
 
 
 
 
 
 
 
Leianny Giseli Ribeiro Poiani 
 
 
 
 
SISTEMA DE ALARME CODIFICADO EM ARDUINO 
 
 
 
 
 
 
PROJETO AVALIATIVO REFERENTE A MATÉRIA DE 
LABORATÓRIO DE HARDWARE 
 
 
 
 
 
 
 
 
 
 
INDAIATUBA 2021 
 
 
 
 
 
 
Leianny Giseli Ribeiro Poiani 
 
 
 
 
 
 
 
SISTEMA DE ALARME CODIFICADO EM ARDUINO 
 
 
 
 
 
 
 
 
 
 
Trabalho apresentado como parte dos requisitos para a aprovação na 
disciplina de Laboratório de Hardware, ministrada pelo professor Valmir 
Tadeu e que também visa contribuir para a compilação de todos os 
recursos e ensinamentos vinculados pelo Projeto Integrador de disciplinas 
da FATEC Indaiatuba Dr. Archimedes Lammoglia. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
INDAIATUBA 2021 
 
 
 
RESUMO 
 
 
 
Os sistemas de segurança estão cada vez mais aparecendo em nosso dia 
a dia, como alarmes, cercas eletrônicas, câmeras de vigilância e muitas outras 
tecnologias em desenvolvimento para garantir a segurança de quem deseja 
investir nesses equipamentos. Neste trabalho, será utilizado Arduino UNO, 
sensor de vibração SW-420 e display 16 × 2 para configurar um sistema de 
monitoramento de segurança com alarme sonoro e desarmamento de senha. 
 
 
 
Palavras-Chave: Arduino, projeto, sistema de segurança, monitoramento, 
alarme. 
 
 
 
 
ABSTRACT 
 
 
Security systems are increasingly appearing in our daily lives, such as 
alarms, electronic fences, surveillance cameras and many other technologies in 
development to ensure the safety of those who want to invest in this equipment. 
In this work, Arduino UNO, vibration sensor SW-420 and 16 × 2 display will be 
used to configure a security monitoring system with audible alarm and 
password disarming. 
 
 
 
Keywords: Arduino, project, security system, monitoring, alarm.
 
 
 
 
SUMÁRIO 
 
INTRODUÇÃO .............................................................................................................. 7 
LABORATÓRIO DE HARDWARE .............................................................................. 10 
DESENVOLVIMENTO DO PROJETO ........................................................................ 11 
Componentes Utilizados ............................................................................................. 11 
Montagem ................................................................................................................... 11 
Desenvolvimento do Código ....................................................................................... 13 
 Software .............................................................................................................. 16 
o Função Setup ...................................................................................................... 16 
o Função Loop ........................................................................................................ 17 
Alarme ........................................................................................................................ 17 
Senha ......................................................................................................................... 18 
 Hardware ............................................................................................................. 19 
OPORTUNIDADES DE MELHORIA. .......................................................................... 23 
CONCLUSÕES ........................................................................................................... 24 
REFERÊNCIAS BIBLIOGRÁFICAS ............................................................................ 25 
 
 
 
SUMÁRIO DE FIGURAS 
 
Figura 1 – Montagem do Protótipo .................................................................................. 10 
Figura 2 - Módulo Sensor de Vibração ............................................................................ 17 
Figura 3 - Teclado Matricial 4×4 ...................................................................................... 18 
Figura 4 - Display LCD .................................................................................................... 20 
Figura 5 - Display LCD 16x2 ........................................................................................... 20 
 
 
 
 
INTRODUÇÃO 
 
A segurança dos lares requer cuidado e atenção constante por parte dos 
moradores. Pensando nisso, ao longo deste trabalho, será apresentada uma 
alternativa para ajudar você a oferecer mais segurança à sua família. 
Os criminosos tendem a ser muito cautelosos ao escolher as casas que 
atacam como alvos. Nesse processo, um dos critérios mais relevantes para 
análise é o grau de dificuldade envolvido na execução do plano: quanto maior a 
segurança da residência, menor a chance de ela ser considerada uma meta 
viável. 
Outro resultado positivo da instalação de alarmes residenciais é seu 
desempenho "passivo". Ao contrário de acordeões ou cercas elétricas, eles 
podem evitar acidentes sem causar danos físicos a possíveis infratores. 
Portanto, a presença de alarmes residenciais possui grande importância 
na prevenção de roubos e invasões. 
Arduino é uma plataforma computadorizada open source (de código 
aberto) em uma única placa de hardware, com suporte para entrada e saída de 
dados cujo objetivo é criar projetos e ferramentas de baixo custo ou com custo 
reduzido e acessível, relativamente fáceis de serem utilizadas. Por ser de baixo 
custo, simples de programar, de código aberto para uso conjugado de 
hardware e softwares diversos, a plataforma é bastante atrativa para esse tipo 
de projeto, sendo utilizado em inúmeras aplicações ao redor do mundo[2]. 
As placas de circuito de Arduino são capazes de receber entradas - 
luzes em algum sensor, uma digital em um botão ou até mesmo uma 
mensagem de uma rede social - e transformá-las em saídas - ativar um motor, 
acender algum LED ou publicar algo online, ou seja, possibilita uma gama 
infinita de projetos diversos, com linguagem de programação relativamente 
simples, custos não tão altos e uma alta aplicabilidade em diversos cenários. 
 
O software do Arduino roda, por exemplo, em plataformas Windows, 
Mac ou Linux e professores e estudantes o usam para construir instrumentos 
de baixo custo, para comprovar leis da física e da química ou ainda começar no 
mundo da programação e robótica. Arduino é a chave, hoje em dia, para se 
aprender coisas - e de diversas áreas. 
O processo de trabalho com microcontroladores também é bastante 
simplificado, e oferece algumas vantagens a quem for operá-los: 
● Baixo custo: as placas de Arduino são relativamente baratas comparadas à 
outras plataformas semelhantes, chegando a custar menos de US$ 50,00 
alguns kits básicos; 
● Multiplataforma: O software do Arduino (IDE) roda no Windows, Macintosh 
OSX e em sistemas Linux, embora a maioria dos sistemas dos 
microcontroladores são limitados ao Windows; 
● Ambiente de programação simples: O software do Arduino (IDE) é fácil para 
iniciantes e muito maleável para usuários mais avançados. Para professores, é 
baseado em um ambiente de processamento de programação, assim 
estudantes que estejam aprendendo a programar neste ambiente, se sentirão 
mais familiarizados em como essa interface funciona; 
● Código aberto (open source)1 e software extensível: O software de Arduino é 
open source e a linguagem pode ser expandida por meio de bibliotecas C++. 
Além disso, quem quiser entender os detalhes técnicos pode saltar de Arduino 
para a linguagem de programação AVR-C, na qual ele é baseado (inclusive é 
possível adicionar código AVR-C diretamente nos programas de Arduino); 
● Código aberto (open source) e hardware extensível: as plantas das placas 
de Arduino são publicadas sob uma licença Creative Common[3], o que 
permite que pessoas experientes na criação e design de circuitos possamcriar sua própria versão do módulo, estendendo-o e melhorando-o. 
 
1 Open source é um termo em inglês que significa código aberto. O termo é relativo ao código-
fonte de um software, que pode ser utilizado para diversas finalidades e, por não possuir um 
custo, tem a vantagem de circular mais livremente e ser operado por mais pessoas.[5] 
 
 Os produtos oferecidos em Arduino são diversos e incluem placas, 
módulos, escudos e kits. Todos os modelos produzidos - bem como os 
descontinuados - podem ser encontrados no website oficial do projeto[4]. 
Além disso, é possível encontrar um breve histórico do Arduino, acessar um 
fórum de discussão e muito mais.
10 
 
LABORATÓRIO DE HARDWARE 
 
Nesta disciplina tivemos toda a noção de especificações dos 
hardwares, redes e softwares para a comunicação e trabalho da nossa 
empresa. Nos ajudou a definir qual seria o melhor custo-benefício para nosso 
uso e os padrões mais atuais, além de orientações em relação a futuro 
upgrades dos nossos equipamentos. 
Também aprendemos sobre manutenções preventivas e corretivas para 
melhor economia e manter o ambiente em harmonia e em funcionamento. 
Nos permitiu avaliar os softwares cabíveis a nossa empresa e dos recursos 
de backup que deveríamos utilizar. Sempre preservando a segurança dos 
nossos dados para que não aconteçam imprevistos sérios como a perdas de 
dados necessários ao projeto e empresa. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
11 
 
DESENVOLVIMENTO DO 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 
 
Montagem 
 
A montagem do protótipo pode ser observada pela figura abaixo: 
 
 
 
Figura 1. 
12 
 
 
 
 
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 
13 
 
PWM, por isso o pino 9 foi o escolhido por ser um pino com saída PWM no 
Arduino UNO. 
 
 
Desenvolvimento do 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 <iostream> 
 
using namespace std; 
 
int main() 
{ 
#include //inclui a biblioteca do teclado matricial 
4x4 
#include //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 
14 
 
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 
15 
 
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] && 
 vetor[1] == senha[1] && 
 vetor[2] == senha[2] && 
 vetor[3] == senha[3]){ // compara o vetor das 
teclas pressionadascom 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 
}}}} 
 
16 
 
 return 0; 
} 
 
 
 Software 
 
Inicialmente instalaremos a biblioteca KEYPAD, que pode ser facilmente 
encontrada online para download. No esboço, incluímos a biblioteca e o LCD 
que foram instalados posteriormente. 
 
Em seguida, são nomeados os pinos do LED, campainha, entrada de sinal e 
botão de desligamento. As variáveis do tipo "Int" são usadas para controlar e 
receber dados do sensor, e as variáveis do tipo "Byte" são usadas para mapear 
os pinos do teclado bytepinLines [], bytepinColumns []. Um vetor ‘’ Char ’’ é 
usado para definir a senha antecipadamente, e o outro é usado para 
armazenar o número quando o alarme ocorre para comparação no programa. 
As teclas Char [4] [4] representam os caracteres de cada tecla. 
 
Uma variável chamada keyboard1 é criada na biblioteca do teclado para 
armazenar os caracteres pressionados no teclado. Esta série de definições e 
suplementos termina com o mapeamento de pinos 
Para monitores LCD LCD LiquidCrystal (7, 6, 5, 4, 3, 2). 
 
o Função Setup 
 
Na função de configuração, definiremos a porta conectada ao buzzer e o LED 
de alarme como uma saída digital: 
 
pinMode (led_alarme, OUTPUT) 
 
 
Os sinais do sensor de vibração e o botão de desativar são usados como entrada: 
 
 
PinMode(sinal_sensor, INPUT) 
 
17 
 
E 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") 
 
 
o 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() 
 
Se você pressionar a tecla "#", o programa entra para executar o comando do 
bloco IF e ativa o alarme escrevendo ON no display. Nesta fase do programa, o 
sistema monitora continuamente o sensor de vibração, mas esta ação ainda 
pode ser revertida pressionando a tecla `` * ''. 
 
Enquanto a tecla ‘’ * ’não for pressionada ou o sensor de vibração se 
(sensor_read == HIGH) não enviar um comando para o Arduino, o programa 
será executado em um loop while: 
 
 
while( tecla_pressionada != '*') 
 
 
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: 
18 
 
 
while ( desliga_alarme != HIGH) 
 
que irá emitir um bipe de campainha piscando. O botão de desativação do 
nosso protótipo está diretamente vinculado ao nível alto de ALTO, por isso 
deixa a opção de desativar o alarme apenas com uma senha. A senha foi 
definida originalmente, mas pode ser alterada de acordo com as preferências 
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] &amp;&amp; vetor[1] == senha[1] &amp;&amp; vetor[2] 
== senha[2] &amp;&amp; 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 
19 
 
intermitente zerando também o contador i++ para uma nova tentativa de senha. 
 
 
 Hardware 
 
Módulo Sensor de Vibração SW-420 
 
Figura 2. 
 
 
 
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. 
20 
 
 
Pinagem: 
– VCC: 3,3 – 5V 
– GND: GND 
– D0: Saída Digital 
 
 
Teclado Matricial 4×4 
 
 
Figura 3. 
 
 
 
21 
 
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 
isplay na posição (0,0) 
– 4 – Linha 4 
– 5 – Coluna 1 
– 6 – Coluna 1 
– 7 – Coluna 1 
– 8 – Coluna 1 
 
 
Display LCD 16×2 BackLight Azul 
 
Figura 4. 
 
22 
 
 
 
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. 
 
Figura 5. 
 
23 
 
 
 
 
 
OPORTUNIDADES DE MELHORIA. 
 
Uma boa implantação seria a possibilidade da troca da senha. Uma abordagem 
para implementar tal função, seria primeiramente definir qual comando de 
teclado iria iniciar o comando de troca de senha, poderíamos por exemplo usar 
uma tecla de letra, teríamos quatro opções: ‘A’, ‘B’, ‘C’ ou ‘D’, já que as teclas 
‘*’ e ‘#’ já são usadas em outros contextos dentro do projeto, e utilizá-las 
novamente poderia ficar confuso. 
 
Tendo definido o comando que inicia a função de alteração de senha, 
precisamos decidir em que contexto queremos permitir a alteração de senha. O 
ideal seria permitir alterações de senha apenas quando o alarme estiver 
desligado. Depois de defini-la acima, começo a pensar em como implementar 
essa função de alteração de senha. A função de loop começa escrevendo na 
tela que o alarme está desligado. A variável key_pressed monitora qual 
comando / tecla é pressionado pelo usuário. Se ele pressionar a tecla "#", o 
alarme será disparado, mas você pode adicionar outras condições aqui. 
Comece selecionando a letra "A" no teclado.a funcionalidade de troca de 
senha: 
 
if(techa_pressionada == ‘A’) 
{ 
// chama a sua funcao de troca de senha 
trocarSenhar(); 
} 
 
 
 
 
 
 
 
 
CONCLUSÕES 
 
É possível perceber o quanto a tecnologia recente avançou em termos 
de praticidade, economia e diversidade de recursos, sendo possível 
praticamente qualquer pessoa comprar um kit de desenvolvimento em 
Arduino, aprender como funciona e desenvolver inúmeros projetos. 
Este protótipo permite que você compreenda e controle diferentes 
tipos de componentes e módulos, como monitores LCD 16x2, teclados de 
matriz 4x4, sensores devibração e campainhas. Com esses componentes, 
estamos abertos a uma ampla gama de aplicações com o Arduino. O sistema 
de vigilância apresentado pode ser implementado com vários tipos diferentes 
de sensores, o que pode melhorar o nível de segurança. 
É claro que é preciso um tempo mínimo para se acostumar com a 
programação dos módulos e com a eletrônica e mecânica do projeto como 
um todo. Porém, ao se comparar com dez ou vinte anos atrás, a 
personalização de um projeto desse porte a nível doméstico e com custo 
relativamente baixo é um dos grandes avanços tecnológicos dos nossos 
tempos. Com isso, podemos cada ver mais desenvolver ferramentas para 
nos ajudar em nosso dia a dia, bem como em nossas atividades 
profissionais. 
 
 
REFERÊNCIAS BIBLIOGRÁFICAS 
 
[1] MARCONDES, José Sérgio. Sistemas de alarme e segurança eletronica, 
conceitos e equipamentos. Gestão de segurança provada, [S. l.], p. 12, 10 dez. 
2021. 
 
[2] ARDUINO. Introduction: What is arduino? 2018. Guide. Disponível em: 
<https://www.arduino.cc/en/Guide/Introduction/>. Acesso em: 02 de out. de 
2020; 
 
[3] CREATIVE COMMONS BRASIL. Creative Commons Br, 2020. Página 
Inicial. Disponível em: <https://br.creativecommons.org/>. Acesso em: 02 de 
out. de 2020; 
 
[4] ARDUINO. Arduino Products, 2018. Disponível em: 
<https://www.arduino.cc/en/Main/Products/>. Acesso em: 02 de out. de 2020; 
 
[5] REDAÇAO. Canaltech: O que é open source? 2019. Disponível em: 
<https://canaltech.com.br/produtos/O-que-e-open-source/>. Acesso em: 02 de 
out. de 2020; 
 
[6] PORTAL DO ARDUÍNO (Brasil); PEREIRA, Pedro. Sistema de Alarme 
codificado com sensor de vibracao. Portal do Arduíno, [S. l.], p. 3-15, 25 out. 
2018. Disponível em: http://portaldoarduino.com.br/sistema-de-alarme-
codificado-com-sensor-de-vibracao/. Acesso em: 22 abr. 2021. 
 
[7] MURTA, Gustavo. Eletrogate: Guia básico dos Módulos TX / RX – RF 
433MHZ, 2018. Página Inicial. Disponível em: <https://blog.eletrogate.com/guia-
basico-dos-modulos-tx-rx-rf-433mhz/>. Acesso em: 02 de out. de 2020; 
 
[8] RNT BLOG. Random Nerd Tutorials: Guide for I2C OLED Display with 
Arduino, 2016. Disponível em: <https://randomnerdtutorials.com/guide-for-
oled-display-with-arduino/>. Acesso em: 02 de out. de 2020; 
 
 
[9] ADAFRUIT. Learn Adafruit: Monochrome OLED Breakouts, 2012. 
Disponível em: <https://learn.adafruit.com/monochrome-oled-breakouts>. 
Acesso em: 02 de out. de 2020;