Arduino Polska Forum

Poradnik jak za pomocą modułów nRF24l01+ komunikować ze sobą 2 uc Arduino .
niestety zasięg w pomieszczeniach to około 15-20 m 3-4 ściany , na otwartej przestrzeni producent podaje około 100 m przy idealnych warunkach Tongue

Z własnego doświadczania wiem że ten zasięg to 50-60 m ale za 5zł nie można spodziewać się cudów Big Grin

Moduły nRF pracują w paśmie 2.4 GHz
Zasilanie 1.9v- 3,3v
Interfejs SPI tolerancja do 5v

Podłączenie :

1. GDN---->GDN (masa)
2. VCC----> 3,3v !!
3. CE----> Pin 9
4. CSN----> Pin 10
5. SCK----> Pin 13
6. MOSI----> Pin 11
7. MISO----> Pin 12
8. IRQ----> Pin 2 ( opcjonalnie , pin służy do wzbudzania)
[Obrazek: QL3a6A.jpg]

Uwaga!! jeśli moduły nie komunikują się ze sobą musimy dołożyć 2 kondensatory 10uF między VCC a GDN

Przykładowy Program do wł/wył diody :

Nadajnik:

Kod:
#include <SPI.h>

#include "nRF24L01.h"

#include "RF24.h"

int msg[1];

RF24 radio(9,10);

const uint64_t pipe = 0xE8E8F0F0E1LL;

void setup(void){

  pinMode(4,INPUT_PULLUP); // Tact switch nr1 , podciagniety do stanu wysokiego 

  pinMode(5,INPUT_PULLUP); // Tact switch nr2

  radio.begin();

  radio.openWritingPipe(pipe); 

}

void loop () {

  if (digitalRead(4) == LOW) {   // jesli odczyt na pinie 4 (przycisk nr 1 OFF) jest niski to wykonaj..

    msg[0] = 110;  // wpisywanie do zmiennej msg wartosci 110 

    radio.write(msg, 1); // Wysylanie wartosci ze zmiennej msg

    delay(50); 

    radio.write(msg, 1); // wysylamy ponownie po 50ms poniewaz czasami nasza "wiadomosc" nie dociera

  }

 if (digitalRead(5) == LOW){ // przycisk nr 2 ON

 msg[0] = 111; // inna wartosc  w tym przypadku 111

 radio.write(msg, 1); // wysylamy wartosc ze zmiennej msg

 delay(50);

 radio.write(msg, 1); // wysylamy ponownie po odczekaniu 50ms poniewaz nie zawsze "wiadomosc" dociera do obiornika 

 }

}

Odbiornik :

Kod:
#include <SPI.h>

#include "nRF24L01.h"

#include "RF24.h"

int msg[1];

RF24 radio(9,10);

const uint64_t pipe = 0xE8E8F0F0E1LL;

void setup(void){

Serial.begin(9600);

 radio.begin();

 radio.openReadingPipe(1,pipe);

 radio.startListening(); 

 pinMode(7, OUTPUT); // dioda 

 }

void loop(void){

 if (radio.available()){

   bool done = false;    

   while (!done){

     done = radio.read(msg, 1);       

     Serial.println(msg[0]); // wyswietlamy na serial monitor wartosc ze zmniennej msg 

     if (msg[0] == 111){delay(10);digitalWrite(7, HIGH);} // jesli otrzymamy wartosc 111 to czekamy 10ms i ustawiamy stan wysoki na pinie 7

     if (msg[0] == 110){delay(10);digitalWrite(7, LOW);}  // jesli otrzymamy wartosc 110 czekamy 10ms i ustaiwamy stan niski na pinie 7

     delay(10);}}

 else{Serial.println("Nic nie dostałem :(");}}

Dodam tylko że używając odpowiedniej biblioteki możemy stworzyć dość pokaźną sieć tych modułów gdzie zasięg będzie o wiele większy, trzeba tylko pamiętać że nie można przesadzić z ilością przesyłanych danych na pakiet ( max 32 bity ).
Pisząc sieć mam na myśli:

http://tmrh20.github.io/RF24Network_Dev/Tuning.html

Poza tym dostępne są te moduły ze wzmacniaczem i anteną.

Witam,

Po wczytaniu kodu odbiornika i próbie wykonania kompilacji wyskakuje mi taki błąd...

[Obrazek: odbiornik.jpg]

Witam ponownie...

Niestety na moje zapytanie w poprzednim poście muszę sobie odpowiedzieć sam Smile

Po długich bojach w końcu opanowałem transmisję na nRF2401.
Poniżej chciałbym przedstawić najprostsze rozwiązanie jakie udało mi się napisać do obsługi
w jednym kierunku czyli nadajnik --> odbiornik.

Mam nadzieję, że komuś może się to przyda do szybkiego sprawdzenia modułów nRF2401.

Kod wgrywany do Arduino, który będzie nadajnikiem:

Kod:
//Nadajnik nRF2401.

#include <SPI.h>

#include "nRF24L01.h"

#include "RF24.h"

int msg[1];

RF24 radio(9,10);

const uint64_t pipe = 0xE8E8F0F0E1LL;

void setup(void)

{

  radio.begin();

  radio.openWritingPipe(pipe); 

}

void loop () 

{                            

    msg[0] = 123;              

    radio.write(msg, 1);        

    delay(500); 

}

Kod wgrywany do Arduino, który będzie odbiornikiem:

Kod:
//Odbiornik nRF2401.

#include <SPI.h>

#include "nRF24L01.h"

#include "RF24.h"

int msg[1];

RF24 radio(9,10);

const uint64_t pipe = 0xE8E8F0F0E1LL;

void setup(void)

{

  Serial.begin(9600);

  radio.begin();

  radio.openReadingPipe(1,pipe);

  radio.startListening(); 

}

void loop(void)

{

  if (radio.available())

  {

    radio.read(msg, 1);  

    Serial.println(msg[0]);

    delay(100);

  }

}

Oczywiście aby sprawdzić czy jest transmisja musimy uruchomić monitor szeregowy na porcie odbiornika.
Wówczas powinna w nim pojawiać się co chwilę wartość: 123

Pozdrawiam i powodzenia.
ANT

Czy jeżeli podepnę przewody pod icsp ? do musze to gdzieś zmieniąć ? bo te piny które są podane na początku chciałem wykorzystać do wyświetlacza.

No dobra chłopaki tak mi się nie chciało ale trudno rękawicę podniosłem to trzeba powalczyć Wink

Napisałem programik do wysyłania danych w ilościach hurtowych z czujników serw co tam kto chce ,
dane zdeklarowane w strukturach jako int ale mogą być jako jakiekolwiek dane liczbowe byte , long .

poniżej 2 kody dla modułu 1 i 2 komunikacja w 2 kierunkach i wysyłanie danych w pakietach ,
dane są wysyłane po naciśnięciu przycisku na pinie 3 , pin 4 powoduje zapytanie i odpowiedź czyli
wysłanie danych na żądanie . program po drobnych przeróbkach niema ograniczenia ilości modułów
w chmurze .

Nadajnik 1

Kod:
#include <SPI.h>

#include "nRF24L01.h"

#include "RF24.h"

RF24 radio(9,10);  

const uint64_t pipe = 0xF0F0F0F0E1LL;

rf24_pa_dbm_e paLevel = RF24_PA_MAX;

typedef struct{ // Dane do wysłania 

  byte X,Y; // sygnatura nadawania i odbioru

  int A,B,C,D,E,F,G,H,I;                              

}

W_t;

typedef struct{ // Dane odebrane

  byte X,Y; // sygnatura nadawania i odbioru

  int A,B,C,D,E,F,G,H,I;               

}

O_t;

W_t Send_data;     // Struktura danych wysłanych

O_t Recive_data;   // Struktura danych odebranych

int A_1,B_1,C_1,D_1,E_1,F_1,G_1,H_1,I_1 ;

byte state = LOW;

byte state1 = LOW;

void setup() {

  Serial.begin(115200);

  pinMode(3 , INPUT_PULLUP);

  pinMode(4 , INPUT_PULLUP);

  radio.begin();                 

  radio.openWritingPipe(pipe);

  radio.openReadingPipe(1,pipe);

  radio.startListening();

  delay(500);

  Serial.println("gotowy NRF-1");

  Send_data.Y = 0;

}

void loop() {

  if ( digitalRead(3) == LOW and state == LOW ){state = HIGH;

      Send_data.X = 2;Send_data.Y = 0;Radio();}

      // Send_data.X = 2 określa nam moduł do którego wysyłamy dane 

  if ( digitalRead(3) == HIGH )state = LOW;

  if ( digitalRead(4) == LOW and state1 == LOW ){state1 = HIGH;

      Send_data.Y = 1;Send_data.X = 0;Radio();}

      // Send_data.Y = 1 określa nam moduł który prosi o dane zwrotne  

  if ( digitalRead(4) == HIGH )state1 = LOW;

  if (radio.available()){ // Sprawy radiowe tak ma być

    bool done = false;

    while (!done){

    done = radio.read( &Recive_data, sizeof(Recive_data) );

    Radio();}

  }   

}

 void Radio(){

  if ( Recive_data.Y > 0 ){Send_data.X = Recive_data.Y;}

     // linia powyżej ustala kto wysłał zapytanie i komu odpowiedzieć 

  if ( Send_data.X > 0 or Send_data.Y > 0 ){ 

  // odpowiedz jak otrzymasz zapytanie lub wyślij do ...

      if (Send_data.Y > 0){Serial.print("Odpowiedz dla NRF-");Serial.println(Send_data.Y);}

      if (Send_data.X > 0){Serial.print("Wysylam do NRF-");Serial.println(Send_data.X);}

       Send_data.A = 11;    // wyślij dane od A do I na zapytanie    

       Send_data.B = 12;    // czyli inny modół wysyła X o wartości 1

       Send_data.C = 13;    // lub po naciśnięciu przycisku na pinie 4

       Send_data.D = 14;                  

       Send_data.E = 15;         

       Send_data.F = 16;          

       Send_data.G = 17;          

       Send_data.H = 18;         

       Send_data.I = 19;

       Send_data.Y ;       

     radio.stopListening();

     radio.write( &Send_data, sizeof(Send_data) );

     radio.startListening();

    }

    if ( Recive_data.X == 1 ){

      A_1 = Recive_data.A;       // po odebraniu wartości X = 11      

      B_1 = Recive_data.B;       // podstaw do zmiennych A_1 do I-1 

      C_1 = Recive_data.C;       // wartości odebrane A - I  

      D_1 = Recive_data.D;                  

      E_1 = Recive_data.E;         

      F_1 = Recive_data.F;          

      G_1 = Recive_data.G;          

      H_1 = Recive_data.H;         

      I_1 = Recive_data.I; 

      Print_data();              

    }

    Recive_data.X = 0 ; // Skasuj rejestr odbioru czekaj na następne połączenie

    Send_data.X = 0;

    Recive_data.Y = 0;

    Send_data.Y = 0;

  }

void Print_data(){

  Serial.println("NRF-1 odebralem");

  Serial.println(A_1);  // wydrukuj nasze odebrane dane

  Serial.println(B_1);

  Serial.println(C_1);

  Serial.println(D_1);

  Serial.println(E_1);

  Serial.println(F_1);

  Serial.println(G_1);

  Serial.println(H_1);

  Serial.println(I_1);

}

Nadajnik 2

Kod:
#include <SPI.h>

#include "nRF24L01.h"

#include "RF24.h"

RF24 radio(9,10);  

const uint64_t pipe = 0xF0F0F0F0E1LL;

rf24_pa_dbm_e paLevel = RF24_PA_MAX;

typedef struct{ // Dane do wysłania 

  byte X,Y; // sygnatura nadawania i odbioru

  int A,B,C,D,E,F,G,H,I;                              

}

W_t;

typedef struct{ // Dane odebrane

  byte X,Y; // sygnatura nadawania i odbioru

  int A,B,C,D,E,F,G,H,I;               

}

O_t;

W_t Send_data;     // Struktura danych wysłanych

O_t Recive_data;   // Struktura danych odebranych

int A_1,B_1,C_1,D_1,E_1,F_1,G_1,H_1,I_1 ;

byte state = LOW;

byte state1 = LOW;

void setup() {

  Serial.begin(115200);

  pinMode(3 , INPUT_PULLUP);

  pinMode(4 , INPUT_PULLUP);

  radio.begin();                 

  radio.openWritingPipe(pipe);

  radio.openReadingPipe(1,pipe);

  radio.startListening();

  delay(500);

  Serial.println("gotowy NRF-2");

  Send_data.Y = 0;

}

void loop() {

   if ( digitalRead(3) == LOW and state == LOW ){state = HIGH;

      Send_data.X = 1;Send_data.Y = 0;Radio();}

      // Send_data.X = 1 określa nam moduł do którego wysyłamy dane 

  if ( digitalRead(3) == HIGH )state = LOW;

  if ( digitalRead(4) == LOW and state1 == LOW ){state1 = HIGH;

      Send_data.Y = 2;Send_data.X = 0;Radio();}

      // Send_data.Y = 2 określa nam moduł który prosi o dane zwrotne  

  if ( digitalRead(4) == HIGH )state1 = LOW;

  if (radio.available()){ // Sprawy radiowe tak ma być

    bool done = false;

    while (!done){

    done = radio.read( &Recive_data, sizeof(Recive_data) );

    Radio();}

  }   

}

 void Radio(){

  if ( Recive_data.Y > 0 ){Send_data.X = Recive_data.Y;}

     // linia powyżej ustala kto wysłał zapytanie i komu odpowiedzieć 

  if ( Send_data.X > 0 or Send_data.Y > 0 ){ 

    // odpowiedz jak otrzymasz zapytanie lub wyślij do ...

      if (Send_data.Y > 0){Serial.print("Odpowiedz dla NRF-");Serial.println(Send_data.Y);}

      if (Send_data.X > 0){Serial.print("Wysylam do NRF-");Serial.println(Send_data.X);}

       Send_data.A = 21;    // wyślij dane od A do I na zapytanie    

       Send_data.B = 22;    // czyli inny modół wysyła X o wartości 1

       Send_data.C = 23;    // lub po naciśnięciu przycisku na pinie 4

       Send_data.D = 24;                  

       Send_data.E = 25;         

       Send_data.F = 26;          

       Send_data.G = 27;          

       Send_data.H = 28;         

       Send_data.I = 29;            

       Send_data.Y ; 

     radio.stopListening();

     radio.write( &Send_data, sizeof(Send_data) );

     radio.startListening();

    }

     if ( Recive_data.X == 2 ){

      A_1 = Recive_data.A;       // po odebraniu wartości X = 11      

      B_1 = Recive_data.B;       // podstaw do zmiennych A_1 do I-1 

      C_1 = Recive_data.C;       // wartości odebrane A - I  

      D_1 = Recive_data.D;                  

      E_1 = Recive_data.E;         

      F_1 = Recive_data.F;          

      G_1 = Recive_data.G;          

      H_1 = Recive_data.H;         

      I_1 = Recive_data.I; 

      Print_data();              

    }

    Recive_data.X = 0 ; // Skasuj rejestr odbioru czekaj na następne połączenie

    Send_data.X = 0;

    Recive_data.Y = 0;

    Send_data.Y = 0;

  }

void Print_data(){

  Serial.println("NRF-2 odebralem");

  Serial.println(A_1);  // wydrukuj nasze odebrane dane

  Serial.println(B_1);

  Serial.println(C_1);

  Serial.println(D_1);

  Serial.println(E_1);

  Serial.println(F_1);

  Serial.println(G_1);

  Serial.println(H_1);

  Serial.println(I_1);

}

(14-11-2015, 22:49)ANT napisał(a): [ -> ]Witam ponownie...

Niestety na moje zapytanie w poprzednim poście muszę sobie odpowiedzieć sam
Po długich bojach w końcu opanowałem transmisję na nRF2401.
Poniżej chciałbym przedstawić najprostsze rozwiązanie jakie udało mi się napisać do obsługi
w jednym kierunku czyli nadajnik --> odbiornik.

Mam nadzieję, że komuś może się to przyda do szybkiego sprawdzenia modułów nRF2401.

Kod wgrywany do Arduino, który będzie nadajnikiem:

Kod:
//Nadajnik nRF2401. #include <SPI.h> #include "nRF24L01.h" #include "RF24.h" int msg[1]; RF24 radio(9,10); const uint64_t pipe = 0xE8E8F0F0E1LL; void setup(void) { radio.begin(); radio.openWritingPipe(pipe); } void loop () { msg[0] = 123; radio.write(msg, 1); delay(500); }

Kod wgrywany do Arduino, który będzie odbiornikiem:

Kod:
//Odbiornik nRF2401. #include <SPI.h> #include "nRF24L01.h" #include "RF24.h" int msg[1]; RF24 radio(9,10); const uint64_t pipe = 0xE8E8F0F0E1LL; void setup(void) { Serial.begin(9600); radio.begin(); radio.openReadingPipe(1,pipe); radio.startListening(); } void loop(void) { if (radio.available()) { radio.read(msg, 1); Serial.println(msg[0]); delay(100); } }

Oczywiście aby sprawdzić czy jest transmisja musimy uruchomić monitor szeregowy na porcie odbiornika.
Wówczas powinna w nim pojawiać się co chwilę wartość: 123

Pozdrawiam i powodzenia.
ANT

Głupie zagadnienie - mam Mega 2560 i Micro Pro. Ponieważ dopiero zaczynam mam dość prosty problem.
Czy w/w kod będzie się nadawał do tych modułów ?

Jeśli tak to gdzie podpiąć przewody CS i CE w jednym i drugim module. Próbuję cały dzień przykład RF24/usege/led_remote i nic mi nie wychodzi, a bardzo chcę zrobić takie zdalne sterowanie po WiFi.

Moduły NRF24L01 te z dużą antenką o dużym zasięgu.

NRF24L01 to nie są nadajniki WiFi. Częstotliwość jest ta sama ale to nie to. A kable zależy co w programie podałeś RF24 radio(x, x); zamiast x wstawiasz nr pinów do których masz podpięte te przewody.

Wysłane z mojego ALE-L21 przy użyciu Tapatalka

m.bielak91

shalvan

ANT

ANT

byniom

JasQ

jetstream

Deletor