Scheda di sviluppo NRF-Nano V3.0, CH340, ATMega328p con NRF24L01, tipo C

Questo tutorial utilizza la scheda NRF-Nano V3.0 come scheda di sviluppo a sé stante, programmata dall'Arduino IDE come Arduino Nano, senza altra scheda Arduino. La scheda combina un microcontrollore ATmega328P con un radio nRF24L01+ a 2.4 GHz, quindi si usa per telecomandi, reti di sensori e qualsiasi progetto in cui due o più schede devono scambiare dati senza fili.

Realizzeremo un test radio con due schede identiche. Su ogni scheda si collegano un pulsante e un LED, e ogni scheda invia lo stato del proprio pulsante e accende il LED dell'altra scheda. L'alimentazione e la programmazione avvengono tramite USB Type-C dal computer.

Come funziona:

La scheda ha due parti che collaborano. Il microcontrollore ATmega328P esegue il programma, mentre il radio nRF24L01+ trasmette e riceve pacchetti nella banda a 2.4 GHz. I due comunicano tramite SPI, con CE su D7, CSN su D8, MOSI su D11, MISO su D12 e SCK su D13. Per questo motivo questi cinque pin non possono essere usati per altro.

Il radio lavora su canali da 1 MHz, numerati da 0 a 125. La frequenza di un canale si calcola così: frequenza = 2400 MHz + numero del canale. Per il canale 76 utilizzato nel programma risulta 2400 + 76 = 2476 MHz. Le due schede devono usare lo stesso canale e la stessa velocità di trasferimento.

Ogni scheda ha un indirizzo di 5 byte. La scheda A invia all'indirizzo della scheda B e ascolta sul proprio indirizzo. La scheda B fa il contrario. Il radio usa la conferma automatica dei pacchetti, quindi la funzione write() restituisce true solo se l'altra scheda ha ricevuto il pacchetto. Un pacchetto può avere al massimo 32 byte, e noi inviamo un solo byte con lo stato del pulsante.

Il pulsante viene letto con INPUT_PULLUP. La resistenza interna collega il pin a 5 V, mentre alla pressione il pulsante collega il pin a GND, quindi la lettura è LOW quando il pulsante è premuto. Il LED ha una resistenza da 220 ohm in serie. La corrente nel LED è circa (5 V - 2 V) / 220 ohm = 14 mA, sotto il limite di 40 mA di un pin.

Collegamento:

Alimentate la scheda tramite USB Type-C da una porta USB del computer, a 5 V. La logica della scheda è a 5 V, mentre il radio è alimentato internamente a 3.3 V dal regolatore presente sulla scheda, quindi non serve un convertitore di livello né un'alimentazione separata per il radio. Montate gli stessi componenti su entrambe le schede.

Pulsanti, regolazioni e indicatori:

Il pulsante RESET non ha una pressione lunga con altre funzioni. Premetelo una volta dopo aver collegato il montaggio e vedrete sul monitor seriale il messaggio di avvio, che conferma che il programma è ripartito.

Il LED di test su D13 non richiede regolazioni. In questo tutorial non lo comandiamo dal programma, e può lampeggiare leggermente perché D13 trasporta il clock SPI del radio. Questo è normale.

Il pulsante su D2 e il LED su D3 sono i componenti montati da voi. All'avvio il pulsante deve essere libero (lettura HIGH) e il LED spento. Premendo il pulsante su una scheda, deve accendersi il LED dell'altra scheda.

Scheda e librerie:

Nell'Arduino IDE scegliete Strumenti > Scheda > Arduino AVR Boards > Arduino Nano. Il pacchetto Arduino AVR Boards è incluso nell'Arduino IDE e non va installato separatamente. In Strumenti > Processore scegliete ATmega328P, e se il caricamento dà errore, scegliete ATmega328P (Old Bootloader). In Strumenti > Porta scegliete la nuova porta seriale apparsa.

Installate dal Gestore librerie la libreria RF24 di TMRh20, versione 1.4.0 o successiva. La libreria SPI è inclusa nell'Arduino IDE e non va installata.

Codice:

Lo stesso programma si carica su entrambe le schede. L'unica differenza è il valore di NODE_ID all'inizio, che è 0 per la prima scheda e 1 per la seconda.

/*
  NRF-Nano V3.0 radio test: two boards, each sends its button state
  and lights the LED of the other board.
  Board in Arduino IDE: Arduino Nano (Tools > Board > Arduino AVR Boards > Arduino Nano)
  Processor: ATmega328P (if upload fails, use ATmega328P (Old Bootloader))
  Board package: Arduino AVR Boards (comes with Arduino IDE)
  Library to install from Library Manager: RF24 by TMRh20 (version 1.4.0 or newer)
  SPI library comes with Arduino IDE.
  Wiring on each board:
    D2  -> push button pin 1 (button pin 2 -> GND), INPUT_PULLUP
    D3  -> resistor 220 ohm -> LED anode (LED cathode -> GND)
  Built-in radio nRF24L01+: CE = D7, CSN = D8, MOSI = D11, MISO = D12, SCK = D13
  Upload this same sketch to both boards.
  Set NODE_ID to 0 for the first board and to 1 for the second board.
*/
#include <SPI.h>
#include <RF24.h>
// Identity of this board: 0 for the first board, 1 for the second board
#define NODE_ID 0
// Pin definitions
const uint8_t PIN_BUTTON = 2;   // Push button to GND, read with internal pull-up
const uint8_t PIN_LED = 3;      // LED through 220 ohm resistor
const uint8_t PIN_CE = 7;       // Radio CE pin on NRF-Nano V3.0
const uint8_t PIN_CSN = 8;      // Radio CSN pin on NRF-Nano V3.0
// Timing settings in milliseconds
const unsigned long SEND_INTERVAL_MS = 100;    // How often the button state is sent
const unsigned long LINK_TIMEOUT_MS = 1000;    // Link is lost after this time without packets
const unsigned long PRINT_INTERVAL_MS = 500;   // How often the status is printed
// Radio object
RF24 radio(PIN_CE, PIN_CSN);
// One address for each board (5 characters plus the end of string)
const byte addresses[][6] = {"NODE0", "NODE1"};
// State variables
uint8_t localState = 0;        // 1 when the local button is pressed
uint8_t remoteState = 0;       // 1 when the button of the other board is pressed
bool lastSendOk = false;       // Result of the last transmission
bool everReceived = false;     // True after the first packet is received
unsigned long lastSend = 0;
unsigned long lastReceive = 0;
unsigned long lastPrint = 0;
// Prints the current status on the serial monitor
void printStatus() {
  bool linkOk = everReceived && (millis() - lastReceive < LINK_TIMEOUT_MS);
  Serial.print(F("Local: "));
  Serial.print(localState ? F("PRESSED") : F("RELEASED"));
  Serial.print(F(" | Sent: "));
  Serial.print(lastSendOk ? F("OK") : F("FAILED"));
  Serial.print(F(" | Remote: "));
  Serial.print(remoteState ? F("PRESSED") : F("RELEASED"));
  Serial.print(F(" | Link: "));
  Serial.println(linkOk ? F("OK") : F("LOST"));
}
void setup() {
  // Start the serial monitor
  Serial.begin(9600);
  // Configure the button with pull-up and the LED as output
  pinMode(PIN_BUTTON, INPUT_PULLUP);
  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_LED, LOW);
  // Start the radio and stop if it does not answer
  if (!radio.begin()) {
    Serial.println(F("Radio not responding. Check CE and CSN pins."));
    while (true) {
      // Wait here forever
    }
  }
  // Radio settings, they must be the same on both boards
  radio.setPALevel(RF24_PA_LOW);   // Low power is enough for a bench test
  radio.setChannel(76);            // 2400 + 76 = 2476 MHz
  // This board writes to the other board and listens on its own address
  const uint8_t ownIndex = NODE_ID;
  const uint8_t peerIndex = 1 - NODE_ID;
  radio.openWritingPipe(addresses[peerIndex]);
  radio.openReadingPipe(1, addresses[ownIndex]);
  // Listen by default
  radio.startListening();
  Serial.print(F("Radio ready on channel 76, node "));
  Serial.println(NODE_ID);
}
void loop() {
  unsigned long now = millis();
  // Read the button and send its state at a fixed interval
  if (now - lastSend >= SEND_INTERVAL_MS) {
    lastSend = now;
    localState = (digitalRead(PIN_BUTTON) == LOW) ? 1 : 0;  // LOW means pressed
    radio.stopListening();                                   // Switch to transmit mode
    lastSendOk = radio.write(&localState, sizeof(localState));
    radio.startListening();                                  // Back to receive mode
  }
  // Read every packet that arrived
  while (radio.available()) {
    radio.read(&remoteState, sizeof(remoteState));
    lastReceive = millis();
    everReceived = true;
  }
  // Turn the LED on only while the link is alive and the remote button is pressed
  bool linkOk = everReceived && (millis() - lastReceive < LINK_TIMEOUT_MS);
  digitalWrite(PIN_LED, (linkOk && remoteState) ? HIGH : LOW);
  // Print the status from time to time
  if (now - lastPrint >= PRINT_INTERVAL_MS) {
    lastPrint = now;
    printStatus();
  }
}

Come funziona il codice:

All'inizio definiamo NODE_ID, i pin PIN_BUTTON (D2), PIN_LED (D3), PIN_CE (D7) e PIN_CSN (D8), e gli intervalli di tempo SEND_INTERVAL_MS, LINK_TIMEOUT_MS e PRINT_INTERVAL_MS. L'oggetto radio viene creato con RF24 radio(PIN_CE, PIN_CSN), e l'array addresses contiene gli indirizzi delle due schede.

In setup() avviamo la porta seriale a 9600 baud, configuriamo il pulsante con INPUT_PULLUP e il LED come uscita, poi avviamo il radio con radio.begin(). Se il radio non risponde, il programma mostra un messaggio e si ferma. Poi impostiamo il canale 76, il livello di potenza RF24_PA_LOW, l'indirizzo di scrittura dell'altra scheda con openWritingPipe() e l'indirizzo proprio di lettura con openReadingPipe(). Alla fine chiamiamo startListening(), quindi la scheda ascolta per impostazione predefinita.

In loop() inviamo lo stato del pulsante ogni SEND_INTERVAL_MS. Prima leggiamo il pulsante nella variabile localState, che vale 1 se il pulsante è premuto. Fermiamo l'ascolto con stopListening(), inviamo il byte con write(), memorizziamo il risultato in lastSendOk e riprendiamo l'ascolto.

Finché radio.available() è vero leggiamo il pacchetto in remoteState e memorizziamo il momento della ricezione in lastReceive. Il LED su D3 segue lo stato remoteState, e se non riceviamo nulla per più di LINK_TIMEOUT_MS, il LED si spegne per sicurezza. Ogni PRINT_INTERVAL_MS la funzione printStatus() mostra lo stato del pulsante locale, il risultato dell'invio, lo stato del pulsante dell'altra scheda e lo stato del collegamento.

Risultato:

Aprite Strumenti > Monitor seriale e impostate la velocità a 9600 baud. Dopo l'avvio, le due schede mostrano il loro stato ogni mezzo secondo. Quando premete il pulsante di una scheda, si accende il LED dell'altra, e la riga sul monitor seriale mostra RELEASED o PRESSED.

Radio ready on channel 76, node 0
Local: RELEASED | Sent: FAILED | Remote: RELEASED | Link: LOST
Local: RELEASED | Sent: OK | Remote: RELEASED | Link: OK
Local: RELEASED | Sent: OK | Remote: RELEASED | Link: OK
Local: PRESSED | Sent: OK | Remote: RELEASED | Link: OK
Local: PRESSED | Sent: OK | Remote: RELEASED | Link: OK
Local: RELEASED | Sent: OK | Remote: PRESSED | Link: OK
Local: RELEASED | Sent: OK | Remote: PRESSED | Link: OK
Local: RELEASED | Sent: OK | Remote: RELEASED | Link: OK

Problemi frequenti:

La scheda non appare come porta seriale. La causa è di solito un cavo che serve solo a caricare, oppure il driver CH340. Usate un cavo USB-A a USB Type-C con trasferimento dati, e se la porta continua a non apparire, installate il driver dalla sezione Download, perché l'ultima versione del 2023 potrebbe essere incompatibile con la scheda.

Il caricamento si interrompe con l'errore avrdude not in sync. La scheda ha un bootloader più vecchio. Scegliete in Strumenti > Processore la variante ATmega328P (Old Bootloader) e caricate di nuovo.

Sul monitor seriale appare il messaggio che il radio non risponde. Verificate di usare RF24 radio(7, 8), che è corretto per la V3.0. Le schede più vecchie RF-Nano V1 e V2 usano CE su D10 e CSN su D9, quindi per loro provate RF24 radio(10, 9). Verificate anche di non aver collegato nulla su D7, D8, D11, D12 o D13.

Lo stato del collegamento è sempre LOST. Verificate che su le due schede NODE_ID sia diverso (0 e 1), che entrambe usino il canale 76 e che entrambe siano alimentate. Avvicinate le schede a qualche metro e allontanatele da oggetti metallici.

Il LED è sempre spento o sempre acceso. Verificate la polarità del LED (anodo verso la resistenza) e che il pulsante sia montato in diagonale, con un pin su D2 e l'altro su GND. Con INPUT_PULLUP il pulsante deve leggere LOW solo quando è premuto.

Il radio si ferma o si riavvia in modo casuale. Il radio è sensibile a un'alimentazione instabile. Usate una porta USB diretta del computer oppure un alimentatore buono, non un hub con alimentazione debole.

Limitazioni e consigli:

I pin D7, D8, D11, D12 e D13 sono occupati dal radio, quindi per i sensori restano liberi D2 - D6, A0 - A7 (A6 e A7 sono solo ingressi analogici) e i pin seriali D0 e D1. Ogni pin I/O sopporta al massimo 40 mA, quindi relè e motori si comandano tramite transistor o moduli dedicati.

Un pacchetto radio ha al massimo 32 byte, e la portata dipende dall'ambiente, dagli ostacoli e dalla potenza impostata. La potenza RF24_PA_LOW è sufficiente per i test sul banco, mentre per distanze maggiori potete aumentare il livello con setPALevel(), purché l'alimentazione sia stabile.

Partendo da questo montaggio potete realizzare un telecomando con più pulsanti, un sensore di temperatura che invia valori a una scheda centrale, oppure una rete a stella in cui una scheda riceve su più indirizzi da più trasmettitori.