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

Responder esta

Respostas a este tópico

gustavo, tmb estou montando um sistema de automação e alarme porém, no momento com fios. sou programador web e se precisar de ajuda estou a disposição me interessei no projeto e futuramente pretendo fazer tudo sem fio tmb

abraços e boa sorte

Obrigado Erik, 

Escolhi fazer o alarme sem fio, devido a facilidade de instalação.

Alarme com fio é bem trabalhoso para ser instalado.

Amigo Gustavo,

estou na mesma situação. Também estudei DOS, BASIC, e Turbo Pascal e, por isso mesmo, consigo minimamente, "perceber" os Sketch para arduino.

Pelo menos já temos algumas noções de como funciona um código de programação mas não chega, pelo menos para mim, para entender nem conhecer bem os comandos e a sintaxe dum sketch.

Nos projectos que vou fazer, tentarei contar com a ajuda do pessoal aqui do forum!

Espero também ajudar no que me for possivel.

Boas arduinices!

 

Mário como já disse, relutei por anos em aprender linguagem C.

Tentei várias vezes e desistia - achava e ainda acho ser uma linguagem nada amigável.

E o Arduino me motivou a estuda-la. Finalmente agora estou aprendendo.

Veja que o Sketch que criei usa a mesma metodologia do Turbo Pascal - procedures.

(no caso funções void). 

Estudei e tenho estudado no link sobre Referencia da linguagem  do Arduino:

http://arduino.cc/en/Reference/HomePage#.Uwx9kvldWa8

Não encontrei nenhum livro que fosse específico sobre esse aprendizado.

Obrigado mais uma vez.

Sim, eu reparei nisso. Gostava bastante do método do "procedure", IF-THEN-ELSE, etc. Parece-me muito mais simples.

Coloquei uma duvida em "Arduino + TFT 3.2" porque os Voids não estão a funcionar muito bem e necessitava de alguma ajuda.

Vou pesquisar o link que postou. Acho que vou começar a "queimar pestana" a estudar C

Melhores Cumprimentos

O Blog do Mauricio Macchia, tem muitas video aulas Pic Liguagem C

http://www.macchia.com.br/2012/10/video-aulas-pic-linguagem-c/#more...

Ele é calmo, e explica bem. gostei, baixei 37 aulas dele, mas veja lá.

Um abraço 

Pessoal , estou atualmente montando o primeiro protótipo.

Para simplificar o mesmo, não inclui ainda a parte de RF, dos sensores sem fio e do controle remoto.

Estou estudando e aprendendo Sketch. Estou programando o Sketch do alarme.

Portanto essa é a configuração simplificada do Alarme Arduino:

- Switch S1 para simular a ativação de um sensor sem fio.

- Switch S2 para simular o controle remoto para ativar ou desativar o alarme, 

- Led Verde - indicação de que o alarme esta operacional

- Led Vermelho - indicações de alarme ativado ou disparado, 

- Led Azul - para simular o acionamennto da sirene, 

- Um Buzzer - indicações sonoras de ativação, desativação e disparo do alarme,

Estou usando (e aprendendo a usar) o site da Autodesk http://123d.circuits.io/

É muito fácil de usar, e tem um simulador Arduino também.

Estou gostando.

http://123d.circuits.io/circuits/111735-alarme-arduino-open-source

Opa! corrigindo as ligações nas chaves :

Valeu Gustavo. Você esta correto. Quando parei de prender o conhecimento cresci muito. Não sei se estamos falando sobre o mesmo assunto, mas na área naval existe um pré-conceito de que todos os equipamentos têm que ser interligados por cabos navais, difíceis de serem obtidos e caros. Não conheço ninguém que pesquise remoto sem fio, hi-fi, etc. Claro que existem vários complicadores: o navio é de ferro, interferências em outros equipamentos, vibrações, etc. Tecnicamente não sei se posso contribuir com o projeto, mas caso seja útil, tenho condição de instalar protótipos a bordo para avaliações, te levar a bordo para levantamentos testes, etc, te apresentar a engenheiros navais especializados e a centros de pesquisas navais aqui no Rio de Janeiro e isto sem custo para você. Acredito que quem sair na frente poderá colher frutos. Forte abraço, Julio

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.

RSS

© 2022   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço