nRF24L01 – Hoe het werkt, Arduino-interface, circuits, codes

U kunt de benodigde componenten voor deze Arduino-tutorial vinden via de onderstaande links:

• NRF24L01 Zendontvangermodule…………
• Arduino-bord ……………………………
• Broodplank en springdraden ………… 

Arduino- en nRF24L01-code

Zodra we de NRF24L01-modules op de Arduino-kaarten 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 het programmeren minder moeilijk maakt. We kunnen deze bibliotheek ook rechtstreeks vanuit de Arduino IDE Library Manager installeren. Zoek gewoon naar "rf24" en zoek en installeer die van "TMRh20, Avamander".

Hier zijn de twee codes voor de draadloze communicatie en hieronder is de beschrijving ervan.

Zendercode

/*
* Arduino Wireless Communication Tutorial
*     Example 1 - Transmitter Code
*                
* 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);
}Code language: Arduino (arduino)

Ontvangercode

/*
* Arduino Wireless Communication Tutorial
*       Example 1 - Receiver Code
*                
* 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 language: Arduino (arduino)

Codebeschrijving

We moeten dus de basis-SPI en de nieuw geïnstalleerde RF24-bibliotheken opnemen en een RF24-object maken. De twee argumenten hier zijn de CSN- en CE-pinnen.

RF24 radio(7, 8); // CE, CSNCode language: Arduino (arduino)

Vervolgens moeten we een bytearray maken die het adres vertegenwoordigt, of de zogenaamde pijp waardoor de twee modules zullen communiceren.

const byte address[6] = "00001";Code language: Arduino (arduino)

We kunnen de waarde van dit adres wijzigen in een willekeurige reeks van 5 letters en dit maakt het mogelijk om te kiezen met welke ontvanger we willen praten, dus in ons geval hebben we hetzelfde adres bij zowel de ontvanger als de zender.

In de setup-sectie moeten we het radio-object initialiseren en met behulp van de radio.openWritingPipe()-functie stellen we het adres in van de ontvanger waarnaar we gegevens zullen verzenden, de 5-letterreeks die we eerder hadden ingesteld.

radio.openWritingPipe(address);Code language: Arduino (arduino)

Aan de andere kant, bij de ontvanger, stellen we met behulp van de radio.setReadingPipe()-functie hetzelfde adres in en op die manier maken we de communicatie tussen de twee modules mogelijk.

radio.openReadingPipe(0, address);Code language: Arduino (arduino)

Vervolgens gebruiken we de radio.setPALevel()-functie om het Power Amplifier-niveau in te stellen, in ons geval zal ik het op het minimum zetten omdat mijn modules heel dicht bij elkaar staan.

radio.setPALevel(RF24_PA_MIN);Code language: Arduino (arduino)

Merk op dat als u een hoger niveau gebruikt, het wordt aanbevolen om bypass-condensatoren over GND en 3,3 V van de modules te gebruiken, zodat ze een stabielere spanning hebben tijdens het gebruik.

Vervolgens hebben we de functie radio.stopListening() die de module als zender instelt, en aan de andere kant hebben we de functie radio.startListening() die de module als ontvanger instelt.

// at the Transmitter
radio.stopListening();Code language: Arduino (arduino)

// at the Receiver
radio.startListening();Code language: Arduino (arduino)

In de lussectie, bij de zender, creëren we een reeks tekens waaraan we het bericht "Hello World" toewijzen. Met behulp van de radio.write() functie sturen we dat bericht naar de ontvanger. Het eerste argument hier is de variabele die we willen sturen.

void loop() {
 const char text[] = "Hello World";
 radio.write(&text, sizeof(text));
 delay(1000);
}Code language: Arduino (arduino)

Door de "&" voor de variabelenaam te gebruiken, stellen we in feite een aanduiding in van de variabele die de gegevens opslaat die we willen verzenden en met het tweede argument stellen we het aantal bytes in dat we van die variabele willen nemen. In dit geval krijgt de functie sizeof() alle bytes van de strings "text". Aan het einde van het programma voegen we 1 seconde vertraging toe.

Met de functie radio.write() kunnen we maximaal 32 bytes tegelijk verzenden.

Aan de andere kant, bij de ontvanger, in de lussectie met behulp van de radio.available() functie controleren we of er data is om te ontvangen. Als dat waar is, maken we eerst een array van 32 elementen, "tekst" genaamd, waarin we de binnenkomende gegevens opslaan.

void loop() {
  if (radio.available()) {
    char text[32] = "";
    radio.read(&text, sizeof(text));
    Serial.println(text);
  }
}Code language: Arduino (arduino)

Met behulp van de radion.read()-functie lezen en slaan we de gegevens op in de variabele "text". Op het einde printen we gewoon tekst op de seriële monitor. Dus zodra we beide programma's hebben geüpload, kunnen we de seriële monitor op de ontvanger laten draaien en zullen we zien dat het bericht "Hello World" elke seconde wordt afgedrukt.

Problemen oplossen

Het is vermeldenswaard dat ruis van de voeding is een van de meest voorkomende problemen die mensen ervaren bij het maken van succesvolle communicatie met de NRF24L01-modules. Over het algemeen zijn RF-circuits of radiofrequentiesignalen gevoelig voor ruis van de voeding. Daarom is het altijd een goed idee om een ​​ontkoppelcondensator over de voedingslijn te plaatsen. De condensator kan variëren van 10uF tot 100uF.

Een ander veelvoorkomend probleem is dat de 3.3V-pin van de Arduino-boards niet altijd voldoende stroom kan leveren aan de NRF24L01-module. Het is dus ook een goed idee om de module van stroom te voorzien met een externe voedingsbron.

Bidirectionele draadloze communicatie met twee NRF24L01 en Arduino

Laten we eens kijken naar het tweede voorbeeld, een bidirectionele draadloze communicatie tussen twee Arduino-kaarten. Hier zijn de circuitschema's:

U kunt de benodigde componenten voor dit voorbeeld vinden via de onderstaande links:

• NRF24L01 Zendontvangermodule…………
• Arduino-bord……………………………….
• Joystick-module …………………………….
• Servomotor ………………………………….
• Drukknop …………………………………..
• LED ………………………………………………

nRF24L01 Broncode

Hier zijn de twee codes en hun beschrijving hieronder.

Zendercode

/*
* Arduino Wireless Communication Tutorial
*     Example 2 - Transmitter Code
*                
* 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);
  }
}Code language: Arduino (arduino)

Ontvangercode

/*
* Arduino Wireless Communication Tutorial
*     Example 2 - Receiver Code
*                
* 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));
  }
}Code language: Arduino (arduino)

Wat hier anders is dan in het vorige voorbeeld, is dat we twee buizen of adressen moeten maken voor de bidirectionele communicatie.

const byte addresses[][6] = {"00001", "00002"};Code language: Arduino (arduino)

In de setup-sectie moeten we beide leidingen definiëren, en merk op dat het schrijfadres op de eerste Arduino het leesadres op de tweede Arduino moet zijn, en vice versa, het leesadres op de eerste Arduino moet het schrijfadres zijn op de tweede Arduino.

// at the Transmitter
radio.openWritingPipe(addresses[1]); // 00001
radio.openReadingPipe(1, addresses[0]); // 00002Code language: Arduino (arduino)

// at the Receiver
radio.openWritingPipe(addresses[0]); // 00002
radio.openReadingPipe(1, addresses[1]); // 00001Code language: Arduino (arduino)

In de loop-sectie met behulp van de radio.stopListening()-functie stellen we de eerste Arduino in als zender, lezen en brengen de waarde van Joystick in kaart van 0 tot 180, en gebruiken de radio.write()-functie om de gegevens naar de ontvanger te sturen.

radio.stopListening();
int potValue = analogRead(A0);
int angleValue = map(potValue, 0, 1023, 0, 180);
radio.write(&angleValue, sizeof(angleValue));Code language: Arduino (arduino)

Aan de andere kant stellen we met de functie radio.startListening() de tweede Arduino in als ontvanger en controleren we of er data beschikbaar is. Hoewel er gegevens beschikbaar zijn, zullen we deze lezen, opslaan in de variabele "angleV" en vervolgens die waarde gebruiken om de servomotor te draaien.

radio.startListening();
  if ( radio.available()) {
    while (radio.available()) {
      int angleV = 0;
      radio.read(&angleV, sizeof(angleV));
      myServo.write(angleV);
    }Code language: Arduino (arduino)

Vervolgens stellen we bij de zender de eerste Arduino in als ontvanger en met een lege "while"-lus wachten we op de tweede Arduino de verzendgegevens, en dat zijn de gegevens voor de status van de drukknop, of deze nu wordt ingedrukt of niet. Als de knop wordt ingedrukt, gaat de LED branden. Dit proces wordt dus voortdurend herhaald en beide Arduino-kaarten verzenden en ontvangen voortdurend gegevens.

Voorbeeld 3 – Meerdere variabelen in één pakket verzenden

Laten we nog een voorbeeldcode bekijken met behulp van de NRF24L01-modules. Alles blijft hetzelfde als in de vorige voorbeelden, verwacht de manier waarop we de datum structureren en verzenden.

Zendercode

/*
  Arduino Wireless Communication Tutorial
      Example 1 - Transmitter Code

  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";

// Max size of this struct is 32 bytes - NRF24L01 buffer limit
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; // Create a variable with the above structure

void setup() {
  radio.begin();
  radio.openWritingPipe(address);
  radio.setPALevel(RF24_PA_MIN);
  radio.stopListening();
}

void loop() {
  // Send the whole data from the structure to the receiver
  radio.write(&data, sizeof(Data_Package));
  delay(500);
}Code language: Arduino (arduino)

We kunnen dus een struct creëren die eigenlijk een verzameling is van verschillende soorten variabelen.

// Max size of this struct is 32 bytes - NRF24L01 buffer limit
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; // Create a variable with the above structureCode language: Arduino (arduino)

We moeten er rekening mee houden dat de maximale grootte van deze structgegevens 32 bytes kan zijn. Hier kunnen we zien dat ik drie variabelen van het type byte, een integer-variabele (4 bytes), een float-variabele (4 bytes) en een string met vier tekens (4 bytes) heb opgenomen. Dat is in totaal 15 bytes.

Ontvangercode

/*
  Arduino Wireless Communication Tutorial
        Example 1 - Receiver Code

  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";

// Max size of this struct is 32 bytes - NRF24L01 buffer limit
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; //Create a variable with the above structure

void setup() {
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setPALevel(RF24_PA_MIN);
  radio.startListening();
}

void loop() {
  // Check whether there is data to be received
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
  }
  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);
}Code language: Arduino (arduino)

Aan de ontvangerzijde moeten we dezelfde structuurgegevens definiëren om de binnenkomende gegevens te kunnen ontvangen. Om te testen of de draadloze communicatie goed werkt, heb ik elke variabele op de seriële monitor afgedrukt.

Conclusie

De NRF24L01-module is een geweldige optie voor wanneer u draadloze communicatie nodig heeft voor uw Arduino-project. Ik heb deze module al in veel van mijn Arduino-projecten gebruikt.

Hier zal ik al mijn projecten opsommen waarin ik deze modules heb gebruikt.

• Arduino Robot Car Wireless Control met behulp van HC-05 Bluetooth, NRF24L01 en HC-12 Transceiver Modules
• Arduino draadloos weerstationproject
• DIY Arduino RC-zender
• Arduino Ant Hexapod-robot
• DIY Arduino-gebaseerde RC Hovercraft
• Arduino Mecanum Wheels-robot
• DIY Arduino RC-ontvanger voor RC-modellen en Arduino-projecten
• Arduino RC-vliegtuig | 100% doe-het-zelf

Elk van deze projecten/tutorials heeft een gedetailleerde uitleg over het gebruik van de NRF24L01-module, inclusief schakelschema's, verbeterde code-implementatie voor betere communicatie, enzovoort.

Mijn favoriete project is deze op maat ontworpen Arduino RC-zender. Het is eigenlijk een 14-kanaals RC-controller die kan worden gebruikt voor het besturen van vrijwel elk Arduino-project.

Dat was alles voor deze tutorial, ik hoop dat je ervan genoten hebt en iets nieuws hebt geleerd. Stel zoals altijd gerust een vraag in de opmerkingen hieronder.