PROJETO ALARME SEM FIO - ARDUINO (OPEN SOURCE)

Pessoal , estou lançando esse novo projeto open source, isto é, quem quiser ajudar será bem vindo.

Todos terão acesso á todo projeto, portanto cada um poderá montar o seu.

Depois de desvendar o funcionamento de controle remoto sem fio no Lab de Garagem, agora já é possível começar o projeto.

http://labdegaragem.com/forum/topics/desvendando-controle-remoto-rf

Esse diagrama em blocos que eu fiz é uma idéia inicial. Quando sugerir alguma coisa, especifique de qual bloco esta tratando, para facilitar a compreensão de todos.

Módulo de recepção RF :

A frequência que usarei é a de 433,92 MHz - a mais comum. Mas nada impede de usar outra frequência, desde que o receptor, os sensores e o controle remoto sejam da mesma frequência.

O sistema de codificação que usarei é o do chip Encoder HT6P20B. 

Data sheet :http://www.holtek.com.tw/pdf/consumer/6p20v170.pdf

Selecionei esse, pois existem inúmeros sensores e controles remotos que usam esse chip.

Vejam no tutorial mencionado acima, para entender como ele funciona.

Módulo RTC :

Usando o chip DS1307 - muito comum. Será usado para registro de log, isto é, todas a operações realizadas pelo Arduino serão registradas com horário. Exemplo: Alarme ativado, alarme disparado, sensor ativado, etc. Esses arquivos de log serão gravados no Módulo SD CARD.

Painel - Botões :

Painel de controle do Alarme, podendo ter botões, como aprender sensor, aprender controle remoto, etc. Se necessário, poderá ter um teclado numérico para digitação de senha e ou  de configurações.

Módulo Sirene:

Seria interessante inovar na sirene, como usar sons personalizados. 

No início poderá ser usada uma sirene comum.

Módulo Display LCD:

Para mostrar status do alarme, horário, configuração e disparos, etc

Interface WEB / GSM:

O objetivo é enviar email ou então mensagem SMS, avisando o proprietário que o alarme foi disparado. Informando qual sensor e qual horário foi acionado.

Seria muito bom também se o proprietário pudesse remotamente ativar ou desativar o alarme  e verificar o status do mesmo. 

Fonte / Bateria:

Fonte de alimentação do Alarme e da Sirene. Uma bateria de backup é essencial.

O projeto esta lançado. Aos poucos acrescentarei mais informações.

Agradeço antecipadamente a todos que desejarem fazer contribuições para o projeto.

Sempre quis gerenciar um projeto OPEN SOURCE, e esta vai ser uma nova oportunidade.

Open Source (Código Aberto):

http://pt.wikipedia.org/wiki/C%C3%B3digo_aberto

Gustavo Murta (BH) .

Exibições: 59391

▶ Responder esta

Respostas a este tópico

Permalink Responder até Eduardo castellani em 13 julho 2015 at 8:32

é, as vezes sou mal entendedor. kkk

Permalink Responder até Eduardo castellani em 12 julho 2015 at 22:57
Permalink Responder até José Gustavo Abreu Murta em 23 abril 2014 at 23:54

Erick , veja esse Sketch como exemplo.

Talvez seja a solução para resolver o problema do Delay junto com a interface I2C:

uso do cli() e do sei()

http://themakersworkbench.com/content/tutorial/reading-pc-fan-rpm-a...

//code by Crenn from http://thebestcasescenario.com
//project by Charles Gantt from http://themakersworkbench.com

/*To disable interrupts:
cli();                // disable global interrupts

and to enable them:  
sei();                // enable interrupts
*/

                                   //Varibles used for calculations
int NbTopsFan; 
int Calc;

                                  //The pin location of the sensor
int hallsensor = 2;

                        
typedef struct{                  //Defines the structure for multiple fans and their dividers
  char fantype;
  unsigned int fandiv;
}fanspec;

//Definitions of the fans
fanspec fanspace[3]={{0,1},{1,2},{2,8}};

char fan = 1;   //This is the varible used to select the fan and it's divider, set 1 for unipole hall effect sensor 
               //and 2 for bipole hall effect sensor

void rpm ()      //This is the function that the interupt calls 
{ 
NbTopsFan++; 
}

              //This is the setup function where the serial port is initialised,
             //and the interrupt is attached
void setup() 
{ 
pinMode(hallsensor, INPUT); 
Serial.begin(9600); 
attachInterrupt(0, rpm, RISING); 
} 
void loop () 
{
   NbTopsFan = 0; //Set NbTops to 0 ready for calculations
   sei(); //Enables interrupts
   delay (1000); //Wait 1 second
   cli(); //Disable interrupts
   Calc = ((NbTopsFan * 60)/fanspace[fan].fandiv); //Times NbTopsFan (which is apprioxiamately the fequency the fan is spinning at) by 60 seconds before dividing by the fan's divider
   Serial.print (Calc, DEC); //Prints the number calculated above
   Serial.print (" rpm\r\n"); //Prints " rpm" and a new line
}

Permalink Responder até Paulo souza em 3 agosto 2014 at 20:45

boa noite,

amigo estou usando seu codigo fiz umas modificações e ta tudo ok.

minha duvida e tem como colocar o alarme pra sempre ficar armado 24 horas monitorando o sensor.

da umas dicas aew se poder.

brigado

Permalink Responder até José Gustavo Abreu Murta em 3 agosto 2014 at 21:32

Paulo , claro que tem possibilidade de ficar armado o tempo que desejar.

Esse é o objetivo de todo alarme.

Depois que ativa-lo, ele poderá disparar com um sensor ou ser desativado pelo usuário.

Permalink Responder até Paulo souza em 3 agosto 2014 at 22:39

entendi mais minha duvida e quero que ele arma sozinho sem precisar eu ativar, quando ligar o arduino  ele armar automático, se alguém passar pelo sensor ele disparar.

tem como?

Permalink Responder até José Gustavo Abreu Murta em 4 agosto 2014 at 6:00

Claro que sim.

Como eu disse, o alarme pode ser ativado em qualquer momento.

Se acrescentar um relógio (RTC timer) ao Arduino, pode programar o horário de ativação ou desativação.

Ou então programa-lo para ativação do alarme, quando o Arduino for ligado.

Qual Sketch esta usando?

Permalink Responder até Paulo souza em 4 agosto 2014 at 8:48

Estou usando esse Open Source

/*
ALARME ARDUINO - OPEN SOURCE - Versão 01_2014
CRIADO POR: Gustavo Murta
DATA: 02/02/2014
USANDO ARDUINO 2009 - Versão 1.05
E-MAIL: jgustavoam@gmail.com
Permitido o uso público, mas deve-se manter o nome do autor.
*/
//Declaração das variáveis referentes às entradas e saídas do Arduino 2009

int SensorSF = 4;
int Controle_remoto = 3;
int Led_Verde = 6;
int Led_Verm = 7;
int Apito = 8;
int Sirene = 5;
int valor_SensorSF = 1;
int valor_Controle_remoto = 1;
unsigned int tempo_apito = 0;
boolean Alarme_ativado = false;
int i = 0;

void setup()
{
Serial.begin(9600); //Inicializando o monitor serial

//Definindo pinos como entrada ou saída

pinMode(SensorSF,INPUT);
pinMode(Controle_remoto,INPUT);
pinMode(Led_Verde,OUTPUT);
pinMode(Led_Verm,OUTPUT);
pinMode(Apito,OUTPUT);
pinMode(Sirene,OUTPUT); // Led Azul simulando a Sirene

// Inicialização do Alarme

digitalWrite(Led_Verde, LOW); // Led Verde aceso = Alarme Operacional
digitalWrite(Led_Verm, !Alarme_ativado); // Led Vermelho apagado = Alarme Desativado
digitalWrite(Sirene, HIGH); // Sirene desativada (Led Azul)
noTone(Apito); // Desliga o apito
Serial.println("Alarme Operacional ");

// Aguardando a ativação do alarme, através do controle remoto

do
{
delay(50); // Atraso para aguardar Controle Remoto
valor_Controle_remoto = digitalRead(Controle_remoto);
} while (valor_Controle_remoto != 0); // Loop até o controle remoto ser acionado

Serial.println("Alarme Ativado");
Alarme_ativado = !Alarme_ativado; // Ativa o bit de Alarme Ativado
digitalWrite(Led_Verm, !Alarme_ativado); // Acende o led vermelho = Alarme Ativado
Buzzer(200); // um Bip

}

// Função Apito (Buzzer)

void Buzzer(unsigned int tempo_apito)
{
tone(Apito,4000); // Ligando o Apito com uma frequencia de 4000 hz.
delay(tempo_apito); // Duração do Apito
noTone(Apito); // Desliga o apito
}
// Função de monitoramento dos Sensores sem fio

void Monitor_SensorSF()
{
valor_SensorSF = digitalRead(SensorSF);
if (valor_SensorSF == 0 && Alarme_ativado == 1){ // Somente dispara se o Alarme estiver ativado
Serial.println("Sensor sem fio acionado");
dispara_Alarme() ;
}
}

// Função de verificação do estado do Controle Remoto

void CR_acionado()
{
valor_Controle_remoto = digitalRead(Controle_remoto); // Verifica se Controle remoto foi acionado
}

// Função de monitoramento do Controle Remoto

void Monitor_CR()
{
CR_acionado();
if (valor_Controle_remoto == 0)
{
Alarme_ativado = !Alarme_ativado; // Controle remoto foi acionado
Serial.print("Controle remoto acionado = ");
if (Alarme_ativado == 1)
{
Serial.println("Alarme ativo");
digitalWrite(Led_Verm,!Alarme_ativado);
Buzzer (200); // Um Bip
} else {
desliga_Alarme();
}
}
}

// Função de Disparo do Alarme

void dispara_Alarme()
{

Serial.println("Alarme disparado - acione o controle remoto em 120 segundos para cancelar");
for (int i=0; i<120; i++) // tempo de espera para cancelamento do acionamento da Sirene
{

digitalWrite(Led_Verm, LOW); // Acende o led vermelho
Buzzer(200); // Duração do Apito = 200 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }

digitalWrite(Led_Verm, HIGH); // Apaga o led vermelho
delay(200); // Atraso de 200 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }

digitalWrite(Led_Verm, LOW); // Acende o led vermelho
Buzzer(400); // Duração do Apito = 400 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }

digitalWrite(Led_Verm, HIGH); // Apaga o led vermelho
delay(200); // Atraso de 200 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }
}
dispara_Sirene();
}

void dispara_Sirene()
{
digitalWrite(Sirene, HIGH); // Liga a Sirene (Led Azul)
Serial.println("Sirene ligada");

for (int i=0; i<120000; i++){ // Tempo que a Sirene ficará ligada

digitalWrite(Led_Verm, LOW); // Acende o led vermelho
Buzzer(100); // Duração do Apito = 100 ms

CR_acionado();
if (valor_Controle_remoto == 0){ break; }

digitalWrite(Led_Verm, HIGH); // Apaga o led vermelho
delay(100); // Duração do Apito = 100 ms

CR_acionado();
if (valor_Controle_remoto == 0){ break; }
}
Alarme_ativado = !Alarme_ativado;
desliga_Alarme();
}

// Função de desativação do Alarme

void desliga_Alarme()
{
digitalWrite(Sirene, LOW); // Desliga a Sirene (Led Azul)
Serial.println("Alarme desativado");
Buzzer (100); // Dois bips
delay(100);
Buzzer (100);
noTone(Apito); // Desliga o apito
digitalWrite(Led_Verm,!Alarme_ativado); // Led Vermelho apagado = Alarme Desativado
}

void loop()
{
Monitor_CR();
Monitor_SensorSF();
}

ESSE DAQUI MUDEI A PARTE DE CONTROLE DE SIRENE E TIME DE ESPERA PARA RECONHECIMENTO!!

quero deixar ele sempre ativo ligando o Arduíno ele já esteja pronto monitorando sensor,sem precisar de acionamento do controle remoto.

agora se o sensor for aberto ele conta 2 minutos esperando o cancelamento, isso ta joia.

Obrigado desde ja.

Permalink Responder até José Gustavo Abreu Murta em 4 agosto 2014 at 23:17

Luis obrigado pelas sugestões!

Fique à vontade para acrescentar ideías no projeto.

Permalink Responder até Rogerio A. Filho em 4 agosto 2014 at 23:19

Você pode criar uma API.. que você cadastra no servidor os dados para enviar o email, e gera um TOKEN.

no arduino vc faz um GET com o Token e texto para enviar o email. :)

Permalink Responder até Rogerio A. Filho em 4 agosto 2014 at 23:29

ficaria +/- assim

GET URL_SITE.com/?TOKEN=1234&msg=TEXTO DA MENSAGEM&assunto=assunto

um script em PHP pode simplesmente pegar esses dados e enviar o email.

Permalink Responder até Erick Eden Fróes em 5 agosto 2014 at 0:08
E ai amigos..quanto tempo..como anda o projeto? Eu tive uma monte de contrat tempos e fiquei sem net, mudei de ap, minha filha nasceu e minhas encomendas chegaram no mes 07(desde o mes 03)

Vou retornar o projeto...

abraços

RSS

Destaques

Registre-se no Lab de Garagem
clicando aqui

Convide um amigo para fazer parte

curso gratis de arduino

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço