Placa dezvoltare NRF-Nano V3.0, CH340, ATMega328p cu NRF24L01, Type C

Acest tutorial foloseste placa NRF-Nano V3.0 ca placa de dezvoltare in sine, programata din Arduino IDE ca Arduino Nano, fara alta placa Arduino. Placa combina un ATmega328P cu un radio nRF24L01+ de 2.4 GHz, deci se foloseste la telecomenzi, retele de senzori si orice proiect in care doua sau mai multe placi trebuie sa schimbe date fara fir.

Vom construi un test radio cu doua placi identice. Pe fiecare placa se conecteaza un buton si un LED, iar fiecare placa trimite starea butonului ei si aprinde LED-ul celeilalte placi. Alimentarea si programarea se fac prin USB Type-C de la calculator.

Cum functioneaza:

Placa are doua parti care colaboreaza. Microcontrolerul ATmega328P ruleaza programul, iar radioul nRF24L01+ transmite si receptioneaza pachete in banda de 2.4 GHz. Cele doua comunica prin SPI, cu CE pe D7, CSN pe D8, MOSI pe D11, MISO pe D12 si SCK pe D13. Din acest motiv acesti cinci pini nu pot fi folositi pentru altceva.

Radioul lucreaza pe canale de 1 MHz, numerotate de la 0 la 125. Frecventa unui canal se calculeaza astfel: frecventa = 2400 MHz + numarul canalului. Pentru canalul 76 folosit in program rezulta 2400 + 76 = 2476 MHz. Cele doua placi trebuie sa foloseasca acelasi canal si aceeasi viteza de transfer.

Fiecare placa are o adresa de 5 octeti. Placa A trimite catre adresa placii B si asculta pe adresa ei. Placa B face invers. Radioul foloseste confirmare automata a pachetelor, deci functia write() intoarce true doar daca cealalta placa a primit pachetul. Un pachet poate avea cel mult 32 de octeti, iar noi trimitem un singur octet cu starea butonului.

Butonul este citit cu INPUT_PULLUP. Rezistenta interna leaga pinul la 5 V, iar la apasare butonul il leaga la GND, deci citirea este LOW cand butonul este apasat. LED-ul are o rezistenta de 220 ohmi in serie. Curentul prin LED este aproximativ (5 V - 2 V) / 220 ohmi = 14 mA, sub limita de 40 mA a unui pin.

Conectare:

Alimentati placa prin USB Type-C de la un port USB al calculatorului, la 5 V. Logica placii este de 5 V, iar radioul este alimentat intern la 3.3 V de regulatorul de pe placa, deci nu este nevoie de convertor de nivel si nici de alimentare separata pentru radio. Montati aceleasi componente pe ambele placi.

Butoane, reglaje si indicatoare:

Butonul RESET nu are apasare lunga cu alta functie. Apasati-l o data dupa ce ati conectat montajul si veti vedea pe monitorul serial mesajul de pornire, ceea ce confirma ca programul a repornit.

LED-ul de test de pe D13 nu necesita reglaj. In acest tutorial nu il comandam din program, iar el poate palpai usor pentru ca D13 transporta ceasul SPI al radioului. Acest lucru este normal.

Butonul de pe D2 si LED-ul de pe D3 sunt componentele montate de dumneavoastra. Pornirea se face cu butonul liber (citire HIGH) si LED-ul stins. La apasarea butonului pe o placa trebuie sa se aprinda LED-ul de pe cealalta placa.

Placa si biblioteci:

In Arduino IDE alegeti Tools > Board > Arduino AVR Boards > Arduino Nano. Pachetul Arduino AVR Boards vine odata cu Arduino IDE si nu trebuie instalat separat. La Tools > Processor alegeti ATmega328P, iar daca incarcarea da eroare, alegeti ATmega328P (Old Bootloader). La Tools > Port alegeti portul serial nou aparut.

Instalati din Library Manager biblioteca RF24 de TMRh20, versiunea 1.4.0 sau mai noua. Biblioteca SPI vine cu Arduino IDE si nu trebuie instalata.

Codul:

Acelasi program se incarca pe ambele placi. Singura diferenta este valoarea NODE_ID de la inceput, care este 0 pentru prima placa si 1 pentru a doua.

/*
  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();
  }
}

Cum functioneaza codul:

La inceput definim NODE_ID, pinii PIN_BUTTON (D2), PIN_LED (D3), PIN_CE (D7) si PIN_CSN (D8), precum si intervalele de timp SEND_INTERVAL_MS, LINK_TIMEOUT_MS si PRINT_INTERVAL_MS. Obiectul radio este creat cu RF24 radio(PIN_CE, PIN_CSN), iar tabloul addresses contine adresele celor doua placi.

In setup() pornim portul serial la 9600 baud, configuram butonul cu INPUT_PULLUP si LED-ul ca iesire, apoi pornim radioul cu radio.begin(). Daca radioul nu raspunde, programul afiseaza un mesaj si se opreste. Apoi setam canalul 76, nivelul de putere RF24_PA_LOW, adresa de scriere a celeilalte placi cu openWritingPipe() si adresa proprie de citire cu openReadingPipe(). La final apelam startListening(), deci placa asculta implicit.

In loop() trimitem la fiecare SEND_INTERVAL_MS starea butonului. Mai intai citim butonul in variabila localState, care este 1 daca butonul este apasat. Oprim ascultarea cu stopListening(), trimitem octetul cu write(), memoram rezultatul in lastSendOk si reluam ascultarea.

Cat timp radio.available() este adevarat citim pachetul in remoteState si retinem momentul primirii in lastReceive. LED-ul de pe D3 urmeaza starea remoteState, iar daca nu primim nimic mai mult de LINK_TIMEOUT_MS, LED-ul se stinge ca masura de siguranta. La fiecare PRINT_INTERVAL_MS functia printStatus() afiseaza starea butonului local, rezultatul trimiterii, starea butonului celeilalte placi si starea legaturii.

Rezultat:

Deschideti Tools > Serial Monitor si setati viteza la 9600 baud. Dupa pornire, cele doua placi afiseaza la fiecare jumatate de secunda starea lor. Cand apasati butonul de pe o placa, LED-ul celeilalte se aprinde, iar linia de pe monitorul serial arata RELEASED sau 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

Probleme frecvente:

Placa nu apare ca port serial. Cauza este de obicei un cablu care doar incarca sau driverul CH340. Folositi un cablu USB-A la USB Type-C cu transfer de date, iar daca portul tot nu apare, instalati driverul din sectiunea Download, deoarece ultima versiune din 2023 poate fi incompatibila cu placa.

Incarcarea se opreste cu eroarea avrdude not in sync. Placa are un bootloader mai vechi. Alegeti la Tools > Processor varianta ATmega328P (Old Bootloader) si incarcati din nou.

Pe monitorul serial apare mesajul ca radioul nu raspunde. Verificati ca folositi RF24 radio(7, 8), care este corect pentru V3.0. Placile mai vechi RF-Nano V1 si V2 folosesc CE pe D10 si CSN pe D9, deci pentru ele incercati RF24 radio(10, 9). Verificati si ca nu ati conectat nimic pe D7, D8, D11, D12 sau D13.

Starea legaturii este mereu LOST. Verificati ca pe cele doua placi NODE_ID este diferit (0 si 1), ca ambele folosesc canalul 76 si ca ambele sunt alimentate. Apropiati placile la cativa metri si indepartati-le de obiecte metalice.

LED-ul este mereu stins sau mereu aprins. Verificati polaritatea LED-ului (anodul spre rezistenta) si ca butonul este montat pe diagonala, cu un pin la D2 si celalalt la GND. Cu INPUT_PULLUP butonul trebuie sa citeasca LOW doar cand este apasat.

Radioul se opreste sau se reseteaza aleatoriu. Radioul este sensibil la alimentare instabila. Folositi un port USB direct al calculatorului sau o sursa buna, nu un hub slab alimentat.

Limitari si sfaturi:

Pinii D7, D8, D11, D12 si D13 sunt ocupati de radio, deci pentru senzori raman liberi D2 - D6, A0 - A7 (A6 si A7 sunt doar intrari analogice) si pinii serial D0 si D1. Fiecare pin I/O suporta cel mult 40 mA, deci releele si motoarele se comanda prin tranzistoare sau module dedicate.

Un pachet radio are cel mult 32 de octeti, iar raza de actiune depinde de mediu, de obstacole si de puterea setata. Puterea RF24_PA_LOW este suficienta pentru teste pe masa, iar pentru distante mai mari puteti creste nivelul cu setPALevel(), cu conditia unei alimentari stabile.

Pornind de la acest montaj puteti construi o telecomanda cu mai multe butoane, un senzor de temperatura care trimite valori catre o placa centrala sau o retea in stea, in care o placa receptioneaza pe mai multe adrese de la mai multi emitatori.