RF communication with nRF24L01 in Arduino - Time & Space Complexity

Time Complexity: RF communication with nRF24L01

O(n)

Understanding Time Complexity

When using the nRF24L01 module for RF communication, it is important to understand how the time taken to send and receive data changes as the amount of data grows.

We want to know how the program's running time changes when we send more bytes of data.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

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

void setup() {
  radio.begin();
  radio.openWritingPipe(address);
  radio.setPALevel(RF24_PA_LOW);
}

void loop() {
  byte data[32];
  // fill data with values
  radio.write(data, sizeof(data));
  delay(1000);
}
    

This code sends a fixed-size data packet of 32 bytes repeatedly over RF using the nRF24L01 module.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Sending a fixed-size data packet using radio.write().
• How many times: This happens once every loop cycle, repeatedly with a fixed delay.

How Execution Grows With Input

The time to send a packet of size n bytes (n ≤ 32) grows linearly with n.

Input Size (n bytes)	Approx. Time
8	Short time to send 8 bytes
16	About twice the time to send 16 bytes
32	About four times the time to send 32 bytes

Pattern observation: The time grows linearly with the size of the data packet sent.

Final Time Complexity

Time Complexity: O(n)

This means the time to send data grows directly in proportion to the number of bytes you send.

Common Mistake

[X] Wrong: "Sending data with nRF24L01 always takes the same time regardless of data size."

[OK] Correct: The module sends data byte by byte, so larger data packets take more time to send than smaller ones.

Interview Connect

Understanding how communication time grows with data size helps you design efficient wireless systems and shows you can think about performance in real devices.

Self-Check

"What if we split the data into smaller packets and send them separately? How would the time complexity change?"