nRF24L01 PA LNA Proteus Library | Arduino Range Simulation

Hello friends, I hope you are doing well. In today's tutorial, I am going to share our nRF24L01 PA LNA Proteus Library. This is the long-range version of the nRF24L01 module, with a power amplifier, a low noise amplifier and an external antenna. With this library, we can place two of these modules in one Proteus design, connect each of them to an Arduino Uno and send messages from one board to the other. A row of distance buttons moves the two radios from 1 m to 2 km apart.

First, we will see what the two amplifiers do and how this module differs from the plain nRF24L01. Then we will install the library files, wire the circuit and run the supplied simulation. The main part of this tutorial is the control panel of the module. We will test how the distance, the data rate and the power level decide whether a message is acknowledged. We will also see why two of these modules fail when they are too close to each other. Finally, we will understand both Arduino sketches and repeat the calculations of the model by hand.

This tutorial uses our V1.0 package, the TEP Arduino UNO V3 and a 16 MHz clock. The package notes record a test of the supplied project in Proteus 8.5 SP0. In the running screenshot below, the transmitter is on the left and the receiver is on the right. The panel of the transmitter is set to 100 m. Nine messages have been sent, and every one of them was acknowledged without a retry. The panel of the receiver shows the level of the last packet, which is -72 dBm.

What Is the nRF24L01 PA LNA Module?

The nRF24L01 PA LNA module is a 2.4 GHz radio transceiver for longer distances. It is built around the same nRF24L01+ chip from Nordic Semiconductor as the small module with the printed antenna. We have explained this chip in our Introduction to NRF24L01, and Nordic describes it in the nRF24L01+ Product Specification. The long-range module adds three parts to the chip:

• PA: a power amplifier. It makes the transmitted signal stronger before it reaches the antenna.
• LNA: a low noise amplifier. It makes the received signal stronger before it reaches the chip.
• SMA connector: a connector for an external antenna, which replaces the printed antenna of the small module.

Both amplifiers are usually inside one small front-end chip. Our board artwork shows the RFX2401C, which is a common choice for these modules. Its data sheet lists a saturated output power of +22 dBm, a receive gain of 12 dB and a noise figure of 2.5 dB.

Main Features of the nRF24L01+ Chip

• It works in the 2.4 GHz band with 126 channels. The frequency of a channel is 2400 MHz plus the channel number.
• It supports the data rates 250 kbps, 1 Mbps and 2 Mbps.
• Its sensitivity is -94 dBm at 250 kbps, -85 dBm at 1 Mbps and -82 dBm at 2 Mbps.
• Its output power has four levels, which are 0, -6, -12 and -18 dBm.
• Its Enhanced ShockBurst protocol acknowledges every packet and repeats a packet that was not acknowledged.
• Its supply range is 1.9 to 3.6 V, and its inputs are 5 V tolerant.

Plain Module and PA LNA Module

The following table compares the two modules as our model simulates them.

The table also shows the price of the amplifiers. The PA LNA module cannot handle a very strong signal, so two of them must not be too close at full power. We will test this case in detail.

Important Terms

• dBm: a unit of signal power. A value of 0 dBm is 1 mW, and +20 dBm is 100 mW. Negative values are weaker signals.
• Sensitivity: the weakest signal that the receiver can still decode.
• Overload: the state of a receiver whose input signal is too strong. The amplifier saturates, and the packet is lost.
• ACK: a short answer of the receiver. It tells the transmitter that the packet has arrived.
• Retry: a repeated transmission of a packet that was not acknowledged.
• RPD: the received power detector of the chip. It is a single bit that tells us whether the signal at the chip was stronger than -64 dBm.
• Link budget: the calculation of the signal at the receiver from the output power, the antennas and the losses on the way.

Features of Our Proteus Model

• The component is named NRF24PALNATEP and has eight pins in the same order as our plain nRF24L01 component.
• Every nRF24L01 module placed in the same design shares one virtual 2.4 GHz band, so no wire is needed between the two sides.
• A control panel beside each module shows its live mode, its settings, its addresses, its counters and the last packet.
• Eight distance buttons, from 1 m to 2 km, set the distance to the other radios.
• The model calculates the signal at the receiver and compares it with the sensitivity and with the overload limit.
• The ACK is checked on its way back, with the power level of the receiver.
• The Arduino communicates with the model through real SPI commands and registers, so the unmodified RF24 library works with it.

Keep one distinction in mind. This is a functional model of the chip with a simple range calculation. It does not simulate antennas in detail, walls, reflections or the Wi-Fi networks that share the 2.4 GHz band. The distance buttons teach us how the settings and the distance are related, but they do not predict the range of a real installation.

Download the nRF24L01 PA LNA Library for Proteus

First of all, download the V1.0 package using the button below. Extract the complete ZIP into a normal folder before opening the project, and keep the files of the simulation folder together.

Download nRF24L01 PA LNA Proteus Library V1.0 and Arduino Simulation

One Model File for Both nRF24L01 Modules

The model file of this package has the same name as the file of our plain nRF24L01 library. The device name tells the model which module it has to be. All nRF24L01 modules of a design must use the same file, because only then do they share one radio band.

• This package contains version 1.1 of the file. Version 1.0 does not know the PA LNA module.
• Version 1.1 also runs the plain module. Its example works as before at the default distance of 10 m.
• With version 1.1, the panel of the plain module shows the distance buttons of this tutorial. They replace the switch between IN RANGE and OUT OF RANGE of version 1.0.

The Proteus library and the Arduino library have different jobs. The LIB file defines the component that we place on the schematic, and the DLL gives it its behavior. The RF24 library gives our sketch the functions for talking to the radio. Installing the Arduino library alone will not make NRF24PALNATEP appear in Proteus.

How to Install the nRF24L01 PA LNA Library in Proteus

Copy the Library and Model Files

Save your work and close Proteus before copying the files. Then follow these steps:

1. Open the extracted Proteus Library Files folder.
2. Copy TEPNRF24PALNA.LIB into the library directory configured for your Proteus installation.
3. Copy ArduinoV3TEP.LIB and ArduinoV3TEP.IDX from the same folder if our TEP Arduino UNO V3 library is not installed already.
4. Open Proteus Model Files and copy TEPNRF24L01.DLL into your configured Proteus MODELS directory. Replace an older file of the same name.
5. Restart Proteus, open Pick Devices and search for NRF24PALNATEP. A search for nRF24 finds the module as well.
6. Place the module on the schematic, or open the supplied project to use the completed circuit.

Points to Remember

• Use the library and model folders that your installation actually searches. Their locations differ between installations.
• The module is supplied as a LIB file without a separate IDX. The included IDX belongs to the Arduino board.
• Keep the extra DLL beside the project in the Proteus Simulation folder.
• If the panel still shows IN RANGE and OUT OF RANGE, the older DLL is installed. Copy the file of this package into MODELS.
• The two HEX files are programs for the two Arduino boards. The radio module does not need a HEX file.
• Proteus 7 has not been tried.

The Arduino board in this project comes from our Arduino Library for Proteus V3.0. Start with the supplied project, so that the boards, wiring and firmware match the demonstration.

nRF24L01 PA LNA Pinout and Arduino Uno Wiring

The TEP module has eight pins along its lower edge. From left to right, they are VCC, GND, SCK, MISO, MOSI, CSN, CE and IRQ. This is the order of our plain nRF24L01 component, so its wiring carries over. Start each wire at the exposed pin endpoint below the board artwork.

Both boards use the same wiring. The Arduino named ARD1 works with module U1 as the transmitter, and ARD2 works with U2 as the receiver. Before the simulation starts, both panels show STANDBY-I, the default distance of 10 m and counters at zero.

• CE and CSN are given to the driver in this order. In both sketches, the line is RF24 radio(9, 10).
• There is no wire between U1 and U2. The two modules are connected only through the simulated radio band.

Virtual Terminal Connections

• Connect Arduino D1/TX to RXD on the Virtual Terminal of each board.
• Set both terminals to 9600 baud, eight data bits, no parity and one stop bit.
• The return connection to D0/RX is shown in the circuit, but these sketches do not read typed commands.

Notes for Physical Hardware

• The real module is a 3.3 V part. The supply range of the chip is 1.9 to 3.6 V, and a supply of 5 V can damage it.
• The power amplifier needs much more current than the plain module. The package notes give about 115 mA while the module sends.
• Add a capacitor of 10 to 100 microfarads directly across VCC and GND of the module. A weak or noisy supply is the usual reason for a PA LNA module that does not work.
• The model does not check the supply voltage or the current, so a working simulation does not prove that your hardware supply is correct.
• Connect the antenna before you transmit.
• Use RF24_PA_LOW while the two modules lie on the same desk. We will see the reason in the overload test.
• The license-free 2.4 GHz band ends at 2483.5 MHz in most countries. Channel 108 of the example is 2508 MHz. Check the local rules and choose a permitted channel before you use real hardware.

Run the Two-Arduino Simulation

Start the Simulation

1. Open Proteus Simulation/NRF24PALNA-ArduinoUnoV3.pdsprj from the extracted package.
2. Keep both HEX files and TEPNRF24L01.DLL in that folder.
3. Double-click ARD1 and confirm that its Program File is PALNA_Transmitter.hex.
4. Double-click ARD2 and confirm that its Program File is PALNA_Receiver.hex.
5. Confirm the 16 MHz clock on both boards and 9600 baud on both terminals.
6. Press Run. If the two terminal windows open on top of each other, drag them apart.

Read the Terminal Output

• The transmitter prints its heading and then Radio ready: channel 108, 250 kbps, PA MAX, address 00001.
• Once per second, the transmitter prints a line such as Sent: Hello TEP #1 -> ACK received, retries: 0.
• The receiver prints Listening: channel 108, 250 kbps, address 00001.
• For every message, the receiver prints a line such as Received #1: Hello TEP #1 (signal > -64 dBm).
• For a weaker signal, the end of this line changes to (weak signal).
• When no ACK arrives, the transmitter prints FAILED, no ACK.

In the running screenshot at the top, the transmitter has printed the messages 1 to 9, all with an ACK and 0 retries. The receiver has printed the same nine messages. The two panels agree with the terminals. The panel of the transmitter shows SENT 9 and FAILED 0, and the panel of the receiver shows RECEIVED 9.

Read the Simulation Log

The model also writes short messages into the Simulation Log of Proteus. Each message starts with TEP nRF24L01+PA+LNA and the name of the module, such as U1.

Understand the nRF24L01 PA LNA Control Panel

The control panel is the most interesting part of this library. It shows what the radio is doing at every moment, and its distance buttons let us test the link without changing the code. The following picture shows the receiver's module U2 and its panel after 40 messages.

The title of the panel is nRF24L01+PA+LNA CONTROLS. Let us go through the panel from top to bottom.

The Mode Banner and Its Colors

• The receiver's banner is green and shows RX - LISTENING for the whole simulation.
• The transmitter's banner is blue and shows STANDBY-I. A successful message needs less than 2 ms, so the orange banner is hardly visible.
• When the ACK is missing, the transmitter repeats the packet 15 times. This takes about 45 ms, and the orange banner flashes once per second.

The Settings Line

The first line below the banner shows the radio settings. In our example, it reads CH 108 = 2508 MHz, 250 KBPS, CRC 16 and +20 dBm. The values are read from the registers of the chip, so they show what the sketch has really written.

The output power is the level of the chip plus the 20 dB of the power amplifier. The four levels of the driver give these values:

The Address Line

The second line shows the address for sending and the address for receiving. An address of readable characters is shown as text, and any other address is shown in hexadecimal form.

• The transmitter shows TX: 00001 and RX: 00001. The driver writes the address into both registers, because the ACK comes back on the same address.
• The receiver shows TX: E7 E7 E7 E7 E7 and RX: 00001. The receiver never opens a pipe for sending, so its TX address keeps the reset value of the chip.

The Counters

• SENT counts the packets that were sent with success. For a packet with ACK, this means that the ACK has arrived.
• FAILED counts the packets that were given up after the last retry.
• RECEIVED counts the packets that this radio has received. A repeated packet is counted only once.
• TOO WEAK counts the transmissions that matched the settings of this radio but were below its sensitivity.
• OVERLOAD counts the transmissions that were too strong for this radio.
• LAST shows the level of the last transmission that this radio has heard, in dBm. It appears after the first one.

The last three values belong to the radio that listens. In the picture above, the receiver shows RECEIVED 40, TOO WEAK 0, OVERLOAD 0 and LAST -72 dBm.

The Last Packet Line

Before the first packet arrives, this line shows a dash. After that, it shows the payload in quotation marks, followed by its length. In the picture above, the receiver shows "Hello TEP #40" with 32 bytes. The text is shorter than 32 characters, but the sketch always sends the complete buffer of 32 bytes. A payload that is not readable text is shown as hexadecimal bytes.

The Distance Buttons and the Prediction Line

Below the heading DISTANCE TO THE OTHER RADIOS, there are eight buttons: 1 m, 10 m, 50 m, 100 m, 250 m, 500 m, 1 km and 2 km. The selected button is dark blue, and the default is 10 m. Click a button while the simulation runs.

The line below the buttons is a prediction. In the picture above, it reads AT 10 m: -44 dBm, 250 KBPS NEEDS -102 dBm -> OK. It has three parts:

1. AT 10 m: -44 dBm is the signal that a packet from this radio has at the selected distance, at an identical module.
2. 250 KBPS NEEDS -102 dBm is the sensitivity at the present data rate.
3. The result is OK, TOO WEAK or OVERLOAD.

The prediction uses the settings and the distance button of its own panel only. The hint below it says that 250 kbps reaches further, and the last line names the module.

Panel Combinations: Distance, Data Rate and Power Level

Now comes the exciting part. The result of a transmission depends on several settings together, and the panel lets us try them one after the other. The level of -72 dBm agrees with the screenshots of this tutorial. The package notes record the tests at 10 m, 1 km and 2 km and the overload test at 1 m in Proteus. The other values are calculated with the formulas of the model, which we will work through after the code.

Combination 1: The Distances on the Two Panels

Each radio has its own distance buttons. For a packet between two radios, the model uses the larger of the two selected distances.

The second row is the state of our screenshots. The transmitter's panel is set to 100 m, the receiver's panel is set to 10 m, and the receiver shows LAST -72 dBm. This rule has three consequences:

• To move the radios apart, one click on either panel is enough.
• To bring them together again, both panels must show a short distance.
• The prediction line of one panel can show OK while the packets fail, because the other panel has a larger distance. The LAST value of the receiver always shows the real level.

Combination 2: Walk Through the Distance Buttons

Keep the settings of the example, which are PA MAX and 250 kbps. Set both panels to the same distance and watch the two terminals.

• The link works from 10 m to 1 km. At 1 km, the signal is only 1.6 dB above the sensitivity of -102 dBm.
• The link fails at both ends of the row. At 2 km the signal is too weak, and at 1 m it is too strong.
• The text of the receiver changes between 100 m and 250 m. We will see the reason in the combination about the RPD.

Combination 3: Too Close at Full Power

This test shows a problem that many beginners meet with real PA LNA modules. The two modules lie on the same desk, the sketches use the highest power level, and nothing is received.

1. Let the simulation run at 10 m with an ACK for every message.
2. Click 1 m on the panel of the transmitter. Nothing changes, because the receiver's panel still shows 10 m.
3. Click 1 m on the panel of the receiver as well.
4. The prediction line now reads AT 1 m: -16 dBm and OVERLOAD.
5. The transmitter prints FAILED, no ACK for every message, and its FAILED counter increases.
6. The OVERLOAD counter of the receiver increases, and its LAST value shows -16 dBm.
7. Click 10 m on either panel. The link recovers with the next message.

The limit of the model is -20 dBm at the antenna. The following table shows the four power levels at a distance of 1 m.

So the cure is a lower power level. Use RF24_PA_LOW for tests on the desk, and change to RF24_PA_MAX when the modules are installed at their final distance.

Combination 4: Distance and Data Rate

The hint on the panel says that 250 kbps reaches further. A lower data rate gives the receiver more time for every bit, so it can work with a weaker signal.

• To change the data rate, change the parameter of radio.setDataRate() in both sketches. The values are RF24_250KBPS, RF24_1MBPS and RF24_2MBPS.
• The data rate must be the same on both sides. A packet with a different data rate is not received and not counted.
• After the change, the settings line shows the new rate, and the prediction line shows the new sensitivity.
• The low noise amplifier improves every sensitivity by 8 dB in the model.

Combination 5: Distance and Power Level

Every step of the power level changes the signal by 6 dB. Only the highest level reaches 1 km, and only the highest level fails at 1 m. The buttons of the panel have fixed distances, so two neighboring levels can end at the same button.

Combination 6: The Way Back of the ACK

A message counts as sent only when its ACK has arrived. The ACK travels from the receiver to the transmitter, and it is sent with the power level of the receiver. For this reason, the receiver sketch also calls radio.setPALevel(RF24_PA_MAX).

The second and the third row show a link that works in one direction only. The transmitter reports a failure, although the message has arrived. Two details of the model are important here:

• The transmitter repeats the packet 15 times. The receiver recognizes the repeated packets by their packet number and stores the message only once, as the real chip does.
• The panel of the receiver shows RECEIVED, and the panel of the transmitter shows FAILED. No TOO WEAK counter increases, because the data packets themselves were strong enough.

Combination 7: The Counters During a Failure

When a packet is not acknowledged, the chip repeats it. The RF24 library sets 15 retries with a delay of 1500 microseconds. One message therefore causes 16 transmissions.

With the driver function radio.setRetries(), you can change the delay and the number of the retries. After radio.setRetries(5, 3), a failed message causes 4 transmissions, and the TOO WEAK counter increases by 4.

Combination 8: The Received Power Detector

The nRF24L01+ does not measure the signal strength as a number. It only has the RPD bit, which tells us whether the signal at the chip was stronger than -64 dBm. The receiver sketch reads this bit with radio.testRPD() and prints one of two texts.

• In the PA LNA module, the low noise amplifier raises the signal by 12 dB before it reaches the chip.
• A level of -64 dBm at the chip is therefore a level of -76 dBm at the antenna.
• At 100 m, the antenna receives -72 dBm, and the chip sees -60 dBm. The RPD bit is set, and the receiver prints signal > -64 dBm.
• At 250 m, the antenna receives -84 dBm, and the chip sees -72 dBm. The RPD bit is not set, and the receiver prints weak signal.

This explains our screenshots. The panel shows LAST -72 dBm, which is the level at the antenna, and the terminal shows signal > -64 dBm, which refers to the level at the chip. The LAST value of the panel is a help of the simulation. A real module gives you only the RPD bit.

Combination 9: A PA LNA Module and a Plain Module

Both components can be placed in one design. The link between them is not the same in both directions, because only one side has the amplifiers.

• The plain module needs -94 dBm at 250 kbps, and the PA LNA module needs -102 dBm.
• The data packet is sent with +20 dBm, and the ACK of the plain module is sent with 0 dBm. The ACK is therefore 20 dB weaker.
• For a long link in both directions, use a PA LNA module at both ends.
• For a link in one direction, the sketch can send without an ACK. The driver offers radio.enableDynamicAck() and the third parameter of radio.write() for this.

Combination 10: Settings That Must Agree

Put the two panels side by side when nothing is received. The settings line and the RX address of the receiver must fit the settings line and the TX address of the transmitter.

Arduino Code for the nRF24L01 PA LNA Transmitter

The following is the exact transmitter sketch included in the download. It uses the bundled RF24 library, version 1.6.2. Use the supplied copy for your first build, so that your firmware matches the packaged HEX file.

// TEP nRF24L01+PA+LNA Transmitter Demo v1.0
// The Engineering Projects - www.TheEngineeringProjects.com
//
// Sends "Hello TEP #n" once a second to address "00001" at 250 kbps with the PA at
// maximum (+20 dBm on a PA+LNA module) and reports whether the receiver acknowledged
// it, and after how many retries. Pair it with PALNA_Receiver on a second Arduino.
//
// Wiring (Arduino UNO): VCC -> 3.3V, GND -> GND, SCK -> D13, MISO -> D12,
//                       MOSI -> D11, CSN -> D10, CE -> D9, IRQ -> not used
// Real PA+LNA modules draw up to ~115 mA while sending: give them a clean 3.3 V supply
// with a 10-100 uF capacitor across VCC/GND, and use RF24_PA_LOW when the two
// modules are close together (the receiver's LNA overloads at PA_MAX).
// Library: RF24 by TMRh20 / nRF24 (Arduino Library Manager: "RF24")

#include <SPI.h>
#include <RF24.h>

RF24 radio(9, 10);                    // CE, CSN
const byte address[6] = "00001";
unsigned long counter = 0;

void setup() {
  Serial.begin(9600);
  Serial.println(F("TEP nRF24L01+PA+LNA Transmitter Demo v1.0"));
  if (!radio.begin()) {
    Serial.println(F("nRF24L01 not responding - check the SPI wiring and power"));
    while (true) {}
  }
  radio.setPALevel(RF24_PA_MAX);      // +20 dBm with the module's PA
  radio.setDataRate(RF24_250KBPS);    // best sensitivity = longest range
  radio.setChannel(108);              // 2508 MHz, above most Wi-Fi channels
  radio.openWritingPipe(address);
  radio.stopListening();              // transmitter mode
  Serial.println(F("Radio ready: channel 108, 250 kbps, PA MAX, address 00001"));
}

void loop() {
  char message[32] = "";
  snprintf(message, sizeof message, "Hello TEP #%lu", ++counter);
  bool ok = radio.write(message, sizeof message);
  Serial.print(F("Sent: "));
  Serial.print(message);
  if (ok) {
    Serial.print(F("  -> ACK received, retries: "));
    Serial.println(radio.getARC());
  } else {
    Serial.println(F("  -> FAILED, no ACK"));
  }
  delay(1000);
}

Start the Radio

1. RF24 radio(9, 10) creates the radio object with the pins for CE and CSN.
2. radio.begin() starts the SPI interface and the chip. If the chip does not answer, the sketch prints nRF24L01 not responding and stops.
3. radio.setPALevel(RF24_PA_MAX) selects the highest level of the chip. With the amplifier of the module, this gives +20 dBm.
4. radio.setDataRate(RF24_250KBPS) selects the data rate with the best sensitivity.
5. radio.setChannel(108) selects the frequency of 2508 MHz.
6. radio.openWritingPipe(address) sets the address of the receiver.
7. radio.stopListening() puts the radio into the transmitter mode.

The driver knows nothing about the amplifiers. It sets the level of the chip, and the module adds its 20 dB. For this reason, the same sketch works with the plain module and with the PA LNA module.

Send a Message

1. The sketch writes the text and the counter into a buffer of 32 bytes.
2. radio.write() sends the complete buffer. It returns true when the ACK has arrived, and false when the chip has given up.
3. radio.getARC() returns the number of retries that the last packet needed. At a good link, it is 0.
4. The sketch waits for one second.

Arduino Code for the nRF24L01 PA LNA Receiver

The settings of the receiver are the same as in the transmitter. Here is the exact sketch from the package:

// TEP nRF24L01+PA+LNA Receiver Demo v1.0
// The Engineering Projects - www.TheEngineeringProjects.com
//
// Listens on address "00001" (channel 108, 250 kbps) and prints every message it
// receives, with the nRF24's Received Power Detector (RPD: signal above -64 dBm).
// Pair it with PALNA_Transmitter on a second Arduino.
//
// Wiring (Arduino UNO): VCC -> 3.3V, GND -> GND, SCK -> D13, MISO -> D12,
//                       MOSI -> D11, CSN -> D10, CE -> D9, IRQ -> not used
// Library: RF24 by TMRh20 / nRF24 (Arduino Library Manager: "RF24")

#include <SPI.h>
#include <RF24.h>

RF24 radio(9, 10);                    // CE, CSN
const byte address[6] = "00001";
unsigned long counter = 0;

void setup() {
  Serial.begin(9600);
  Serial.println(F("TEP nRF24L01+PA+LNA Receiver Demo v1.0"));
  if (!radio.begin()) {
    Serial.println(F("nRF24L01 not responding - check the SPI wiring and power"));
    while (true) {}
  }
  radio.setPALevel(RF24_PA_MAX);      // the ACKs go back at +20 dBm too
  radio.setDataRate(RF24_250KBPS);    // must match the transmitter
  radio.setChannel(108);
  radio.openReadingPipe(0, address);
  radio.startListening();             // receiver mode
  Serial.println(F("Listening: channel 108, 250 kbps, address 00001"));
}

void loop() {
  if (radio.available()) {
    bool strong = radio.testRPD();    // received power above -64 dBm?
    char message[32] = "";
    radio.read(message, sizeof message);
    Serial.print(F("Received #"));
    Serial.print(++counter);
    Serial.print(F(": "));
    Serial.print(message);
    Serial.println(strong ? F("  (signal > -64 dBm)") : F("  (weak signal)"));
  }
}

Listen for Messages

• radio.openReadingPipe(0, address) sets the address on which the radio listens.
• radio.startListening() puts the radio into the receiver mode. The banner of the panel changes to RX - LISTENING.
• radio.available() tells the loop whether a packet is waiting.

Read the Message and the RPD Bit

1. radio.testRPD() reads the received power detector. The sketch calls it before it reads the packet.
2. radio.read() copies the 32 bytes of the packet into the buffer.
3. The sketch prints its own counter, the text of the message and one of the two texts for the signal.

The receiver does not send the ACK in the sketch. The chip sends it on its own, directly after the packet has arrived.

Calculate the Link Budget

A link budget tells us whether the signal at the receiver is inside the limits. The model uses four steps, and we can repeat them with a calculator.

Step 1: Calculate the Frequency and the Path Loss

The frequency of channel 108 is 2400 + 108 = 2508 MHz. The model uses the free-space loss for the first metre, and then a loss that grows with 28 dB for every ten-fold increase in distance:

Path loss in dB = 20 × log10(4 × pi × f / c) + 28 × log10(distance in metres)

Here, f is the frequency in Hz and c is the speed of light. At 2508 MHz, the first part is 40.43 dB.

Step 2: Calculate the Level at the Receiver

Level = output power + gain of both antennas - path loss

The output power is +20 dBm, and each antenna has a gain of 2 dBi in the model. The sum of the first two parts is 24 dBm.

• 10 m: 24 - 68.43 = -44.43 dBm, which the panel shows as -44 dBm.
• 100 m: 24 - 96.43 = -72.43 dBm, which the panel shows as -72 dBm.
• 1 km: 24 - 124.43 = -100.43 dBm.
• 2 km: 24 - 132.86 = -108.86 dBm.
• 1 m: 24 - 40.43 = -16.43 dBm.

Step 3: Calculate the Sensitivity of the Module

Sensitivity of the module = sensitivity of the chip - 8 dB

At 250 kbps, this is -94 - 8 = -102 dBm. The low noise amplifier has a gain of 12 dB, but it also amplifies the noise. The model therefore counts 8 dB as the improvement of the sensitivity.

Step 4: Compare the Level With Both Limits

• 1 km: -100.43 dBm is above -102 dBm and below -20 dBm. The packet is received.
• 2 km: -108.86 dBm is below -102 dBm. The packet is too weak.
• 1 m: -16.43 dBm is above -20 dBm. The receiver is overloaded.

Calculate the Time on Air and the Time of a Failure

1. A packet has 8 bits of preamble, 40 bits of address, 9 control bits, 256 bits of payload and 16 bits of CRC. This gives 329 bits.
2. At 250 kbps, one bit takes 4 microseconds. The packet needs 329 × 4 = 1316 microseconds.
3. An ACK without a payload has 73 bits and needs 292 microseconds.
4. The chip needs 130 microseconds before it sends and before it listens. A successful exchange takes 130 + 1316 + 130 + 292 = 1868 microseconds in the model.
5. For a failure, the chip sends the packet 16 times. After every transmission, it waits for 1500 microseconds.
6. The total is 130 + 1316 + 15 × (1500 + 1316) + 1500 = 45,186 microseconds, which is about 45 ms.

Experiments to Try in Proteus

Change one thing at a time and predict the result before you press Run. The results below follow from the model's rules. The supplied project and the distances 10 m, 1 km, 2 km and 1 m were tested in Proteus. The package notes list the other cases as tests of the model on a PC, so check them in your own simulation.

After each experiment, compare both panels before reading the code again. The counters of the receiver tell you whether the packets were too weak, too strong or not heard at all.

Compile and Load Your Own Arduino Changes

1. Open Arduino Code/PALNA_Transmitter/PALNA_Transmitter.ino or the receiver sketch in Arduino IDE.
2. Install the RF24 library by TMRh20 from the Library Manager. For the same version as the example, copy Arduino Code/libraries/RF24 into your sketchbook's libraries folder.
3. Select Arduino Uno as the board.
4. Compile the sketch and use the Export Compiled Binary command.
5. Select the new application HEX in the Program File property of the correct Arduino.
6. Restart the simulation.

Remember that the project has two programs. If you change a radio setting, rebuild both sketches and load each HEX into its own board. The package also contains a rebuild script and the AVR core source archive.

Common Problems and Their Solutions

If a problem remains, return to the unmodified project and change one thing at a time. When you ask for help, include both terminal windows and a screenshot of both control panels.

Practical Review and Model Limitations

This library is useful for understanding what the amplifiers of the PA LNA module change. The panel turns the link budget into an experiment, and it shows three lessons that are hard to see on real hardware. The range depends on the data rate, two modules at full power can be too close, and a link can work in one direction only.

What the Model Supports

• The registers and all SPI commands of the nRF24L01+.
• The transmit and receive buffers with three levels.
• Enhanced ShockBurst with automatic ACK, retries and packet numbers.
• Dynamic payloads, ACK payloads and six receive pipes.
• The IRQ pin, the CE timing and the power-down mode.
• The link budget with power level, amplifier, antennas, distance, sensitivity and overload.
• The received power detector.
• Designs with PA LNA modules and plain modules together.

What the Model Does Not Simulate

• Collisions between radios that send at the same moment.
• Interference from Wi-Fi and from other devices in the 2.4 GHz band.
• The supply current of the module and the dips of its supply voltage.
• The test modes of the chip with a constant carrier.
• Real antennas, walls, terrain and fading.

Treat the range values as teaching examples. The model uses one path loss rule for an outdoor link with some obstacles. The range of real hardware depends on the antennas, their height and the surroundings, so it must be measured with the actual devices.

More Proteus Libraries of This Series

This library belongs to a series of wireless and RFID libraries for Proteus. Every library has its own control panel and its own tutorial:

• nRF24L01 Proteus Library: a 2.4 GHz link between two Arduino Uno boards with the RF24 library.
• SX1278 LoRa Proteus Library: a LoRa link at 433 MHz with the Ra-02 module.
• RFM95W LoRa Proteus Library: a LoRa link at 868 MHz with RSSI, SNR and spreading factor.
• SX1262 LoRa Proteus Library: a LoRa link with up to +22 dBm, the Arduino Mega 2560 and RadioLib.
• CC1101 Proteus Library: a link at 433.92 MHz with signal strength and distance buttons.
• RFM69HCW Proteus Library: a node and a gateway at 433 MHz with acknowledgements.
• MFRC522 RFID Proteus Library: a 13.56 MHz RFID reader with virtual MIFARE cards.
• EM-18 RFID Proteus Library: a 125 kHz RFID reader with serial output.
• PN532 NFC Proteus Library: an NFC reader for I2C and SPI with MIFARE Classic and NTAG213 cards.

Frequently Asked Questions

Do I Need a Different Arduino Library for the PA LNA Module?

No. The module uses the same nRF24L01+ chip, so the RF24 library and the functions of the plain module work without a change. Only the meaning of the power levels is different, because the module adds 20 dB.

Why Do Two PA LNA Modules Fail on the Same Desk?

At the highest power level, the signal is too strong for the low noise amplifier of the receiver. In the model, this happens when both panels show 1 m. Use RF24_PA_LOW for short distances.

Why Does the Terminal Show signal > -64 dBm When the Panel Shows -72 dBm?

The panel shows the level at the antenna. The RPD bit of the chip is measured behind the low noise amplifier, which adds 12 dB. A level of -72 dBm at the antenna is -60 dBm at the chip.

Why Does the Transmitter Report a Failure Although the Message Arrived?

The ACK did not come back. This happens when the receiver sends with a lower power level, or when the receiver is a plain module without an amplifier. The receiver stores the message only once, although the transmitter repeats it.

Which Data Rate Should I Use?

Use 250 kbps for the largest range. Use 1 Mbps or 2 Mbps when the distance is short and the packets must be fast.

Can the PA LNA Module Talk to the Plain nRF24L01 in Proteus?

Yes. Both components share one radio band when the DLL of this package is installed. Keep in mind that the plain module reaches a much shorter distance, so the ACK of a plain module is the weak part of the link.

Do I Need Arduino IDE to Run the Supplied Circuit?

No. Both compiled HEX files are included. You need Arduino IDE, or the documented build tools, only when you change a sketch.

That completes our nRF24L01 PA LNA Proteus Library tutorial. Start with the supplied project, watch both panels and then click through the distance buttons. Once the levels make sense, change the data rate or the power level and compare the results with your own calculation. Share your questions and simulation results in the comments below.