soais, resolvi montar uma ideia com vários componentes, sensores, etc. Talvez ampla e complexa demais para iniciar, mas acredito ser um bom objetivo.
Sou de TI, e sempre gostei muito de "fuçar" nos mais diversos escopos. Trabalhei e trabalho com várias coisas, Windows, Mac, Linux, banco de dados, núvem, AWS, GCP, e várias outras tecnologias. Programação básica em Golang, Lua, Javascript, Node JS, PHP e mais básica ainda em Python.
Acredito que este conhecimento prévio ajude.
O Projeto: Automação Residencial
Premissas:
A parte de automação em si, deve funcionar de forma 100% autônoma. Por autônoma, eu quero dizer:
Todos os componentes devem funcionar com suas próprias baterias/fontes de energia (para casos de queda de energia, o principal continuar funcionando, como fechaduras e alarmes/alertas
Comunicação sem Fio entre os dispositivos
Independente de Internet (apesar de conectada para monitoramento e automação remota)
Independente de Rede WiFi (pois dependeria de um roteador WiFi)
Ser possível controle por voz
Ser possível fazer programações de horários, ambiente, etc
Ser possível monitorar/controlar remotamente
Evitar equipamentos caros
Dispositivos:
Sensor de temperatura/pressão atmosférica, dióxodo de carbono e luminosidade (com e sem visor no sensor)
Sensor de umidade em vasos (futuramente, automatizar com bomba de agua)
Sensores de Presença
Sensores de Identificação (saber quem está no lugar)
Controlar e receber informações de cameras IP
Automação de dispositivos de audio/video IR e IP (TV, Home Theather, etc)
Automação de iluminação
Medição de consumo de energia e controle liga/desliga (Bidirecional para receber informações de status e consumo, e controle remoto liga/desliga)
Fechadura de portas (bidirecional para poder abrir remotamente, e informar/registrar status da porta)
Para este projeto, o que estou pesando em usar:
Central de Comando
Algum Arduino, inicial um R3/UNO e talvez depois um Mega
Comunicação Monodirecional - RF 433 (não achei outras boas opções alem desta com simplicidade e baixo custo)
vários dispositivos irão enviar dados para este dispositivo
Comunicação Bidirecional - NRF24L01 (entendo que um XBee, X10, Zigbee ou Z Wave tem muitas vantanges, mas são muito mais caros)
vários dispositivos irão se comunicar
"Controle remoto universal" feito com arduino usando NRF24L01 e talvez uma tela Touch
Módulo GSM para enviar alertas
Dispositivos
Sensor de Temperatura, etc
Attiny85
sensores
rf 433
bateria (é possível monitorar a carga? e sinalizar quando estiver acabando?)
Sensor de umidade em vasos
Attiny85
sensor
rf 433
bateria (é possível monitorar a carga? e sinalizar quando estiver acabando?)
Sensor de Presença
Attiny85
sensor PIR
rf 433
bateria (é possível monitorar a carga? e sinalizar quando estiver acabando?)
Sensor de identificação
Attiny85
Bluetooth (utilizar "MAC" do bluetooth para identificar pessoas pelo smartphone)
rf 433
bateria (é possível monitorar a carga? e sinalizar quando estiver acabando?)
Controlar e receber informações de camera IP
inicialmente direto com raspberry (acho que será mais fácil)
Automação de dispositivos de Audio/Video
Attiny85
transmissor IR
rf 433
bateria (é possível monitorar a carga? e sinalizar quando estiver acabando?)
Automação de iluminação(aqui terei algum trabalho para entender como funciona quando tem várias pontos de liga/desliga)
Attiny85
Rele
NRF24L01
bateria (é possível monitorar a carga? e sinalizar quando estiver acabando?)
Medição de consumo de energia e liga/desliga
Attiny85
1 ou vários reles
sensor de tensão/corrente
NRF24L01
bateria (é possível monitorar a carga? e sinalizar quando estiver acabando?) (para permitir mudar o status para desligado quando acabar energia e evitar queima quando voltar, faz sentido?)
Fechadura de porta
Attiny85
sensor de toque
sensor de "trepidação"
servo/motor para abrir/fechar
NRF24L01
bateria (é possível monitorar a carga? e sinalizar quando estiver acabando?)
Algum smarthub como o Samsung Smartthings Hub para integrar Zigbee, ZWave, etc
Raspberry PI 3 para ser a central de comando e repositório de dados com algo como home-assistant, openhab, mqtt, node-red, etc
Alguma solução em núvem para gateway, backups, etc (aws, gcp, azure, etc)
Esta é uma descrição que fiz do projeto para ajudar a visualizar e começar a fazer as coisas. Porém, ainda restam muitas dúvidas. Devem ter muitas outras ideias melhores, também por isto gostaria de pedir ajuda de vocês.
Inicialmente fiz algumas pesquisas, mas ainda não ficou claro, as principais dúvidas que pairam sobre estas ideias são:
O Attiny85 "aguenta" esta quantidade de componentes? Exemplo do caso do sensor de temperatura e outras coisas que serão vários sensores?
A parte de comunicação é factível?
1 receptor no arduino e vários transsores RF 433 é realmente possível e recomendável? Algum sugestão de melhor alternativas?
Este NRF24L01 funciona para estes casos? 1 na central e um em cada dispositivo vai me antender?
Tem muito riscos de interferências?
Como montar os esquemas para alimentação de energia? Quais baterias utilizar?
Como calcular/estimar o consumo de energia de cada dispositivo e duração das baterias?
Fora isto, toda crítica, opinião e sugestão será extremamente bem vinda.
Grato e espero poder contribuir.…
Adicionado por Ricardo Tutume ao 19:33 em 27 outubro 2017
dos via celular; mais na pratica esta dando o seguinte erro: ele começa a repetir codigo ir, mesmo que na função ele esteja programado para repetir somente 3 vezes.
Exemplo pratico, eu mando ligar o smart da tv, ele liga, so que ai começa a buga e andar a seta, mudar o volume, mudar tom da tela.
Meu codigo é o seguinte, alguem pode dar uma ideia de qual o problema?
Essa parte mostra dados do ambiente e le o que esta na url do site.
void conexaowifi(){
// criando conecção com o cliente
char* param;if(param = ethernet.serviceRequest()){//output chars to serial port//Serial.print(param);//Serial.print("ashdjkahsdkjahsdj");ethernet.print(param);ethernet.print("Sensor sonoro : ");ethernet.print(analogRead(sensorPin));fDHT11();ethernet.respond();reles(param);}
}
Essa outra parte recebe o que esta na url ja limpa e toma a ação pertinente.
void reles(String auxReadString){if(auxReadString.indexOf("L=01")>=0){if (a==1){digitalWrite(ledPinA, HIGH);Serial.println("recebido A");a=0;}else{digitalWrite(ledPinA, LOW);Serial.println("recebido B");a=1;}}/***********************************************************//***********************************************************/if(auxReadString.indexOf("L=02")>=0){if (b==1){digitalWrite(ledPinB, HIGH);Serial.println("Recebido B");b=0;}else{digitalWrite(ledPinB, LOW);Serial.println("recebido b");b=1;}}/***********************************************************//***********************************************************/if(auxReadString.indexOf("L=03")>=0){if (c==1){digitalWrite(ledPinC, HIGH);c=0;}else{digitalWrite(ledPinC, LOW);c=1;}}/***********************************************************//***********************************************************/if(auxReadString.indexOf("L=04")>=0)
{if (d==1){digitalWrite(ledPinD, HIGH);d=0;}else{digitalWrite(ledPinD, LOW);d=1;}}/***********************************************************//***********************************************************/if(auxReadString.indexOf("L=05")>=0){if (e==1){digitalWrite(ledPinE, HIGH);e=0;}else{digitalWrite(ledPinE, LOW);e=1;}}/***********************************************************//***********************************************************/if(auxReadString.indexOf("L=06")>=0){if (f==1){digitalWrite(ledPinF, HIGH);f=0;}else{digitalWrite(ledPinF, LOW);f=1;}}/***********************************************************//***********************************************************/if(auxReadString.indexOf("L=07")>=0){ //ligar ar condicionadofor (int i = 0; i < 3; i++) { irsend.sendRC6(0x1000C, 20); // on tv delay(150); }
}if(auxReadString.indexOf("L=08")){ //Subir temperaturafor (int i = 0; i < 3; i++) { irsend.sendRC6(0x100BE, 20); // Smart Tv delay(150); }}
if(auxReadString.indexOf("L=09")){ //Subir temperaturafor (int i = 0; i < 3; i++) { irsend.sendRC6(0x1000A, 20); // Voltar delay(150); }}
if(auxReadString.indexOf("L=10")){ //Subir temperaturafor (int i = 0; i < 3; i++) { irsend.sendRC6(0x10011, 20); // Vol menos delay(150); }}
if(auxReadString.indexOf("L=11")){ //Subir temperaturafor (int i = 0; i < 3; i++) { irsend.sendRC6(0x10010, 20); // volume mais delay(150); }}
if(auxReadString.indexOf("L=12")){ //Subir temperaturafor (int i = 0; i < 3; i++) { irsend.sendRC6(0x1000D, 20); // mute delay(150); }}
if(auxReadString.indexOf("L=13")){ //Subir temperaturafor (int i = 0; i < 3; i++) { irsend.sendRC6(0x1004C, 20); // ch+ delay(150); }}
if(auxReadString.indexOf("L=14")){ //Subir temperaturafor (int i = 0; i < 3; i++) { irsend.sendRC6(0x1004D, 20); // ch- delay(150); }}
if(auxReadString.indexOf("L=15")){ //Subir temperaturafor (int i = 0; i < 2; i++) { irsend.sendRC6(0x58, 20); // cima delay(150); }}
if(auxReadString.indexOf("L=16")){ //Subir temperaturafor (int i = 0; i < 2; i++) { irsend.sendRC6(0x59, 20); // baixo delay(150); }}
if(auxReadString.indexOf("L=17")){ //Subir temperaturafor (int i = 0; i < 2; i++) { irsend.sendRC6(0x5A, 20); // esquerda delay(150); }}
if(auxReadString.indexOf("L=18")){ //Subir temperaturafor (int i = 0; i < 2; i++) { irsend.sendRC6(0x5B, 20); // direita delay(150); }}}/*------------------ fim da funcao rele--------------------------*/
Se não fui claro, explico novamente.
Obrigado.
…
Adicionado por Luiz Antonio ao 17:50 em 11 fevereiro 2014
mpadas da minha casa.
É assim, a central recebe uma String via Bluetooth e se for algum comando de multimídia, ela envia os códigos via IR para os aparelhos. E, se for comandos de iluminação a central envia a String via RF para as placas Slaves que estão instaladas pela casa.
Aparentemente tudo está funcionando, porém quando eu utilizo o comando de multimídia ele até pisca o led emissor (vejo pela câmera) mas o comando não funciona.
Sou curioso e não sei absolutamente nada de programação, todos os projetos que montei até hoje foram adaptações de colegas que compartilham o conhecimento.
Seguem os códigos:
emissor
#include <VirtualWire.h> // carrega a biblioteca do rf
#include <IRremote.h> // carrega a biblioteca do controle remoto
IRsend irsend; // declaração da "variavel" do controle remoto
char info[30];
int index = 0;
char inChar; // declaração das variaveis que irão carregar a "string"
int lamp4= 13;//LED da porta 13
int lamp3= 12;//LED da porta 12
int lamp2= 44;//LED da porta 44
void setup() {
pinMode(6,OUTPUT); //saida de envio do rf
pinMode(lamp4,OUTPUT); // config o estado da porta como saida
pinMode(lamp3,OUTPUT); // config o estado da porta como saida
pinMode(lamp2,OUTPUT); // config o estado da porta como saida
Serial.begin(9600);
vw_set_tx_pin(6); // Pino para Transferir
vw_set_ptt_inverted(true);
vw_setup(2000); // Velociade de Transmissão
}
void loop() {
if (Serial.available() > 0) {
while (1) {
inChar = Serial.read(); // Guarda o Primeiro Caracter
info[index] = inChar; // Coloca o Caracter numa Array
index++;
delay(2);
if (Serial.available() <= 0) {
index = 0;
const char *msg = info;
vw_send((uint8_t *)msg, strlen(msg)); // Envia a Informação
vw_wait_tx();
// estes abaixo são os testes com leds que a central irá executar e o último "led6" é a String que
// aumenta o volume da TV e não funciona.
if(String(info) == "led4"){
digitalWrite(lamp4,!digitalRead(lamp4));
}
if(String(info) == "led3"){
digitalWrite(lamp3,!digitalRead(lamp3));
}
if(String(info) == "led2"){
digitalWrite(lamp2,!digitalRead(lamp2)); //
}
if(String(info) == "led6"){
irsend.sendNEC(0x20DFC03F, 32);
}
memset( &info, 0, sizeof(info) );
break;
}
}}}
ReCEPTOR
#include <VirtualWire.h>
int lamp1=8;//LED da porta 13
int lamp2=6;//LED da porta 13
int lamp5=4;//LED da porta 13
char info[30];
void setup() {
pinMode(7,INPUT);
pinMode(lamp1,OUTPUT);
pinMode(lamp2,OUTPUT);
pinMode(lamp5,OUTPUT);
Serial.begin(9600);
vw_set_rx_pin(7); // Pino de Recepção
vw_set_ptt_inverted(true);
vw_setup(2000);
vw_rx_start();
}
void loop() {
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen)) {
int i;
for (i = 0; i < buflen; i++) { // Guarda a Informação Recebida num Array
info[i]=buf[i];
}
if(String(info) == "led1"){
digitalWrite(lamp1,!digitalRead(lamp1));
}
if(String(info) == "led5"){
digitalWrite(lamp5,!digitalRead(lamp5));
}
Serial.println(String(info)); // Escreve no SerialMonitor a Informação Recebida
memset( &info, 0, sizeof(info) );
}}
Fontes:
Arduino Livre
Serial Link
http://mais-digital.blogspot.com.br/2012/11/arduino-comunicacao-via-rf-link.html
…
os(as), eu até já postei esta dúvida recentemente em outro fórum. No entanto, gostaria de saber se alguém deste fórum poderia me ajudar.
Antes de mais nada, peço desculpas por talvez demorar a responder aqueles que tentarem me ajudar, pois o tempo infelizmente não é nada meu amigo. Do nada, eu preciso realizar um serviço e a carga horária é bem indefinida. Mas, me esforçarei para não deixar ninguém no "vácuo". Eu prometo.
Enfim, caros(as) amigos(as), creio eu que esta dúvida requer que a pessoa que possa me dar uma grande moral, tenha um bom conhecimento em programação e em V-USB para Arduino.
Seguinte, galera...eu encontrei uma adaptação que podemos considerar bem recente, da biblioteca "UsbJoystick". Caso alguns não conheçam, ao realizar uma pesquisa na rede, vocês encontrarão projetos fabulosos, desde uma adaptação do controle do nintendinho para USB, até braços robóticos por controle remoto. É uma gama de coisas bacanas que o V-USB para microcontroladores AVR, permite ao usuário.
Eu achei esta adaptação fantástica, além de me parecer mais "objetiva", ela permite a implementação de incríveis oito botões. Diferente da versão anterior, que só permitia quatro. Porém, uma coisa me inferniza, seja nesta versão ou na anterior: "axis". Isto me deixa ainda mais careca do que eu já sou...
Quero montar um gamepad, onde haja os oito botões e quatro direções, as direções comuns, "cima", "baixo", "esquerda" e "direita". Eu usei os pinos analógicos como default para consolidar as direções. Exemplo:
#define pinY A0,
void setup(){
pinMode(pinY, INPUT_PULLUP);
}
void loop,(){
if(pinY == LOW){
\\digamos que ativa o direcional para "cima"
}
}
Só que os axis na biblioteca estão configurados de acordo com o " USB descriptor" que determina o Logical Minimum como zero e o Logical Maximum, como 127.
Aí, os botões que configuro para saída digital, funcionam maravilhosamente. Mas os benditos axis não. Testando um joguinho em um emulador, os axis funcionam de maneira louca. Num jogo de plano X e Y, o bonequinho vai direto para cima e se pressionamos para ir para direita, ele até vai, mas volta para a esquerda, ou seja, um inferno.
Eu sei o seguinte: 127 em Y, vai para baixo, em X, vai para a direita. Mas quais são os valores para cima e para esquerda ? em tese, seria zero — eu acho. Mas, se ponho zero, nada acontece, não ocorre nenhum evento. Inclusive, para qualquer valor menor que zero, a biblioteca determina que valores menores que zero serão iguais a zero. Se coloco 1 , que é maior que zero e é menor que 127, ainda fica desfuncional. Voltando ao exemplo do game com plano X e Y, o bonequinho fica igual a um doido rodopiando.
Já alterei os descriptors para 255, mas a porcaria do problema persiste. Eu não sei mais o que fazer.
Tipo...será que algum(a) fera pode me orientar na programação desses raios de axis ? se necessário, eu mando a biblioteca mais a Sketch de exemplo. Quero tanto dar um "gamepad das antigas" aos meus moleques. Se amarraram no emulador do mega drive, estão sempre jogando... :'(
No mais, obrigado a todos pela atenção e tomara que alguém possa dar esse valioso help.
Obrigado !
…
e ficam os servidores da minha empresa, nessa sala tenho um Ar Cond. de 30.000 btus Carrier, preciso que ele ligue aos finais de semana, pois no calor o nosso server HP Proliant quase frita, mas no final de semana fica apenas um Vigilante na empresa e como os servidores ficam na sala dos Diretores então não fornecemos acesso a qualquer pessoa.
O caminho:
Já havia me interessado por Arduino e comecei a pesquisar sobre e decidi meter as caras, comprei um Arduino UNO, receptor IR, emissor IR, eu fui fazer um monte de teste. Descobrir que ligar um AR Cond. via IR é "quase" impossível, pois as bibliotecas atuais não contemplam esses dispositivos, fiz teste de tudo quanto foi jeito e sem sucesso. Decidi que ia fazer isso de forma manual mesmo, ligando o AR Cond. através do botão "AUTO/COLL" que existe internamente na evaporadora, isso claro implica em alguns limites, por exemplo a temperatura no AUTO é sempre de 24 Graus e a Carrier não fornece informações sobre como alterar.
A Solução:
Feito toda a Skecth e testando em uma LED dai então resolvi que era hora de por a mão na massa e fazer a coisa acontecer, decidi soldar dois fios no botão da Evaporadora para que a porta digital 12 do Arduino para ser a ponte:
Antes eu usei o multímetro para ver qual era a corrente passava no botão (5V), ainda fiz teste jampeando para ver se realmente ia funcionar.
Agora seguem as fotos , esquemas e Sketch do projeto, sintam-se a vontade para dar dicas, informações informar sobre correções e etc.
Prototipo:
Acabado:
Coloquei uma chave para desligar no caso de Verão ou uso através do controle remoto e alimentação através de fonte de 5V / 1A
Decidi usar o Garagino, por que é Ótimo custo Beneficio, e tamanho excelente.
Sketch:
// SKECTH PARA QUEM TEM PROBLEMA DE CONTROLE DE AR CONDICINADO, //DESSA FORMA TEM QUE SER ACIONADO MANUALMENTE// COMO ALGUNS AC TEM O BOTAO MANUAL , É SÓ SOLDAR O O PINO 12 E O //GND NO BOTAO DE ACIONAMENTO MANUAL// É BEM BÁSICO SERVE PARA SALAS DE SERVIDOR.// QUALQUER DUVIDA MEU EMAIL É michaeltamoio@gmail.com
int pinoSensor = 0; //pino que está ligado o terminal central do LM35 (porta analogica 0)int valorLido = 0; //valor lido na entrada analogicafloat temperatura = 0; //valorLido convertido para temperatura
void setup() { // INICIA SETUP DO SKETCH pinMode(12, OUTPUT); // SETANDO PINO DIG 12 COMO OUTPUT digitalWrite(12, LOW); // INICIA DESLIGANDO O PINO 12 Serial.begin(9600); // INICIA COMUNICACAO SERIAL}
void loop() { // ###$$$ INICIA O LOOP $$$## retornaAcima: // 1.A #### LENDO A TEMPERATURA E CONVERTENDO ##### valorLido = analogRead(pinoSensor); temperatura = (valorLido * 0.00488); // (5V / 1023) = 0.00488 (precisão do A/D) OBS: USANDO LM35 temperatura = temperatura * 100; //Converte milivolts para graus celcius, lembrando que a cada 10mV equivalem a 1 grau celcius Serial.print("Temperatura atual: "); Serial.print(temperatura); Serial.println(" C"); // 1.A FIM
if(temperatura >26){ // TESTA A TEMP SE ESTIVER MAIOR QUE 26 ACIONA PINO DIG 12 PARA PULSAR O BOTAO DO AR digitalWrite(12,HIGH); // ACIONA O PINO DIG 12 delay(100); // AGUARDA TEMPO EM MILISEG PARA DESLIGAR digitalWrite(12,LOW); // DESACIONA O PINO DIG 12 Serial.println("TEMP. ACIMA DE 26c. LIGANDO AC !!!"); // ESCREVE NO MONITOR A ACAO delay(600000); // AGUARDA 10 MIN. goto retornaAcima; // RETORNA AO LABEL "retornaAcima" }else if(temperatura >25){ // FAZ O TESTE PARA O RESTANTE DAS TEMPERATURAS ATÉ A TEMPERATURA DE CONFORTO Serial.println("AINDA EM 25c."); delay(600000); goto retornaAcima; }else if(temperatura >=24){ Serial.println("AINDA ACIMA DE 24c."); delay(600000); goto retornaAcima; }else if(temperatura < 24){ // SE A TEMP FOR MENOR QUE 24c. INICIA SEQUENCIA PARA DESLIGAR AC digitalWrite(12,HIGH); delay(100); digitalWrite(12,LOW); delay(1000); digitalWrite(12,HIGH); delay(100); digitalWrite(12,LOW); Serial.println("TEMP. ABAIXO DE 24c. DESLIGANDO AC !!!"); delay(600000); } // FINAL DOS IF PARA AC LIGADO
retornaAbaixo: // 1.A #### LENDO A TEMPERATURA E CONVERTENDO ##### valorLido = analogRead(pinoSensor); temperatura = (valorLido * 0.00488); // 5V / 1023 = 0.00488 (precisão do A/D) temperatura = temperatura * 100; //Converte milivolts para graus celcius, lembrando que a cada 10mV equivalem a 1 grau celcius Serial.print("Temperatura atual: "); Serial.print(temperatura); Serial.println(" C"); // 1.A FIM
if(temperatura < 24){ // SE A TEMP AINDA FOR MENOR QUE 24c. FICA NESSE LOOP ATÉ SUBIR Serial.println("TEMP. ABAIXO DE 24c."); delay(600000); goto retornaAbaixo; } delay(600000); // ESPERA MAIS 10 MINUTOS PARA TESTAR TUDO DENOVO
} // ###$$$ ENCERRA LOOP $$$###
Basicamente o que a Sketch faz é a cada 10 Minutos ela lê o LM35 converte a temperatura e liga ou desligar o ACond. Se a sala estiver com a temperatura maior que 26 graus ele liga o ar, e quando baixar de 24 graus desliga.
A Sketch, é bem amadora, eu fiz juntando alguns codigos prontos, acrescentei mais alguns linhas, tendo em vista que conheço de programação PHP, então fui adicionando linhas que entendia que precisava
Vou continuar tentando aperfeiçoar esse projeto, talvez transmitindo a informação de ligar e desligar via RF433 Mghz (preciso estudar um pouco mais) mas se alguém tiver também alguma ideia seria bem vinda.
Galera é isso, agradeço a loja do Lab de Garagem que me ajudou tirando algumas duvidas.
Grande Abraço…
Adicionado por Michael Araujo ao 12:38 em 27 outubro 2014
ra coleguismos e reclamações em geral. A ideia era implementar um sistema tipo o lendário botão que dá verde ou vermelho da receita federal. Fiz com um indutor montado no piso. Como o piso era de paralelepipedos tudo ficou mais fácil.
Enrolei não sei quanto de fio fino mas não mto, como secundário de transformado,algo em torno de 100 espiras, numa bobina com coisa de 1 metro de diametro. Enrolei tudo isso com fita de autofusão, coloquei dentro de uma mangueira (cortada do lado) e passei mais fita de autofusão...
Isso ficou encaixado nos veios do paralelepipédo e os 2 fios foram até a "caixinha".
Na caixinha montei em aranha um oscilador do tipo colpits que copiei do livro do Malvino.
Esse oscilador tem a frequencia muito determinada pelo valor do indutor (tb poderia ser qq outro com indutor). Quando acontece uma variação nele a frequencia varia. Com um carro como nucleo do indutor a variação é absurda.
Então meu microcontrolador (era um 8051 de 20pinos (AT89S2051)) media a frequencia a cada decimo de segundo. Guardava a media das ultimas n leituras. Se houvesse uma variação grande (calibrada) entre a atual e a media ele considerava quer havia um carro, disparando o circuito de aleatorio (rotina de roleta) e a lampada.
Para medir velocidade vc precisaria de pelo menos 2. O ideal seria ter 3 para poder confirmar a velocidade.
Realmente esse tipo de sistema gera um quebra-quebra grande, se não for paralelepipedo.
Enfim, vale a dica: Dá pra fazer um desses, não é tão critico assim, mas não sei se é a melhor solução pra vc.
Condominios costumam ter ruas estreitas, para no maximo 2 carros (um vai e um volta), nesse cenário acho que o modelo que o Mauro sugeriu seria o ideal.
Só para "fertilizar" a mente, imaginei até mais uma opção barata mas duvidosa:
Se vc prender um transmissor e um receptor de IR do tipo controle remoto (para ter mais alcance) apontados para o mesmo lado o receptor só ira receber se houver onde refletir. Vira um sensor de reflexão.
Claro que comprar pronto é bem melhor, mas se a opção for pelo improviso...
Para evitar falsas leituras o ideal seria ter sempre 3 sensores, que geram 2 medidas. Assim dificilmente um ruído vai gerar uma foto.
Para deixar a coisa mais legal ainda tenho outra sugestão: Colocar um microfone e medir o ruído emitido. Num condomínio que conheço a velocidade foi baixada por muuitas lombadas aih o problema principal é que sempre tem um moleque pra chegar de madrugada com o som alto ou escapamento aberto intencionalmente. Pra calibrar mais ou menos tem um App do iphone que promete ser um decibelimetro. Deve ter pra Android tb.
…
biente no display (I2c). Eu já cheguei no seguinte ponto:
Quando eu aperto um botão do controle remoto liga o ar condicionado (representado por um led) e liga também o lcd. Mas quando eu aperto o msm botão consigo desligar o led e tal mas o bendito do lcd fica ligado. Vcs podem me ajudar nessa questão? Segue o código:
#include <IRremote.h> #include <Wire.h> #include <LiquidCrystal_I2C.h>// Inicializa a biblioteca com os números dos pinos de interfaceLiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Cria um objeto lcd e atribui os pinosbyte maxC=0, minC=100, maxF=0, minF=212;boolean scale = 1;unsigned char buttonPin=8;unsigned char RECV_PIN = 11; float armazenavalor; unsigned char pinoledvermelho = 5; unsigned char pinoledverde = 7;IRrecv irrecv(RECV_PIN); decode_results results; void setup() { lcd.begin(16, 2); // Define o display com 16 colunas e 2 linhas analogReference(INTERNAL); pinMode(buttonPin, INPUT); lcd.clear(); lcd.backlight();//activas a backlight pinMode(pinoledvermelho, OUTPUT); pinMode(pinoledverde, OUTPUT); Serial.begin(9600); irrecv.enableIRIn(); // Inicializa o receptor IR } void loop() { if (irrecv.decode(&results)) { Serial.print("Valor lido : "); Serial.println(results.value, HEX); armazenavalor = (results.value); if (armazenavalor == 0xFDA857) //Verifica se a tecla 1 foi acionada { digitalWrite (pinoledvermelho,!digitalRead(pinoledvermelho)); } if (digitalRead (pinoledvermelho),HIGH) { changeLCD(); } else { lcd.noBacklight(); delay(10); } irrecv.resume(); //Le o próximo valor } } int changeLCD() {lcd.setCursor(0,0); // Define o cursor na posição de inícioint sensor = analogRead(0); // Lê a temperatura do sensorint buttonState = digitalRead(buttonPin); // Verifica se o botão foi pressionadoswitch (buttonState) { // Altera o estado da escala, caso tenha sido pressionadocase HIGH:scale=-scale; // Inverte a escalalcd.clear();}delay(250);switch (scale) { // Decide por escala em Celsius ou Fahrenheitcase 1:celsius(sensor);break;case -1:fahrenheit(sensor);}}void celsius(int sensor) {lcd.setCursor(0,0);int temp = sensor * 0.0927734375; // Converte para Celsiuslcd.print(temp);lcd.write(B11011111); // Símbolo de graulcd.print("C ");if (temp>maxC) {maxC=temp;}if (temp<minC) {minC=temp;}lcd.setCursor(0,1);lcd.print("H=");lcd.print(maxC);lcd.write(B11011111);lcd.print("C L=");lcd.print(minC);lcd.write(B11011111);lcd.print("C ");}void fahrenheit(int sensor) {lcd.setCursor(0,0);float temp = ((sensor * 0.09765625) * 1.8)+32; // Converte para Fahrenheitlcd.print(int(temp));lcd.write(B11011111); // Imprime o símbolo de graulcd.print("F ");if (temp>maxF) {maxF=temp;}if (temp<minF) {minF=temp;}lcd.setCursor(0,1);lcd.print("H=");lcd.print(maxF);lcd.write(B11011111);lcd.print("F L=");lcd.print(minF);lcd.write(B11011111);lcd.print("F ");} int offLCD(){ lcd.setCursor(0,0); lcd.clear(); lcd.setCursor(0,1); lcd.clear(); lcd.setBacklight(LOW);}
Abraço!!!!!!…
Adicionado por biu filho ao 10:30 em 5 janeiro 2017
guagens que vc citou eu não conheço... Sou do tempo em que se resolvia tudo em C..
A carência é total. O único smartphone no mercado compativel com cegos hoje é o IPhone. O Simbian (N95 pra cima) também se for incluido um programinha:
http://www.allaboutsymbian.com/features/item/14068_Screen_Reader.php
O Android tem apenas leitor de tela, não tem acessibilidade, embora tenha um item no menu que prometa fazer isso. Pergunte a um cego... A diferença é no click. Eh preciso que vc possa passar o dedo pela tela (icones, por ex) e ele ir lendo o que está sob o dedo. Com um duplo cick vc seleciona. Para cada item, dentro de cada programa. Não adianta fazer aplicativos, é preciso que saia uma nova versão do android que possua a função de acessibilidade corrigida.
Existem ainda aplicativos especificos para cegos no iphone, mas eles são ainda bem limitados. Nenhum atende plenamente. Se fosse possivel já desenvolver de forma que rode em qualquer coisa de uma vez, como:
http://www.unity3d.com
http://www.appgamekit.com/
Adiantando, não pelo seu comentário, que é perfeito, mas só pra adiantar uns porquês gerais:
Qto ao sensor de cor:
O sensor de cor não dá pra ser feito com a camera do celular. Eh assim hoje e é como não ter... Eh preciso encostar na peça no ponto exato onde se quer saber a cor, existir uma iluminação padrão, e medir. Com a camera fica muito impreciso. Imagine tentar saber a cor de um cinto, um comprimido, etc.. Como um cego iria mirar ele no meio da camera ? tem que ter flash pq cego não acende a luz em casa. Aih satura de iluminação, não dá foco, fica uma droga. O sensor de cor ideial seria como o da Parallax ou da Avago. que medem praticamente encostando na coisa e tem luz propria. Fixado no bico do aparelho ou na frente se a frente for em bico.
Qto ao sensor de distancia:
Não entendo pq ate hj o cego não consegue comprar um brinquedo desses... Imagino quantos projetos já não foram feitos de bengala ultrasom. Mas nenhuma chega no mercado. O que existe é absolutamente inviável:
http://www.ultracane.com/
Inviável pelo preço, pelo peso, tamanho, pela durabilidade (não dá pra usar numa calçada de SP), etc.
Um simples VCO ligado num sensor ultrasom colocado a 15cm do chão preso na bengala e ligado num falante no cabo, não precisa vibrar, é cego e não surdo, mas tudo bem... que vibre... Já atende plenamente a necessidade do cego: Saber que a bengala vai bater em alguma coisa sem ter que bater de fato pra saber... Mas não tem no mercado... Isso o smartphone não faz, mas poderia ficar no "modulo remoto", que nem sequer precisa conversar com o smartphone. Eh uma coisa completamente independente. Pode mesmo ser outro produto.
A maior dificuldade nesse caso é o gabinete. ele precisa sobreviver às porradas da bengala no chão. Essa Ultra cane conseguiu isso eliminando as porradas. ela tem uma rodinha na ponta. Mas isso só funciona em chão tipo granito. É impossivel usar em uma calçada brasileira. Se ficar batendo a ultracane ela quebra.. Então salvo o cego só andar dentro de bibliotecas, shoppings e bancos, não serve.
GPS:
Esse é o ponto forte do smartphone. Existem aplicativos especificos para cegos e são até bons. Só não tem uma boa base de dados focada no cego. O que se deseja de um programa desses é: Falar onde vc está e para onde está indo baseado em pontos de referencia conhecidos.
Exemplo do que seria errado: "-Vc está na rua Luis coelho, 25", que é exatamente o que temos hoje...
Exemplo do que seria ideal: "-Vc está Na rua Luis Coelho, 25, metro Consolação à 135m a direita, Conjunto nacional 145m à esqueda, indo em direção à Paulista." Por ex.
Acontece que nós as vezes não sabemos nem o nome da rua de trás do nosso quarteirão. O Cego menos ainda. A ideia dele de onde fica é mais baseada em proximidade a pontos que ele sabe que existem. Lombadas, praças, metro, etc. São ótimos.. Ele classifica só as ruas principais, os pontos principais. A ideia seria ter uma base com todos os shoppings, lojas de rede, bancos, lombadas, etc. Isso eu tenho, tá facil. Ele usa as lombadas, por ex, para saber em que ponto de onibus descer.
Todas as outras funcionalidade o smartphone mata a pau. Só falta o Google tornar o aparelho 100% usável por um cego.
Aih, nesse modelo seria eliminado o raspberry e entraria um Android.
Mas teriamos como funções da "caixinha":
- Colorimetro, Ultrasom e serial bluetooth...
Sei lá, a R$16,00 (10 do transmissor (chaveiro) e 6 do receptor) incluiria o controle de portão. Me refiro a esse modelo:
Pq ele pode ser muito facilmente preso no cabo da bengala (que já tem uma cordinha) e ficaria mto pratico. Tentar reproduzir esse tamanho e simplicidade com bluetooth complica... Aih ele poderia servir tanto para dar comandos para a caixinha quanto para dar comandos para o celular. Seria um opcional...
Enfim, ficaria assim:
Basico:
Smartphone <-bt-> caixinha (colorimetro+ultrasom)
Avançado:
Smartphone <-bt-> caixinha (colorimetro+ultrasom) <-433-> remoto
Mas pra simplificar a vida do cego o ideal seria que a caixinha pudesse falar sozinha tb, pelo menos o básico.. as cores.. Aih poderia ter um integrado de som ( http://www.aplusinc.com.tw/ ) gosto deles pq funcionam com 3v e já tem audio potente integrado. Ou mesmo usar um D/A e colocar o audio na memoria, enfim, não é complicado.
Sei que rodei, rodei e chega-se a conclusão de que:
- Quase tudo pode ser feito com um smartphone;
- O sensor ultrasom não, só que ele tb não tem nada que falar com o smartphone, é independente.
- O sensor de cor não, só que idem...
Ouvindo o cego, ele me disse:
- Tudo que eu quero é poder saber onde estou, baseado em referencias e não em nome numero de rua, e poder fazer isso sem ter que precisar carregar o celular na palma da mão. Tudo que ele queria era o chaveirinho na bengala pra poder disparar o "onde estou".
- Fora isso um leitor de cor e um "river raid" de ultrasom, que são coisas independentes.
- Queria ainda poder ouvir radio sabendo em que rádio está. Segundo ele o unico produto no mercado que faz isso é o Ipod. Para nós rádio, ainda mais se falar em AM, é uma coisa pequena. Mas pra eles, como tem pouco acesso à tv, por ex para saber de um jogo de futebol, o radio é fundamental. Saber em que rádio está é um sonho. Nenhum radio no mundo (que eu e ele saibamos) sintoniza AM e "fala" em que rádio está.
Quem sabe rola um "divisão" que soma ???
Equipes para a parte de smartphone e parte de equipamentos.
As duas àreas podem ser lucrativas. O App gerado pode ser vendido, sem dó. Não é de dó que o cego precisa e sim de bons apps. Tá, alguns vão falar que estou pegando pesado, mas se vcs conversarem com o Luiz (meu amigo cego) vão ver como funciona. É muita promessa de coisa ótima e gratuita e nenhuma realização, nem pagando.
A parte de hardware poderia ter vários produtos, por grupos.
Eu pensei (versão reformuada depois das novas ideias/sugestões):
- Leitor de cor + Ultrasom, como uma pequena lanterna. De um lado cor e do outro ultrasom. Posso por na placa a furação pra um receptor de controle de portão. Vai agradar, creio. Monta-se conforme o gosto do cliente. Pode ainda ter o radio bluetooth... mas se ela já falar acho que nem precisa...
- Radio+Relogio+Despertador+Bina. Era um radiorelogio e outro produto era o Bina, mas se fundiram... Teria um cartão SD onde vc grava arquivos .wav com os nomes das pessoas. O nome do arquivo é o numero dela. Simples assim. E fala o nome da pessoa. Se não está na lista canta os numeros. Pode ainda ter toques .wav configuráveis. Pensei no MP3 mas encarece mto... E o cego não quer... Quer só poder saber quem está ligando e acordar na hora certa... Esse eu já estou fazendo. Esse semestre deve estar pronto. Tenho já 1 cliente, hehehe, meu pai, que xinga mto qdo toca o telefone, faz ele se levantar e é alguem com quem ele não quer falar. Ele enxerga até bem, mas não consegue ler o bina...
Achei ótimo que o tópico deu um up ! Tava mto parado..
…
Adicionado por Eduardo ao 21:01 em 25 fevereiro 2013