Olá pessoal, estou usando meus transceiver NRF24 e estão funcionando corretamente a não ser o alcance de sinal. O máximo que consigo são uns 10m, e dentro de casa depois de passar uma parede já perde o sinal, mesmo usando os módulos com antena que seriam para até 1000m.
Obs: Em tudo que já li a respeito vi muito falar da importância de manter a alimentação em 3,3v, para os testes estou usando um arduino em cada módulo mantendo assim a tensão necessária.
Alguém usa e pode contribuir com o meu trabalho? Obrigado.
Tags:
Adilson,
Estes módulos são para funcionar entre 30 e 100 metros, antes de tudo coloque um capacitor de 100uf/6v entre os pinos de alimentação do NRF, como demonstrado na foto, de preferencia capacitor de tantalum.
Após a instalação do capacitor vc ainda estiver com distancias muito pequenas, verifique seu código pode estar com problemas.
Assista os videos do Julian Ilett tem muita informação sobre o NRF24L01+ .
https://www.youtube.com/watch?v=dxgznEOGyPc
Abs
Mauricio Ortega
Olá Adilson,
Tô estudando a sério esses modulos, eles são incriveis alem de baratos, costumo brincar dizendo que eles são os xbee pra pobre ha ha ha.
Por falar em xbee só lembrando que o ROGERCOM vai inicar um curso online de xbee, vá no www.rogercom.com e dá uma olhada ok.
Sobre seu problema o Mauricio tá correto, faça o que fizer tem que colocar um capacitor entre o VCC(3.3v) e o GND do modulo, em geral a galera recomenda realmente o de 100uF, eu porem, faço diferente, tenho sempre em mão capacitores que vão de 4.7uF até 1000uF, dai quando tenho um problema como o seu saio testando um por um até conseguir o que desejo, lembrando que nem sempre maior é melhor, o bom é o que lhe atende, logo, começa tentando com o capacitor ok.
MAAAAAAAAAAAAASSSSSSSSSSSSS.... tem mais, vamos agora falar de codigo...
Acredito que você esta utilizando a biblioteca RF24 do Maniacbug, caso seja, dá uma conferida no guia de referencia da biblioteca ( http://maniacbug.github.io/RF24/classRF24.html ).
Nela você verá comandos como setPALevel (rf24_pa_dbm_e level) e setPayloadSize (uint8_t size).
Eu tive problemas com esses modulos e descobri que você tem que ajustar o nível da potencia de acordo com sua necessidade, o tamanho do pacote a ser enviado tambem é bom ser trabalhado, senão o modulo poderá usar muita banda pra nada.
EEEEEEEEE TEM MAIS.....
Como disse, andei estudando mesmo esses radios, e ainda tem muito que eu queria aprender, e o que descobri nos grupos de estudo dele(tudo em ingles) e no forum do arduino.cc é que a biblioteca RF24 do maniacbug, tem erros, logo, comportamentos inadequados dos radios podem ser devido ao uso dela, porem, as outras bibliotecas como a mirf são amadoras perto da RF24, e segundo os grupos tem muuuito mais bugs que ela, dai surgiram correções dessa bibliotecas feitas por usuários, são cópias corrigidas das bibliotecas, a melhor versão e que eu estou usando sem problemas é a do greg copeland.
Para acessar essa biblioteca vá até o site dele:
http://maniacalbits.blogspot.com.br/2013/04/new-rf24-driver-release...
lá ele explica passo a passo o que ha de errado na original e o que ele corrigiu, mas a versão dele continua compativel com a original.
Bem, por enquanto é isso, dá o retorno pra gente se conseguiu ok.
ah! outra coisa, ontem chegou meus NRF24L01+PA+LNA CERAMIC, que são a nova geração desses radios.
São radiozinhos incrivelmente pequenos, minusculos mesmo, algo como uns 2cm só que com potencia de 1.200m em campo aberto.
Agora até onde sei a familia é composta por 3 integrantes:
NRF24L01+ - versão mais basica e barata com menor alcançe
NRF24L01+PA+LNA - versão com antena externa destacável e com alcançe de 1000m. em campo aberto
NRF24L01+PA+LNA CERAMIC- nova versão com antena de ceramica embutida e tamanho total do radio reduzido, alcançe de 1.200m segundo sites que o vendem.
Oba!
Agora tem mais gente para eu indicar, quando alguém me pergunta sobre estes rádios.
Parabéns...
Abs
Mauricio Ortega
Primeiramente muito obrigado pela contribuição pessoal.
Mauricio, to vendo o link que passou vi que tem algo pra ser estudado la, valeu.
Quando ao capacitor já estava usando, testei uns 3 já e não resolveu.
Weider, vi que vc já viu bastante coisa a respeito, realmente eles são da hora, pela utilidade e preço.
Quero aplicar na minha automação residencial, então vou usar um central digamos assim, com um ethernet ele manda para os demais que ficam na caixa de interruptor, e estes recebem sinal para ligar a lâmpada e respondem dizendo se a lâmpada realmente ligou, já fiz isso e deixei 3 em teste, e funcionou a não ser esse problema da distância e perda de sinal.
Vou ler esses materiais e fazer mais alguns testes.
Alguém de vcs usa com ethernet? cheguei a pensar que pudesse ser por isso que estava tendo esse problema, alguma coisa no código, mas testei com outros também e ficou igual.
Obrigado pelas contribuições, vou continuar postando.
Montei uma placa teste para instalar na caixa de interruptor, segue foto:
O problema pode estar ocorrendo devido o posicionamento da placa de radio mude a posição da antena para fora da placa.
abs
O mesmo ocorre com testes sem essa placa, ligando o rf direto no arduino.
Olhem o modo que estou ligando e vou postar também os sketchs que estou usando.
Vi que o material que vocês passaram se refere a biblioteca RF24, e esses códigos que estou usando utiliza a biblioteca nRF24L01p.h.
#include <SPI.h>
#include <nRF24L01p.h>
nRF24L01p transmitter(7,8);//CSN,CE
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = { 0x90, 0xA2, 0xDA, 0x0E, 0x0C, 0x05 }; //physical mac address
byte ip[] = { 192, 168, 0, 150 }; // ip in lan
byte gateway[] = { 192, 168, 0, 1 }; // internet access via router
byte subnet[] = { 255, 255, 255, 0 }; //subnet mask
EthernetServer server(80); //server port
String readString;
int pin = 13;
int ligado = 1;
void setup(){
pinMode(pin, OUTPUT); //pin selected to control
//start Ethernet
Ethernet.begin(mac, ip, gateway, subnet);
delay(150);
Serial.begin(115200);
SPI.begin();
SPI.setBitOrder(MSBFIRST);
transmitter.channel(90);
transmitter.TXaddress("Artur");
transmitter.init();
}
String message;
void loop(){
// Create a client connection
EthernetClient client = server.available();
if (client) {
while (client.connected()) {
if (client.available()) {
char c = client.read();
//read char by char HTTP request
if (readString.length() < 100) {
//store characters to string
readString += c;
//Serial.print(c);
}
//if HTTP request has ended
if (c == '\n') {
///////////////////// control arduino pin
Serial.println(readString); //print to serial monitor for debuging
if(readString.indexOf("?ligar") >0)//checks for on
{
transmitter.txPL("ligar");
transmitter.send(SLOW);
ligado = 0;
}
else{
if(readString.indexOf("?desligar") >0)//checks for off
{
transmitter.txPL("desligar");
transmitter.send(SLOW);
ligado = 1;
}
}
//clearing string for next read
readString="";
///////////////
client.println("<html><head><title></title><meta http-equiv='Content-Type' content='text/html; charset=ISO-8859-1'><script>function AlteraEstadoRele(){var estado = document.getElementById(\"estado\").innerHTML;if(estado == 0){document.getElementById(\"estado\").innerHTML=\"1\";document.getElementById(\"rele\").innerHTML=\"<div class='rele_ligado'></div>\";document.getElementById(\"botao\").innerHTML=\"<a href='/?desligar' class='botao'>Desligar Rele</a>\";}else{document.getElementById(\"estado\").innerHTML=\"0\";document.getElementById(\"rele\").innerHTML=\"<div class='rele_desligado'></div>\";document.getElementById(\"botao\").innerHTML=\"<a href='/?ligar' class='botao'>Ligar Rele</a>\";}}</script></head><body><div id='wrapper'>Automatizacao<div id='rele'></div><div id='estado' style='visibility: hidden;'>");
client.print(ligado);
client.println("</div><div id='botao'></div></div><script>AlteraEstadoRele()</script></body></head>");
delay(1);
//stopping client
client.stop();
}
}
}
}
}
#include <SPI.h>
#include <nRF24L01p.h>
nRF24L01p receiver(7,8);//CSN,CE
void setup(){
delay(150);
Serial.begin(115200);
SPI.begin();
SPI.setBitOrder(MSBFIRST);
receiver.channel(90);
receiver.RXaddress("Artur");
receiver.init();
pinMode(2,OUTPUT);
}
String message;
void loop(){
if(receiver.available()){
receiver.read();
receiver.rxPL(message);
Serial.println(message);
if(message == "ligar"){
digitalWrite(2,HIGH);
}else{
digitalWrite(2,LOW);
}
message="";
}
}
E aí pessoal.
Lendo mais uns materiais aí, vi comentários a respeito de diminuir o clock, ter uma velocidade menor aumenta a confiabilidade e fica mais dificil a perca de sinal, na biblioteca RF24 achei onde alterar mas na nRF24L01p não encontrei.
Weider, falando nas bibliotecas vc que parece estar usando e conhece bastante a respeito desses módulos, tens algum exemplo da biblioteca RF24 com ethernet, usando eles como transceiver, ambos enviando e recebendo?
Adilson algumas dicas:
PRIMEIRA DICA - Evite usar nrf24l01 de tipos diferentes no mesmo projeto, ou seja, se usar o nrf14l01(sem o +) não coloque na mesma rede nrf14l01+, já se estiver usando nrf14l01+PA+LNA(de maior potencia) utilize todos os nós do mesmo tipo.
RAZÃO: A razão é que diferenças de potencia podem causar interferencias segundo alguns lugares que li, nos testes rola até legal, mas com o tempo tende a causar problemas.
SEGUNDA DICA - a biblioteca nRF24L01p.h é uma das primeiras bibliotecas criadas para esses modulos, ela bem antiga e até onde sei não sofreu correções, ela até serve de base para novas bibliotecas, logo, te aconselho a partir pra outras bibliotecas mais novas.
DICA: ao contrario dos radios xbee da digi, os nrf24l01 da nordic não possuem infraestrutura completa para os microcontroladores como arduino ou pic, dependendo de bibliotecas e suporte técnico da comunidade, vou explicar melhor:
Os radios Xbee são como um produto da apple, ou seja, o hardware, o software e o suporte é todo dado pela companhia e criados um para o outro, dai são bem mais caros.
Os NRF24L01 da Nordic como são um produto para android, ou seja, a nordic produz apenas o chip, existem diferente empresas que produzem o hardware com eles e essas empresas colocam o produto no mercado sem suporte de software, dai entra a comunidade que desenvolve as bibliotecas, codigos, suporte. Resumindo, são bem mais baratos, mas dependem muito do usuário pra fazer eles funcionarem bem.
TERCEIRA E ULTIMA DICA: Tente conhecer as bibliotecas, eu em particular, alem da RF24 do maniacbug que agora utilizo a versão do greg copeland, estou partindo pra estudar e começar a usar a RF24NETWORK, mas existem outras, como a RADIOHEAD, que dá poder aos NRF24L01 de virarem uma especie de xbee, podendo criar redes mesh.
Dá uma olhada nesses links:
- Essa aqui é a pagina do arduino playground falando sobre algumas das bibliotecas para o NRF24L01: http://playground.arduino.cc/InterfacingWithHardware/Nrf24L01
- Essa aqui vai falar sobre a biblioteca RF24NETWORK: https://maniacbug.wordpress.com/2012/03/30/rf24network/
- Essa aqui fala sobre a biblioteca RADIOHEAD: http://www.airspayce.com/mikem/arduino/RadioHead/
mete a cara ai e posta o que você for descobrindo ok.
Weider, obrigado pelas dicas. Este assunto dos Nrf24 ainda tem pouco material comparado com outros módulos, shields e etc... que usamos com arduino, por isso está sendo mais dura a batalha kkkk, mas vamos em frente.
Quanto a questão da biblioteca, estou testando com a nRF24L01p.h pelo motivo de apenas ter encontrado nela um exemplo em que ambos enviam e recebem dados e usando um com ethernet. Como não encontrei outros exemplos ficou dificil, já que não tenho conhecimento a ponto de montar determinados códigos exemplo esse que preciso.
Você chegou a modificar o CLOCK para diminuir a velocidade de transferência de dados? Vi um material dando muito enfase a isso.
Vi que você estava fazendo um trabalho para uma distância de 500m, e estava tento problemas parecidos com os meus, conseguiu concluir? ficou estável?
Mais uma vez obrigado pela ajuda, se pudermos continuar trocando informações a respeito ótimo.
Abraço.
Sim, é verdade, não só tem pouco material como praticamente tudo que você acha é em cima da mesma coisa: inicialização, ou seja, parece que fazem os tutoriais lançam na net e nem testam a fundo.
Quanto a usar a nRF24L01p.h pelo exemplo de fazer TX e RX em um mesmo modulo, você não vai acreditar, dentro dos exemplos que vem com a biblioteca RF24 tem um chamado PINGPAIR que faz exatamente isso, e mais, não é um pingpair só são varios exemplos com variados focos, eu descobri por acaso, tava precisando exatamente disso e busquei pra caramba na internet, até que encontrei um exemplo de um cara que tinha feito isso, e nos comentários do exemplo dele, ele dizia "baseado no exemplo pingpair da biblioteca rf24"
Mudar o Clock? acho que você se enganou na descrição, quando se lida com o nrf24l01 não se trabalha com o clock até onde eu saiba, o que se mexe é Na taxa de transferencia, na potência de comunicação ou se você estiver vendo os resultados na serial, em geral se aconselha aumentar a frequencia da serial do padrão 9600 para 115000, no meu caso, eu preferi usar um display externo, um NOKIA 5100 para ver os resultados, e dai NÃO utilizo a serial pra não dar interferencias, tipo não coloco nem o Serial.begin() pois se colocar você vai ativar a serial.
Sim, eu tava fazendo um trabalho pra distancia, era um controle remoto de longa distancia, até onde eu testei tá funcionando sim, o problema era realmente o lance do capacitor, eu tava usando de 100uF e as vezes funcionava as vezes não, quando subi pra 470uF resolveu legal.
Eu desenvolvi uma shield bem simples, que serve pra você testar os modulos com o arduino UNO sem precisar de protoboard nem aquele monte de fios, se quiser te passo os arquivos do EAGLE CAD ou vetorial pra você fazer, Tu sabe fazer PCI ?
Olá Weider.
Quando falo em CLOCK, talvez expressei mal, me referia a isso.
( Para melhorar ainda mais o desempenho, é possível utilizar um divisor de 2 (SPI_CLOCK_DIV2) ) o cara se refere a alterar essa linha.
Vou procurar esse exemplo na biblioteca NR24, PINPAIR.
E quero sim o arquivo EAGLE, eu faço umas placas as vezes.
Obrigado.
Aproveitando o topico, alguem pode me informar. se é possível ter uns 2mil aparelhos desse ? seria uma aplicação que cada um teria que enviar dados para um servidor..
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues. Ativado por