Arduino nRF24L01 comunicazione base

Erano anni ormai che avevo acquistato uno stock di moduli nRF24L01 con tutte le buone intenzioni di mettermi a smanettare con loro, ma come si evince dallo stato di abbandono del sito, purtroppo non è stato così.
Ieri durante una delle tante pulizie casalinghe di questo periodo di quarantena eccoli che saltano fuori e mi si accende la lampadina. Perché non approfittarne di questi momenti forzatamente indoor? Ed ecco quindi che nasce l’idea di questo articolo.
Si tratta di una configurazione base per mettere in comunicazione due Arduino attraverso appunto il modulo nRF24L01.

Prima di passare all’azione direi di fare qualche presentazione. Parliamo di un modulo radio a basso consumo sia energetico che economico avendo prezzi davvero bassi. Riesce a stabilire comunicazioni bidirezionali, pertanto se opportunamente configurato può diventare un ottimo componente per una rete di sensori.

È bene ricordare che non stiamo parlando di comunicazione Wireless nel modo in cui siamo abituati a conoscerla, questi moduli comunicano sulla banda di frequenza 2.4GHz e con un dispendio energetico davvero contenuto riescono a trasmettere teoricamente (non ho modo di fare dei test) fino ad un centinaio di metri.

SPI

Per essere gestito da Arduino, il modulo nRF24L01 utilizza l’interfaccia SPI.
SPI sta per Serial Peripheral Interface ed in sostanza nel nostro caso, è un interfaccia seriale che consente la comunicazione tra il micro controllore dell’Arduino e altri circuiti integrati esterni.
Senza scendere troppo nei dettagli, la comunicazione avviene tra un dispositivo master e dispositivi detti slave. Il master (nel nostro caso l’Arduino) come lascia intuire il nome, è quello che comanda la baracca. Esso gestisce il clock necessario a scandire il transito dei dati sul bus, e decide inoltre quando aprire o chiudere la comunicazione.

nRF24L01 Pinout

GNDGround
Vcc1.9V – 3.3V
CEChip Enable
CSNChip Select
SCKSerial Clock
MOSIMaster Output Slave Input
MISOMaster Input Slave Output
IRQInterrupt (generalmente non ci serve)
nRF24L01 Pinout
nRF24L01 Pinout

Ricorda che il modulo va alimentato con una tensione che va da 1.9V a massimo 3.3V anche se può tollerare livelli di 5V sugli altri pin. Se dovessimo alimentarlo a 5V possiamo dire ciao alla nostra radio. Altra cosa importante da ricordare è che i pin SPI di Arduino, possono variare in base al modello. Di seguito riporto uno screen del sito ufficiale Arduino. https://www.arduino.cc/en/reference/SPI

Screen del sito ufficiale di Arduino

Come da immagine alcuni Arduino presentano una zona (ICSP) dedicata di pin per comodità di prototipazione di nuove shield o board, ma fate attenzione che al pin 2 +Vcc potreste trovarvi 5V e non 3.3.
Nel mio esempio avrei voluto utilizzare due Arduino Nano, anch’essi abbandonati nella stessa scatola dei moduli radio, ma purtroppo ho scoperto che uno di questi non funziona, quindi mi sono dovuto arrangiare con un Arduino Leonardo ed un Nano.

Le librerie

Come capita spesso, per scrivere i nostri programmini su Arduino abbiamo bisogno di utilizzare delle librerie che ci facciano risparmiare tempo e mal di testa, come in questo caso.
Di librerie che trattano la comunicazione con i moduli nRF24 ce ne sono diverse, io mi sono concentrato su questa, che a quanto sembra è tra le più diffuse ed ottimizzate. Si chiama RF24 e puoi trovare la documentazione a questa pagina. http://tmrh20.github.io/RF24/
Ricordo che per installarla sull’IDE Arduino, basta andare su “Sketch -> #include libreria -> Gestione Librerie” e da li eseguire la ricerca. L’autore è TMRH20.

Scenario

Come anticipato si tratta di un progettino base giusto per capire come collegare il modulo e stabilire una comunicazione tra due Arduino.
In questo caso l’Arduino Nano sarà il trasmettitore e l’Arduino Leonardo sarà il ricevitore. Sappiate però che è possibile creare anche comunicazioni bidirezionali e sistemi di reti mesh con più attori. Ma di questo ne parleremo magari in un altro articolo.
L’Arduino Nano avrà un potenziometro collegato ad un pin analogico che simulerà la lettura di un ipotetico sensore, dall’altro lato l’Arduino Leonardo mostrerà in console (Serial Monitor) il valore inviato dal trasmettitore.

Il Codice

Come sempre utilizzo i commenti nel codice per descrivere le varie fasi, quindi ti rimando ai listati per vedere cosa ho fatto.

Trasmettitore (Arduino Nano)

/*
   Arduino nRF24L01 comunicazione base

   Autore  : Andrea Lombardo
   Web     : http://www.lombardoandrea.com
   Post    : https://wp.me/p27dYH-Oi
*/
//Inclusione delle librerie
#include <nRF24L01.h>
#include <RF24_config.h>
#include <RF24.h>


//definizione indirizzo sul quale stabilire la comunicazione
const byte indirizzo[5] = {0,0,0,0,0};

//Creo un'istanza della "radio" passandogli il numero dei pin collegati a CE e CSN del modulo
RF24 radio(9, 10);

//Definisco quali saranno i pin per il LED e per il Potenziometro
int pinLed = 7;
int pinPot = A5;

//Creo due variabili nelle quali andrò a salvare lo stato del led ed il valore del potenziometro
boolean ledStatus;
int valPot;

void setup() {

  //Inizializzo le due variabili
  ledStatus = false;
  valPot = 0;

  //Stabilisco la modalità dei pin
  pinMode(pinLed, OUTPUT);
  pinMode(pinPot, INPUT);

  //Spengo il led
  digitalWrite(pinLed, ledStatus);

  //Inizializzo la radio
  radio.begin();


  /*
     La radio può lavorare a diverse potenze: RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH e RF24_PA_MAX
     Che corrispondono a: -18dBm, -12dBm,-6dBM, e 0dBm
  */
  //Setto la potenza della radio a LOW
  radio.setPALevel(RF24_PA_LOW);

  //Apro un canale di comunicazione sull'indirizzo specificato (sarà lo stesso per il ricevitore)
  radio.openWritingPipe(indirizzo);

  //Richiamando questo metodo sto impostando la radio come trasmettitore
  radio.stopListening();
}

void loop() {

  //Leggo il valore del potenziometro
  int readPot = analogRead(pinPot);

  //Se il valore del potenziometro è diverso dall'ultimo valore letto
  if (readPot != valPot) {
    //salvo il nuovo valore nella variabile valPot
    valPot = readPot;
    //Accendo il led
    digitalWrite(pinLed, true);
    //Invio il valore per radio
    radio.write(&valPot, sizeof(valPot));
    //Spengo di nuovo il led
    digitalWrite(pinLed, false);
  }
  //un minimo di respiro trai i cicli del loop
  delay(15);
}

Ricevitore (Arduino Leonardo)

/*
   Arduino nRF24L01 comunicazione base

   Autore  : Andrea Lombardo
   Web     : http://www.lombardoandrea.com
   Post    : https://wp.me/p27dYH-Oi
*/
//Inclusione delle librerie
#include <nRF24L01.h>
#include <RF24_config.h>
#include <RF24.h>


//definizione indirizzo sul quale stabilire la comunicazione
const byte indirizzo[5] = {0, 0, 0, 0, 0};

//Creo un'istanza della "radio" passandogli il numero dei pin collegati a CE e CSN del modulo
RF24 radio(5, 4);


void setup() {

  //Inizializzo la comunicazione seriale per il monitor
  Serial.begin(115200);

  //Aspetto ad andare avanti fin quando non viene aperto il monitor seriale
  while (!Serial) {
    //Aspetto
  }

  Serial.println(F("Avvio ricevitore"));

  //Inizializzo la radio
  radio.begin();

  /*
     La radio può lavorare a diverse potenze: RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH e RF24_PA_MAX
     Che corrispondono a: -18dBm, -12dBm,-6dBM, e 0dBm
  */
  //Setto la potenza della radio a LOW
  radio.setPALevel(RF24_PA_LOW);

  //Apro un canale in lettura sull'indirizzo specificato
  radio.openReadingPipe(1, indirizzo);

  //Metto la radio in ascolto
  radio.startListening();

  Serial.println(F("Radio in ascolto!"));

}

void loop() {

  //Se ci sono dati in ricezione sulla radio
  if (radio.available()) {
    //Creo una variabile di appoggio
    int buff = 0;
    //Leggo i dati sul buffer e li salvo nella variabile di appoggio
    radio.read(&buff, sizeof(buff));
    //Invio al monitor seriale il valore appena letto
    Serial.println(buff);
  }

}

Schemi

Di seguito ti mostro come ho fatto i collegamenti.

Schema dei collegamenti per il trasmettitore

Come avrai notato dal codice, e qui sopra dallo schema, al Nano ho collegato anche un led. Lo uso come feedback visivo dell’avvenuta trasmissione. Non ho potuto usare il led onboard, coincidente con il pin D13, proprio perché questo pin fa parte dell’interfaccia SPI dell’Arduino Nano.

Schema dei collegamenti per il ricevitore

A questo punto lascerò l’Arduino Leonardo connesso al PC in modo da poter leggere il monitor seriale, mentre l’Arduino Nano lo alimenterò a parte con un power bank o simili. Se tutto è collegato per bene, e non abbiamo tralasciato nulla, ad ogni variazione del potenziometro, mi aspetterò il suo valore stampato sulla console del monitor seriale.

Conclusioni

Questa era appunto una dimostrazione di funzionamento base, che potrebbe però aprire le porte ad innumerevoli scenari.

A fine pagina trovi il link per scaricare il pacchetto con codici e schemi di collegamento. Come sempre ti ricordo che acquistando prodotti Amazon passando attraverso i link del mio sito, io percepisco una piccola commissione (parliamo di centesimi) in buoni regalo. Questi buoni sommati alle eventuali donazioni PayPal, servono a mantenere attivo il sito web e ad acquistare nuovi componenti.



Ricerche che hanno riportato a questa pagina:

Potrebbero interessarti anche...