Alarme com Arduino by Arne

Atualmente proteger de alguma forma os bens que com muito trabalho conseguimos conquistar não é uma tarefa fácil, mas com um pouco de criatividade pode ser feita de maneira "doméstica", e o maker pode criar um sistema que avise quando uma invasão a um ponto importante de sua casa acontecer. E que tal se este sistema tiver algumas características bastante interessantes como um sistema de liberação baseado na leitura de Tags RFID, tornando ainda mais difícil a incursão do invasor?! O projeto que apresento neste artigo visa demonstrar como isso pode ser feito utilizando um microcontrolador Arduino e mais alguns componentes.

Abaixo listo as principais características do alarme a ser apresentado nesse artigo:

A figura acima mostra o circuito do Alarme. O componente principal é um Arduino Nano (U1). É ele quem faz a leitura da TAG RFID para liberação ou ativação do alarme, a leitura do sensor da porta/janela e o controle da SIRENE em caso de invasão, do BUZZER usado na ativação/desativação, o controle do LED bicolor e do relé usado para conectar a bateria ao recarregador externo.

O transistor Q1 serve como drive entre o Arduino e a sirene 12VDC/300mA. O resistor R2 serve apenas para criar uma carga no coletor e pode ser retirado do circuito no caso de algumas sirenes. O transistor Q2 controla o buzzer do tipo comum sem oscilador interno. O resistor R4 tem a mesma função que R2, já explicado. Já o transistor Q3 é o drive entre o Arduino e o relé, que serve para ligar/desligar um carregador externo à bateria. O LED3 serve como indicação de que a bateria está sendo recarregada. O LED1 deve ser do tipo bicolor e o mesmo serve como indicação visual do status do alarme: ativado (RED) e desativado (GREEN).

O leitor para a TAG RFID é um módulo leitor RC522 de 13.56MHz, muito comum no mercado especializado em componentes eletrônicos. Esse sensor é o responsável pela leitura da TAG que será utilizada para ativação/desativação do alarme.

O circuito conta ainda com uma fonte de alimentação 5VDC com D1 servindo como proteção contra qualquer inversão de polaridade na entrada. C1, C2 e C3 são capacitores de filtro da fonte. REG1 é um LM317 e os resistores R8 e R9 foram dimensionados para prover na saída de REG1 uma tensão de 5VDC aproximadamente. O LED2 é a indicação visual da presença dos 5VDC no circuito.

A figura acima mostra a o layout da PCI utilizada no meu protótipo. Você poderá, se assim desejar, desenhar o seu próprio layout de circuito impresso ou ainda montar o circuito em uma placa padrão. Para aqueles que desejam apenas testar o circuito ou ainda demonstrá-lo em uma feira ou outro tipo de evento, a montagem poderá ser realizada de forma temporária em uma matriz de contatos.

Sugiro iniciar montando os jumpers. Estes podem ser feitos com pedaços de fio fino rijo ou ainda pedaços de terminais de componentes já utilizados. Em seguida monte os resistores. Os mesmos não são polarizados e você não precisa ter nenhum cuidado a respeito. Mas preste bastante atenção para não trocá-los de posição. Use a lista de materiais caso tenha dificuldades para identificar os valores dos mesmos através do seu código de cores.

Monte os capacitores eletrolíticos tomando cuidado para não trocar valores e também tomando todo cuidado com a polaridade dos mesmos. O mesmo cuidado deve ser tomando com relação aos diodos.

Monte os transistores tomando cuidado para não montá-los invertidos em relação ao indicado no layout. Os LEDs devem ser montados preferencialmente utilizando fios para facilitar sua instalação posterior numa caixa. Cuidado apenas para não inverter Cátodo com Anodo.

O sensor RFID deve ser montado também utilizando fios, para que o mesmo possa ser instalado dentro ou fora da caixa, em uma posição que facilite a aproximação para a leitura da TAG RFID.

O uso ou não de barra de pinos para a entrada do SENSOR e RFID_MC522, além das saídas SIRENE e BUZZER fica por conta de cada um. Cada um destes itens pode ser montados de maneira direta à placa utilizando fios. Note que Q1 é um BC338 com uma corrente de coletor máxima de 500mA. Lembre-se disso ao selecionar a sua sirene. A que utilizei em meu protótipo foi uma de 12VDC/200mA de corrente de operação, 120dB @ 1m e 2,4W. Veja na figura acima.

Com relação a entrada BAT12VDC (bateria) e a saída das chaves do relé CH_ONOFF (carregador), também é possível soldar os fios de maneira direta, dispensando o uso dos conectores do tipo KRE. A figura acima mostra como a bateria e o carregador externo devem ser conectados à placa. O carregador de baterias deve ficar ligado a uma tomada da rede elétrica.

O regulador REG1 requer um dissipador de calor para auxiliar no arrefecimento do mesmo. Um pedaço de perfil de alumínio com medidas entre 30mm x 75mm e 2 ou 3 mm de espessura é o suficiente.

O programa

Abaixo apresento a listagem do programa desenvolvido para o controle do alarme. Você só precisa, antes de gravar seu Arduino, inserir o número da sua TAG dentro da variável tipo string Tag. Substitua os XX XX XX XX pelo valor hexadecimal da sua TAG.

Obs.: Na internet é possível encontrar programas que exemplificam o uso do sensor RFID que permitem ler uma TAG qualquer demonstrando seu valor via monitor da IDE Arduino. Você terá de utilizar um desses programas exemplo ou outro que faça o mesmo para descobrir o ID da TAG que deseja utilizar!

Código fonte principal:

******************************************************************************************
 * Projeto Alarme contra intrusos - Alarme_Intrusos.ino
 * 
 * Testa sensor de porta/janela e em caso de invasão dispara sirene
 * Usa sensor RFID para ativação/desativação do alarme
 * Controla carga da bateria 12VDC
 * 
 * Desenvolvido por: Eng. Márcio José Soares
 * 
 * Editor: Kate
 * Compilador: arduino-cli (linha de comando)
 * 
 * Pinos para Arduino Uno/Nano:
 * 
 * D2  - Sensor (porta e janela)
 * D3  - Sirene
 * D4  - LED live   (vermelho)
 * D6  - LED live 2 (verde)
 * D5  - Buzzer de ACK/NACK para o RFID
 * A0  - analógico para medir a tensão da bateria
 *
 * D9  - RST          \
 * D10 - SS ou SDA    |
 * D11 - MOSI          > Sensor RFID (SPI)
 * D12 - MISO         |
 * D13 - SCK          /
 * 
******************************************************************************************/

/******************************************************************************************
* Arquivos includos no modulo
******************************************************************************************/
#include <EEPROM.h>
#include <SPI.h>
#include <MFRC522.h>
#include <avr/wdt.h>
#include "pitches.h"


/******************************************************************************************
 * Pinos de I/O
******************************************************************************************/
#define SENSOR    2
#define SIRENE    3
#define BUZZER    5
#define LED_LIVE  4
#define LED_LIVE2 6
#define RELECAR   8

#define BATAN     A0

#define PINO_SS   10
#define PINO_RST  9

/******************************************************************************************
 * Definiçoes importantes do módulo
******************************************************************************************/
#define TRUE          1
#define FALSE         0
#define TIMETIMEOUT 20          //       
                         
/******************************************************************************************
 Cria o item para configurar o módulo RC522
******************************************************************************************/
MFRC522 mfrc522(PINO_SS, PINO_RST); 

/******************************************************************************************
 Variáveis globais
******************************************************************************************/
int liberado = 0;                     //alarme acorda sempre ativado!
int liga_sirene = 0;                  //sirene desligada
int LEDliveState = LOW;
int Sirene_state = LOW;

int counter_err = 0;
int counter_inv = 0;
long interval = 100;                 //ms  - tempo para intervalo
long previous = 0;

int count_seg = 0;
int count_min = 0;
int count_hour = 0;

int bat_carrega = 0;

int prima = 0;
int comando = 0;
int complem = 0;

int timeout = 0;
int time_timeout = 0;

float FEscala = 14.50;               //fundo de escala em 14,5V

int melody[] = {
    NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4
};

int noteDurations[] = {
    4, 8, 8, 4, 4, 4, 4, 4
};

String Tag = "XX XX XX XX";         //minha tag
bool erro;

/******************************************************************************************
 Constantes globais
******************************************************************************************/
const int LEDTIME = 5;              //ms  - 500ms   = 5  x 100ms = 500ms
const int TMPINV  = 20;             //ms  - 10000ms = 20 x 500ms = 10s
const int TMPAN   = 10;             //ms  - 5000ms  = 10 x 500ms = 5s

/******************************************************************************************
 Declara funçoes do módulo
******************************************************************************************/
void music_tone(void);
void alerta(void);

bool read_sensor(void);


/******************************************************************************************
 * Setup
******************************************************************************************/
void setup(){
  
    wdt_enable(WDTO_2S);
	
    SPI.begin();                                // Inicializa a comunicação SPI
    mfrc522.PCD_Init();                         // Inicializa o módulo MFRC522
  
    pinMode(SENSOR, INPUT_PULLUP);
    pinMode(SIRENE, OUTPUT);
    pinMode(BUZZER, OUTPUT);
    pinMode(LED_LIVE, OUTPUT);
    pinMode(LED_LIVE2, OUTPUT);
    pinMode(RELECAR, OUTPUT);
	
}

/******************************************************************************************
 * Loop - função principal
 * 
 * Entradas - nenhuma
 * Saidas   - nenhuma
******************************************************************************************/
void loop() 
{
    int timeLED = 0;
    int timeAN  = 0;
    int i, j;
    int porta = 0;
    
    uint16_t valan = 0;
    long current = 0;
    float conv = 0;
    
    digitalWrite(SIRENE, LOW);
    digitalWrite(BUZZER, LOW);
    digitalWrite(LED_LIVE, LOW);
    digitalWrite(LED_LIVE2, LOW);
    digitalWrite(RELECAR, LOW);
	
    delay(1000);

    //le sensor porta
    if(read_sensor() == LOW){                    //porta fechada?!
        liga_sirene = 0;
    }
    else{
        liga_sirene = 1;
    }

    while(TRUE){
         current = millis();                    //  tempo atual em ms
        if((current - previous) > interval){
            previous = current;                 //  salva tempo atual
            
            wdt_reset();                                           
            alerta();				//verifica estado da porta!
			
            timeLED++;
            if(timeLED >= LEDTIME/(1+liga_sirene)){     //  faz a cada 500ms
                timeLED = 0;  
                if(LEDliveState == LOW){               //  troca estado atual do LED            
                    LEDliveState = HIGH;
                }
                else{
                    LEDliveState = LOW;
                }

                if(liberado == 0){
                    digitalWrite(LED_LIVE, LEDliveState);  
                    digitalWrite(LED_LIVE2, LOW);
                }
                else{
                    digitalWrite(LED_LIVE2, LEDliveState);  
                    digitalWrite(LED_LIVE, LOW);
                }
                
                if(timeout == 1){                                   //se autorizado a contar
                    time_timeout++;                                 //incrementa
                    if(time_timeout == TIMETIMEOUT){                //se deu o tempo
                        time_timeout = 0;                           //zera tudo
                        timeout = 0;
                        prima = 0;
                        comando = 0;
                        complem = 0;
                    }
                }
                
            
                if (mfrc522.PICC_IsNewCardPresent()){      // Aguarda a aproximação do token
                    if (mfrc522.PICC_ReadCardSerial()){    // Seleciona qual token vai ser utilizado 
                        String conteudo= "";
                        byte letra;
                        for (byte i = 0; i < mfrc522.uid.size; i++){
                            if(mfrc522.uid.uidByte[i] < 0x10){
                                conteudo.concat(String(" 0"));
                            }
                            else{
                                conteudo.concat(String(" "));
                            }
        		    

                           // Concatena a string convertida em hexadecimal

                           conteudo.concat(String(mfrc522.uid.uidByte[i], HEX)); 
                        }
                        conteudo.toUpperCase();               // coloca todas as letras da string em maiúscula
                        if (conteudo.substring(1) == Tag){    // Verifica se o conteúdo do cartão coincide
                            counter_err = 0;                  // zera contador de erros  
                            liga_sirene = 0;                  // mantem sirene desligada
                            counter_inv = 0;
                            if(liberado == 0){                // alarme estava ativado 
                                liberado = 1;                 // libera sensor
                                EEPROM.write(ADDLIB, 1);
                                EEPROM.write(ADDSIR, 0);      // marca desativada
                                digitalWrite(SIRENE, LOW);
                                digitalWrite(LED_LIVE, LOW);
                                digitalWrite(LED_LIVE2, LOW);
                                music_tone();

                            }
                            else{                              // alarme estava desativado
                                for(int i=0;i<5;i++){          // faz 20 vezes - 10 segundos para sair!
                                    for(int j=0;j<2;j++){      // prepara para ativar
                                        analogWrite(BUZZER, 127);   // toque no buzzer
                                        delay(250);
                                        analogWrite(BUZZER, 60);  
                                        delay(250);
                                        wdt_reset();
                                    }
                                    analogWrite(BUZZER, 0);
                                    delay(500);
                                    wdt_reset();
                                }

                                if(read_sensor() == LOW){
                                    liberado = 0;                  // alarme ativado!
                                    EEPROM.write(ADDLIB, 0);       // marca ativado
                                    EEPROM.write(ADDSIR, 0); 
                                    digitalWrite(SIRENE,HIGH);
                                    delay(100);
                                    digitalWrite(SIRENE,LOW);
                                }
                            }
                        }
                        else{
                            counter_err += 1;                       // incrementa erros
                            if(counter_err >= 10){                  // se chegou a 10 tentativas
                                liga_sirene = 1;                    // ativa alarme, possivel tentativa de invasao
                                counter_inv = 0;
                            }
                        }
					}
				}
            }
            
            if(liga_sirene >= 1){        
		if(counter_inv < TMPINV)                             // se contador  menor               
		   counter_inv++;                                    // dispara contador 
                      
                if(counter_inv >= TMPINV){                           // se tempo  maior que 10s
                     counter_inv = 0;                                // mantem tempo 
                     Sirene_state = HIGH;                            // liga sirene
                     digitalWrite(SIRENE, Sirene_state);
                     porta = 0;
                     if(read_sensor() == HIGH)                       //porta aberta?!
                         porta = 1;
                }
                else{
                }
            }
            else{
                digitalWrite(SIRENE, LOW);
                Sirene_state = LOW;
            }
 
	    if(bat_carrega){                                          //se pediu para carregar a bateria
		count_seg++;                                          //prepara carga lenta por 10 horas
                if(count_seg >= 120){                                 //500ms x 120 = 60s
		    count_seg = 0;                                    //zera segundos
                    count_min++;                                      //incrementa minutos
                    if(count_min >= 60){                              //se contou 59 minutos       
                        count_min = 0;                       
                        count_hour++;                                 //incrementa
                        if(count_hour >= 10){                         //se chegou a 10 horas
                            count_hour = 0;
                            bat_carrega = 0;
                            digitalWrite(RELECAR, LOW);               //desliga rele do carregador                
                        }
                    }
                }
            }
            else{                                     //do contrario apenas verifica se necessario carregar
                timeAN++;
                if(timeAN >= TMPAN){                  //contou 5 segundos
                    timeAN = 0;                       //zera para continuar contando
                    valan = analogRead(BATAN);        //le condicao da bateria
                    if(valan){
                        conv = (float)((float)(FEscala / 1023) * (float)valan);
                        if(conv <= 10.5){                  //se bateria baixa, inicia carga
                            bat_carrega = 1;               //manda carregar a bateria
                            digitalWrite(RELECAR, HIGH);   //liga rele do carregador
                        }
                    }
                }
            }
        }
    }
}

/******************************************************************************************
 * read_sensor - lê situação do sensor da porta
 * 
 * Entradas - nenhuma
 * Saidas   - low ou high (high para aberta, low para fechada)
******************************************************************************************/
bool read_sensor(void){
    
    int val = digitalRead(SENSOR);
    return val;
    
}

/******************************************************************************************
 * Alerta - funçao que responde a int conectada ao sensor de porta e janela
 * 
 * Entradas - nenhuma
 * Saidas   - nenhuma
******************************************************************************************/
void alerta(void){

    if(read_sensor() == HIGH){                  //porta aberta?!
        if(liberado == 0){                      //se var zerada, alarme ativado
            liga_sirene = 1;                    //liga a sirene
            EEPROM.write(ADDSIR, 1);            // marca ativada
        }
    }
}

/******************************************************************************************
 * Music Tone - funçao para tocar "musica" usando a funçao tone
 * 
 * Entradas - nenhuma
 * Saidas   - nenhuma
******************************************************************************************/
void music_tone(void){
    
    for (int thisNote = 0; thisNote < 8; thisNote++) {
        int noteDuration = 1000 / noteDurations[thisNote];
        tone(BUZZER, melody[thisNote], noteDuration);
        int pauseBetweenNotes = noteDuration * 1.30;
        delay(pauseBetweenNotes);
        noTone(BUZZER);
        wdt_reset();
    }
    
}

Código fonte pitches.h:

/*************************************************
* Constantes publicas
*************************************************/
#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978

Montagem final (caixa e outras dicas)

Para a montagem do meu protótipo utilizei uma caixa Patola PB-200, reaproveitada de um outro projeto fora de uso. Para instalar o sensor RFID imprimi uma pequena "tampa" que foi parafusada na parte frontal da caixa Patola (que já havia sido cortada, furada, detonada, etc, no projeto anterior). Essa pequena tampa deu um acabamento bem legal a montagem final salvando a caixa do seu destino certo - a reciclagem!

Não é necessário lembrar que a sirene deve ser instalada de maneira a ficar fora do alcance de um possível invasor e também de maneira totalmente desobistruída para que seu som possa ser ouvido em alto e bom tom! A instalação da sirene na parte externa do ambiente a ser protegido também é possível, desde que a mesma esteja bem protegida contra a chuva e outros problemas e também desde que os mesmos cuidados com relação a sua instalação interna sejam levados em conta.

O sensor por mim utilizado foi do tipo read switch encapsulado (chave magnética) e o mesmo deve ser instalado na porta e/ou janela(s) a serem protegidos. O "plural" aqui é válido, pois apesar de existir apenas uma única entrada para um SENSOR na placa é possível ligar mais de uma "chave" em série (considerando um mesmo ambiente/sala). Assim, seja qual for a porta ou janela aberta o alarme irá disparar! A figura acima mostra o tipo descrito já instalado em uma porta.

Prova e uso

O teste final deste alarme é bem simples e pode ser feito com o mesmo na bancada (preferencialmente) ou já instalado. Grave o programa no Arduino (acho desnecessário ter que dizer isso, mas....). Conecte a bateria 12VDC ao circuito já devidamente carregada. Com o SENSOR fechado (ou seja, com a parte do imã próximo a parte da chave) verifique se o LED bicolor pisca na cor vermelha (o alarme sempre que ligado, inicia ativado!). Se não estiver piscando ou a cor estiver trocada faça as inversões nas conexões do LED bicolor até obter o padrão desejado. Agora passe a sua TAG RFID sobre o sensor RFID e observe o sinal no buzzer (uma melodia será tocada). Imediatamente o LED bicolor deverá piscar na cor verde indicando que o alarme foi desativado. Remova o imã próximo ao sensor e observe que a sirene não disparará, afinal você liberou a "entrada" no ambiente.

Agora passe novamente sua TAG sobre o sensor RFID. Um sinal sonoro permanecerá por um período próximo a 10 segundos. Esse é o tempo que você tem para fechar a porta (ou aproximar o imã do sensor). Após o término do sinal, um breve toque poderá ser ouvido na sirene e o LED bicolor voltará a piscar na cor vermelha indicando a ativação do alarme. Caso a porta não tenha sido fechada até o final do sinal sonoro, o alarme não será ativado e uma nova operação de leitura da TAG deverá ser realizada, com um novo período se iniciando para a ativação do alarme.

Para testar o disparo da sirene, basta "abrir a porta". Nesse momento o LED bicolor começará a piscar bem rápido durante aproximadamente 5s. Se a TAG cadastrada não for aproximada do sensor RFID a sirene irá disparar. Para pará-la, basta aproximar a TAG do sensor RFID. Se a "porta" for aberta e posteriormente fechada, numa tentativa de "enganar" o alarme, a sirene vai disparar da mesma maneira. Faça o teste! Apenas a leitura da TAG correta desativa o alarme!

Conclusão

Como você pôde ver, construir um alarme para um ambiente não é assim tão complicado. Basta ter em mente alguns pontos importantes como a alimentação independente da rede elétrica (para que o mesmo funcione mesmo quando há falta de energia), instalação segura e inteligente das partes (evitando assim que estas sejam destruídas antes/durante a invasão) e principalmente o apoio de visinhos e amigos próximos ao local "vigiado". Estes precisam saber da presença do alarme para caso o mesmo dispare estes possam avisá-lo e/ou a polícia sobre uma possível invasão. Lembrando que o alarme serve para apenas alertar sobre esse fato e não impedir que a invasão aconteça. E nestes casos, você deve sempre chamar a polícia. Nunca, de forma alguma, tente agir por conta própria! Espero ter ajudado de alguma maneira com mais este projeto. Boa montagem e até a proxima!

Downloads:

- Circuito elétrico
- Layout para circuito impresso 1 - desenho não invertido - confecção por transferência térmica
- Layout para circuito impresso 2 - desenho invertido - confecção manual
- Lista de materiais

Especificações:

- Cérebro  : Arduino Nano
- Saídas   : Sirene, buzzer, LEDs e relé
- Senhas   : Dentro da TAG RFID
- Programa : Linguagem C