nRF2424L01

De mogelijkheid om met de Arduino een andere Arduino op afstand te bedienen zonder gebruikt te moeten maken van een web interface of bleutooth.
Het gaat om 2x een microprocessor en 2x een NRF24L01. De NRF24L01 heeft een ander protocol(berichten format) dan een 'gewone' RC voor modelbouw.
De nRF gebruikt <1 byte preamble, 3~5 bytes adres, 9 bytes packet control field en 1~2 bytes CRC>. A7105 <4 bytes preamble, 4 bytes ID code, payload en 2 bytes CRC>.
Echter er blijken RF modulles te zijn die wel dicht bij de nRF24L01 protocol zitten.
De benodigdheden zijn 2x een Arduino en 2x een nRF242L01. Elke nRF242L01 (nRF24L01+ Wireless Module) kan zenden en ontvangen op ca 100 meter maar grofweg de nRF242L01 (nRF24L01+ PA LNA Wireless Transceiver Module with External Antenna) met de grote antene kan tot 1000 meter zenden.

Er is een nRF24L01 en een nRF24L01+. De plus versie is nieuwer kan een extra 250kbs aan airdata. Je kan beide versies door elkaar en met elkaar gebruiken, bij de 1 en 2 Mbs (niet plus versie). De + PA versie is met antene.
De nRF24L01 gebruikt de 2.4Ghz band en gebruikt GFSK modulatie voor data transmissie. De data overdracht kan 250kbps, 1Mbps en 2Mbps zijn.
De NRF24L01 werkt op 1.9 V t/m 3.3V en communiceert met SPI. De pinnen blijken 5V tolerant te zijn waardoor het te verbinden is met de Arduino of andere 5V microprocessor zonder gebruik te hoeven maken van een levelshifter.
De module ondersteund programeerbare output van 0 dBm, -6dBm, -12dBm of -18dBm. Het verbruik is ongeveer 12 mA bij zenden van 0 dBm wat minder is dan verbruik van een doorsnee led. Bij standby gebruikt de module 26uA en 900 nA in power down mode.
De module werkt met de SPI interface op 10Mbs. Alle instellingen zoals zendfrequentie (125 verschillende), uitzend kracht, en snelheid kunnen worden ingesteld.
De master is de Arduino en de module is de slave. Maximaal per SPI 2 nRF24L01 modules.
Er zijn diverse module versies, met en zonder antene. Met antene is er meer bereik (ca 100m). De versie met antene heeft soms ook een SMA connector en antene en heeft een RFX240C chip welke de PA, LNA zend/ontvang schakeling circuit heeft. Hierdoor is een vergroting van het bereik tot 1000meter.
wat is PA LNA PA is Power Amplifier welke de spanning opkrikt van de nRF24L01.
LNA is Low Noise Amplifier die krikt het signaal van de antene op tot een beter te gebruiken spanning. (.5 t/m 1V)
Hoe werkt de nRF24L01
De module zend en ontvangt op een bepaalde frequentie dat vaak kanaal wordt genoemd. Dat kanaal kan elke frequentie op de 2.4Ghz ISM band zijn. (Tussen 2400 tot 2525 MHz). Elk kanaal gebruikt een bandbreedte van 1Mhz. Dat geeft 125 verschillende kanalen met 1 Mhz. Dus 125 verschillende modems op 1 plaats te benaderen. De frequentie afstelling is 2400+CH (kanaal) Kanaal 11 is dus frequentie 2411.
Dat kan dus bij zenden en ontvangen. Een ontvanger kan ook op 125 kanalen luisteren.

Er worden pakketjes verstuur van 1 t/m 32 bytes. Een simpel pakketje is opgedeeld in 5 delen.

1 byte Preamble
3-5 bytes Adress
9 bytes Packet Control ->6 bytes Payload lenght 2 bytes Packet ID 1 byte No Ack
0-32 bytes Payload
1-2 bytes CRC

Packet ID is handig voor de ontvanger, lijkt dit op een pakketje wat hij al ontvangen had dan kan hij het pakketje negeren.
Er is ook controle op ontvangst. (AC) Dat moet binnen 130uS worden verstuurd door de ontvanger na ontvangst van een pakketje data en ontvangen door de verstuurder na het zenden van een pakketje, anders wordt hetzelfde verstuurde pakketje opnieuw door de zender verzonden.

Voordat je nu alles gaat aansluiten kijk dan even op de Arduino pagina want niet elke Arduine gebruikt dezelfde pinnen. De aansluiting van de 6 pinnen op het Arduino board correspondeerd dan met de aangesloten pinnen van het tabel.


De NRF24L01 sluit ik op de Nano aan met de adapter:
||
AdapterESP8266 Wemos D1|Nano|Mega
1 GndG|gnd|gnd
2 Vcc3.3V|3.3V|3.3V
3 CED2 GPIO 4|9|9
4 CSND4 GPIO 2|10|10
5 SCKD5 GPIO 14 |D13|52
6 MoD7 GPIO 13 |D11|51
7 MiD6 GPIO 12 |D12|50
8 IrqNiet verbonden|NC|nc

D5, D6 en D7 Worden door de Wemos D1 gebruikt voor de Mosi Miso verbinding. Ce en Csn zijn vrij bepaalbaar en bij RF24 radio(4, 2); // CE, CSN besloten.
De zender en ontvanger worden beide op dezelfde wijze aangesloten. Door software worden ze of zender of ontvanger. Welke processor je dus ook gebruikt, als hij als zender of ontvanger werkt weet je dat de aansluiting goed is.
De Nano en Uno gebruiken beide dezelfde pinnen voor de communicatie.
Nu is het aansturen van de nRF242L01 een behoorlijke programeer klus maar gelukkig is er al een aantal jaren de RF24 library (zie bronnen) die het programeerwerk een stuk aangenamer maken.
Uiteraard begin je met uit te leggen waarom de sketch door wie gemaakt is. Daarna komen de gebruikte library's:

//Include Libraries
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

Daarna moet de RF24 object maken. Hier worden 2 pin nummers voor CE en CSN bepaald.

//create an RF24 object
RF24 radio(9, 8); // CE, CSN
Vervolgens maken we een (array) opslag plek voor de data waarmee 2 nRF24201 modulles met elkaar gaan communiceren.


//address through which two modules communicate.
const byte address[6] = "00001";
De waarde van dat aderes (address) naar elk 5 letter string zoals b.v. 'node1'. Het adres is nodig als je een paar modules in je netwerk heb. Dankzij het adres kan je precies comuniceren met 1 module. In het voorbeeld gebruikt de zender en ontvanger hetzelfde adres.

Vervolgens de setup. Nu starten we de radio object met radio(begin) en gebruiken de radio.openWritingPipe(address) om het adres te bepalen van de zend module.

//set the address
radio.openWritingPipe(address);
De radio.stopListing() opdracht zet de module om in een zender.


//Set module as transmitter
radio.stopListening();
In de loop void maken we een array van karakters waarin we de tekst 'Hello World'opslaan. Die tekst gaan we versturen naar de ontvanger. Het eerste argument is de tekst 'Hello World' en het 2e argument is het aantal bytes lengte van die tekst.


const char text[] = "Hello World";
radio.write(&text, sizeof(text));
Met deze methode kan je maximaal 32 bytes per keer verzenden, meer kan de nRF24L01+ niet aan. Als je een bevestiging wil dat de data aangekomen is dan radio.write geeft een bool waarde TRUE als de data aangekomen is en FALSE als de data niet aan kwam. Radio.write blokeerd het programma tot de ACK info binnen is.

Het programma voor de ontvanger is vrijwel gelijk aan het zend deel.
De ontvanger script start met natuurlijk ook de library's maar de eerste wijziging is radia.setReadingPipe(0,address). Hiermee maken we een gelijk aderes met de zender zodat ze weten dat ze met elkaar kunnen communiceren.


//set the address
radio.openReadingPipe(0, address);
Het 1e argument is het nummer van de 'stream' je kan 6 'streams' hebben die coresponderen met verschillende adressen. Het 2e argument is het adres van de 'stream' om de data te ontvangen.
De volgende stap is de module in te stellen als ontvanger en data te ontvangen, dat doen we met radio.startListening() functie. Vanaf dat moment verwacht de module data te ontvangen.


//Set module as receiver
radio.startListening();
In de loop() void controleert de module of er data ontvangen kan worden met de radio.available() methode. Deze methode geeft een TRUE als er data in de buffer is.

if (radio.available()){
char text[32] = {0};
radio.read(&text, sizeof(text));
Serial.println(text);
}
Als er data is ontvangen, dan wordt er een array van 32 karakters van 0 gemaakt welke 0 later wordt veranderd door andere karakkters. Om de data te lezen gebruiken we radio.read (& text, sizeof (text)).
Dat slaat de data op in de karakter array.
Via Serialmonitor kan je dan de tekst lezen.(als het goed ging.)

Versterken van het signaal Een RF dat een radia frequentie genereerd is erg afhankelijk van een storingvrije voedingspanning. Een 10 uF condensator tussen de plus en de min van de voedingspanning vlak bij de module kan al veel helpen. Ook de speciale goedkope Adapter Module met aansluiting voor de nRF242L01 kan veel schelen. De adapter kan je met 5V voeden. De adapter levert dan 3.3V aan de module.
Een andere storingsbron kunnen andere RF modules zijn. Gebruik daarom bij voorkeur de hoogste 25 kanalen. De meeste zenders gebruiken de laagste kanalen.
Ook de data hoeveelheid verminderen kan behoorlijk schelen in het bereik. het versturen van een data paket kost spanning, hoe langer het pakket hoe meer spanning verlies. Bij250kbps heb je een goed resultaat. De output power op 0 heeft een hoger zendbereik dan -6, -12 of -18 dBm.

Als het niet werkt Kijk dan hier bij deze Engeltalige uitleg. Hier las ik dat het handig is om pipe 0 als alleen zend pipe te gebruiken en pipe 1 als ontvang pipe. De NRF24L01 kan naar 6 pipes luisteren maar die 6 mogen niet allemaal tegelijk zenden.
Er wordt in het ontvangen bericht gekeken naar het adres, als dat niet het adres is wat er wordt verwacht dan wordt het bericht gewist.
Soms moet je even de spanning van de Nano afhalen om de NRF24L01 te resetten.
Voed de NRF24L01 met 3.3V.

/*
zender
Created by Yvan / https://Brainy-Bits.com
This code is in the public domain...
You can: copy it, use it, modify it, share it or just plain ignore it!
Thx!
*/

// NRF24L01 Module Tutorial - Code for Transmitter using Arduino NANO

//Include needed Libraries at beginning
#include "nRF24L01.h" //NRF24L01 library created by TMRh20 https://github.com/TMRh20/RF24
#include "RF24.h"
#include "SPI.h"

#define SwitchPin 8 // Arcade switch is connected to Pin 8 on NANO
int SentMessage[1] = {000}; // Used to store value before being sent through the NRF24L01

RF24 radio(9,10); // NRF24L01 used SPI pins + Pin 9 and 10 on the NANO

const uint64_t pipe = 0xE6E6E6E6E6E6; // Needs to be the same for communicating between 2 NRF24L01

void setup(void){

pinMode(SwitchPin, INPUT_PULLUP); // Define the arcade switch NANO pin as an Input using Internal Pullups
digitalWrite(SwitchPin,HIGH); // Set Pin to HIGH at beginning

radio.begin(); // Start the NRF24L01
radio.openWritingPipe(pipe); // Get NRF24L01 ready to transmit
}

void loop(void){

if (digitalRead(SwitchPin) == LOW){ // If Switch is Activated
SentMessage[0] = 111;
radio.write(SentMessage, 1); // Send value through NRF24L01
}
else {
SentMessage[0] = 000;
radio.write(SentMessage, 1);
}
}

/*
ontvanger
Created by Yvan / https://Brainy-Bits.com
This code is in the public domain...
You can: copy it, use it, modify it, share it or just plain ignore it!
Thx!
*/
// NRF24L01 Module Tutorial - Code for Receiver using Arduino UNO

//Include needed Libraries at beginning
#include "nRF24L01.h" // NRF24L01 library created by TMRh20 https://github.com/TMRh20/RF24
#include "RF24.h"
#include "SPI.h"
#include "FastLED.h" // FastLED library for WS2812 RGB Stick http://fastled.io/

#define NUM_LEDS 8 // Number of leds on stick
#define LED_PIN 8 // Digital In (DI) of RGB Stick connected to pin 8 of the UNO

CRGB leds[NUM_LEDS]; // FastLED Library Init

int ReceivedMessage[1] = {000}; // Used to store value received by the NRF24L01

RF24 radio(9,10); // NRF24L01 used SPI pins + Pin 9 and 10 on the UNO

const uint64_t pipe = 0xE6E6E6E6E6E6; // Needs to be the same for communicating between 2 NRF24L01

void setup(void){

FastLED.addLeds<NEOPIXEL,LED_PIN>(leds, NUM_LEDS); // Setup FastLED Library
FastLED.clear(); // Clear the RGB Stick LEDs

// Light up starting LED's
for(int x = 0; x != NUM_LEDS; x++) {
leds[x] = CRGB::Red;
}

FastLED.setBrightness(50);
FastLED.show();

radio.begin(); // Start the NRF24L01

radio.openReadingPipe(1,pipe); // Get NRF24L01 ready to receive

radio.startListening(); // Listen to see if information received

pinMode(LED_PIN, OUTPUT); // Set RGB Stick UNO pin to an OUTPUT
}

void loop(void){

while (radio.available())
{
radio.read(ReceivedMessage, 1); // Read information from the NRF24L01

if (ReceivedMessage[0] == 111) // Indicates switch is pressed
{
for(int x = 0; x != NUM_LEDS; x++)
{
leds[x] = CRGB::Green;
FastLED.show();
}
}
else
{
for(int x = 0; x != NUM_LEDS; x++)
{
leds[x] = CRGB::Red;
FastLED.show();
}
}
delay(10);
}
}


Bronnen:

arduino.cc reference/SPI Miso Mosi info
howtomechatronics.com arduino-wireless-communication-nrf24l01-tutorial
arduinoinfo.mywikis.net Nrf24L01-2.4GHz-HowTo
brainy-bits.com how-to-use-the-nrf24l01-2-4ghz-wireless-module
Library github.com/nRF24/RF24
forum.arduino storing zoeken.
Library github.com/FastLED
lastminuteengineers.com nrf24l01-arduino-wireless-communication
steve.fi wemos D1 hardware pinnen
rcgroups.com Hubsan-X4-protocol-analysis
hackaday.io -nrf24l01-rc-plane-joystick