Trabalho do projeto Arduino. Sistema de alarme de segurança.

Neste artigo, desenvolveremos um projeto real e viável do sistema de alarme de segurança. Você pode adaptar facilmente o dispositivo às suas tarefas e condições.

Este é um análogo do meu desenvolvimento usando o controlador PIC, feito apenas com base na placa Arduino UNO.

Informações gerais sobre o dispositivo.

O alarme de segurança fornece:

• Monitoramento do estado de dois loops de segurança com medição da resistência dos circuitos sensores e filtragem digital dos sinais.
• Controle do dispositivo usando o controle remoto (LED e dois botões):
  • ativação de alarme;
  • desabilitando o alarme usando um código secreto;
  • configuração de um código secreto (o código está contido na EEPROM do controlador).
• Indicação de modo por fonte de luz externa e LED de controle remoto.
• O dispositivo gera os atrasos necessários para fechar as portas da sala e discar o código secreto.
• Quando um alarme é disparado, o dispositivo liga a sirene.

Diagrama de blocos do dispositivo.

Para a unidade de controle de alarme estão conectados:

• 2 loops de segurança padrão com:
  • NÃO – sensores normalmente abertos;
  • NC – sensores normalmente fechados;
  • Rterm – resistores terminais.
• Controle remoto.
• Unidade de indicação externa e alerta sonoro.
• Fonte de alimentação 12 V.
• Fonte de alimentação de reserva.

Modos e controles.

O controle remoto é uma pequena caixa com um LED e dois botões.

É melhor instalar o painel de controle dentro da porta de entrada. Com a ajuda dele, o alarme é ligado e desligado, o código secreto é definido.

Quando a energia é aplicada, o dispositivo entra no modo desabilitado (alarme desligado). O LED remoto não acende. Neste modo, o dispositivo está durante a jornada de trabalho.

O alarme é ativado (modo de segurança) pressionando dois botões simultaneamente. O LED começa a piscar com uma frequência de 5 vezes por segundo e, após 20 segundos, o dispositivo muda para o modo de segurança, ou seja, monitora o status dos sensores de segurança.

É necessário um tempo de 20 segundos para sair das instalações, fechar a porta de entrada.

Se durante este tempo (20 segundos) pressionar qualquer botão do controle remoto, o aparelho voltará ao modo desabilitado. Muitas vezes as pessoas se lembram de algo antes de sair da sala.

20 segundos após ligar, o dispositivo entrará no modo de segurança. Os LEDs do console e da unidade de exibição externa piscam uma vez por segundo, o status dos sensores é monitorado.

Quando algum sensor é acionado, o LED do controle remoto começa a piscar a uma frequência de 5 vezes por segundo, e o dispositivo faz a contagem regressiva após o qual a sirene soará. Este tempo (30 segundos) é necessário para desabilitar o alarme lidando com um código secreto com os botões do controle remoto.

No controle remoto, existem apenas dois botões. Portanto, o código é uma combinação dos números 1 e 2. Por exemplo, o código 2122221 significa que você deve pressionar os botões 2, 1, quatro vezes 2 e 1. O código secreto pode conter de 1 a 8 dígitos.

Se o código foi discado incorretamente, é necessário pressionar 2 teclas do controle remoto simultaneamente e repetir o código.

O código inserido corretamente coloca o dispositivo no modo desabilitado.

Se o código correto não for discado em 30 segundos após o sensor de segurança ser acionado, a sirene será ligada. Você pode desativá-lo lidando com o código correto. Caso contrário, a sirene soará por um minuto e, em seguida, o dispositivo entrará no modo desabilitado.

O código secreto só pode ser definido no modo desativado. Para fazer isso, mantenha pressionados os dois botões do controle remoto por pelo menos 6 segundos. Solte quando o LED do controle remoto acender. Isso significa que o dispositivo mudou para o modo de configuração do código secreto.

Agora você precisa discar um novo código secreto (de 1 a 8 dígitos). A pausa entre os pressionamentos de botão não deve ser superior a 5 segundos. Espere até que o LED apague (mais 5 segundos). O novo código secreto será armazenado na memória não volátil do controlador.

Os status do alarme de segurança estão resumidos na tabela.

O controle de alarme praticamente se resume a duas operações:

• Saindo das instalações – pressione os dois botões do controle remoto ao mesmo tempo e feche a porta.
• Entrando nas instalações – disque o código secreto.

Desenvolvimento do hardware do dispositivo.

Mesmo com toda a versatilidade da placa Arduino, para criar um dispositivo funcional, você precisa adicionar componentes eletrônicos a ele para conectar:

• loops de segurança;
• botões e controle remoto LED;
• sirene e indicação de luz externa
• sistemas de energia.

Considere esses nós em detalhes.

Loops de alarme de segurança.

Os sistemas de segurança usam loops especiais para conectar os sensores. O loop de segurança é uma cadeia de sensores em linha e conectados em paralelo. Vários sensores, normalmente fechados (NC) e normalmente abertos (NO), podem ser conectados a um circuito.

A unidade de alarme monitora a resistência do circuito. Se a resistência for menor que o limite inferior ou maior que o limite superior, o dispositivo gera um alarme. Normal é a resistência do loop fornecida pelo resistor terminal (geralmente 2 kΩ). Se o invasor fechar os fios do loop ou quebrá-los, um alarme será acionado.

Vamos selecionar se os parâmetros do loop.

A resistência do loop na faixa de 540 … 5900 ohms é considerada normal. Quando o valor da resistência do loop excede os limites especificados, um alarme deve ser disparado.

Para que o controlador meça a resistência dos loops, nós os conectamos às entradas analógicas da placa Arduino. O circuito para conectar o loop de segurança é semelhante a este:

O resistor R1 define a corrente do loop. O divisor R2, R3 combina o nível de tensão do circuito com a tensão de entrada da entrada analógica (5 V). Com os valores dos resistores no diagrama, os seguintes valores de tensão de entrada corresponderão à resistência do loop.

O capacitor C1, junto com os resistores, realiza a filtragem analógica do sinal do loop. Para aumentar a imunidade ao ruído do sistema, a filtragem do sinal digital também ocorre no dispositivo.

Botões remotos.

Os botões do controle remoto, bem como os sensores de segurança, são conectados ao controlador com fios longos. Os sinais deles também requerem filtragem analógica e digital para garantir alta imunidade a ruídos e eliminar saltos. Vamos conectar os botões aos pinos digitais da placa: 9 e 10.

Quando o botão está aberto, a tensão de 12 V é limitada a 5 V pelo diodo de proteção interno do microcontrolador.

Indicação externa do modo e sirene.

A sirene e a fonte de luz para indicação externa do modo podem exigir correntes significativas para alimentação. Além disso, eles são conectados ao controlador com fios longos. Portanto, interruptores de transistor são necessários para controlar esses elementos. Aqui está um diagrama de uma chave para corrente de até 2 A.

O resistor R12 limita a corrente de base do transistor. Os diodos protegem o transistor da emissão de um sinal de uma longa linha de comunicação durante a comutação.

Sistema de abastecimento.

O dispositivo é alimentado por uma fonte de alimentação de 12 V. Esta tensão é adequada para alimentar a placa Arduino e a sirene. Para conectar a bateria de reserva, você pode usar um circuito simples de dois diodos

Como díodo para a alimentação principal, utiliza-se o díodo Schottky (VD1). Isso garante a prioridade da fonte de alimentação quando a tensão de saída for igual à tensão da fonte de alimentação de backup.

Circuito de alarme de segurança baseado na placa Arduino UNO R3.

Montei o sistema no ProtoBoard. Em vez dos interruptores do transistor, coloquei os LEDs. Nesse layout, você pode depurar totalmente o programa e, em seguida, criar uma versão funcional do dispositivo.

O desenvolvimento do programa.

Em primeiro lugar, incluímos bibliotecas, atribuímos pinos de controlador, criamos objetos, variáveis com as quais trabalharemos:

• dois botões remotos;
• interrupção do temporizador;
• blocos de software para leitura de entradas analógicas para loops e média de seus valores.

Como resultado, temos as seguintes variáveis com as quais trabalharemos:

• sinais do estado dos botões do controle remoto:
  • button1.flagPress;
  • button1.flagClick;
  • button2.flagPress;
  • button2.flagClick;
• valores médios medidos da tensão nas saídas dos loops:
  • averageShleif1;
  • averageShleif2.

Para verificação, enviamos o estado dessas variáveis por meio de uma porta serial para um computador.

// alarme de segurança
#include <MsTimer2.h>
#include <Button.h>
#include <avr/wdt.h>

// atribuição de pino
#define BUTTON_1_PIN 9  // botão de controle remoto 1
#define BUTTON_2_PIN 10 // botão de controle remoto 2
#define LED_PIN 11    // LED remoto e indicação externa
#define SIREN_PIN 12  // sirene está conectada ao pino 12
#define SHLEIF_1_PIN A0 // loop 1
#define SHLEIF_2_PIN A1 // loop 2

Button button1(BUTTON_1_PIN, 25); // cria um botão de objeto 1
Button button2(BUTTON_2_PIN, 25); // cria um botão de objeto 2

unsigned int sumShleif1, sumShleif2; // variáveis para somar códigos ADC
unsigned int averageShleif1, averageShleif2; // soma dos códigos ADC (tensão média dos loops * 50)
int averageCount; // Contador de média para códigos ADC (tensão de loop)
int serialCount;    // contador para transferência de dados de depuração via UART
void setup() {
  pinMode(LED_PIN, OUTPUT);      // saída LED
  pinMode(SIREN_PIN, OUTPUT);    // saída da sirene
  
  MsTimer2::set(2, timerInterrupt); // período de interrupção do temporizador 2 ms
  MsTimer2::start();                // habilita a interrupção do cronômetro

  Serial.begin(9600); // inicializa a porta, taxa 9600
  wdt_enable(WDTO_15MS); // habilita o cronômetro de watchdog, tempo limite de 15 ms
}

void loop() {

  // transferir dados de depuração via UART
  // a cada 500 ms
  if ( serialCount >= 250 ) {

    // estado dos botões
    if ( button1.flagPress == true ) Serial.print("Btn1 -_- ");
    else Serial.print("Btn1 _-_ ");
    if ( button2.flagPress == true ) Serial.print("Btn2 -_- ");
    else Serial.print("Btn2 _-_ ");

    // tensão de loops
    Serial.print(" Shleif1= ");
    Serial.print( (float)averageShleif1 * 0.000097656, 2);
    Serial.print(" V");
    Serial.print(" Shleif2= ");
    Serial.print( (float)averageShleif2 * 0.000097656, 2);
    Serial.println(" V");    
    // * 0.000097656 = / 50. * 5. / 1024.            
  }
}

// manipulador de interrupção, 2 ms
void  timerInterrupt() {
  wdt_reset();  // zera o cronômetro de watchdog

  button1.filterAvarage();  // chama o método de filtragem do sinal do botão 1
  button2.filterAvarage();  // chame o método de filtragem do sinal do botão 2

  // leia o ADC e calcule a média dos valores de tensão dos loops
  // como resultado averageShleif = tensão média do circuito * 50 
  averageCount++;  // +1 contador de média
  sumShleif1 += analogRead(SHLEIF_1_PIN);  // soma dos códigos ADC
  sumShleif2 += analogRead(SHLEIF_2_PIN);  // soma dos códigos ADC

  // verifique o número de amostras de média (50)
  if ( averageCount >= 50 ) {
    averageCount= 0;
    averageShleif1 = sumShleif1; // sobrecarga média 
    averageShleif2 = sumShleif2; // sobrecarga média
    sumShleif1 = 0;
    sumShleif2 = 0;
    }

  serialCount++; // contador para transferência de dados de depuração via UART
}

Carregue o programa na placa. Inicie o monitor de porta. Verificando:

• Pressionando cada botão.
• Conectamos em vez de cada loop um resistor variável (por exemplo, com uma resistência de 10 kΩ). Meça a tensão nas entradas analógicas correspondentes da placa com um voltímetro. Verifique se a medição das tensões nas saídas dos loops está correta.

Em seguida, pensamos na estrutura do programa. As variantes podem ser diferentes. Eu escolho isso.

Crie uma variável – modo, que determina o modo atual do programa. Modos de configuração:

Crie no loop infinito uma construção para alternar para o modo desejado.

if (mode == 0) {
  // ALARME ESTÁ DESATIVADO
}  else if (mode == 1) {
  // CONFIGURAR PARA O MODO DE SEGURANÇA
}  else if (mode == 2) {
  // SEGURANÇA
}  else if (mode == 3) {
  // LOCK
}  else if (mode == 4) {
  // ALARME
}  else if (mode == 5) {
  // DEFINA O CÓDIGO
} else mode = 0;

Para mudar para outro modo, basta alterar o valor do modo variável.
Adicione no modo de dados de depuração.

// mode
Serial.print ("Mode ="); Serial.print (mode);

Agora preencha os blocos – modos.

Todos os blocos de software eu explico em detalhes nos comentários do programa. Ao preencher cada bloco, você pode baixar o programa para o quadro e conferir. É melhor depurar cada bloco separadamente, sem esperar que os erros se acumulem. Por exemplo, você pode adicionar um módulo “transição para o modo de instalação no alarme”, carregue na placa e verifique se pressionando dois botões ao mesmo tempo, o programa muda para o modo 1. E não responde ao pressionar um botão. Para isso criamos um bloco de transferência de dados de depuração para um computador.

Em seguida, adicionamos o bloco “mudar para configuração de código (segurar longamente dois botões)” e novamente verificamos se o programa vai para o modo 5 enquanto mantemos ambos os botões pressionados por 6 segundos. E assim, gradualmente, depure todo o programa.

Aqui está o sketch completo do programa: (Aqui)

Carregue o programa no quadro. Tudo está funcionando bem para mim.

Conclusão

Neste artigo, mostrei como criar um sistema de alarme, simples usando o Arduino. Espero que você tenha achado útil e informativo. Se sim, compartilhe com um amigo que também gosta de eletrônica e de fazer coisas!

Eu adoraria saber quais projetos você planeja construir (ou já construiu) com esse Projeto de Alarme. Se você tiver alguma dúvida, sugestão ou se achar que falta algo neste tutorial, por favor, deixe um comentário abaixo.