[24] Arduino - Transmisja radiowa nRF24L01+

W tym poście chciałbym przedstawić sposób wykonania transmisji bezprzewodowej za pomocą modułu nRF24L01+.

Opis modułu

Moduł transmisji opiera się na paśmie 2.4 GHz. Płytka zawiera wbudowaną antenę. Teoretyczny zasięg deklarowany w idealnych warunkach ma wynosić 100m. Zbadany zasięg pozwala na osiągnięcie odległości około 25m.

Poniżej przedstawiam opis najważniejszych elementów układu:

• Zasilanie 3.3V, Akceptowane z zakresu od 1.9V do 3.6V.
• Pobór prądu - odbieranie 13mA, wysyłanie 12mA
• Częstotliwość 2,4GHz
• Prędkość transmisji 250kbps, 1Mbps, 2Mbps
• Antena wbudowana w moduł
• Wzmocnienie sygnału 0 dB, -6 dB, -12 dB, -18 dB,

Rys. 1. nRF24L01+

Podczas odbierania danych pobierany jest prąd o wartości 13 mA. Natomiast podczas odbioru 12 mA. Wartość pobieranego prądu można zmniejszyć wykorzystując jeden ze stanów oszczędzania energii.

Układ posiada następujące wyprowadzenia:

• GND - Masa
• VCC - Zasilanie
• CE - Pin aktywacyjny(Chip Enable)
• CSN - Wyjście wybierające (Chip Select)
• SCK - Sygnał zegarowy (Serial Clock)
• MOSI - Dane dla układu peryferyjnego (Master Output Slave Input) 

Pin aktywacyjny CE odpowiada za wybranie sposobu pracy układu czy będzie występowało nadawanie bądź odbieranie danych. Piny CSN, SCK, MOSI oraz MISO są wyprowadzeniami interfejsu SPI. Mają one za zadanie wybranie układu peryferyjnego, zadania sygnału taktujące, obsługi danych wejściowych oraz wyjściowych.

Do transmisji danych wykorzystywana jest modulacja GFSK. Jest ona odmianą modulacji FSK, która jest stosowana przy wykonywaniu różnego typu łączności bezprzewodowej. Wartość logicznej jedynki jest generowana poprzez dodanie odchylenia częstotliwości , natomiast logiczne zero jest wyrażone poprzez ujemne odchylenie.

Ten moduł nie posiada wzmacniacza sygnału, możliwe jest wyłącznie tłumienie sygnału, w celu obniżenia wartości prądu jaki jest potrzebny do działania układu. Poniżej przedstawiam listę możliwych wartości wzmocnienia wraz z wartością prądu jaki jest pobierany:

• 0dBm - 11,3 mA
• -6dBm - 9mA
• -12dBm - 7,5mA
• -18dBm - 7,0mA

Oczywiście im mniejsza wartość wzmocnienia tym zasięg ulega drastycznemu zmniejszeniu. Przy wartości -18dBm, efektywny zakres pracy będzie się znajdował w granicach 2-3 metów.

Podłączenie

Układ należy podłączyć w następujący sposób:
VCC - 3,3V
GND - GND
MOSI - Pin 11 Arduino
MISO - Pin 12 Arduino
SCK - Pin 13 Arduino
CE - Pin 2 Arduino
CSN - Pin 3 Arduino

Dodatkowo jak najbliżej układu dobrze jest podłączyć kondensator 10uF. Inny sposób polega na podłączeniu dwóch równolegle jeden 10uF, drugi natomiast 0,1uF. 

Rozkład pinów na module do komunikacji jest taki jak na rysunku 2.

Rys. 2. Rozmieszczenie wyprowadzeń

Programowanie

Wykorzystywane są moduły jeden pracuje w trybie nadajnika, drugi natomiast jako odbiornik.

Pierwszy program będzie wysyłał stałą wartość w postaci ciągu znaków co określony interwał czasowy.

1. //Dołączone biblioteki
2. #include <SPI.h>
3. #include <nRF24L01.h>
4. #include <RF24.h>
6. //Obiekt o nazwie radio
7. //Jako dane piny do podłączenia
8. //Odpowiednio CE oraz CSN
9. RF24 radio(2, 3);
11. //Stworzenie tablicy
12. //z podanym adresem urządzenia
13. //Istotne w przypadku podłączenie
14. //kilku takich modółów
15. const byte rxAddr[6] = "00001";
17. void setup()
18. {
19.   //Aktywacja układu
20.   radio.begin();
21.   //ilosc prob jakie nastapia
22.   //do utraty polaczenia, w tym przypadku
23.   //wystąpi 20 prób
24.   radio.setRetries(20, 20);
25.   //dodanie nazwy adresu odbiornika z ktorym
26.   //nastąpi komunikacja
27.   radio.openWritingPipe(rxAddr);
29.   //przełączenie układu do trybu transmisji
30.   radio.stopListening();
31. }
33. void loop()
34. {
35.   //zdefiniowanie tablicy z danymi
36.   const char text[] = "Dziala!";
38.   //Przeslanie danych
39.   radio.write(&text, sizeof(text));
41.   //Funckja opozniajaca
42.   delay(4000);
43. }

Teraz wersja oprogramowania dla odbiornika.

1. //Dołączone biblioteki
2. #include <SPI.h>
3. #include <nRF24L01.h>
4. #include <RF24.h>
6. //Obiekt o nazwie radio
7. //Jako dane piny do podłączenia
8. //Odpowiednio CE oraz CSN
9. RF24 radio(2, 3);
11. //Stworzenie tablicy
12. //z podanym adresem urządzenia
13. //Istotne w przypadku podłączenie
14. //kilku takich modółów
15. const byte rxAddr[6] = "00001";
17. void setup()
18. {
19.   //Oczekiwanie na włączenie
20.   //transmisji szeregowej
21.   while (!Serial);
22.   Serial.begin(9600);
24.   //Aktywacja układu
25.   radio.begin();
26.   //Podanie adresu oraz liczby strumieni
27.   //z danymi
28.   radio.openReadingPipe(0, rxAddr);
30.   //przełączenie układu do trybu transmisji
31.   radio.startListening();
32. }
34. void loop()
35. {
36.   //sprawdzenie czy jakies dane zostały dostarczone
37.   if (radio.available())
38.   {
39.     //Definicja tablicy z danymi
40.     char text[32] = {0};
41.     //Odczytanie danych
42.     radio.read(&text, sizeof(text));
44.     //Wyswietlenie danych
45.     Serial.println(text);
46.   }
47. }

Kolejny program będzie odczytywał dane z potencjometru, które po przesłaniu będą wyświetlane poprzez port szeregowy oraz wyświetlacz ze sterownikiem HD44780 podłączony poprzez konwerter I2C.

W pierwszej kolejności przychodzi program z nadajnika:

1. //Dołączone biblioteki
2. #include <SPI.h>
3. #include <nRF24L01.h>
4. #include <RF24.h>
6. //Obiekt o nazwie radio
7. //Jako dane piny do podłączenia
8. //Odpowiednio CE oraz CSN
9. RF24 radio(2, 3);
11. //Stworzenie tablicy
12. //z podanym adresem urządzenia
13. //Istotne w przypadku podłączenie
14. //kilku takich modółów
15. const byte rxAddr[6] = "00001";
16. const int PotPin = 0;
17. int PotencjometrWar;
18. char Pomocnicza;
20. void setup()
21. {
22.   //Oczekiwanie na włączenie
23.   //transmisji szeregowej
24.   while (!Serial);
25.   Serial.begin(9600);
27.   //Aktywacja układu
28.   radio.begin();
30.   //ilosc prob jakie nastapia
31.   //do utraty polaczenia, w tym przypadku
32.   //wystąpi 20 prób
33.   radio.setRetries(20, 20);
34.   //dodanie nazwy adresu odbiornika z ktorym
35.   //nastąpi komunikacja
36.   radio.openWritingPipe(rxAddr);
38.   //przełączenie układu do trybu transmisji
39.   radio.stopListening();
40. }
42. void loop()
43. {
44.   PotencjometrWar = analogRead(PotPin);
45.   //Pomocnicza = int(PotencjometrWar);
46.   //zdefiniowanie tablicy z danymi
47.   int wart = PotencjometrWar;
49.   //Przeslanie danych
50.   radio.write(&wart, sizeof(wart));
52.   //Funckja opozniajaca
53.   delay(1000);
55.   //Wyswietlenie danych
56.   Serial.println(PotencjometrWar);
57.   Serial.println(wart);
58. }

Program dla odbiornika:

1. //Dołączone biblioteki
2. #include <SPI.h>
3. #include <nRF24L01.h>
4. #include <RF24.h>
5. #include <Wire.h>  
6. #include <LiquidCrystal_I2C.h>
8. //Ustawienie adresu układu
9. LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
11. //Obiekt o nazwie radio
12. //Jako dane piny do podłączenia
13. //Odpowiednio CE oraz CSN
14. RF24 radio(2, 3);
16. //Stworzenie tablicy
17. //z podanym adresem urządzenia
18. //Istotne w przypadku podłączenie
19. //kilku takich modółów
20. const byte rxAddr[6] = "00001";
22. void setup()
23. {
24.   //Oczekiwanie na włączenie
25.   //transmisji szeregowej
26.   while (!Serial);
27.   Serial.begin(9600);
29.   //Aktywacja układu
30.   radio.begin();
32.   //Rozpoczęcie pracy wyświetlacza
33.   lcd.begin(16,2);
35.   //Włączenie podświetlania
36.   lcd.backlight();
38.   //Ustawienie kursora w pozycji poczatkowej
39.   lcd.setCursor(0,0);
41.   //Podanie adresu oraz liczby strumieni
42.   //z danymi
43.   radio.openReadingPipe(0, rxAddr);
45.   //przełączenie układu do trybu transmisji
46.   radio.startListening();
47. }
49. void loop()
50. {
51.   //sprawdzenie czy jakies dane zostały dostarczone
52.   if (radio.available())
53.   {
54.     lcd.clear();
55.     //Definicja tablicy z danymi
56.     int wart = 0;
57.    
58.     //Odczytanie danych
59.     radio.read(&wart, sizeof(wart));
61.     lcd.println(wart);
63.     //Wyswietlenie danych
64.     Serial.println(wart);
65.   }
66. }