Componenten · 16 min leestijd

nRF24L01 Arduino-tutorial: bedrading, RF24-code, bereik en oplossingen

nRF24L01 Arduino-gids: bedrading, 3,3 V-voeding en de oplossing met een 10 µF-condensator, RF24 TX- en RX-code, PA+LNA-bereik tot 1 km, een joystickafstandsbediening, ESP32 en Pico.

De combinatie nRF24L01 Arduino is de goedkoopste en meest praktische manier om data tussen twee boards te versturen zonder kabel. Deze module ter grootte van een vingernagel werkt in de 2,4 GHz-band, haalt tot 2 megabit per seconde en kan zowel zender als ontvanger zijn. Hij is ideaal voor RC-autootjes, draadloze joysticks, een station dat meetwaarden van een tuinsensor naar binnen stuurt, of alarmknooppunten die elkaar waarschuwen. De standaardversie haalt ongeveer 100 meter in open ruimte, terwijl de nRF24L01+PA+LNA-versie met externe antenne onder goede omstandigheden tot 1 kilometer kan komen.

In deze gids leer je hoe de module werkt, welke SPI-pins hij gebruikt, waarom hij op 3,3 V moet draaien en hoe een 10 µF-condensator het meest voorkomende probleem oplost. Daarna schrijf je zender- en ontvangercode met de RF24-bibliotheek, begrijp je adressen en kanalen, bouw je een joystickafstandsbediening, sluit je de module aan op een ESP32 en een Raspberry Pi Pico en los je ten slotte de problemen "radio.begin() false" en "geen data ontvangen" stap voor stap op.

nRF24L01 draadloze 2,4 GHz-communicatiemodule
Standaard nRF24L01+-module: het zigzagspoor aan het einde van het board is de printantenne; de module wordt via de 8-pins header met SPI aangesloten.

Wat is de nRF24L01 en hoe werkt hij?

De nRF24L01 is een 2,4 GHz-radiotransceiverchip van Nordic Semiconductor; bijna elke module die tegenwoordig wordt verkocht heeft de verbeterde nRF24L01+-versie of een compatibele kloonchip. De module praat met de Arduino via SPI: de Arduino schrijft de instellingen en de te verzenden data via SPI, en de chip regelt de rest. Het hardwareprotocol van Nordic, Enhanced ShockBurst, voorziet elk pakket van een adres en een CRC (foutcontrole). Als de ontvanger een pakket correct ontvangt, stuurt hij automatisch een bevestiging (ACK) terug naar de zender; komt er geen ACK, dan probeert de zender het zelf opnieuw. Je code zegt dus alleen "verstuur", en het opnieuw proberen en de foutcontrole gebeuren in hardware.

Een pakket bevat maximaal 32 bytes data. Dat klinkt weinig, maar twee joystickassen, een paar knoppen en meerdere sensorwaarden passen er makkelijk in. De module gebruikt een van de 126 kanalen, en de kanaalfrequentie is 2400 + kanaalnummer (MHz); kanaal 76 is bijvoorbeeld 2476 MHz. Een ontvanger kan tegelijk naar 6 verschillende adressen (pipes genoemd) luisteren, dus één hub kan data van zes zenders verzamelen.

EigenschapWaarde
Frequentie2,400–2,525 GHz (126 kanalen, 1 MHz tussenruimte)
Datasnelheid250 kbps, 1 Mbps, 2 Mbps
Voedingsspanning1,9–3,6 V (in de praktijk 3,3 V)
Ingangspins5 V-tolerant (CE, CSN, SCK, MOSI)
Uitgangsvermogen0, −6, −12, −18 dBm
Stroom (zenden, 0 dBm)Ongeveer 11,3 mA
Stroom (ontvangen, 2 Mbps)Ongeveer 13,5 mA
Power downOngeveer 900 nA
Ontvangstgevoeligheid−94 dBm (250 kbps), −85 dBm (1 Mbps), −82 dBm (2 Mbps)
Payloadgrootte1–32 bytes
InterfaceSPI, tot 10 MHz
Aantal pipes6

nRF24L01 vs nRF24L01+PA+LNA

Er zijn twee soorten modules te koop. Op de standaardmodule is de antenne een zigzagspoor van koper op de print. De nRF24L01+PA+LNA-versie voegt een RF-front-endchip toe vóór dezelfde transceiver: de PA (Power Amplifier) versterkt het uitgaande signaal en de LNA (Low Noise Amplifier) versterkt zwakke binnenkomende signalen voordat ze de chip bereiken. Een externe schroefantenne wordt op een SMA-connector geplaatst. Beide modules hebben dezelfde pinout en gebruiken dezelfde code, en ze praten zonder problemen met elkaar; het verschil zit in bereik en stroomverbruik. De onderstaande cijfers zijn bij benadering en hangen af van de omgeving.

nRF24L01+PA+LNA RF-module met antenne
nRF24L01+PA+LNA: de versie met zend- en ontvangstversterkers en een SMA-antenne. Hij draait dezelfde code, maar verbruikt veel meer stroom.
EigenschapnRF24L01+ (printantenne)nRF24L01+PA+LNA
AntenneOp de print gedruktExterne SMA-antenne
UitgangsvermogenTot 0 dBm (1 mW)Tot +20 dBm (100 mW), afhankelijk van het model
Piekstroom bij zendenOngeveer 12 mATot 115 mA
Piekstroom bij ontvangenOngeveer 13,5 mATot 45 mA
Bereik in open lucht (250 kbps)50–100 m800–1100 m
Bereik binnenshuis10–30 m, 1–2 murenMeerdere verdiepingen en tientallen meters
Aanbevolen voeding3,3V-pin + 10 µF-condensatorAparte 3,3 V-regelaar + condensator

nRF24L01-pinout en Arduino-bedrading

De module heeft 8 pins in een 2×4-header. De pin met het vierkante soldeerpad is pin 1, en dat is GND; VCC zit er direct naast. CE (Chip Enable) zet de module in luister- of zendmodus, en CSN (Chip Select Not) wordt LOW getrokken om op de SPI-bus te zeggen: "ik praat nu met jou". SCK, MOSI en MISO zijn de standaard SPI-lijnen en moeten naar de vaste SPI-pins van je board, terwijl CE en CSN op elke digitale pin kunnen. De IRQ-pin is optioneel; hij gaat LOW als er een pakket binnenkomt of een verzending klaar is en wordt gebruikt als je met interrupts wilt werken. Hoe SPI werkt lees je in Wat is SPI, en voor de volledige pinindeling van je board gebruik je de tool Pinout.

nRF24L01-pinFunctieArduino Uno / NanoArduino MegaESP32Raspberry Pi Pico
1 GNDMassaGNDGNDGNDGND
2 VCCVoeding (3,3 V)3.3V3.3V3V33V3(OUT)
3 CEModusselectieD9D9GPIO 4GP6
4 CSNSPI-chipselectieD10D10GPIO 5GP5
5 SCKSPI-klokD13D52GPIO 18GP2
6 MOSIData van board naar moduleD11D51GPIO 23GP3
7 MISOData van module naar boardD12D50GPIO 19GP4
8 IRQInterrupt (optioneel)Niet aangeslotenNiet aangeslotenNiet aangeslotenNiet aangesloten
Sluit VCC nooit aan op 5 V. De chip verdraagt maximaal 3,6 V en 5 V kan hem blijvend beschadigen. De signaalpins zijn 5 V-tolerant, dus die kunnen rechtstreeks naar de SPI-pins van de Uno, maar de voeding moet altijd 3,3 V zijn. Steek de module ook niet rechtstreeks in een breadboard: door de 2×4-header komen pins tegenover elkaar in dezelfde strip en sluiten ze kort. Gebruik in plaats daarvan jumperdraden female-male.

De meest gemaakte fout: voeding en de 10 µF-condensator

De meeste nRF24L01-problemen worden niet door code veroorzaakt, maar door de voeding. De module trekt korte, scherpe stroompulsen op het moment dat hij zendt. Lange jumperdraden en een zwakke 3,3 V-bron kunnen die pulsen niet bijhouden; de spanning zakt even in en de chip verstuurt een beschadigd pakket, mist ACK's of reset zichzelf. Volgens de officiële documentatie levert de 3,3 V-pin van de Arduino Uno maximaal 50 mA; dat is genoeg voor de standaardmodule, maar niet voor de PA+LNA-versie, die tot 115 mA trekt. Op sommige Nano-klonen komt de 3,3 V-pin van de USB-serial-chip en is hij nog zwakker. De symptomen zullen bekend klinken: write() lukt soms wel en soms niet, de module werkt beter als je hem aanraakt, of het bereik stopt na een paar meter.

  • 10 µF-condensator: Plaats een elco van 10 µF tussen de VCC- en GND-pin van de module, zo dicht mogelijk bij de pins. Het lange pootje (+) gaat naar VCC en de kant met de streep (−) naar GND. Alles van 10 tot 100 µF werkt ook; waarom dit helpt lees je in Wat is een condensator.
  • 100 nF keramische condensator: Een kleine keramische condensator (opdruk 104) parallel aan de elco filtert hoogfrequente ruis weg. Opdrukken van condensatoren ontcijfer je met de tool Condensatorcode.
  • Socketadapter: De 8-pins adapterprints die voor de nRF24L01 worden verkocht, hebben al een AMS1117-3.3-regelaar en condensatoren. Je voedt de VCC van de adapter met 5 V en de module krijgt een schone 3,3 V.
  • Aparte regelaar: Voed de PA+LNA-versie niet via de 3,3 V-pin van de Arduino, maar via een aparte AMS1117-3.3-regelaar die op 5 V draait, en verbind alle massa's met elkaar.
  • Korte draden: Houd jumperdraden waar mogelijk onder 10 cm; lange, losse draden verstoren zowel de voeding als de SPI-signalen.
AMS1117 3.3 V spanningsregelaar
AMS1117-3.3-regelaar: hij brengt 5 V terug naar 3,3 V en kan de hoge stroom die de PA+LNA-module tijdens het zenden trekt makkelijk aan.

De RF24-bibliotheek installeren

  1. Open in de Arduino IDE Tools > Manage Libraries of klik links op het bibliotheekpictogram.
  2. Typ RF24 in het zoekvak en installeer de RF24-bibliotheek van TMRh20. RF24Network, RF24Mesh en RF24Ethernet zijn aparte bibliotheken en heb je om te beginnen niet nodig.
  3. Na de installatie vind je het voorbeeld GettingStarted onder File > Examples > RF24. De code in dit artikel volgt de syntaxis van RF24 versie 1.5 en nieuwer.
  4. Als je voor het eerst een bibliotheek installeert, volg dan de stappen in Een bibliotheek toevoegen in Arduino.
In oudere voorbeelden online zie je radio.openWritingPipe(address) gevolgd door radio.stopListening(). Sinds RF24 versie 1.5 is de aanbevolen manier één regel: radio.stopListening(address). De oude vorm compileert nog wel, maar kan een "deprecated"-waarschuwing geven. Als de code in dit artikel niet compileert, update dan je RF24-bibliotheek.

Adres, kanaal en datasnelheid: twee modules op één lijn krijgen

Om elkaar te horen moeten sommige instellingen aan beide kanten precies hetzelfde zijn. Zie het als een gesprek via portofoons: als je niet op dezelfde frequentie (kanaal), dezelfde spreeksnelheid (datasnelheid) en dezelfde roepnaam (adres) zit, hoor je de andere kant niet. Het adres is een array van 5 bytes, en de makkelijkste manier om het in code te schrijven is als string van 5 tekens, zoals "00001". Zie het adres niet als de identiteit van een apparaat, maar als een gedeeld pad tussen twee apparaten: de zender legt pakketten op dat pad en de ontvanger die naar dat pad luistert pakt ze op. Ook de payloadgrootte telt; RF24 gebruikt standaard payloads van vaste grootte, en als de ontvanger niet dezelfde grootte verwacht als de zender, ziet hij het pakket nooit.

InstellingRF24-functieWaarde in dit artikelOpmerking
KanaalsetChannel(76)76 (2476 MHz)0–125; moet aan beide kanten overeenkomen
DatasnelheidsetDataRate(RF24_250KBPS)250 kbpsLagere snelheid betekent groter bereik
AdresstopListening(address) / openReadingPipe(1, address)"00001"Doel van de zender = pipe van de ontvanger
PayloadgroottesetPayloadSize(sizeof(data))32 bytes (5 in het joystickvoorbeeld)Bij vaste grootte moeten beide kanten overeenkomen
UitgangsvermogensetPALevel(RF24_PA_LOW)LaagHoeft niet overeen te komen; bepaalt het bereik
Auto-ACK en CRCStandaard aan16-bit CRCAls je ze uitzet, doe dat dan aan beide kanten

Zendercode (TX)

Sluit voor je eerste test de twee Arduino's aan op twee aparte USB-poorten en zet 1–2 meter tussen de modules. Upload de onderstaande zendercode naar een van beide. Elke seconde verstuurt hij een genummerd bericht en toont hij in de Serial Monitor of de ontvanger het heeft bevestigd. Vergeet niet de Serial Monitor op 115200 baud te zetten.

C++ (Arduino IDE)
1#include <SPI.h>
2#include <RF24.h>
3
4RF24 radio(9, 10);                        // CE, CSN pinleri / CE, CSN pins
5const uint8_t address[6] = "00001";       // iki tarafta aynı adres / same address on both sides
6char message[32];                         // en fazla 32 bayt / 32 bytes max
7uint16_t counter = 0;
8
9void setup() {
10  Serial.begin(115200);
11  if (!radio.begin()) {                   // modül cevap vermiyor / module not responding
12    Serial.println(F("nRF24L01 bulunamadi, kablolari kontrol et!"));
13    while (true) {}
14  }
15  radio.setChannel(76);                   // kanal 76 = 2476 MHz / channel 76 = 2476 MHz
16  radio.setDataRate(RF24_250KBPS);        // en uzun menzil / longest range
17  radio.setPALevel(RF24_PA_LOW);          // masa testi için düşük güç / low power for desk tests
18  radio.setPayloadSize(sizeof(message));  // paket boyu 32 bayt / 32-byte payload
19  radio.stopListening(address);           // verici modu + hedef adres / TX mode + target address
20}
21
22void loop() {
23  snprintf(message, sizeof(message), "Merhaba BlueGrays #%u", counter++);
24  bool ok = radio.write(message, sizeof(message));   // onay (ACK) geldi mi? / was it acknowledged?
25  if (ok) {
26    Serial.print(F("Gonderildi: "));
27    Serial.println(message);
28  } else {
29    Serial.println(F("Onay gelmedi"));
30  }
31  delay(1000);
32}

Ontvangercode (RX)

C++ (Arduino IDE)
1#include <SPI.h>
2#include <RF24.h>
3
4RF24 radio(9, 10);                        // CE, CSN pinleri / CE, CSN pins
5const uint8_t address[6] = "00001";       // vericiyle aynı adres / same address as the transmitter
6char message[32];
7
8void setup() {
9  Serial.begin(115200);
10  if (!radio.begin()) {
11    Serial.println(F("nRF24L01 bulunamadi, kablolari kontrol et!"));
12    while (true) {}
13  }
14  radio.setChannel(76);                   // ayarlar vericiyle aynı / settings match the transmitter
15  radio.setDataRate(RF24_250KBPS);
16  radio.setPALevel(RF24_PA_LOW);
17  radio.setPayloadSize(sizeof(message));
18  radio.openReadingPipe(1, address);      // 1 numaralı boruyu aç / open pipe 1
19  radio.startListening();                 // alıcı modu / RX mode
20}
21
22void loop() {
23  if (radio.available()) {                // paket geldi mi? / has a packet arrived?
24    radio.read(message, sizeof(message));
25    Serial.print(F("Gelen: "));
26    Serial.println(message);
27  }
28}

radio.write() verstuurt het pakket en geeft true terug als de ontvanger het bevestigt; met de standaardinstellingen probeert hij het 15 keer opnieuw met ongeveer 1,5 ms ertussen voordat hij false teruggeeft. Op de ontvanger stelt openReadingPipe(1, address) pipe 1 in op het adres van de zender, zet startListening() de module in luistermodus, vertelt available() of er een pakket klaarstaat en kopieert read() het naar je variabele. Als de Serial Monitor van de ontvanger regels toont die oplopen zoals "Gelen: Merhaba BlueGrays #0", "#1", "#2", werkt je verbinding.

Zet de modules tijdens het testen niet direct naast elkaar en houd het vermogen laag. Vooral PA+LNA-modules overbelasten elkaars ontvangers als ze op vol vermogen een paar centimeter uit elkaar staan, en dan gaan pakketten verloren, wat op een defect lijkt. Gebruik RF24_PA_LOW of RF24_PA_MIN op korte afstand en verhoog het vermogen op de echte afstand.

Bereik: van 100 meter tot 1 kilometer

Drie dingen bepalen het bereik: uitgangsvermogen, ontvangstgevoeligheid en de omgeving. Hoe lager de datasnelheid, hoe zwakker de signalen die de ontvanger kan decoderen; de gevoeligheid is −94 dBm bij 250 kbps maar −82 dBm bij 2 Mbps. Dat verschil van 12 dB betekent grofweg 4 keer zoveel bereik in open ruimte. Muren, bomen, mensen en metalen oppervlakken verzwakken 2,4 GHz-signalen aanzienlijk, en wifirouters, Bluetooth-apparaten en magnetrons delen dezelfde band.

DatasnelheidOntvangstgevoeligheidRelatief bereikWanneer gebruiken
250 kbps−94 dBmLangsteAfstandsbedieningen, verre sensoren
1 Mbps−85 dBmGemiddeldAlgemeen gebruik (RF24-standaard)
2 Mbps−82 dBmKortsteHoge snelheid, korte afstand

Ook de kanaalkeuze telt. De veelgebruikte Wi-Fi-kanalen 1, 6 en 11 beslaan ruwweg 2401–2473 MHz; nRF24L01-kanalen 74–83 liggen daarboven en zijn rustiger, zolang geen router in de buurt Wi-Fi-kanaal 12 of 13 gebruikt. In Europa (en Turkije) loopt de vergunningvrije 2,4 GHz-band van 2400 tot 2483,5 MHz, dus gebruik geen kanalen boven 83; de kanalen vanaf 100 die sommige voorbeelden online voorstellen, liggen buiten deze band, en de exacte grenzen hangen af van de regels in jouw land. Probeer het volgende om meer bereik te krijgen:

  • Gebruik 250 kbps: Afstandsbedieningen en sensordata hebben geen hoge snelheid nodig, en de lagere snelheid geeft je bereik.
  • Eerst de voeding op orde, dan het vermogen verhogen: RF24_PA_MAX heeft alleen zin met een stabiele 3,3 V en een condensator; het vermogen verhogen op een zwakke voeding maakt het erger.
  • Monteer de antennes hoog en in dezelfde richting: 1–2 meter boven de grond, met beide antennes rechtop in dezelfde richting, verbetert het bereik merkbaar.
  • Houd afstand tot metaal: Plaats de module niet in een metalen doos of vlak naast een groot batterijpakket.
  • Wikkel een PA+LNA-print zonder afscherming in: Een PA+LNA-module zonder metalen kap omwikkelen met isolatietape en daarna aluminiumfolie vermindert de storing die hij zichzelf bezorgt; de folie mag geen enkele pin of de antenneaansluiting raken.
  • Zend niet zonder antenne: Een PA+LNA-module op vol vermogen laten draaien zonder antenne belast de eindversterker.

Draadloze afstandsbediening met een joystick

Nu bouwen we een echt project: met een joystick op de ene Arduino bestuur je draadloos een servomotor en een LED op een tweede Arduino. Op de zender gaat de VRx-pin van de joystick naar A0, VRy naar A1 en de knop (SW) naar D2; de details vind je in Joystickmodule. Op de ontvanger gaat de signaaldraad van de servo naar D3 en de LED via een weerstand van 220 Ω naar D4. De nRF24L01-bedrading aan beide kanten is dezelfde als in de tabel hierboven.

De netste manier om meerdere waarden in één pakket te versturen is een struct. Hier is een belangrijk detail: gebruik types met vaste grootte, zoals int16_t en uint8_t. Een int is 2 bytes op de Arduino Uno maar 4 bytes op de ESP32, en de ESP32-compiler voegt ook opvulbytes toe aan het einde van de struct voor uitlijning. Als dezelfde struct 5 bytes is op de Uno en 6 bytes op de ESP32, komen de payloadgroottes niet overeen en komt er helemaal geen data aan. __attribute__((packed)) haalt die opvulling weg en maakt de struct op elk board 5 bytes. Eerst de zender:

C++ (Arduino IDE)
1#include <SPI.h>
2#include <RF24.h>
3
4struct __attribute__((packed)) JoystickData {   // her kartta 5 bayt / 5 bytes on every board
5  int16_t x;
6  int16_t y;
7  uint8_t button;
8};
9
10RF24 radio(9, 10);                        // CE, CSN pinleri / CE, CSN pins
11const uint8_t address[6] = "JOY01";       // kumanda adresi / remote address
12JoystickData data;
13
14void setup() {
15  pinMode(2, INPUT_PULLUP);               // joystick butonu (SW) / joystick button (SW)
16  if (!radio.begin()) {
17    while (true) {}                       // modül yok / no module
18  }
19  radio.setChannel(76);
20  radio.setDataRate(RF24_250KBPS);
21  radio.setPALevel(RF24_PA_HIGH);         // orta-yüksek güç / medium-high power
22  radio.setPayloadSize(sizeof(data));
23  radio.stopListening(address);           // verici modu / TX mode
24}
25
26void loop() {
27  data.x = analogRead(A0);                // VRx ekseni 0-1023 / VRx axis 0-1023
28  data.y = analogRead(A1);                // VRy ekseni 0-1023 / VRy axis 0-1023
29  data.button = (digitalRead(2) == LOW);  // basılıysa 1 / 1 when pressed
30  radio.write(&data, sizeof(data));
31  delay(50);                              // saniyede 20 paket / 20 packets per second
32}

Daarna de ontvanger die de servo en de LED aanstuurt:

C++ (Arduino IDE)
1#include <SPI.h>
2#include <RF24.h>
3#include <Servo.h>
4
5struct __attribute__((packed)) JoystickData {   // vericiyle birebir aynı / identical to the transmitter
6  int16_t x;
7  int16_t y;
8  uint8_t button;
9};
10
11RF24 radio(9, 10);                        // CE, CSN pinleri / CE, CSN pins
12const uint8_t address[6] = "JOY01";       // vericiyle aynı / same as the transmitter
13JoystickData data;
14Servo servo;
15unsigned long lastPacket = 0;
16
17void setup() {
18  pinMode(4, OUTPUT);                     // LED çıkışı / LED output
19  servo.attach(3);                        // servo sinyal pini / servo signal pin
20  if (!radio.begin()) {
21    while (true) {}
22  }
23  radio.setChannel(76);
24  radio.setDataRate(RF24_250KBPS);
25  radio.setPALevel(RF24_PA_HIGH);
26  radio.setPayloadSize(sizeof(data));
27  radio.openReadingPipe(1, address);
28  radio.startListening();                 // alıcı modu / RX mode
29}
30
31void loop() {
32  if (radio.available()) {
33    radio.read(&data, sizeof(data));
34    servo.write(map(data.x, 0, 1023, 0, 180));   // X ekseni -> servo açısı / X axis -> servo angle
35    digitalWrite(4, data.button ? HIGH : LOW);   // buton LED'i yakar / button lights the LED
36    lastPacket = millis();
37  }
38  if (millis() - lastPacket > 500) {      // 0,5 sn paket yok: güvenli konum / no packet for 0.5 s: failsafe
39    servo.write(90);
40    digitalWrite(4, LOW);
41  }
42}

De zender verstuurt 20 pakketten per seconde; voor elk pakket zet de ontvanger de X-as om naar 0–180 graden en schrijft die naar de servo. Het failsafe-deel op de ontvanger is erg belangrijk: als de batterij van de afstandsbediening leeg raakt of je buiten bereik komt, wordt de laatste opdracht niet eeuwig uitgevoerd; als er 0,5 seconde geen pakket aankomt, centreert de servo en gaat de LED uit. Bouw je een robotauto, stop dan op dezelfde plek de motoren. Als je de servo op een aparte 5 V-bron voedt in plaats van op de 5V-pin van de Arduino, verstoren de stroompieken van de servo de nRF24L01 ook niet. Sluit de Y-as aan op een L298N-motordriver en je hebt een draadloze robotauto; voor details over servo's, zie Wat is een servomotor.

Tweerichtingscommunicatie en meerdere zenders

De nRF24L01 kan niet tegelijk zenden en luisteren, maar er is een makkelijke manier voor tweerichtingscommunicatie: een ACK-payload, oftewel data die in het bevestigingspakket wordt meegestuurd. De ontvanger bereidt de data voor de volgende ACK vooraf voor met writeAckPayload() (bijvoorbeeld een batterijspanning of sensorwaarde), en na een geslaagde write() leest de zender dat antwoord met available() en read(). Hiervoor moeten beide kanten enableDynamicPayloads() en enableAckPayload() aanroepen. Voor meerdere zenders heeft de ontvanger 6 pipes: pipes 0 en 1 nemen een volledig adres van 5 bytes, terwijl pipes 2–5 de rest van het adres van pipe 1 delen en slechts in één byte verschillen. In RF24 is die byte het eerste teken van de adresarray, daarom verschillen adressen als "1Node", "2Node" en "3Node" alleen in hun eerste teken. Voor grotere netwerken zijn er de bibliotheken RF24Network en RF24Mesh.

De nRF24L01 aansluiten op een ESP32

De RF24-bibliotheek werkt ongewijzigd op de ESP32, en radio.begin() gebruikt standaard de VSPI-bus: SCK = GPIO 18, MISO = GPIO 19, MOSI = GPIO 23. GPIO 5 is een goede keuze voor CSN en GPIO 4 voor CE. De 3,3 V-regelaar op ESP32 DevKit-boards is sterker dan die van de Uno, maar sla de 10 µF-condensator niet over. Op modellen zoals de ESP32-C3 of ESP32-S3 zijn de standaard SPI-pins anders, dus controleer de pinindeling van je board. Omdat de wifi van de ESP32 ook op 2,4 GHz werkt, kies je een nRF24L01-kanaal ver van het Wi-Fi-kanaal van je router als je beide samen gebruikt. De onderstaande code leest de pakketten van de joystickzender op een ESP32; met dezelfde structuur kun je de ESP32 als gateway gebruiken die data van nRF24L01-knooppunten doorstuurt naar internet. Ben je nieuw met dit board, begin dan met Wat is de ESP32.

C++ (Arduino IDE)
1#include <SPI.h>
2#include <RF24.h>
3
4struct __attribute__((packed)) JoystickData {   // packed olmasa 6 bayt olurdu / 6 bytes without packed
5  int16_t x;
6  int16_t y;
7  uint8_t button;
8};
9
10RF24 radio(4, 5);                         // CE = GPIO 4, CSN = GPIO 5 pinleri / CE = GPIO 4, CSN = GPIO 5 pins
11const uint8_t address[6] = "JOY01";
12JoystickData data;
13
14void setup() {
15  Serial.begin(115200);
16  if (!radio.begin()) {                   // varsayılan VSPI: SCK 18, MISO 19, MOSI 23 / default VSPI pins
17    Serial.println("nRF24L01 bulunamadi!");
18    while (true) delay(1000);
19  }
20  radio.setChannel(76);
21  radio.setDataRate(RF24_250KBPS);
22  radio.setPALevel(RF24_PA_HIGH);
23  radio.setPayloadSize(sizeof(data));     // packed sayesinde 5 bayt / 5 bytes thanks to packed
24  radio.openReadingPipe(1, address);
25  radio.startListening();
26}
27
28void loop() {
29  if (radio.available()) {
30    radio.read(&data, sizeof(data));
31    Serial.printf("X=%d  Y=%d  Buton=%d\n", data.x, data.y, data.button);
32  }
33}

Als je alleen ESP32-boards met elkaar wilt verbinden, is ESP-NOW, waarvoor je geen extra module nodig hebt, ook een goede optie; het voordeel van de nRF24L01 is dat hij ook werkt met goedkope boards met laag verbruik, zoals de Uno, Nano en Pro Mini.

nRF24L01 met de Raspberry Pi Pico en MicroPython

Voor MicroPython op de Pico gebruik je het stuurprogramma nrf24l01.py uit de officiële repository micropython-lib. Je kunt het bestand met Thonny naar de Pico kopiëren of vanaf je computer installeren met mpremote mip install nrf24l01. De bedrading gebruikt SPI0: SCK = GP2, MOSI = GP3, MISO = GP4, CSN = GP5, CE = GP6 en VCC = 3V3(OUT). De standaardwaarden van het stuurprogramma verschillen van die van RF24 (kanaal 46, payload van 16 bytes), dus om met de Arduino te praten stellen we kanaal, datasnelheid en payloadgrootte expliciet in de code in. De onderstaande code decodeert de pakketten van de joystickzender op de Pico:

MicroPython
1from machine import Pin, SPI
2import struct
3import utime
4from nrf24l01 import NRF24L01, POWER_2, SPEED_250K
5
6spi = SPI(0, sck=Pin(2), mosi=Pin(3), miso=Pin(4))   # SPI0 pinleri / SPI0 pins
7csn = Pin(5, mode=Pin.OUT, value=1)                  # CSN pini GP5 / CSN pin GP5
8ce = Pin(6, mode=Pin.OUT, value=0)                   # CE pini GP6 / CE pin GP6
9
10nrf = NRF24L01(spi, csn, ce, channel=76, payload_size=5)   # Arduino ile aynı / same as the Arduino
11nrf.set_power_speed(POWER_2, SPEED_250K)             # -6 dBm güç, 250 kbps / -6 dBm power, 250 kbps
12nrf.open_rx_pipe(1, b"JOY01")                        # vericinin adresi / transmitter address
13nrf.start_listening()                                # alıcı modu / RX mode
14print("Dinleniyor... / Listening...")
15
16while True:
17    if nrf.any():                                    # paket geldi mi? / packet waiting?
18        x, y, button = struct.unpack("<hhB", nrf.recv())   # 2 + 2 + 1 bayt / 2 + 2 + 1 bytes
19        print("X:", x, "Y:", y, "Buton:", button)
20    utime.sleep_ms(5)

struct.unpack("<hhB") zet de 5 binnenkomende bytes om in twee 16-bit getallen met teken en één byte; de "<" aan het begin stelt de little-endian bytevolgorde in, die de AVR en ESP32 gebruiken. Als de module niet wordt gevonden, geeft het stuurprogramma "nRF24L01+ Hardware not responding", het MicroPython-equivalent van begin() dat false teruggeeft op de Arduino. Ben je nieuw met de Pico, lees dan eerst Wat is de Raspberry Pi Pico.

radio.begin() geeft false: stap-voor-stap oplossing

Als de Serial Monitor "nRF24L01 bulunamadi" toont of de melding "radio hardware is not responding!!" uit de RF24-voorbeelden, kan de Arduino helemaal niet via SPI met de module praten. Dan zit het probleem bijna altijd in de bedrading of de voeding, niet in de code. Upload eerst de onderstaande diagnosesketch; die toont alle instellingen van de module in leesbare vorm.

C++ (Arduino IDE)
1#include <SPI.h>
2#include <RF24.h>
3#include "printf.h"                       // RF24 ile gelir / ships with RF24
4
5RF24 radio(9, 10);                        // kendi CE, CSN pinlerin / your CE, CSN pins
6
7void setup() {
8  Serial.begin(115200);
9  printf_begin();                         // printPrettyDetails için / needed for printPrettyDetails
10  bool ok = radio.begin();
11  Serial.print(F("begin(): "));
12  Serial.println(ok ? "true" : "false");
13  Serial.print(F("isChipConnected(): "));
14  Serial.println(radio.isChipConnected() ? "true" : "false");
15  radio.printPrettyDetails();             // tüm ayarları yazdır / print every setting
16}
17
18void loop() {
19}
  1. Controleer MOSI en MISO: Dit zijn de twee draden die het vaakst worden verwisseld. Op de Uno en Nano zijn MOSI = D11, MISO = D12 en SCK = D13; op de Mega zijn het 51, 50 en 52.
  2. Komen CE en CSN overeen met de code: Als je RF24 radio(9, 10) hebt geschreven, gaat CE naar D9 en CSN naar D10. Het GettingStarted-voorbeeld van RF24 gebruikt pins 7 en 8; als je het voorbeeld ongewijzigd probeert, bedraad het dan zo.
  3. Is de voeding 3,3 V: Meet met een multimeter tussen VCC en GND; je moet 3,0–3,6 V zien. Als de module ooit op 5 V is aangesloten, kan hij beschadigd zijn.
  4. Bekijk de uitvoer van printPrettyDetails: Als de adressen en registerwaarden allemaal 0x00 of 0xff tonen, werkt de SPI-bus niet. Als de waarden er normaal uitzien maar er toch geen verbinding is, ligt het probleem bij de CE-pin, de instellingen of de voeding.
  5. Kort de draden in en verlaag de SPI-snelheid: Bij lange of losse draden schrijf je RF24 radio(9, 10, 4000000) om de SPI-snelheid van de standaard 10 MHz naar 4 MHz te verlagen.
  6. Wissel de module om: Als al het andere klopt, probeer dan een reservemodule; goedkope multipacks kunnen een defecte bevatten.

Geen data of haperende data: veelvoorkomende problemen

SymptoomWaarschijnlijke oorzaakOplossing
begin() is true maar er komt niets aan bij de ontvangerKanaal, datasnelheid, adres of payloadgrootte verschillen tussen de twee kantenVergelijk de vier instellingen naast elkaar in beide sketches
Geen data van de Uno naar de ESP32Andere structgrootte (5 vs 6 bytes)Gebruik types met vaste grootte en __attribute__((packed))
write() is false maar de ontvanger krijgt de data welDe ACK van de ontvanger bereikt de zender niet, meestal door de voeding van de ontvangerVoeg ook aan de ontvangermodule een 10 µF-condensator toe
Steeds lege data of onzin op het schermLosse SPI-draad of een verbroken MISO-verbindingVervang de draden en verlaag de SPI-snelheid naar 4 MHz
Werkt niet naast elkaar, werkt wel als je ze uit elkaar zetDe ontvanger is overbelast bij vol vermogenGebruik setPALevel(RF24_PA_LOW) of RF24_PA_MIN
Werkt beter als je hem aanraaktInstabiele voeding of een PA+LNA zonder afschermingCondensator, aparte regelaar en afscherming met folie
De verbinding valt na een paar meter wegDatasnelheid van 2 Mbps, zwakke voeding of wifi-storing250 kbps, schone voeding, een kanaal tussen 74 en 83
Ga bij het oplossen van problemen altijd terug naar de eenvoudigste opstelling: twee modules op 1–2 meter afstand, RF24_PA_LOW, 250 kbps, korte draden en een 10 µF-condensator. Heb je met die opstelling een werkende verbinding, vergroot dan stap voor stap de afstand, het vermogen en de complexiteit van de code, zodat je meteen ziet bij welke stap het probleem begint.

nRF24L01-projectideeën

  • Afstandsbediening voor een draadloze robotauto: Bestuur een robotauto vanaf tientallen meters afstand met een afstandsbediening met twee joysticks.
  • Tuinsensorstation: Stuur gegevens van een bodemvochtsensor en temperatuur vanaf een zender op batterijen naar een display in huis. Met radio.powerDown() trekt de module ongeveer 900 nA als hij slaapt; de levensduur van de batterij kun je schatten met de tool Batterijduur.
  • Draadloos deur- en bewegingsalarm: Laat een buzzer bij de hub afgaan als een PIR-sensor of een reedschakelaar wordt geactiveerd.
  • Temperatuurnetwerk voor meerdere kamers: Verzamel meetwaarden van sensoren in zes kamers op één ontvanger via zes pipes.
  • ESP32-gateway: Stuur data van nRF24L01-knooppunten met een ESP32 door naar internet, je telefoon of een dashboard.
  • Draadloos scorebord: Werk een 7-segmentsscorebord in een sporthal bij vanaf knoppen op afstandsbedieningen.

Ondanks de lage prijs biedt de nRF24L01 meer bereik, lagere latentie en ondersteuning voor meerdere apparaten dan Bluetooth; hij vraagt alleen om een schone 3,3 V-voeding en overeenkomende instellingen aan beide kanten. Wil je met je telefoon bedienen, dan past de HC-05 Bluetooth-module misschien beter, en voor kilometers bereik LoRa; een vergelijking van de opties vind je in Draadloze communicatiemodules voor Arduino. In de BlueGrays-app vind je projecten zoals communicatie tussen twee Arduino's, joystickbesturing van een servo en een LED, en een auto met afstandsbediening, stap voor stap met schakelschema's en kant-en-klare code.

Veelgestelde vragen

Wat is het bereik van de nRF24L01?

De standaard nRF24L01+ met printantenne haalt ongeveer 50–100 meter in open ruimte bij 250 kbps, en 10–30 meter binnenshuis, afhankelijk van de muren. De nRF24L01+PA+LNA-versie met externe antenne kan 800–1100 meter halen in open ruimte zonder obstakels. Voor deze cijfers heb je een schone 3,3 V-voeding, een 10 µF-condensator en een lage datasnelheid nodig.

Kan de nRF24L01 op 5 V draaien?

Nee. De VCC-pin werkt tussen 1,9 en 3,6 V en 5 V kan de chip vernielen. De ingangspins CE, CSN, SCK en MOSI zijn echter 5 V-tolerant, dus die kunnen zonder niveauconverter op de SPI-pins van een Arduino Uno worden aangesloten. Wil je de module op 5 V voeden, gebruik dan een socketadapter met een AMS1117-3.3-regelaar.

Waarom krijg ik de fout "radio hardware is not responding"?

Deze melding wordt getoond als radio.begin() false teruggeeft, en betekent dat de Arduino niet via SPI met de module kan praten. De meest voorkomende oorzaken zijn verwisselde MOSI en MISO, CE- en CSN-pins die afwijken van de code, een zwakke of 5 V-voeding en losse jumperdraden. Controleer de bedrading en bekijk de uitvoer van printPrettyDetails() om het probleem in te perken.

nRF24L01 of HC-05 Bluetooth: welke moet ik gebruiken?

Heb je tussen Arduino's veel bereik, lage latentie en meerdere apparaten nodig, dan is de nRF24L01 de betere keuze. Wil je met een telefoon bedienen, kies dan een Bluetooth-module zoals de HC-05 of een ESP32, want telefoons spreken het protocol van de nRF24L01 niet. De HC-05 haalt doorgaans ongeveer 10 meter, terwijl de nRF24L01 voor een vergelijkbare prijs veel verder komt.

Naar hoeveel zenders kan één nRF24L01-ontvanger luisteren?

Een ontvanger kan tegelijk naar 6 pipes luisteren, dus hij kan rechtstreeks data van 6 zenders verzamelen. Pipes 2–5 delen het grootste deel van het adres van pipe 1 en verschillen slechts in één byte. Voor meer knooppunten kun je de zenders om de beurt afvragen of veel grotere netwerken bouwen met de bibliotheken RF24Network en RF24Mesh.

Kan de nRF24L01 verbinding maken met een telefoon?

Niet rechtstreeks. Hoewel de nRF24L01 in dezelfde 2,4 GHz-band werkt, gebruikt hij de protocollen van wifi of Bluetooth niet. Wil je met een telefoon bedienen, zet dan een ESP32 in het midden van je nRF24L01-netwerk en geef de data via wifi of Bluetooth door aan de telefoon. Zo praten de externe knooppunten nRF24L01 en praat de telefoon met de ESP32.

Alle projecten bekijken
Eenrichtingscommunicatie tussen 2 Arduino's
AR-57Gemiddeld
Premium

Eenrichtingscommunicatie tussen 2 Arduino's

Je laat twee Arduino's met elkaar praten via één draad: druk op de knop van de ene en de led van de andere gaat aan, druk nog een keer en hij gaat uit.

4.4(37)
50
Tweerichtingscommunicatie tussen 2 Arduino's
AR-58Gemiddeld
Premium

Tweerichtingscommunicatie tussen 2 Arduino's

Twee Arduino's zijn met draden aan elkaar gekoppeld en praten met elkaar: druk op de knop van de ene en het lampje van de andere gaat aan, druk nog eens en het gaat uit.

4.5(20)
26
Led bedienen met joystick
AR-59Gemiddeld
Premium

Led bedienen met joystick

Duw het stokje van de joystick helemaal in een richting en de led voor die richting gaat branden: er zijn vier kleuren voor rechts, links, omhoog en omlaag.

4.7(50)
67
Servo's bedienen met joystick
AR-60Gemiddeld
Premium

Servo's bedienen met joystick

Stuur twee motoren aan met een joystick, net als bij het draaien van een bewakingscamera.

4.7(42)
58
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
LED bedienen met je telefoon via Bluetooth
AR-34Beginner
Premium

LED bedienen met je telefoon via Bluetooth

Een kleine oefening voor het aan- en uitzetten van de lampen in je kamer met je telefoon.

4.8(69)
91
Led aan- en uitzetten met IR-ontvanger en afstandsbediening
AR-17Gemiddeld
Premium

Led aan- en uitzetten met IR-ontvanger en afstandsbediening

Alsof je drie losse lampen bedient zonder uit je stoel te komen: toets 1, 2 en 3 van de afstandsbediening zetten de blauwe, rode en groene led aan, en toets 4, 5 en 6 zetten ze in dezelfde volgorde…

4.7(45)
66
ESP32 IR-universeelafstandsbediening (IR-ontvanger + afstandsbediening + 3 LED's + buzzer + OLED)
ES-39Gevorderd
Premium

ESP32 IR-universeelafstandsbediening (IR-ontvanger + afstandsbediening + 3 LED's + buzzer + OLED)

Lees een kant-en-klare IR-afstandsbediening uit met de ESP32 en bestuur je eigen apparaat! De infraroodontvanger (NEC-protocol, 38kHz) vangt de signalen op van een afstandsbediening met 20 toetsen: toets 1/2/3 schakelen drie aparte LED's aan en uit en PWR zet ze allemaal uit. Druk je op een onbekende toets, dan toont de OLED de HEX-code, zodat je de knoppen van je eigen afstandsbediening makkelijk aan de code toevoegt.

4.5(9)
16