Arduino Transceiver modul
NRF24L01 er et modul, der kan bruges til at sende og modtage data fra en microcontroller til en anden.
Dette betyder, at modulet både kan bruges som transmitter og receiver. Men det skal dog stadigvæk have klare instrukser om, hvilket af de to stadier den skal være i, altså om den skal sende eller modtage, så derfor er to vejs kommunikation ikke så lige til, som f.eks. bluetooth er.
Selve modulet kører på 2.4 GHz båndet, hvilket er det samme som de fleste wifi kommunikationer. Modulet er i stand til at levere data med 2 Mbps, hvilket er forholdsvist meget, for en så lille og billig chip.
Modulet har et meget lavt strømforbrug, da det maksimalt bruger 14 mA, samt har en "standby" funktion, hvilket bruger få µA. Dette gør modulet ideelt til projekter, som kører på batteri.
Uddybende information om modulet kan findes her [1]
Databladet for modulet kan findes på Nordic Semiconducter's hjemmeside [2]
Modulet kan skaffes forskellige steder [3] [4].
Uddybende information om NRF24L01
Forskellige versioner
NRF24L01 modulerne, er en serie af billige RF moduler, baseret på "Nordic Semiconductor nRF24L01+" chippen.
De findes i flere forskellige versioner. Både med indbyggede antenner i printpladen (low-power version) og eksterne antenner (high-power version). De mest almindelige og billigste er dem med antennen indbygget i printpladen. Disse opnår dog ikke en rækkevidde, som er nær så lang som dem med eksterne antenner.
Rækkevidde
Modulerne med indbygget antenne, reklameres med at have en rækkevidde op til 100 meter. Dette er dog, under meget optimale forhold. Dette vil sige udenfor, uden nogen forhindringer og med en solid strømkilde. Derudover vil man heller ikke kunne bruge de fulde 2 Mbps, hvis man vil opnå så stor rækkevidde med low-power versionen. Indenfor vil man igennem mure kunne opnå ca. 10 meter. Der er dog visse ting, der kan gøre, for at gøre rækkevidden bedre. Dette vil der stå mere om, under afsnittet forbedring af rækkevidden
Med den eksterne antenne, vil man med nogle moduler kunne opnå en rækkevidde på op til 1 km.
Her ses en video af youtuberen "iforce2d", som laver en sammenligning af rækkevidden på nogle forskellige moduler:
Han har også lavet et forsøg, hvor han formåede at få en rækkevidde på over 31 km, med et NRF24L01 modul, med en stor antenne. Det er ca den samme afstand, som der er fra Holstebro og til Herning.
Brug af NRF24L01
Biblioteker
Der findes flere forskellige biblioteker til modulet, som alle sammen gør det meget nemmer at benytte det ellers meget komplekse modul. Det mest udførlige, samt det bibliotek der vil blive brugt i eksemplerne er TMRh20's RF24 bibliotek. Det kan findes i Arduinoens IDE under Sketch - Include Library - Manage Libraries... Søg der efter "RF24" og led efter biblioteket fra TMRh20. Eller download biblioteket fra github. [5]
Opkobling af modul (Hardware)
Det er meget vigtigt, at være klar over, at modulet kører på 3.3V(1.9 til 3.6V) og ikke 5V, som ellers er normalt for de fleste arduino moduler! Heldigvis er alle data benene 5V tolerante, hvilket betyder, at de kan kobles direkte op til arduinoens data pins.
Det kan være besværligt, at finde ud af, hvilke pins der skal hvortil første gang man bruger modulet, men en let måde at kende det på, er ved at kigge efter den firkantede solder pad. Dette er pin 1, hvorefter de tæller opad i 4 rækker.
Dette billede viser modulet set oppefra.
Det er muligt at ændre på de to pins CE og CSN i programmet man skriver, hvilket vil sige, at de kan bruges på andre pins i stedet. Men SCK, MOSI og MISO er bestemt efter, hvilke pins modulet, som man kobler sin NRF op til, bruger til SPI kommunikation.
Der er en del forskellige måder at koble modulet op, alt efter hvilket library man bruger.
| Ben | Navn | Note | TMRh20-RF24 | RF24 | Mirf | RH_NRF24 | RF24(Mega) | RH_NRF24(Mega) |
|---|---|---|---|---|---|---|---|---|
| 1 | GND | Stel | GND | GND | GND | GND | GND | GND |
| 2 | VCC | 3.3V! | 3.3V* | 3.3V* | 3.3V* | 3.3V* | 3.3V* | 3.3V* |
| 3 | CE | - | 7 | 9 | 8 | 8 | 9 | 8 |
| 4 | CSN | - | 8 | 10 | 7 | 10 | 53 | 53 |
| 5 | SCK | - | 13 | 13 | 13 | 13 | 52 | 52 |
| 6 | MOSI | - | 11 | 11 | 11 | 11 | 51 | 51 |
| 7 | MISO | - | 12 | 12 | 12 | 12 | 50 | 50 |
| 8 | IRQ | - | -** | 2 | -** | -** | 2 | -** |
Hvis man bruger TMRh20's bibliotek, kan andre moduler kobles op på følgende måde:
| Ben | Navn | Note | Arduino UNO | Arduino Mega | ATtiny25/45/85 | ATtiny44/84 | RPi |
|---|---|---|---|---|---|---|---|
| 1 | GND | Stel | GND | GND | pin 4 | pin 14 | RPi-GND |
| 2 | VCC | 3.3V! | 3.3V* | 3.3V* | pin 8 | pin 1 | RPi-3v3 |
| 3 | CE | - | 7 | 7 | pin 2 | pin 12 | RPi-GPIO22 |
| 4 | CSN | - | 8 | 8 | pin 3 | pin 11 | RPi-GPIO8 |
| 5 | SCK | - | 13 | 52 | pin 7 | pin 9 | RPi-sckl |
| 6 | MOSI | - | 11 | 51 | pin 6 | pin 7 | RPi-mosi |
| 7 | MISO | - | 12 | 50 | pin 5 | pin 8 | RPi-miso |
| 8 | IRQ | - | -** | -** | -** | -** | -** |
Bemærk! Ved de to arduino boards, bliver der refereret til deres digitale outputs, mens de to ATtiny chips, refererer til deres respektive pins på selve microcontrolleren.
* Grunden til mange problemer med modulet, er at arduinoens indbyggede 3.3V ikke kan give så meget strøm, som modulet har brug for under de meget korte sendinger af data. Arduino Mega'en er det største problem. Læs mere om dette problem, og hvordan man løser det under forbedring af rækkevidden
Dette betyder ikke, at man ikke kan bruge de indbyggede 3.3V fra arduinoen. Man kan bare ikke forvente lige så gode resultater.
** Det er ikke alle biblioteker, der benytter sig af IRQ, men RF24 biblioteket benytter sig af det i nogle eksempler.
Sending af data (Software)
Kommandoer
Der findes et hav af kommandoer til dette modul, som alle kan findes på TMRH20's side for modulet. [6] Dog vil der kun blive gennemgået de basale, så det er muligt at få modulet op at køre.
Det først der skal gøres, er at starte en ny radio. Dette skal gøres både på afsender og modtager modulet. I dette tilfælde kalder vi den bare "radio", men den kan også hedde hvad som helst andet. Det er også her vi definerer hvilke pins, der skal bruges til hhv. CE og CS.
//Overordnet definition af kommando:
RF24 nameOfRadio(CEPIN, CSPIN); //nameOfRadio kan udskiftes med lige hvad man vil, og bruges i andre kommandoer, når man bruger modulet. uint8_t _cepin og uint8_t _cspin bestemmer hvilke pins man bruger som hhv. CE og CS pins.
//Eksempel:
RF24 radio(7,8); //I vores eksempel kalder vi radioen for radio og vi bruger pin 7 som CE og pin 8 som CS.Nu hvor vi har kaldt vores radio "radio", skal dette indgå i kommandoer, når vi bruger modulet. Dette gøre ved at skrive "radio" efterfulgt af et punktum, og derefter kommandoen man vil udføre.
For at kunne benytte vores modul, skal det først startes. Dette gøres med med følgende kommando:
//Overordnet definition af kommando:
nameOfRadio.begin(); //Indsæt navnet på din radio på nameOfRadio's plads
//Eksempel:
radio.begin(); //I dette tilfælde benytter vi vores navn "radio", som valgte i kommandoen ovenfor.Det er også muligt at indstille hastigheden, hvorved modulet overfører data til et andet modul. Grunden til, at dette er brugbart, forklares i sektionen med forbedring af rækkevidden. For at indstille hastigheden, skal følgende kommando bruges:
//Overordnet definition af kommando:
nameOfRadio.setDataRate(RF24_DATARATE); //I parenteserne, skal datahastigheden indsættes. Der er 3 forskellige muligheder.
//Eksempel:
radio.setDataRate(RF24_250KBPS); //Sæt data hastigheden til 250 Kbps, for at opnå maksimal rækkevidde.
radio.setDataRate(RF24_1MBPS); //Sæt data hastigheden til 1 Mbps, for at opnå middel hastighed og rækkevidde.
radio.setDataRate(RF24_2MBPS); //Sæt data hastigheden til 2 Mbps, for at opnå maksimal hastighed.Derudover er det også muligt at indstille, hvor meget strøm modulet bruger. Brugbarhede naf dette forklares under forbedring af rækkevidden. For at benytte sig af funktionen, benyttes følgende kommando:
//Overordnet definition af kommando:
nameOfRadio.setPALevel(RF24_POWER); //I parenteserne, skal strømniveauet af modulet sættes til et af de 4 følgende værdier.
//Eksempel:
radio.setPALevel(RF24_PA_MIN); //Sæt strømniveauet for modulet til det minimale
radio.setPALevel(RF24_PA_LOW); //Sæt strømniveauet for modulet til lav
radio.setPALevel(RF24_PA_HIGH); //Sæt strømniveauet for modulet til høj
radio.setPALevel(RF24_PA_MAX); //Sæt strømniveauet for modulet til det maksimaleDer skal vælges en kanal, som de moduler kan snakke over. Det er vigtigt, at den kanal man bruger, ikke bliver brugt af alt muligt andet udstyr, som kan lave interferens. Denne kanal kan gå fra 0 til 124, så det vil sige 125 forskellige kanaler. Under forbedring af rækkevidden står der mere om, hvorfor det er vigtigt at vælge den rigtige kanal. Kommandoen fungerer som følger:
//Overordnet definition af kommando:
nameOfRadio.setChannel(CHANNEL_NUMBER); //Kanalen sættes til et tal mellem 0 og 124.
//Eksempel:
radio.setChannel(108); //I dette eksempel sættes kanalen til 108.For at kommunikerer imellem de to moduler, skal der først laves et "rør" (pipe), som de to moduler kan snakke igennem. Dette rør, skal have en fælles adresse, kanal og datahastighed, for at de to moduler kan snakke sammen.
For at sende informationer, skal der åbnes et "skrive rør" (writing pipe). Dette gøres ved først at definere en adresse, og derefter lave et "skrive rør" med denne adresse på sendermodulet:
//Overordnet definition af kommando:
byte addresses[][6] = {ADDRESS}; //Indsæt den valgte adresse i ADDRESS.
nameOfRadio.openWritingPipe(addresses[0]); //Her er adressen indsat i kommandoen.
//Eksempel:
byte addresses[][6] = {"0"}; //I dette eksempel er adressen sat til "0".
radio.openWritingPipe(addresses[0]); //Adressen er indsat i kommandoenNu skal der tilsvarende også være et "læse rør" (reading pipe). Dette gøres på næsten samme måde, som med "skrive røret". Den eneste forskel er, at der skal et tal ind som en anden parameter i kommandoen. Følgende kommando skal stå i koden for modtagermodulet:
//Overordnet definition af kommando:
byte addresses[][6] = {ADDRESS}; //Indsæt den valgte adresse i ADDRESS.
nameOfRadio.openReadingPipe(1, addresses[0]); //Her er tallet 1, samt adressen indsat i kommandoen.
//Eksempel:
byte addresses[][6] = {"0"}; //I dette eksempel er adressen sat til "0".
radio.openReadingPipe(1, addresses[0]); //Her er tallet 1, samt adressen indsat i kommandoen.En anden meget vigtig kommando for modtager modulet er kommandoen der får modulet til at lytte:
//Overordnet definition af kommando:
nameOfRadio.startListening(); //Får modulet til at begynde at lytte.
//Eksempel:
radio.startListening(); //Får modulet til at begynde at lytte.For at sende noget til det andet modul, skal bestemme hvad for noget data der skal sendes, og hvor stor dataet er:
//Overordnet definition af kommando:
nameOfRadio.write(&DATA, sizeof(SIZE_OF_DATA); //Den første parameter skal være et & tegn, efterfulgt af det data der skal sendes, og den anden parameter skal være størrelsen af den type data.
//Eksempel:
int test = 42; //42 bliver gemt i variablen test.
radio.write(&test, sizeof(int); //42 bliver sendt, ved at sætte et & tegn foran variablen test's navn. Den anden parameter er størrelsen på en int.For at modtage data fra det andet modul, skal der gøres stort set det samme.
//Overordnet definition af kommando:
nameOfRadio.read(&DATA, sizeof(SIZE_OF_DATA); //Den første parameter skal være et & tegn, efterfulgt af det data der skal modtages, og den anden parameter skal være størrelsen af den type data.
//Eksempel:
int test; //Der allokeres plads til en int ved navn test,
radio.read(&test, sizeof(int); // Der bliver modtaget noget og gemt i variablen test.Dette er alle kommandoer der skal til, for at opbygge en simpel et vejs kommunikation. For at lave mere avancerede programmer, kan man bruge den fulde liste af kommandoer, samt nogle af de andre referencer der er linket til i bunden af siden.
Eksempel
Dette er et eksempel på et meget simpelt program, der sender noget data i en pakke fra et modul til et andet. Koden er skrevet af "educ8s.tv", som også har lavet en kort video, som forklarer de grundlæggende ting ved modulet.[7] Koden til modulet, samt biblioteket på daværende tidspunkt kan findes her
Sender modul:
#include <SPI.h> //Der skal bruges SPI for at kommunikere med modult.
#include "RF24.h" //Biblioteket for modulet tages i brug.
RF24 myRadio (7, 8); //Der laves en radio ved navn "myRadio", der benytter sig af pin 7 og 8.
byte addresses[][6] = {"0"}; //Adressen "0" benyttes til at kommunikere.
struct package //Der laves en struktur med data i.
{
int id = 1; //Nummer på pakken der bliver sendt.
float temperature = 18.3; //Fiktiv temperatur, der illustrerer at man kan sende flere forskellige typer af data på en gang.
char text[100] = "Text to be transmitted"; //Tekst der bliver sendt med hver pakke.
};
typedef struct package Package;
Package data; //Pakken bliver kaldt "data"
void setup()
{
Serial.begin(115200); //Der startes en seriel kommunikation med en båndbredde på 115200.
delay(1000); //Der er et delay på 1 sekund.
myRadio.begin(); //Radioen ved navn "myRadio" startes.
myRadio.setChannel(115); //Kanalen bliver sat til 115
myRadio.setPALevel(RF24_PA_MAX); //Strømniveauet for modulet bliver sat til MAX. (Dette gøres kun, da der bliver brugt en solid strømkilde.)
myRadio.setDataRate(RF24_250KBPS) ; //Båndbredden bliver sat til 250 KBPS, da der ikke skal bruges mere end det, for at sende de 3 typer data.
myRadio.openWritingPipe(addresses[0]); //Der startes et "skrive rør" med adressen, som blev sat til 0 tidligere.
delay(1000); //Endnu et delay på 1 sekund.
}
void loop()
{
myRadio.write(&data, sizeof(data)); //Pakken ved navn data bliver afsendt.
Serial.print("\nPackage:"); //Et linjeskift efterfulgt af "Package:" bliver skrevet til den serielle monitor.
Serial.println(data.id); //Id i pakken data bliver skrevet til den serielle monitor.
Serial.println(data.temperature); //Den fiktive temperatur bliver skrevet til den serielle monitor.
Serial.println(data.text); //Teksten bliver skrevet til den serielle monitor.
data.id++; //Id i pakken data bliver gjort 1 større.
data.temperature += 0.1; //Den fiktive temperatur bliver gjort 0.1 større.
delay(1000); //Der ventes i 1 sekund.
}Modtager modul
#include <SPI.h> //Der skal bruges SPI for at kommunikere med modult.
#include "RF24.h" //Biblioteket for modulet tages i brug.
RF24 myRadio (7, 8); //Der laves en radio ved navn "myRadio", der benytter sig af pin 7 og 8.
byte addresses[][6] = {"0"}; //Adressen "0" benyttes til at kommunikere.
struct package //Der laves en struktur med data i
{
int id; //Der gøres plads til en int ved navn "id"
float temperature; //Der gøres plads til en float ved navn "temperature"
char text[100]; //Der gøres plads til en char ved navn "text"
};
typedef struct package Package;
Package data; //Pakken bliver kaldt "data"
void setup()
{
Serial.begin(115200); //Der startes en seriel kommunikation med en båndbredde på 115200.
delay(1000); //Der er et delay på 1 sekund.
myRadio.begin(); //Radioen ved navn "myRadio" startes.
myRadio.setChannel(115); //Kanalen bliver sat til 115.
myRadio.setPALevel(RF24_PA_MAX); //Strømniveauet for modulet bliver sat til MAX. (Dette gøres kun, da der bliver brugt en solid strømkilde.)
myRadio.setDataRate(RF24_250KBPS); //Båndbredden bliver sat til 250 KBPS, da der ikke skal bruges mere end det, for at sende de 3 typer data.
myRadio.openReadingPipe(1, addresses[0]); //Der startes et "læse rør" med adressen, som blev sat til 0 tidligere.
myRadio.startListening(); //Modulet bliver sat til at lytte efter data.
}
void loop()
{
if (myRadio.available()) //Gør følgende, hvis der er data til rådighed.
{
while (myRadio.available()) //Gør følgende, så længe der er data til rådighed.
{
myRadio.read( &data, sizeof(data) ); //Læs data der er til rådighed og gem den i strukturen data.
}
Serial.print("\nPackage:"); //Et linjeskift efterfulgt af "Package:" bliver skrevet til den serielle monitor.
Serial.println(data.id); //Id i pakken data bliver skrevet til den serielle monitor.
Serial.println(data.temperature); //Den fiktive temperatur bliver skrevet til den serielle monitor.
Serial.println(data.text); //Teksten bliver skrevet til den serielle monitor.
}
}Det er klart anbefalet at uploade koden til sender modulet fra en computer og koden til modtager modulet fra en anden, da man på den måde nemmere kan overskue den serielle monitor fra begge moduler.
Forbedring af rækkevidden
Der kan gøres en række ting, for at forbedre rækkenvidden af NRF24L01 modulet:
- Den mest mærkbare ting, er at bruge en pålidelig 3.3V strømforsyning. Dette skyldes, at modulet bruger forholdsvist meget strøm i de meget korte øjeblikke, hvor den den sender data, selvom den alt i alt har et meget lavt strømforbrug. Arduinoen er nemlig kun i stand til at give 50 mA ved 3.3V. En løsning kan være, at bruge en anden strømforsyning eller bruge en bedre 3.3V regulator, til formindske arduinoens 5V, hvilket kan give rigeligt med strøm. Dette kan gøres, ved at bruge en såkaldt "NRF24L01 socket". Med dette modul er det muligt at bruge arduinoens 5V, mens det derudover også er nemmere at koble modulet til.
- En anden ting, der kan være med til at lave en mærkbar forskel, er at sætte en kondensator fra GND til VCC, så modulet kan suge lidt ekstra strøm, i de korte øjeblikke den har brug for det. Dette kan enten gøres på et breadboard, på en printplade, eller bare ved at lodde den direkte på modulet (Vær opmærksom på polaritet). Det er anbefalet at bruge en kondensator på mellem 3.3 og 10 µF. Nogle brugere har dog også haft meget god succes, med en kombination af en 10µF i parallel forbindelse med en 0.1µF kondensator.
- For at få så lang rækkevidde, som overhovedet muligt, er det en god idé, at sætte modulets strømniveau til det maksimale. Dette er dog kun, hvis den har mulighed for at benytte sig af så meget strøm, som den har brug for. Indtil man har en solid forbindelse, mellem to moduler, med en kort afstand imellem dem, er det en god idé at sætte strømniveauet til det minimale, og så derefter sætte det op. For at indstille strømniveuet, skal man skrive en af følgende fire kommandoer ind i setup:
radio.setPALevel(RF24_PA_MIN); //Sæt strømniveauet for modulet til det minimale
radio.setPALevel(RF24_PA_LOW); //Sæt strømniveauet for modulet til lav
radio.setPALevel(RF24_PA_HIGH); //Sæt strømniveauet for modulet til høj
radio.setPALevel(RF24_PA_MAX); //Sæt strømniveauet for modulet til det maksimale- Hvis man ikke har brug for, at benytte sig af de fulde 2 Mbps, som modulet kan levere, kan man opnå en smule bedre rækkevidde, ved at begrænse hastigheden, hvorved dataen bliver sendt. Dette skal også indsættes i setup:
radio.setDataRate(RF24_250KBPS); //Sæt data hastigheden til 250 Kbps, for at opnå maksimal rækkevidde.
radio.setDataRate(RF24_1MBPS); //Sæt data hastigheden til 1 Mbps, for at opnå middel hastighed og rækkevidde.
radio.setDataRate(RF24_2MBPS); //Sæt data hastigheden til 2 Mbps, for at opnå maksimal hastighed.- Modulet er i stand til at bruge en frekvens på mellem 2.4 GHz og 2.525 GHz. Dette betyder, at man kan undgå den frekvens, som mange Wifi-netværk og Bluetooth apparater benytter sig af, nemlig ~ 2.4GHz. Modulet har 125 mulige kanaler, med 1 MHz mellemrum imellem dem. De 25 højeste kanaler, er anbefalet at bruge. Hvis man er i tvivl om, hvilken kanal der er bedst at bruge, kan man benytte sig af "scanner" eksemplet, som kigger efter interferens på de forskellige kanaler. For at benytte en kanal, skal følgende kommando bruges i setup:
radio.setChannel(CHANNEL_NUMBER); //Indsæt den valgte kanal fra 0 til 124 på pladsen CHANNEL_NUMBER.Scanner eksemplet i Tmrh20's bibliotek virker ved at se efter, hvilke kanaler der bliver brugt meget, altså hvilke kanaler man vil opleve meget interferens på, hvis man benytter dem. Det kan godt være lidt forvirrende at finde ud af, hvad det, som programmet skriver i den serielle moniter skal betyde, men når man først forstår opsætningen er det meget nemt at finde ud af. Det skal ses som en tabel, hvor der er en masse lodrette rækker. De to første linjer er kanalen skrevet lodret i hex, så hvis der f.eks. står 3a, vises interferensen for kanal 58 lodret ned (da dette er det decimale tal for 33 i hex, da hex er et 16 base talsystem). De forskellige tal, der vises er hvor meget interferens der er på kanalen i hex. Så jo nærmere 0, jo bedre. Nedenfor ses et eksempel på et serielt output for scanner programmet:
RF24/examples/scanner/ 000000000000000011111111111111112222222222222222333333333333333344444444444444445555555555555555666666666666666677777777777777 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd 011111000000122112311010122211233101123222001110000000010000132576445000000221111000000000000000000000000000000000000000000000 001000120010210025320122211120220100000000012111000000024553366456444000001000112000000000000000000000000000000000000000000000 001000000012211000101010112211111222322000011111111000036532354653000000001110112000000000000000000000000000000000000000000000 121100000121111100001111221000132121011000000002210000034321120220000000002221001100000000000000000000000000000000000000000000 000011110001221111111110113331011111200011001320000000034343653562554020000001310000000000000000000000000000000000000000000000 010111102111000121000002442211100112214422210100000000100003476a97465400000000121000000000000000000000000000000000000000000000 000000002413420001001001100011211101212433101010000001044565775677634010000000101000000000000000000000000000000000000000000000 001321021211111100111110122201001000000111100010011000055445763432010000000011010100000000000000000000000000000000000000000000 000100022211200110010000002032323310013211000001211000042200330112000010000011110100000000000000000000000000000000000000000000 000100011121012122011000134530001220000233100000110000000000120234345001000012223100000000000000000000000000000000000000000000 001000012121012332211120011112221111121222211110221000000023665876675010000000011000000000000000000000000000000000000000000000 014320001332113210010100131144110011121000000001000000155555564668432100000021122100000000000000000000000000000000000000000000 010211022320101122232110212101111000110001101111000001025444751332100110001121100000000000000000000000000000000000000000000000
Som det kan ses, er kanalen 52 i hex (82 i decimal) og opefter ikke i brug. Disse ville derfor være optilmale til at bruge. Der er også nogle enkelte huller ind imellem som f.eks. kanal 33 i hex (51 i decimal).
Referencer
- ↑ Uddybende information om modulet på engelsk
- ↑ Datablad fra producent
- ↑ Købsside ved MiniInTheBox.com
- ↑ Købsside ved aliexpress.com
- ↑ TMRh20's RF24 bibliotek på Github
- ↑ Liste over kommandoer for modulet
- ↑ educ8s.tv's hjemmeside om NRF24L01