Comunicação entre dispositivos

Rodrigo Lange · 27 de junho de 2014

Bom dia pessoal,

Voltando ao fórum depois de muito tempo...
Preciso de dicas para comunicar vários dispositivos remotos ( estes dispositivos recebem comandos endereçados do Master e respondem com feedback ).
Resumindo preciso comunicar módulos com um master via RF.
Pensei em usar os módulos NRF24L01+ para criar a rede mas não sei se é a melhor opção. O dispositivo precisa ter custo baixo por isso não quero usar zigbee.
A finalidade é domótica.
Sou iniciante, aprendi um pouco de PIC na faculdade de engenharia mas me identifiquei bastante com o brinquedinho (arduino) rsrs to extraindo bastante coisa dessa plataforma!
Obs: O Master talvez precise ser um Arduino Mega, se bem que os Slaves faram o trabalho sujo, o Master apenas monitora de tempos em tempos, recebe as interrupções e trata as informações decidindo o que fazer..

Agradeço desde já as sugestões.

aphawk · 27 de junho de 2014

@Rodrigo Lange,

Fala meu amigo, faz tempo mesmo.... bom retorno !

Escolher o Arduíno como plataforma é uma excelente escolha para o desenvolvimento, pois fica muito simples montar o circuito final usando um simples AVR, mantendo a compatibilidade com o código.

Existem dois approachs antigos, que são os que eu conheçí... ( velho é a tua vó viu !!!! kkk ) para fazer isso : um é o famoso aleatório ( usado nas antigas redes tipo LAN de empresas com cabo coaxial, onde falava quer quer, e se houvesse colisão, era enviado um sinal de Jam, e a partir daí aleatóriamente era gerado um tempo para cada um dos nodes para tentar fazer a comunicação..... altamente ineficiante com muitos nodes.... )

O outro é mais conheçido como Token Pass , onde um dos nodes sempre é o responsável para controlar a rede toda, dizendo a cada momento qual dos nodes pode se comunicar com quem quiser..... E pela descrição que voce deu, acho que é este princípio que voce vai usar.

O truque é justamente o seu programa decidir em que momento abandonar a comunicação com um node que está demorando a responder e passar para outro... pois isto é o que vai definir a eficiência de sua rede.

Esses módulos são muito bons e baratos,acho que são uma boa escolha.

Vamos ver o que o pessoal tem a dizer disso !

Paulo

Felipe Electronic · 27 de junho de 2014

Token Pass é bem legal!

Como na tua rede está bem definido que haverá um mestre e vários slaves, pensei em uma solução baseada em round - robin, ou seja um time slice para verificação do canal, o master pede o status e aguarda a resposta e inicia uma comunicação até o término da janela de tempo, se aainda houverem dados a transmitir, pode existir um comando de suspend para que aquele slave aguarda até o próximo scan do canal pelo master, assim todos os slaves poderiam ficar em modo low-power e so iniciariam a transmissão se fosse solicitados ao master. É simples porém robusta a solução, a desvantagem maior é que o tempo de resposta aumenta a medida que mais slaves são colocados na rede, obviamente otimizando bem a comunicação o aumento do tempo de resposta chega a ser imperceptíevel.

PS.: Esses módulos da Nordic são demais, simples e com muitas funções legais por hardware.

Abs.

Rodrigo Lange · 27 de junho de 2014

Verdade @aphawk faz tempo mesmo rsrs!!

Lembro como se fosse hoje você me dando uma ajuda via Skipe para programar meu primeiro PIC utilizando o PSI.. Isso à uns 4 anos atrás..

@ lembro quando você entrou no fórum lá em 2008..

Então muito rica as sugestões de vocês.. A ideia é essa mesmo, só preciso ver qual forma é mais fácil de programar.

Meu medo é que não caiba tudo que quero em um ATMEGA328

Só uma ideia do que o módulo Slave vai ter que fazer:

Funções:

1-Dimmer 10Steps com indicação display 7seg (0-9) >(Feito)<

2-Botões Up/Down p/ controlar a saída do Triac >(Feito)<

3-Receptor IR para armazenar código de controles (2 teclas definidas pelo usuário; capturadas e armazenas) >(Parcialmente feito, preciso melhorar a lógica)<

4-LDR

5-Módulo NRF24L01+ ou HC-05 Bluetooth

*6-Emissor IR para controlar alguns equipamentos no ambiente

*7-Sensor LM35/LM335 ou DHT11 (o que for mais fácil de implementar e mais seguro nas leituras)

*8-Sensor PIR

*9-Relé de estado solido ou Triac p/ acionar cargas de até 10A >(Feito)<

*10-4 saidas p/ Triac utilizando em fita LED RGB + Fita LED cor branca

*Nem tudo será implementado, mas se couber na programação do ATMEGA328 crio um modulo genérico com todas as opções, dae apenas uma pci a ser fabricada.

Ai que vem o problema; observaram quanta informação o modulo Slave encaminha pro Master?

Eu não sei de que forma encaminhar isso para tratar todas as variáveis. Li algo sobre serial ou mandar um arquivo do tipo .text com todos os dados.

A parte do Master é provável que pague alguém pra fazer.

Não vou falar dele neste momento, uma coisa de cada vez.

Ao menos a parte de HTML5 / PHP pois vou acessar/enviar as informações via Web.

É o projeto de automação da minha casa. To disposto a investir nisso

Obrigado pessoal!

aphawk · 28 de junho de 2014

@Rodrigo Lange,

Pois é, continuamos aqui, resistindo bravamente hehehhe !

Olha, muito interessante esse seu projeto, creio que posso te passar algumas informações : uns 30% do atmega328 serao usados com os Nordics.... Uns 20% para os receptores / transmissores IR.... O restante cabe tranquilamente nos 50% que sobram.

Acho que a parte mais trabalhosa será a do Master, porque ele vai ter de fazer a comunicação com a Internet, usando aquelas API do Google.... Eu ví um sistema de um termômetro com o Bascom que disponibilizava a temperatura para ser acessada pelo Google Maps, usava um Arduino Uno e um módulo 5110 de Internet, e usava mais de 50% do espaço só para isso.

Acho melhor voce adaptar o Master para usar um Atmega644 ou um Atmega1280 ou Atmega2560... Sabe como é... Melhor ter muita sobra para corrigir futuros problemas !

Paulo

Rodrigo Lange · 28 de junho de 2014

Com certeza!

Mas se bem que o Raspberry já daria um bom adianto no Master.

No Slave acho que vai ter umas 4 variáveis apenas leitura pelo Master e mais 5 de leitura/escrita.

Não teria como eu enviar regularmente um pacote com os dados ao Master ou apenas quando tiver alteração nas variáveis e/ou Master solicitar?

aphawk · 29 de junho de 2014

@Rodrigo Lange,

Enviar dados regularmente envolve uma sincronização bem precisa entre os terminais todos, não acho isto viável.

O que eu acho legal é voce fazer um protocolo simples, onde o Master interroga cada um dos slaves, e o slave sempre devolve uma resposta em bytes, afinal são poucos, o que eu faria é inventar um byte extra, onde o próprio Slave já indica ao Master se teve alguma mudança nos dados desde a última interrogação.

Assim o Master não perderia tempo verificando os dados se não houve nenhuma mudança.

A outra alternativa, que é cada slave informar ao Master quando houver alguma alteração, implica em voce ter de tratar colisões de dados, dos dois lados, e isto vai causar mais trabalho do que fazer um simples token-pass.

Paulo

Rodrigo Lange · 29 de junho de 2014

Seria algo mais ou menos assim:

O fato é que você tera de primeiramente definir o encapsulamento dos dados a serem enviados e recebidos, como por exemplo a seguinte sequencia: <STX><CMD><ADDRESS><D1><D2><D3><D4><CHECKSUM><ETX>. No caso, o byte CMD acima poderia ter funções como Envia ou Retorno. a variavel ADDRESS seria o endereço de cada receptor.

O passo seguinte seria definir o protocolo de comunicação, que nada mais é o fluxo desses pacotes acima, como por exemplo:
Transmissor → Receptor ( envia comando Escrita do valor Dx para o dispositivo ADDRESS )

Transmissor ← Receptor ( Recebe do dispositivo ADDRESS o comando Retorno seguido dos valores D4:D3:D2:D1 )

A opção do token pass me parece boa.

Eu só preciso atualizar os dados no Master, nada critico.

Em caso de alarme não teria problema em esperar até 20s. para o master identificar por exemplo que Slave #002 teve alteração.

Acredito que em 20s. consiga fazer a varredura de até 15 módulos.

Ou estou falando bobagem?

aphawk · 29 de junho de 2014

@Rodrigo Lange,

Acho que voce consegue fazer essa comunicação de 15 módulos em menos de 5 segundos, isso com confirmação de recebimento de dados.

Paulo

Rodrigo Lange · 2 de julho de 2014

Pessoal vou postando os códigos aqui a medida que avanço no projeto.

Uma duvida de lógica básica: (olha que quebrei a cabeça e nenhuma alternativa funcionou adequadamente)

Como faço pra quando pressionar o "botao_UP" por mais de 500ms a variável "conta" receba o valor "9" por exemplo??? Mesma coisa pro botão Down receber "0". ?

O programa abaixo está funciona perfeitamente bem. No outro programa o PWM é mais complexo. O acionamento é para cargas AC com detecção de passagem por zero e controlando os ângulos de disparo do Triac.

Editei/cortei algumas coisas pra deixar apenas o que interessa, que é no caso a rotina de incremento/decremento da variável "conta".

/*Este Sketch realiza um contador de 0 - 9 - 0utilizando um display 7 seguimentos juntamente com o CI HCF4511 e mais2 botões para incremento/decremento*/const int a = 4;                             //define contador binário // a-1, b-2, c-4, d-8 do HCF4511const int b = 5;const int c = 6;const int d = 7;       const int botao_UP = 3;                     //botão Up conectado ao pino 9const int botao_DW = 2;                     //botão Down conectado ao pino 10const int saida = 11;                       //define o pino 11 como saída PWMconst int debounce_time = 10;      int conta = 5;                             //estado inicial da variável "conta" que será mostrado no displayint estado_botao_UP;                       //variável de leitura estado do botãoint estado_anterior_botao_UP;              //variável de leitura estado anterior do botãoint estado_botao_DW;                       //variável de leitura estado do botãoint estado_anterior_botao_DW;              //variável de leitura estado anterior do botãoboolean debounce(int pin) {  int contador = 0;  boolean estado;                         //guarda o estado do botão  boolean estado_anterior;                //guarda o ultimo estado do botão  do {    estado = digitalRead(pin);    if(estado != estado_anterior) {      // compara-se o estado atual com o anterior      contador = 0;                      // reinicia o contador      estado_anterior = estado;    }    else {      contador = contador + 1;          // aumenta o contador em 1    }    delay(1);  } while(contador < debounce_time);    return estado;}  void atualiza_numero() {    switch(conta) {                         // São atribuidos valores de 0 à 9 a variável    case 0:                               // De acordo com cada valor o mcu executa as instruções dentro do Switch Case     digitalWrite(a, LOW);     digitalWrite(b, LOW);     digitalWrite(c, LOW);     digitalWrite(d, LOW);     digitalWrite(saida, LOW);     break;                               // Neste momento o programa finaliza as instruções, sem o Break iria executar as outras instruções.    case 1:     digitalWrite(a, HIGH);     digitalWrite(b, LOW);     digitalWrite(c, LOW);     digitalWrite(d, LOW);     analogWrite (saida, 5);              //escrevemos um valor entre 0 - 255 na saída PWM sendo 0 para nenhum brilho e 255 para máximo brilho do LED     break;    case 2:     digitalWrite(a, LOW);     digitalWrite(b, HIGH);     digitalWrite(c, LOW);     digitalWrite(d, LOW);     analogWrite(saida, 18);     break;    case 3:     digitalWrite(a, HIGH);     digitalWrite(b, HIGH);     digitalWrite(c, LOW);     digitalWrite(d, LOW);     analogWrite(saida, 45);     break;    case 4:     digitalWrite(a, LOW);     digitalWrite(b, LOW);     digitalWrite(c, HIGH);     digitalWrite(d, LOW);     analogWrite(saida, 80);     break;    case 5:     digitalWrite(a, HIGH);     digitalWrite(b, LOW);     digitalWrite(c, HIGH);     digitalWrite(d, LOW);     analogWrite(saida, 110);     break;    case 6:     digitalWrite(a, LOW);     digitalWrite(b, HIGH);     digitalWrite(c, HIGH);     digitalWrite(d, LOW);     analogWrite(saida, 140);     break;    case 7:     digitalWrite(a, HIGH);     digitalWrite(b, HIGH);     digitalWrite(c, HIGH);     digitalWrite(d, LOW);     analogWrite(saida, 175);     break;    case 8:     digitalWrite(a, LOW);     digitalWrite(b, LOW);     digitalWrite(c, LOW);     digitalWrite(d, HIGH);     analogWrite(saida, 215);     break;    case 9:     digitalWrite(a, HIGH);     digitalWrite(b, LOW);     digitalWrite(c, LOW);     digitalWrite(d, HIGH);     digitalWrite(saida, HIGH);     break;  }} void setup() {   pinMode(a, OUTPUT);   pinMode(b, OUTPUT);   pinMode(c, OUTPUT);   pinMode(d, OUTPUT);   pinMode(botao_UP, INPUT);                          //declaramos os botões como entradas digitais   pinMode(botao_DW, INPUT);   pinMode(saida, OUTPUT);                            //declaramos o pino 11 como saída para o PWM }   void loop(){    estado_botao_UP = digitalRead(botao_UP);           //lê o estado do botão    if(estado_botao_UP != estado_anterior_botao_UP){  //se houver mudança no estado // "!=" é o mesmo que "diferente"   if(debounce(botao_UP)) {                          //checa se está pressionado     conta++;                                        //incrementa a contagem     if(conta > 9) {                            conta = 9;     }   } }   estado_anterior_botao_UP = estado_botao_UP;       //guarda o estado do botão     estado_botao_DW = digitalRead(botao_DW);          //lê o estado do botão   if(estado_botao_DW != estado_anterior_botao_DW){  //se houver mudança   if(debounce(botao_DW)) {                          //checa se está pressionado     conta--;                                        //decrementa a contagem     if(conta < 0) {        conta = 0;     }   } } estado_anterior_botao_DW = estado_botao_DW;    atualiza_numero(); }

Rodrigo Lange · 2 de julho de 2014

Ideias?

aphawk · 2 de julho de 2014

@Rodrigo Lange,

Infelizmente não consigo te ajudar em nada com C ...... tem de esperar pelos colegas mais acostumados com ele....

Paulo

Rodrigo Lange · 2 de julho de 2014

Qual seria a lógica usada no Bascom para fazer o botão incrementar a medida que o mesmo permanecesse pressionado após meio segundo?

@aphawk assim que finalizar vou postar um projeto bacaninha com 3 STK4241ii + Amp. p/ Sub + FM + PT2322 que é de fácil aquisição junto com o código fonte para ATMEGA328P.

Achei super interessante aquele circuito onde você utiliza um CI p/ FM que agora não lembro de cabeça qual era.

Ps: Por onde começar no Bascom?

Lembrando que uso placa Arduino UNO e Mega 2560.

Tenho uma vaga lembrança do basic da época dos seus tutoriais. Consigo interpretar bem.

aphawk · 3 de julho de 2014

@Rodrigo Lange,

O Bascom tem uma instrução para tratar botões muito legal chamada Debounçe, com ela voce pode indicar uma função ou uma subrotina que é acionada quando o nível de uma entrada vai para alto ou se vai para baixo, e voce também define o tempo de Debounce e essa instrução já trata isso também.

Usando essa instrução, eu chamo uma função que primeiro ficaria verificando se o botao está apertado e incrementando um contador com delay e verificando se esse delay ultrapassa meio segundo no total, e caso positivo depois de novo cria dentro um contador, com um pequeno delay dentro dele, e fico incrementando enquanto a tecla estiver pressionada. Quando detecto que a tecla foi solta, eu verifico a contagem, e assim consigo saber o tempo que ficou pressionada. É práticamente usar o mesmo processo duas vezes seguidas, só que a primeira vez eu fico verificando se passou o meio segundo ( por exemplo, com um delay de 10 milisegundos, se a contagem atingir 50 estourou o tempo, entendeu ) .

Experimente baixar o meu tutorial lá em cima no tópico destacado, e baixe o programa Bascom, que é free para objetos compilados até 4K.

Legal esse seu projeto, é um belo amplificador, caramba !

Eu até já tenho esse CI aqui, só faltou um incentivo, acho que vou montar esse seu projeto aqui !

O cí de FM caia que nem uma luva nesse projeto seu.... É o TEA5767, voce compra o módulo pronto com ele bem baratinho...

O Bascom consegue gerar o código e já faz o upload para os Arduínos, usando o próprio Bootloader dele, eu também uso o Uno R3 como minha base de experimentos.

Paulo

MOR_AL · 3 de julho de 2014

Rodrigo.

Quanto à chave. Fiz um pseudo código, que retira o bouncing. Ocorre que você que estabelece os três tempos.

O de duração do bouncing inicial, final e da chave estável.

Tente entender o fluxograma que você poderá dar valores às variáveis para conseguir o que deseja.

http://forum.clubedohardware.com.br/forums/topic/1070928-teclas-e-bouncing/

MOR_AL

Rodrigo Lange · 3 de julho de 2014

Obrigado pela ajuda pessoal,

@ no meu código já tem uma rotina de anti bouncing.

Só não estou conseguindo casar uma logica que dê certo para após 400ms +ou- com o botão pressionado ele incremente ou pule direto pro 9 por exemplo. Idem pro botão DOWN.

@aphawk Eu até entendi sua lógica só não consigo ver como implementar no meu código.

Referente ao projeto com o PT2322 vou providenciar o TEA5767 e tomar como base aquele seu projeto no tutorial. De fato ficou muito bom! Parabéns.

To começando a repensar em fazer a automação da minha casa...Não consigo nem fazer um botão funcionar rsrs

Rodrigo Lange · 10 de julho de 2014

up!.......

aphawk · 10 de julho de 2014

@Rodrigo Lange,

Eu não consigo te ajudar em C..... sou um peixe fora d'água aqui kkkkkkk

Paulo

Rodrigo Lange · 12 de julho de 2014

hahaha

Mas mesmo assim obrigado Paulo.

Vou tentar fazer algo nessa madrugada. Tentar alterar o código..

Ae posto os resultados aqui.

Rodrigo Lange · 5 de agosto de 2014

Vixe desisti do código..

Acredito que eu não precise mais da rotina de bouncing pois vou usar switches capacitivas TTP223.

Vou ter que começar praticamente do zero rsrs

E não tenho nem ideia de como farei...acho que preciso usar interrupções.

aphawk · 5 de agosto de 2014

@Rodrigo Lange,

Olha.... Se você está com dificuldades na programação básica, fazer a automação é uma tarefa bem mais difícil do que um debouncing.... Eu em seu lugar iria praticar programação de coisas bem mais simples para aprender mais ....

Paulo

Aox90 · 5 de agosto de 2014

Rodrigo sou novato com trabalho de arduino, estava lendo seu projeto(aqui no forum) e quero fazer algo semelhante, acho que você pode me ajudar dando dicas.

Quero com um arduino Uno e montar um sistema de controle (algo genérico). Quero pegar esse arduino e com dois chips Tramissor e Receptor (via infravermelho ou Bluetooth), fazer leitura de dados. Tipo tenho um Base de dados populada, ai pego o módulo trasmissor que envia um sinal para o receptor que retorna uma informação ao transmissor e este último com auxílio do arduino lê o banco de dados e dá um retorno em tela ao usuário.

Pode me ajudar?

xyko-2020 · 18 de agosto de 2014

Fala Rodrigo... faz tempo, heim!

Tá desistindo muito rápido.

Se quiser mudar pro BASCOM-AVR, resolve-se isto rapidinho.

Eu não uso o C do arduino nem o C#, +, ou ++, porém consigo rapidinho

pegar um código C e mudar pra bascom... ou seja, só não crio em C porque acho que usa muitos sinais.

Ex:

porque == se podemos usar só =... e isto com os demais operadores.

É Verdade que o C não trata diretamente com bits?

No bascom podemos setar ou resetar um bit, por exemplo numa variável de 32 bits.

ex: x é uma var. de 32 bits...

basta fazer

set x.0

a

set x.31

Os bits também podem ser variáveis

por exemplo.. temos uma variável x de 32bits e uma variável y de 8bits, podemos fazer:

set x,y

ou

reset x.y

daí imagina o que se pode fazer facilmente usando variáveis que são contadores...

Isto só um exemplo das facilidades.

Consulte o help do bascom ve veja que não precisará estudar muito.

http://avrhelp.mcselec.com/

Já convenci o colega aí acima e você não vai escapar!

Hoje ele tá melhor que eu.. kkk

xyko-2020 · 5 de setembro de 2014

E aí.. Faremos?

Felipe Electronic · 5 de setembro de 2014

É Verdade que o C não trata diretamente com bits?

Hehehehe:

typedef union{    uint32_t Register;    uint8_t  bit0:1;    .    .    .    uint8_t bit31:1;}Register_t;//Vamos usar:Register_t var32;//Setando um bit:var32.bit0 = 1;

Tenho quase certeza que o código C produzido pelo GNU-Avr para fazer isso é mais eficiente que o do Bascom,

fora que é cusotmizável .

Abs.