arduino, eletrônica, robotica...
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) .
Respostas a este tópico
-
Permalink Responder até José Gustavo Abreu Murta em
-
Ok Jacques!
Eu colocarei o seu nome e do Afonso Turcato.
O Turcato fez algumas alterações.
Muito obrigado aos dois !
Em breve teremos avanços no projeto.
-
-
Estou com uma dúvida cruel !
Tenho feito testes com as rotinas de decoder do HT6P20B (Afonso Turcato/Jacques Moresco) .
Já consigo ativar e desativar o alarme com o controle remoto.
As mesmas rotinas deverão ser usadas para identificar as operações do controle remoto e dos sensores sem fio.
Não estou conseguindo ver como implementar essas rotinas para gerarem interrupções no Arduino.
Acho melhor usar interrupções do que ficar fazendo varreduras.
Imagino que enquanto o Alarme estivesse executando alguma operação, se um sensor sem fio tentasse disparar o alarme, poderia haver alguma falha no disparo do alarme.
Estava pensando em usar um ATmega 85 dedicado como escravo do Arduino Alarme.
Ele ficaria monitorando e descodificando os sinais recebidos (eu estava escrevendo errado - decodificando).
Quando um sinal for descodificado, ele acionaria uma interrupção externa no Arduino Alarme.
Assim o Arduino Alarme analisaria o código do controle remoto ou do sensor sem fio.
A transmissão dos dados entre o Atmega85 e o Arduino pode ser uma simulação de I2C.
O que acham ? Sugerem algo?
Obrigado.
-
-
O trasmissor de código ( Encoder - controle remoto ou Sensor dem fio) demora aproximadamente 42 milisegundos para enviar o código.
O código Pilot dura aproximadamente 115 milisegundos.
Portanto a cada 200 ms aproxidamente, é possível que ocorra a recepção de um novo código pelo receptor de RF.
Assim é necessário um loop de varredura (scan) nesse intervalo, para que o Arduino possa detectar um código.
Por isso, estou pensando nesse ATmega escravo para somente descodificar os sinais recebidos.
-
Permalink Responder até Afonso Celso Turcato em
-
Interessante a ideia de usar um ATmega 85 dedicado ao recebimento dos sinais dos sensores. Parece ser uma boa saída!
E no momento não sei afirmar qual considero a melhor. Analisando os prós e contras eu fico em cima do muro! rs.
Meu, essa palavra "descodificando/descodificado" pode até ser a correta, mas é bem estranha neh? Sempre li/escrevi "decodificar" na minha vida... rs.
T+
-
-
Obrigado Turcato!
Vou tentar gravar um ATTiny 85 com algumas rotinas de teste.
A unica restrição é que a memória Flash do mesmo só tem 8K bytes.
Achei esses links muito bons - ensinam a gravar um Sketch diretamente em um ATmega ou ATtiny:
Make an Arduino into ISP programmer
http://letsmakerobots.com/node/35649
Programming a Target AVR using Arduino Uno board loaded with ArduinoISP
-
Permalink Responder até Raphael afonso em
-
Creio que se o sensor deveria enviar o sinal a todo instante ou com uma determinada pausa, por que enviando apenas quando há mudança de status você pode acabar tendo 1 perda de sinal e possivelmente "bugar" todo o sistema.
-
-
Raphael,
Se por exemplo pressionar o botão do controle remoto, ele fica retransmitindo o código, com alguns intervalos. Vou medir esses intervalos.
Não entendi bem a sua colocação. Mas acho que esta falando do circuito que vai detectar se um código válido foi recebido, não é ?
Esse circuito (talvez um ATtiny 85) quando receber um código válido vai gerar uma interrupção no Arduino Alarme.
Quando o Arduino Alarme receber a interrupção, ele para de executar as rotinas que estava executando e vai processar uma outra rotina que vai conferir o código e verificar se foi enviada pelo controle remoto ou por algum sensor sem fio.
Obrigado pelo apoio.
-
-
Medi o sinal enviado pelo Sensor sem fio , com o Analisador Lógico Arduino:
Quando o imã aciona o sensor ,são transmitidos aproximadamente 10 vezes o mesmo código do sensor, (duração aproximada de 0,5 segundos) - isso é muito bom pois prolonga o tempo de captura.
Cada código transmitido (como eu já tinha dito) dura aproximadamente 42 milisegundos,
E o intervalo entre as repetições é de aproximadamente 10 milisegundos
-
Permalink Responder até Guilherme Spadaccia em
-
José, a algum tempo ja queria colocar um alarme aqui em casa, e como fazer um é muito mais legal do que comprar comecei um projetinho aqui pra uma central de alarme sem fio. Se você se interessar podemos compartilhar algumas coisas.
Fiz um vídeo bem rápido mostrando o projeto mas ele está desatualizado, depois desse vídeo inclui um dalay entre a ativação do alarme (pra poder sair de casa sem a sirene tocar) e do acionamento (pra poder desativa-lo quando entrar).
-
-
Guilherme , a ideia principal do Alarme Arduino sem fio é essa mesmo.
Mas além do alarme sem fio, pretendemos ter um monitoramento remoto - pela internet ou através de mensagens SMS.
Parece que usou um outro circuito para descodificar o sensor ?
É isso ?
Nesse projeto OPEN SOURCE, a descodificação será realizada pelo próprio alarme.
Fique a vontade para contribuir nesse projeto.
Será muito bem vindo.
Obrigado.
-
Permalink Responder até Guilherme Spadaccia em
-
José, utilizei o mesmo circuito tanto pra fazer a leitura quanto pra acionar o alarme.
A leitura do HT6P20B foi feita, se não me engano, por esse fonte: https://www.dropbox.com/s/5jf34olfjmkc2zj/RF_HT6P20B.zip .
O que eu mudava era o estado do arduino.
1º estado: Arduino aguarda ativação do alarme.
Se ativado entra no 2º estado.
2º estado: Aguarda a desativação ou recepção de um sinal válido.
Se for desativado volta ao 1º estado.
Se receber um sinal valido vai para o 3º estado
3º estado: Caso o alarme tenha sido ativado aguarda desativação
Se for desativado volta para o 1º estágio
Também pretendo incluir controle via Web e via Celular, mas estou pensando em como fazer a parada.
Chegando em casa hoje compartilho meu fonte com vocês.
Abraços.
-
Permalink Responder até Guilherme Spadaccia em
-
Como prometido segue o fonte.
Eu fiz esse fonte depois de muuitos testes, então podem conter aluns erros, e pode ser que esse não seja o melhor modo de ler um aparelho HT6P20B, mas foi uma forma que encontrei.
/*
* Projeto: Central de Alarme v1.1
* Nome: Guilherme Spadaccia
* Data: 20/02/2014
* Utilizados fontes de: PAUL BADGER, 2008 e JACQUES DANIEL MORESCO, 2012
* Fonte criado para ser utilizado com o Arduino Uno R3 para montagem de uma central de alarme.
*///variaveis usadas no leitor de RF
int x,startbit,ctr,dataok,t1,larpulso,larpulso1,larpulso2,larpulso3,larpulso4,bt1,bt2,antcode=0;
unsigned long _data=0; // DATA é o Código recebio do HT6p20 todos os 28 BITS onde, 22 do coodigo+2 dos botões+4 do anti-codigo;
unsigned long _dur,_dur1; // Duração do Pulso
unsigned long bkpTempo1;
unsigned long bkpTempo2;
byte _pin; // Pino que vai receber o sinal RF digital.
byte _compar1[] = {1,0,1,0,1,1,1,1,1,1,1,0,0,1,0,1,0,1,0,1,0,1,0,1,1,0,0,1,0};
byte _compar2[] = {1,0,1,0,1,1,0,1,0,0,1,1,0,0,0,1,1,1,0,1,1,0,0,1,0,1,0,1,0};
boolean ret = false;
int botao1 = 3;
int botao2 = 4;
boolean stat = false;
int numMax = 0;
//long intervalo1 = 60000;
long intervalo1 = 10000;
long intervalo2 = 5000;void setup()
{
pinMode(botao1, INPUT);
digitalWrite(botao1,LOW);
pinMode(botao2, INPUT);
digitalWrite(botao2,LOW);
_pin=10;
Serial.begin(9600);
pinMode(_pin, INPUT);
pinMode(13, OUTPUT);
pinMode(12,OUTPUT);
digitalWrite(13,LOW);
}void loop()
{
if (LeTeclado()){
if(millis()-bkpTempo1 > intervalo1){
if (LeSensor()){
if(millis()-bkpTempo2 > intervalo2){
digitalWrite(12,HIGH);
}
}
}
}
}boolean LeTeclado(){
if (!stat){
if(digitalRead(botao1) == HIGH){
digitalWrite(12,HIGH);
delay(200);
digitalWrite(12,LOW);
stat = true;
ret = false;
bkpTempo1 = millis();
}
}else{
if(digitalRead(botao2) == HIGH){
digitalWrite(12,LOW);
delay(200);
digitalWrite(12,HIGH);
delay(200);
digitalWrite(12,LOW);
delay(200);
digitalWrite(12,HIGH);
delay(200);
digitalWrite(12,LOW);
stat = false;
ret = true;
}
}
return(stat);
}boolean LeSensor(){
byte bytes;
char myChar;
if (!ret){
digitalWrite(13, digitalRead(_pin)); //Pisca o LED conforme o valor da entrada digital, testar interferencias.
if (startbit==0)
{// Testa o tempo piloto até o Bit de inicio;
_dur = pulseIn(_pin, LOW);
if(_dur > 8000 && _dur < 12000 && startbit==0)
{
larpulso=_dur/23;
larpulso1=larpulso-50;
larpulso2=larpulso+50;
larpulso3=larpulso+larpulso-50;
larpulso4=larpulso+larpulso+50;
startbit=1;_dur=0;
_data=0;
dataok=0;
ctr=0;
}
}// Se o Bit de inicio OK ENTÃO Inicia a medição do tempo em Nivel ALTO dos sinais, e testa se o tempo está na faixa.
if (startbit==1 && dataok==0 && ctr < 28)
{
++ctr;
_dur1 = pulseIn(_pin, HIGH);
if(_dur1 > larpulso1 && _dur1 < larpulso2) // Se a largura de pulso é entre 1/4000 e 1/3000 segundos
{
_data = (_data 1) + 1; // anexar um * 1 * para a extremidade mais à direita do buffer
}
else if(_dur1 > larpulso3 && _dur1 < larpulso4) // Se a largura de pulso é entre 2/4000 e 2/3000 segundos
{
_data = (_data 1); // anexar um * 0 * para a extremidade mais à direita do buffer
}
else
{
/* força finalização do laço */
startbit=0;
}
}
if (ctr==28)
{
if (bitRead(_data,0)==1)
{
if (bitRead(_data,1)==0)
{
if (bitRead(_data,2)==1)
{
if (bitRead(_data,3)==0)
{
antcode=1;
}
}
}
}if (antcode==1)
{// Se foram recebidos todos os 28 Bits, o valor vai para a variavel _data e pode ser usada como exemplo abaixo.
dataok=1;
Serial.println(_data,BIN);
//Este código comentado le o código de um sensor
/*for(int i=0; i<29;i++){
if (bitRead(_data,i) == _compar1[i]){
Serial.print(bitRead(_data,i),BIN);
Serial.print(" - ");
Serial.println(_compar1[i],BIN);
}else{
Serial.print(bitRead(_data,i),BIN);
Serial.print(" - ");
Serial.println(_compar1[i],BIN);
}
}*/
for(int i=0; i<29;i++){
if (bitRead(_data,i) == _compar1[i]){
ret = true;
}else{
ret = false;
break;
}
}
if(!ret){
for(int i=0; i<29;i++){
if (bitRead(_data,i) == _compar2[i]){
ret = true;
}else{
ret = false;
break;
}
}
}
if(ret){
bkpTempo2 = millis();
}
ctr=0;
startbit=0;
antcode=0;
delay(100);
}
}
}
return(ret);
}
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues.
Ativado por
