• Witaj na Forum Arduino Polska! Zapraszamy do rejestracji!
  • Znajdziesz tutaj wiele informacji na temat hardware / software.
Witaj! Logowanie Rejestracja


Ocena wątku:
  • 1 głosów - średnia: 5
  • 1
  • 2
  • 3
  • 4
  • 5
Komunikacja między 2 Arduino nRF24l01+
#1
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 :(");}}
 
Odpowiedź
#2
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ą.
 
Odpowiedź
#3
Witam,

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

[Obrazek: odbiornik.jpg]
Jeżeli pomogłem, to poproszę o punkt reputacji Big Grin
 
Odpowiedź
#4
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
Jeżeli pomogłem, to poproszę o punkt reputacji Big Grin
 
Odpowiedź
#5
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.
 
Odpowiedź
#6
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);

}
Ważne aby robić co się lubi albo lubić co się robi .
Arduino UNO, TINY, PRO MINI
Pomoc nagradzamy punktami reputacji Wink
 
Odpowiedź
#7
(14-11-2015, 22:49)ANT napisał(a): 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

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.
 
Odpowiedź
#8
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
 
Odpowiedź
  


Skocz do:


Przeglądający: 1 gości