De nRF24L01 onder de knie krijgen: Draadloze communicatie, Arduino-integratie, schema's & code
In deze tutorial leren we hoe we draadloze communicatie tussen twee Arduino-boards realiseren met de nRF24L01 transceiver-modules. De nRF24L01-module is een zeer populaire keuze voor draadloze communicatie met Arduino.
Ik heb deze module al gebruikt in talloze Arduino-projecten, en je kunt er enkele bekijken hier:
- DIY Arduino RC-zender
- Arduino RC-vliegtuig | 100% DIY
- DIY Arduino-gebaseerde RC-hovercraft
- Arduino draadloos weerstationproject
Je kunt de volgende video bekijken of de geschreven tutorial hieronder lezen. Het bevat alles wat we over de nRF24L01-transceivermodule moeten weten, zoals de pinout, werkprincipe, aansluitschema en diverse codevoorbeelden.
Overzicht
Om de draadloze communicatie uit te leggen, maken we twee voorbeelden: het eerste verstuurt een simpele "Hello World"-boodschap van de ene Arduino naar de andere; in het tweede voorbeeld hebben we bidirectionele communicatie tussen de Arduino-boards, waarbij we met de joystick op de eerste Arduino de servomotor op de tweede besturen, en vice versa, met de drukknop op de tweede Arduino de LED op de eerste besturen.
nRF24L01 Transceiver-module
Laten we de NRF24L01-transceivermodule nader bekijken. Hij gebruikt het 2,4 GHz-band en kan werken met baudrates van 250 kbps tot 2 Mbps. In open ruimte en met een lagere baudrate kan de bereik tot 100 meter reiken.
Hier zijn de complete specificaties:
| Frequentiebereik | 2,4 – 2,5 GHz ISM-band |
| Datatarieven | 250 Kbps / 1 Mbps / 2 Mbps |
| Max. uitgangsvermogen | 0 dBm |
| Werklastingsspanning | 1,9 – 3,6 V |
| Max. werkstroom | 12,3 mA |
| Standby-stroom | 22 µA |
| Logische ingangen | 5 V tolerant |
| Communicatiebereik | 100 m (open ruimte) |
Hoe het werkt
De module kan 125 verschillende kanalen gebruiken, wat de mogelijkheid geeft om een netwerk van 125 onafhankelijk werkende modems op één plek te hebben. Elk kanaal kan maximaal 6 adressen hebben, of elk apparaat kan met maximaal 6 andere apparaten tegelijkertijd communiceren.
De stroomverbruik van deze module is slechts ongeveer 12 mA tijdens transmissie, wat zelfs lager is dan een enkele LED. De werklastingsspanning van de module ligt tussen 1,9 en 3,6 V, maar het goede nieuws is dat de andere pinnen 5 V-logica verdragen, zodat we hem eenvoudig aan een Arduino kunnen koppelen zonder logische niveauconverters.
Drie van deze pinnen zijn voor de SPI-communicatie en moeten worden aangesloten op de SPI-pinnen van de Arduino, maar let op: elk Arduino-board heeft andere SPI-pinnen. De pinnen CSN en CE kunnen aan elke digitale pin van de Arduino worden aangesloten en worden gebruikt om de module in standby- of actieve modus te zetten, alsook om te schakelen tussen zend- of commandomodus. De laatste pin is een interrupt-pin die niet hoeft te worden gebruikt.
Modulevarianten
Er zijn verschillende varianten van de NRF24L01-modules. De meest populaire is de met onboard antenne. Dit maakt de module compacter, maar aan de andere kant verlaagt het de transmissiereikwijdte tot ongeveer 100 meter.
De tweede variant heeft in plaats van een onboard antenne een SMA-connector waaraan we een duck-antenne kunnen bevestigen voor een betere bereik.
De derde variant, getoond hier, heeft naast de duck-antenne een RFX2401C-chip die een PA (Power Amplifier) en LNA (Low-Noise Amplifier) bevat. Dit versterkt het NRF24L01-signaal en stelt een nog betere transmissiereikwijdte in van tot 1000 meter in open ruimte.
nRF24L01 Module-pinout
Hier is een gedetailleerde kijk op de NRF24L01-pinout, alsook de NRF24L01+ PA/LNA-module. Beide modules hebben dezelfde pinout, dus we kunnen ze op dezelfde manier in ons circuit aansluiten.
Hoe de nRF24L01 aan de Arduino te koppelen
Hier is hoe we de NRF24L01-modules aan de Arduino-boards moeten koppelen. Zoals al gezegd, heeft elk Arduino-board andere SPI-pinnen, dus houd dat in gedachten bij het aansluiten.
| Arduino | SCK | MISO | MOSI | SS |
| Uno | 13 | 12 | 11 | 10 |
| Nano | 13 | 12 | 11 | 10 |
| Mega | 52 | 50 | 51 | 53 |
Je kunt de benodigde componenten voor deze Arduino-tutorial via de onderstaande links verkrijgen:
- NRF24L01 Transceiver-module
- Arduino-board
- Breadboard en jumperdraden
Arduino en nRF24L01 Code
Zodra we de NRF24L01-modules aan de Arduino-boards hebben aangesloten, zijn we klaar om de codes voor zowel de zender als de ontvanger te maken.
Eerst moeten we de RF24-bibliotheek downloaden en installeren, wat de programmering veel makkelijker maakt. We kunnen deze bibliotheek ook direct vanuit de Arduino IDE Library Manager installeren. Zoek gewoon naar "rf24" en vind en installeer de versie van "TMRh20, Avamander".
Hier zijn de twee codes voor de draadloze communicatie en hieronder de uitleg.
Zendercode
/*
* Arduino Draadloze Communicatie Tutorial
* Voorbeeld 1 - Zendercode
* by Dejan Nedelkovski, www.HowToMechatronics.com
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
void setup() {
radio.begin();
radio.openWritingPipe(address);
radio.setPALevel(RF24_PA_MIN);
radio.stopListening();
}
void loop() {
const char text[] = "Hello World";
radio.write(&text, sizeof(text));
delay(1000);
}
Ontvangercode
/*
* Arduino Draadloze Communicatie Tutorial
* Voorbeeld 1 - Ontvangercode
* by Dejan Nedelkovski, www.HowToMechatronics.com
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address);
radio.setPALevel(RF24_PA_MIN);
radio.startListening();
}
void loop() {
if (radio.available()) {
char text[32] = "";
radio.read(&text, sizeof(text));
Serial.println(text);
}
}
Code-uitleg
We moeten de basis SPI- en de zojuist geïnstalleerde RF24-bibliotheek includeren en een RF24-object aanmaken. De twee argumenten zijn de CSN- en CE-pinnen.
RF24 radio(7, 8); // CE, CSN
Vervolgens maken we een byte-array die het adres vertegenwoordigt, de zogenaamde pijp waarover de twee modules communiceren.
const byte address[6] = "00001";
We kunnen de waarde van dit adres wijzigen in een willekeurige 5-letter string, wat ons in staat stelt te kiezen met welke ontvanger we communiceren. In ons geval gebruiken we hetzelfde adres bij zowel zender als ontvanger.
In de setup-sectie initialiseren we het radio-object en gebruiken we de functie radio.openWritingPipe() om het adres van de ontvanger in te stellen waar we data naartoe sturen, de 5-letter string die we eerder instelden.
radio.openWritingPipe(address);
Aan de andere kant, bij de ontvanger, gebruiken we de functie radio.openReadingPipe() om hetzelfde adres in te stellen en zo de communicatie tussen de twee modules mogelijk te maken.
radio.openReadingPipe(0, address);
Dan gebruiken we de functie radio.setPALevel() om het Power Amplifier-niveau in te stellen; in ons geval zet ik het op minimum omdat mijn modules heel dicht bij elkaar staan.
radio.setPALevel(RF24_PA_MIN);
Let op: bij een hoger niveau wordt aanbevolen om een decouplingcondensator over GND en 3,3 V van de modules te plaatsen voor stabielere spanning tijdens de werking.
Vervolgens hebben we de functie radio.stopListening() die de module als zender instelt, en aan de andere kant de functie radio.startListening() die de module als ontvanger instelt.
// bij de Zender
radio.stopListening();
// bij de Ontvanger
radio.startListening();
In de loop-sectie, bij de zender, maken we een array van karakters waaraan we de boodschap "Hello World" toekennen. Met de functie radio.write() sturen we die boodschap naar de ontvanger. Het eerste argument is de variabele die we willen verzenden.
void loop() {
const char text[] = "Hello World";
radio.write(&text, sizeof(text));
delay(1000);
}
Door het "&"-teken voor de variabelenaam te plaatsen, geven we eigenlijk een verwijzing naar de variabele die de te verzenden data opslaat, en met het tweede argument stellen we het aantal bytes in dat we uit die variabele willen halen. In dit geval haalt de sizeof()-functie alle bytes van de string "text" op. Aan het einde voegen we een vertraging van 1 seconde toe.
Met de radio.write()-functie kunnen we maximaal 32 bytes per keer versturen.
Aan de andere kant, bij de ontvanger, controleren we in de loop-sectie met de functie radio.available() of er data is om te ontvangen. Als dat zo is, maken we eerst een array van 32 elementen, genaamd "text", waarin we de binnenkomende data opslaan.
void loop() {
if (radio.available()) {
char text[32] = "";
radio.read(&text, sizeof(text));
Serial.println(text);
}
}
Met de functie radio.read() lezen en slaan we de data op in de variabele "text". Ten slotte printen we de tekst op de seriële monitor. Zodra we beide programma's uploaden, kunnen we de seriële monitor bij de ontvanger openen en zien we dat de boodschap "Hello World" elke seconde wordt afgedrukt.
Probleemoplossing
Het is de moeite waard om op te merken dat voedingsruis een van de meest voorkomende problemen is die mensen ervaren bij het proberen succesvolle communicatie te maken met de NRF24L01-modules. Over het algemeen zijn RF-circuits of radiofrequentiesignalen gevoelig voor voedingsruis. Het is daarom altijd een goed idee om een decouplingcondensator over de voedingslijn te plaatsen. De condensator kan van 10 µF tot 100 µF zijn.
Een ander veelvoorkomend probleem is dat de 3,3 V-pin van de Arduino-boards niet altijd voldoende stroom kan leveren aan de NRF24L01-module. Het voeden van de module met een externe bron is daarom ook een goed idee.
Bidirectionele draadloze communicatie met twee NRF24L01 en Arduino
Laten we het tweede voorbeeld bekijken: bidirectionele draadloze communicatie tussen twee Arduino-boards. Hier is het schakelschema:
Je kunt de benodigde componenten voor dit voorbeeld via de onderstaande links verkrijgen:
- NRF24L01 Transceiver-module
- Arduino-board
- Joystick-module
- Servomotor
- Drukknop
- LED
nRF24L01 Broncode
Hier zijn de twee codes en hun uitleg.
Zendercode
/*
* Arduino Draadloze Communicatie Tutorial
* Voorbeeld 2 - Zendercode
* by Dejan Nedelkovski, www.HowToMechatronics.com
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define led 12
RF24 radio(7, 8); // CE, CSN
const byte addresses[][6] = {"00001", "00002"};
boolean buttonState = 0;
void setup() {
pinMode(12, OUTPUT);
radio.begin();
radio.openWritingPipe(addresses[1]); // 00002
radio.openReadingPipe(1, addresses[0]); // 00001
radio.setPALevel(RF24_PA_MIN);
}
void loop() {
delay(5);
radio.stopListening();
int potValue = analogRead(A0);
int angleValue = map(potValue, 0, 1023, 0, 180);
radio.write(&angleValue, sizeof(angleValue));
delay(5);
radio.startListening();
while (!radio.available());
radio.read(&buttonState, sizeof(buttonState));
if (buttonState == HIGH) {
digitalWrite(led, HIGH);
} else {
digitalWrite(led, LOW);
}
}
Ontvangercode
/*
* Arduino Draadloze Communicatie Tutorial
* Voorbeeld 2 - Ontvangercode
* by Dejan Nedelkovski, www.HowToMechatronics.com
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Servo.h>
#define button 4
RF24 radio(7, 8); // CE, CSN
const byte addresses[][6] = {"00001", "00002"};
Servo myServo;
boolean buttonState = 0;
void setup() {
pinMode(button, INPUT);
myServo.attach(5);
radio.begin();
radio.openWritingPipe(addresses[0]); // 00001
radio.openReadingPipe(1, addresses[1]); // 00002
radio.setPALevel(RF24_PA_MIN);
}
void loop() {
delay(5);
radio.startListening();
if (radio.available()) {
while (radio.available()) {
int angleV = 0;
radio.read(&angleV, sizeof(angleV));
myServo.write(angleV);
}
delay(5);
radio.stopListening();
buttonState = digitalRead(button);
radio.write(&buttonState, sizeof(buttonState));
}
}
Wat hier anders is ten opzichte van het vorige voorbeeld, is dat we twee pijpen of adressen nodig hebben voor de bidirectionele communicatie.
const byte addresses[][6] = {"00001", "00002"};
In de setup-sectie moeten we beide pijpen definiëren, en let op: het zendadres bij de eerste Arduino moet het leesadres zijn bij de tweede Arduino, en vice versa, het leesadres bij de eerste Arduino moet het zendadres zijn bij de tweede Arduino.
// bij de Zender
radio.openWritingPipe(addresses[1]); // 00001
radio.openReadingPipe(1, addresses[0]); // 00002
// bij de Ontvanger
radio.openWritingPipe(addresses[0]); // 00002
radio.openReadingPipe(1, addresses[1]); // 00001
In de loop-sectie gebruiken we de functie radio.stopListening() om de eerste Arduino als zender in te stellen, lezen en mappen we de waarde van de joystick van 0 tot 180, en sturen we de data met de functie radio.write() naar de ontvanger.
radio.stopListening();
int potValue = analogRead(A0);
int angleValue = map(potValue, 0, 1023, 0, 180);
radio.write(&angleValue, sizeof(angleValue));
Aan de andere kant, met de functie radio.startListening() stellen we de tweede Arduino in als ontvanger en controleren we of er beschikbare data is. Terwijl er data beschikbaar is, lezen we het, slaan het op in de variabele "angleV" en gebruiken we die waarde om de servomotor te draaien.
radio.startListening();
if (radio.available()) {
while (radio.available()) {
int angleV = 0;
radio.read(&angleV, sizeof(angleV));
myServo.write(angleV);
}
Vervolgens, bij de zender, stellen we de eerste Arduino in als ontvanger en met een lege "while"-lus wachten we tot de tweede Arduino data stuurt, en dat is de data voor de toestand van de drukknop of deze ingedrukt is of niet. Als de knop ingedrukt is, brandt de LED. Dit proces herhaalt zich constant en beide Arduino-boards zenden en ontvangen continu data.
Voorbeeld 3 – Meerdere variabelen in één pakket versturen
Laten we nog een voorbeeldcode bekijken met de NRF24L01-modules. Alles blijft hetzelfde als in de vorige voorbeelden, behalve de manier waarop we de data structureren en versturen.
Zendercode
/* Arduino Draadloze Communicatie Tutorial
Voorbeeld 1 - Zendercode
by Dejan Nedelkovski, www.HowToMechatronics.com
Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
// Maximale grootte van deze struct is 32 bytes - NRF24L01 bufferlimiet
struct Data_Package {
byte a = 0;
byte b = 125;
byte c = 255;
int d = 1024;
float e = 3.141592;
String f = "Test";
};
Data_Package data; // Maak een variabele met de bovenstaande structuur
void setup() {
radio.begin();
radio.openWritingPipe(address);
radio.setPALevel(RF24_PA_MIN);
radio.stopListening();
}
void loop() {
// Stuur de hele data uit de structuur naar de ontvanger
radio.write(&data, sizeof(Data_Package));
delay(500);
}
We kunnen een struct aanmaken, wat eigenlijk een verzameling is van verschillende typen variabelen.
// Maximale grootte van deze struct is 32 bytes - NRF24L01 bufferlimiet
struct Data_Package {
byte a = 0;
byte b = 125;
byte c = 255;
int d = 1024;
float e = 3.141592;
String f = "Test";
};
Data_Package data; // Maak een variabele met de bovenstaande structuur
We moeten erop letten dat de maximale grootte van deze struct-data 32 bytes kan zijn. Hier zien we dat ik drie variabelen van type byte, één integer-variabele (4 bytes), één float-variabele (4 bytes) en één String van vier karakters (4 bytes) heb opgenomen. Dat is in totaal 15 bytes.
Ontvangercode
/* Arduino Draadloze Communicatie Tutorial
Voorbeeld 1 - Ontvangercode
by Dejan Nedelkovski, www.HowToMechatronics.com
Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
// Maximale grootte van deze struct is 32 bytes - NRF24L01 bufferlimiet
struct Data_Package {
byte a = 0;
byte b = 125;
byte c = 255;
int d = 1024;
float e = 3.141592;
String f = "Test";
};
Data_Package data; // Maak een variabele met de bovenstaande structuur
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address);
radio.setPALevel(RF24_PA_MIN);
radio.startListening();
}
void loop() {
// Controleer of er data is om te ontvangen
if (radio.available()) {
radio.read(&data, sizeof(Data_Package)); // Lees de hele data en sla op in de 'data'-structuur
}
Serial.print("a: "); Serial.print(data.a);
Serial.print(" b: "); Serial.print(data.b);
Serial.print(" c: "); Serial.print(data.c);
Serial.print(" d: "); Serial.print(data.d);
Serial.print(" e: "); Serial.print(data.e);
Serial.print(" f: "); Serial.println(data.f);
}
Aan de ontvangerzijde moeten we dezelfde struct-data definiëren om de binnenkomende data te kunnen ontvangen. Om te testen of de draadloze communicatie correct werkt, heb ik elke variabele op de seriële monitor geprint.
Conclusie
De NRF24L01-module is een geweldige optie voor wanneer je draadloze communicatie nodig hebt voor je Arduino-project. Ik heb deze module al in veel van mijn Arduino-projecten gebruikt.
Hier lijst ik al mijn projecten op waarin ik deze modules heb gebruikt:
- Arduino Robot Auto Draadloze Besturing met HC-05 Bluetooth, NRF24L01 en HC-12 Transceiver-modules
- Arduino Draadloos Weerstation Project
- DIY Arduino RC-zender
- Arduino Ant Hexapod Robot
- DIY Arduino-gebaseerde RC-hovercraft
- Arduino Mecanum-wielen Robot
- DIY Arduino RC-ontvanger voor RC-modellen en Arduino-projecten
- Arduino RC-vliegtuig | 100% DIY
Elk van deze projecten/tutorials heeft een gedetailleerde uitleg over hoe de NRF24L01-module te gebruiken, inclusief schakelschema's, verbeterde code-implementatie voor betere communicatie, enz.
Mijn favoriete project is deze op maat ontworpen Arduino RC-zender. Het is eigenlijk een 14-kanaals RC-controller die gebruikt kan worden om vrijwel elk Arduino-project te besturen.
Dat was het voor deze tutorial, ik hoop dat je ervan hebt genoten en iets nieuws hebt geleerd. Zoals altijd, voel je vrij om vragen te stellen in de reacties hieronder.
Productieproces
- Luchtkwaliteit meten met OpenSensors: Een Arduino & Python Handleiding
- Bouw een Universele IR-remote met Arduino: Stap-voor-stap Handleiding
- Bouw een Digitale Lichaamslengtemeter: Je Lengte Meten met Arduino en Lasersensor
- JX Wave Generator – Arduino-compatibele DDS-oscillator met OLED-display
- Bouw een DIY VR-skateboard met Arduino, Google Cardboard en Bluetooth
- Arduino Mega koppelen aan een NEO‑6M GPS-module: stapsgewijze handleiding
- Thermistor Gebruik Gemaakt Eenvoudig: Stap-voor-Stap Arduino Handleiding
- Maak Muzikale Tonen met Arduino: Stapsgewijze Handleiding
- Modbus op Arduino onder de knie: Stapsgewijze handleiding
- ArduRadio Wekker: DIY Arduino-gebaseerde FM-radio & Weeksysteem
- Hersen-computer-interfaces: Herstellen van gedachte naar actie