NRF-Nano V3.0 development board, CH340, ATMega328p with NRF24L01, Type C

This tutorial uses the NRF-Nano V3.0 board as the development board itself, programmed from Arduino IDE as an Arduino Nano, without any other Arduino board. The board combines an ATmega328P with a 2.4 GHz nRF24L01+ radio, so it is used for remote controls, sensor networks and any project where two or more boards must exchange data wirelessly.

We will build a radio test with two identical boards. Each board has a button and an LED connected, and each board sends the state of its button and lights the LED of the other board. Power and programming are done through USB Type-C from the computer.

How it works:

The board has two parts that work together. The ATmega328P microcontroller runs the program, and the nRF24L01+ radio transmits and receives packets in the 2.4 GHz band. The two communicate over SPI, with CE on D7, CSN on D8, MOSI on D11, MISO on D12 and SCK on D13. For this reason, these five pins cannot be used for anything else.

The radio works on channels spaced 1 MHz apart, numbered from 0 to 125. The frequency of a channel is calculated as follows: frequency = 2400 MHz + channel number. For channel 76 used in the program, the result is 2400 + 76 = 2476 MHz. Both boards must use the same channel and the same data rate.

Each board has a 5-byte address. Board A sends to the address of board B and listens on its own address. Board B does the opposite. The radio uses automatic packet acknowledgement, so the write() function returns true only if the other board received the packet. A packet can have at most 32 bytes, and we send a single byte with the button state.

The button is read with INPUT_PULLUP. The internal resistor connects the pin to 5 V, and when pressed, the button connects it to GND, so the reading is LOW when the button is pressed. The LED has a 220 ohm resistor in series. The current through the LED is approximately (5 V - 2 V) / 220 ohms = 14 mA, well below the 40 mA limit of a pin.

Connection:

Power the board through USB Type-C from a USB port of the computer, at 5 V. The board logic is 5 V, and the radio is powered internally at 3.3 V by the regulator on the board, so no level converter and no separate power supply for the radio are needed. Mount the same components on both boards.

Buttons, adjustments and indicators:

The RESET button has no long press function. Press it once after you have connected the assembly, and you will see the startup message on the serial monitor, which confirms that the program has restarted.

The test LED on D13 requires no adjustment. In this tutorial we do not control it from the program, and it may blink slightly because D13 carries the SPI clock of the radio. This is normal.

The button on D2 and the LED on D3 are the components you mounted. Startup is done with the button released (HIGH reading) and the LED off. When the button is pressed on one board, the LED on the other board must light up.

Board and libraries:

In Arduino IDE, select Tools > Board > Arduino AVR Boards > Arduino Nano. The Arduino AVR Boards package comes with Arduino IDE and does not need to be installed separately. Under Tools > Processor, select ATmega328P, and if the upload gives an error, select ATmega328P (Old Bootloader). Under Tools > Port, select the newly appeared serial port.

From the Library Manager, install the RF24 library by TMRh20, version 1.4.0 or newer. The SPI library comes with Arduino IDE and does not need to be installed.

The code:

The same program is uploaded to both boards. The only difference is the value of NODE_ID at the beginning, which is 0 for the first board and 1 for the second.

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

How the code works:

At the beginning we define NODE_ID, the pins PIN_BUTTON (D2), PIN_LED (D3), PIN_CE (D7) and PIN_CSN (D8), as well as the time intervals SEND_INTERVAL_MS, LINK_TIMEOUT_MS and PRINT_INTERVAL_MS. The radio object is created with RF24 radio(PIN_CE, PIN_CSN), and the addresses array contains the addresses of the two boards.

In setup() we start the serial port at 9600 baud, configure the button with INPUT_PULLUP and the LED as an output, then start the radio with radio.begin(). If the radio does not respond, the program displays a message and stops. Then we set channel 76, the power level RF24_PA_LOW, the writing address of the other board with openWritingPipe() and our own reading address with openReadingPipe(). Finally we call startListening(), so the board listens by default.

In loop() we send the button state every SEND_INTERVAL_MS. First we read the button into the localState variable, which is 1 if the button is pressed. We stop listening with stopListening(), send the byte with write(), store the result in lastSendOk and resume listening.

As long as radio.available() is true, we read the packet into remoteState and store the moment of reception in lastReceive. The LED on D3 follows the remoteState, and if nothing is received for more than LINK_TIMEOUT_MS, the LED turns off as a safety measure. Every PRINT_INTERVAL_MS, the printStatus() function displays the state of the local button, the result of the transmission, the state of the button on the other board and the state of the link.

Result:

Open Tools > Serial Monitor and set the speed to 9600 baud. After startup, the two boards display their status every half second. When you press the button on one board, the LED on the other lights up, and the line on the serial monitor shows RELEASED or 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

Common problems:

The board does not appear as a serial port. The cause is usually a cable that only charges, or the CH340 driver. Use a USB-A to USB Type-C cable with data transfer, and if the port still does not appear, install the driver from the Download section, because the latest version from 2023 may be incompatible with the board.

The upload stops with the error avrdude not in sync. The board has an older bootloader. Under Tools > Processor, select the ATmega328P (Old Bootloader) option and upload again.

The serial monitor shows a message that the radio does not respond. Check that you are using RF24 radio(7, 8), which is correct for V3.0. The older RF-Nano V1 and V2 boards use CE on D10 and CSN on D9, so for them try RF24 radio(10, 9). Also check that you have not connected anything to D7, D8, D11, D12 or D13.

The link state is always LOST. Check that NODE_ID is different on the two boards (0 and 1), that both use channel 76 and that both are powered. Bring the boards a few meters closer and move them away from metal objects.

The LED is always off or always on. Check the polarity of the LED (anode toward the resistor) and that the button is mounted across the diagonal, with one pin to D2 and the other to GND. With INPUT_PULLUP, the button must read LOW only when it is pressed.

The radio stops or resets randomly. The radio is sensitive to unstable power. Use a direct USB port of the computer or a good power source, not a weakly powered hub.

Limitations and tips:

Pins D7, D8, D11, D12 and D13 are occupied by the radio, so for sensors the free pins are D2 - D6, A0 - A7 (A6 and A7 are analog inputs only) and the serial pins D0 and D1. Each I/O pin supports at most 40 mA, so relays and motors should be driven through transistors or dedicated modules.

A radio packet has at most 32 bytes, and the range depends on the environment, on obstacles and on the power level set. The RF24_PA_LOW power is sufficient for bench tests, and for longer distances you can increase the level with setPALevel(), provided the power supply is stable.

Starting from this setup, you can build a remote control with several buttons, a temperature sensor that sends values to a central board, or a star network in which one board receives on multiple addresses from several transmitters.