Komunikacja między 2 Arduino nRF24l01+ - m.bielak91 - 04-08-2015
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 Z własnego doświadczania wiem że ten zasięg to 50-60 m ale za 5zł nie można spodziewać się cudów
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)
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 :(");}}
RE: Komunikacja między 2 Arduino nRF24l01+ - shalvan - 20-09-2015
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ą.
RE: Komunikacja między 2 Arduino nRF24l01+ - ANT - 12-11-2015
Witam,
Po wczytaniu kodu odbiornika i próbie wykonania kompilacji wyskakuje mi taki błąd...
RE: Komunikacja między 2 Arduino nRF24l01+ - ANT - 14-11-2015
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
RE: Komunikacja między 2 Arduino nRF24l01+ - byniom - 20-12-2015
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.
RE: Komunikacja między 2 Arduino nRF24l01+ - JasQ - 21-12-2015
No dobra chłopaki tak mi się nie chciało ale trudno rękawicę podniosłem to trzeba powalczyć
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);
}
RE: Komunikacja między 2 Arduino nRF24l01+ - jetstream - 26-06-2016
(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.
RE: Komunikacja między 2 Arduino nRF24l01+ - Deletor - 26-06-2016
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
|