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: 59373

Responder esta

Respostas a este tópico

Julio, esse projeto é sobre alarme residencial com sensores sem fio. 

Abraços 

Gustavo Murta

Pessoal, hoje estou divulgando o primeiro protótipo do Alarme Arduino sem fio - Open source.


Essa montagem eu fiz baseando nas ligações do diagrama que postei anteriormente.

Para simplificar o programa Sketch principal que controla o Alarme, simulei o Sensor sem fio e Controle remoto

através de dois botões - o da esquerda corresponde ao acionamento de um Sensor sem fio.

E o botão da direita simula o acionamento do controle remoto RF. 

O Led verde indica que o Alarme esta operacional, isto é, pronto para ser ativado.

O Led vermelho indica que o Alarme esta ativado e quando piscando esta disparado - algum sensor de intrusão  foi acionado.

E o Led azul simula o acionamento da Sirene do Alarme - para evitar barulheira durante os testes.

 

Esse é o vídeo explicando algumas operações do Alarme:

 

E esse é o Sketch - Programa Protótipo Versão V01_2014.  Anexei o arquivo INO.

 

Tenho que fazer alguns melhoramentos e correções. Estou ainda aprendendo a programar  Sketch.

Acho que terei que usar interrupções para verificar o acionamento do Sensor e do Controle remoto.

Tenho que estudar isso.

 

Sugestões, correções são bem vindas. 

Espero que gostem e que seja útil para alguém. 

Esse projeto esta sendo muito bom para mim. Tenho aprendido muita coisa!

 

/*
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 = 2;
int Controle_remoto = 3;
int Led_Verde = 8;
int Led_Verm = 9;
int Apito = 10;
int Sirene = 11;
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 5 segundos para cancelar");
for (int i=0; i<5; 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, LOW); // Liga a Sirene (Led Azul)
Serial.println("Sirene ligada");

for (int i=0; i<20; 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, HIGH); // 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();
}

 

Anexos

Gustavo, este LED indicando se o sistema está operacional já obtive diversos problemas no passado, pois em algum determinado tempo meu sistema travava e eu não podia identificar este problema a partir do LED. Pensando neste problema fiz algo bem simples em meu código que foi fazer o LED ascender no inicio do código e apagar no final, sempre dando um Blink without delay de 1s, foi muito útil para detectar possíveis travamentos, espero que lhe ajude, estou ansioso pelo projeto.

Raphael, valeu pela dica!

Estou no momento programando o Sketch desse Alarme, implementando as rotinas do Decoder que o Afonso Turcato criou.

Já consigo ativar e desativar o alarme com o controle remoto! Estou aprendendo muito sobre a programação Sketch do Arduino. Já fiz alguns testes usando a interrupção externa dos pinos D2 e D3.

Mas tenham paciência, pois estou de férias e amanhã estarei viajando.

E só voltarei na próxima semana...

 

Estou tendo uma grande dificuldade para "parear" meu controle da garagem com o arduino.

Já estudou o tutorial? Você já sabe qual chip é usado no seu controle remoto?

Informe qual chip é.

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

Aguarde o programa que em breve disponibilizarei, com os avanços no projeto.

José Gustavo.

Parabéns pelo projeto.

Você já definiu como incluir uma bateria externa?

Fiz um projeto de automação residencial e gostaria de incluir um alarme junto utilizando o Arduino Mega.

Paulo, não cheguei ainda nessa etapa da bateria.

Mas com certeza usarei uma de 12V de chumbo acido, por ser mais comum e talvez mais acessível.

Pode acionar o Arduino, Raspberry Pi, sirene e outros circuitos.

A principio um circuito básico assim.

Mas pode ser mais sofisticado como indicação da voltagem da bateria, um carregador mais eficiente, etc.

Carregador bateria 12V :

Obrigado José Gustavo, vou dar uma olhada nesse esquema. 

Realmente deve resolver.

Abraço.

Esse circuito não é a melhor opção.

Na verdade nem sei se funciona direito - pesquisei no google.

A tensão de carga de uma bateria de 12V (chumbo-acido) tem que ser 13,8V.

Foi o que eu imaginei, ai terá até menos de 12V devido ao diodo zener

Bom dia caro Sr. José Gustavo,

Sobre a decodificação  do HT6P20B para arduino.

O código original fui eu quem o criei, porem o nome do autor não está constando nos seus projetos.

Favor corrigir esse erro.

Atenciosamente:

Jacques Daniel Moresco.

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço