Tutorial do nRF24L01 com Arduino: ligação, código RF24, alcance e soluções

A dupla nRF24L01 e Arduino é a forma mais barata e prática de enviar dados entre duas placas sem passar cabo. Esse módulo do tamanho de uma unha trabalha na faixa de 2,4 GHz, transmite até 2 megabits por segundo e funciona tanto como transmissor quanto como receptor. É ideal para carrinhos de controle remoto, joysticks sem fio, uma estação que manda para dentro de casa as leituras de um sensor do jardim ou nós de alarme que avisam uns aos outros. A versão padrão alcança cerca de 100 metros em espaço aberto, enquanto a versão nRF24L01+PA+LNA, com antena externa, pode chegar a 1 quilômetro em boas condições.

Neste guia você vai aprender como o módulo funciona, quais pinos SPI ele usa, por que ele precisa ser alimentado com 3,3 V e como um capacitor de 10 µF resolve o problema mais comum. Depois vai escrever código de transmissor e de receptor com a biblioteca RF24, entender endereços e canais, montar um controle com joystick, ligar o módulo a um ESP32 e a um Raspberry Pi Pico e, por fim, resolver passo a passo os problemas “radio.begin() false” e “nenhum dado recebido”.

O que é o nRF24L01 e como ele funciona?

O nRF24L01 é um chip transceptor de rádio de 2,4 GHz fabricado pela Nordic Semiconductor; quase todos os módulos vendidos hoje trazem a versão melhorada nRF24L01+ ou um chip clone compatível. O módulo conversa com o Arduino por SPI: o Arduino escreve por SPI as configurações e os dados a enviar, e o chip cuida do resto. O protocolo de hardware da Nordic, chamado Enhanced ShockBurst, envolve cada pacote com um endereço e um CRC (verificação de erros). Quando o receptor recebe um pacote corretamente, ele envia automaticamente uma confirmação (ACK) de volta ao transmissor; se o ACK não chega, o transmissor tenta de novo sozinho. Ou seja, o seu código só diz “envie”, e as novas tentativas e a verificação de erros acontecem no hardware.

Um pacote leva no máximo 32 bytes de dados. Pode parecer pouco, mas dois eixos de joystick, alguns botões e vários valores de sensores cabem com folga. O módulo usa um de 126 canais, e a frequência do canal é 2400 + número do canal (MHz); o canal 76, por exemplo, é 2476 MHz. Um receptor pode escutar 6 endereços diferentes (chamados pipes) ao mesmo tempo, então uma central consegue juntar dados de seis transmissores.

nRF24L01 vs nRF24L01+PA+LNA

Você vai encontrar dois tipos de módulo no mercado. No módulo padrão, a antena é uma trilha de cobre em zigue-zague impressa na placa. A versão nRF24L01+PA+LNA acrescenta um chip de front-end de RF na frente do mesmo transceptor: o PA (amplificador de potência) reforça o sinal que sai, e o LNA (amplificador de baixo ruído) amplifica os sinais fracos que chegam antes de eles alcançarem o chip. Uma antena externa de rosca se encaixa em um conector SMA. Os dois módulos têm a mesma pinagem, usam o mesmo código e conversam entre si sem problema; a diferença é o alcance e o consumo de corrente. Os números abaixo são aproximados e dependem do ambiente.

Pinagem do nRF24L01 e ligação ao Arduino

O módulo tem 8 pinos em uma barra 2×4. O pino com a ilha de solda quadrada é o pino 1, que é o GND; o VCC fica logo ao lado. O CE (Chip Enable) passa o módulo para o modo de escuta ou de transmissão, e o CSN (Chip Select Not) é levado a LOW para dizer “agora estou falando com você” no barramento SPI. SCK, MOSI e MISO são as linhas SPI padrão e precisam ir aos pinos SPI fixos da sua placa, enquanto CE e CSN podem ir a quaisquer pinos digitais. O pino IRQ é opcional; ele vai a LOW quando chega um pacote ou termina uma transmissão e é usado se você quiser trabalhar com interrupções. Para saber como o SPI funciona, veja O que é SPI, e para o mapa completo de pinos da sua placa, use a ferramenta Pinagem.

O erro mais comum: a alimentação e o capacitor de 10 µF

A maioria dos problemas com o nRF24L01 não vem do código, mas da alimentação. O módulo puxa pulsos de corrente curtos e fortes no instante em que transmite. Jumpers longos e uma fonte de 3,3 V fraca não acompanham esses pulsos; a tensão cai por um instante, e o chip envia um pacote corrompido, perde ACKs ou se reinicia. Segundo a documentação oficial, o pino 3.3V do Arduino Uno fornece no máximo 50 mA; isso basta para o módulo padrão, mas não para a versão PA+LNA, que puxa até 115 mA. Em alguns clones do Nano, o pino 3.3V vem do chip USB-serial e é ainda mais fraco. Os sintomas vão soar familiares: o write() às vezes dá certo e às vezes não, o módulo funciona melhor quando você encosta nele ou o alcance para em poucos metros.

• Capacitor de 10 µF: coloque um capacitor eletrolítico de 10 µF entre os pinos VCC e GND do módulo, o mais perto possível deles. A perna longa (+) vai ao VCC e o lado com a faixa (−) ao GND. Qualquer valor de 10 a 100 µF também funciona; você pode ler por que ele ajuda em O que é um capacitor.
• Capacitor cerâmico de 100 nF: um pequeno capacitor cerâmico (marcado 104) em paralelo com o eletrolítico filtra o ruído de alta frequência. Você pode decodificar as marcações de capacitores com a ferramenta Código de capacitores.
• Adaptador de soquete: as plaquinhas adaptadoras de 8 pinos vendidas para o nRF24L01 já vêm com um regulador AMS1117-3.3 e capacitores. Você injeta 5 V no VCC do adaptador, e o módulo recebe 3,3 V limpos.
• Regulador separado: alimente a versão PA+LNA não pelo pino 3.3V do Arduino, mas por um regulador AMS1117-3.3 separado alimentado com 5 V, e ligue todos os GNDs juntos.
• Fios curtos: mantenha os jumpers abaixo de 10 cm, se puder; fios longos e soltos atrapalham tanto a alimentação quanto os sinais SPI.

Como instalar a biblioteca RF24

1. Na Arduino IDE, abra Ferramentas > Gerenciar Bibliotecas ou clique no ícone de bibliotecas à esquerda.
2. Digite RF24 na caixa de busca e instale a biblioteca RF24, de TMRh20. RF24Network, RF24Mesh e RF24Ethernet são bibliotecas separadas e não são necessárias para começar.
3. Depois da instalação, você encontra o exemplo GettingStarted em Arquivo > Exemplos > RF24. O código deste artigo segue a sintaxe da versão 1.5 e posteriores da RF24.
4. Se é a primeira vez que você instala uma biblioteca, siga os passos em Como instalar uma biblioteca no Arduino.

Endereço, canal e taxa de dados: fazendo dois módulos se entenderem

Para dois módulos se ouvirem, algumas configurações precisam ser exatamente iguais dos dois lados. Pense em uma conversa por walkie-talkie: se vocês não estiverem na mesma frequência (canal), na mesma velocidade de fala (taxa de dados) e com o mesmo indicativo de chamada (endereço), você não ouve o outro lado. O endereço é um array de 5 bytes, e o jeito mais fácil de escrevê-lo no código é como uma string de 5 caracteres, como "00001". Pense no endereço não como a identidade de um dispositivo, mas como um caminho compartilhado entre dois dispositivos: o transmissor deixa pacotes nesse caminho, e o receptor que escuta esse caminho os recolhe. O tamanho do payload também importa; a RF24 usa payloads de tamanho fixo por padrão, e, se o receptor não esperar o mesmo tamanho que o transmissor, ele nunca vê o pacote.

Código do transmissor (TX)

Para o primeiro teste, ligue os dois Arduinos em duas portas USB separadas e deixe 1–2 metros entre os módulos. Carregue o código do transmissor abaixo em um deles. A cada segundo, ele envia uma mensagem numerada e mostra no Monitor Serial se o receptor a confirmou. Não esqueça de ajustar o Monitor Serial para 115200 baud.

1#include <SPI.h>
2#include <RF24.h>
3
4RF24 radio(9, 10);                        // CE, CSN pinleri / CE, CSN pins
5const uint8_t address[6] = "00001";       // iki tarafta aynı adres / same address on both sides
6char message[32];                         // en fazla 32 bayt / 32 bytes max
7uint16_t counter = 0;
8
9void setup() {
10  Serial.begin(115200);
11  if (!radio.begin()) {                   // modül cevap vermiyor / module not responding
12    Serial.println(F("nRF24L01 bulunamadi, kablolari kontrol et!"));
13    while (true) {}
14  }
15  radio.setChannel(76);                   // kanal 76 = 2476 MHz / channel 76 = 2476 MHz
16  radio.setDataRate(RF24_250KBPS);        // en uzun menzil / longest range
17  radio.setPALevel(RF24_PA_LOW);          // masa testi için düşük güç / low power for desk tests
18  radio.setPayloadSize(sizeof(message));  // paket boyu 32 bayt / 32-byte payload
19  radio.stopListening(address);           // verici modu + hedef adres / TX mode + target address
20}
21
22void loop() {
23  snprintf(message, sizeof(message), "Merhaba BlueGrays #%u", counter++);
24  bool ok = radio.write(message, sizeof(message));   // onay (ACK) geldi mi? / was it acknowledged?
25  if (ok) {
26    Serial.print(F("Gonderildi: "));
27    Serial.println(message);
28  } else {
29    Serial.println(F("Onay gelmedi"));
30  }
31  delay(1000);
32}

Código do receptor (RX)

1#include <SPI.h>
2#include <RF24.h>
3
4RF24 radio(9, 10);                        // CE, CSN pinleri / CE, CSN pins
5const uint8_t address[6] = "00001";       // vericiyle aynı adres / same address as the transmitter
6char message[32];
7
8void setup() {
9  Serial.begin(115200);
10  if (!radio.begin()) {
11    Serial.println(F("nRF24L01 bulunamadi, kablolari kontrol et!"));
12    while (true) {}
13  }
14  radio.setChannel(76);                   // ayarlar vericiyle aynı / settings match the transmitter
15  radio.setDataRate(RF24_250KBPS);
16  radio.setPALevel(RF24_PA_LOW);
17  radio.setPayloadSize(sizeof(message));
18  radio.openReadingPipe(1, address);      // 1 numaralı boruyu aç / open pipe 1
19  radio.startListening();                 // alıcı modu / RX mode
20}
21
22void loop() {
23  if (radio.available()) {                // paket geldi mi? / has a packet arrived?
24    radio.read(message, sizeof(message));
25    Serial.print(F("Gelen: "));
26    Serial.println(message);
27  }
28}

radio.write() envia o pacote e retorna true se o receptor o confirmar; com as configurações padrão, ele tenta de novo 15 vezes, com cerca de 1,5 ms de intervalo, antes de retornar false. No receptor, openReadingPipe(1, address) define o pipe 1 com o endereço do transmissor, startListening() passa o módulo para o modo de escuta, available() diz se há um pacote esperando e read() o copia para a sua variável. Se o Monitor Serial do receptor mostrar linhas contando para cima, como “Gelen: Merhaba BlueGrays #0”, “#1”, “#2”, o seu link está funcionando.

Alcance: de 100 metros a 1 quilômetro

Três coisas determinam o alcance: a potência de saída, a sensibilidade do receptor e o ambiente. Quanto menor a taxa de dados, mais fracos são os sinais que o receptor consegue decodificar; a sensibilidade é de −94 dBm a 250 kbps, mas de −82 dBm a 2 Mbps. Essa diferença de 12 dB significa mais ou menos 4 vezes o alcance em espaço aberto. Paredes, árvores, corpos humanos e superfícies metálicas enfraquecem bastante os sinais de 2,4 GHz, e roteadores Wi-Fi, dispositivos Bluetooth e micro-ondas dividem a mesma faixa.

A escolha do canal também importa. Os canais de Wi-Fi mais usados, 1, 6 e 11, cobrem mais ou menos 2401–2473 MHz; os canais 74–83 do nRF24L01 ficam acima disso e são mais tranquilos, desde que nenhum roteador por perto use os canais 12 ou 13 do Wi-Fi. Na Europa, na Turquia e também no Brasil, a faixa de 2,4 GHz de uso livre vai de 2400 a 2483,5 MHz, então não use canais acima de 83; os canais de 100 para cima que alguns exemplos da internet sugerem ficam fora dessa faixa, e os limites exatos dependem das regras do seu país. Para conseguir mais alcance, experimente o seguinte:

• Use 250 kbps: controles remotos e dados de sensores não precisam de alta velocidade, e a taxa menor dá alcance.
• Resolva a alimentação primeiro, depois aumente a potência: RF24_PA_MAX só faz sentido com 3,3 V estáveis e um capacitor; aumentar a potência com uma alimentação fraca piora as coisas.
• Monte as antenas no alto e na mesma orientação: 1–2 metros acima do chão, com as duas antenas em pé do mesmo jeito, melhora bastante o alcance.
• Mantenha longe de metal: não coloque o módulo dentro de uma caixa de metal nem colado em um pacote grande de baterias.
• Envolva uma placa PA+LNA sem blindagem: envolver um módulo PA+LNA sem caixinha metálica em fita isolante e depois em papel-alumínio reduz a interferência que ele causa em si mesmo; o alumínio não pode encostar em nenhum pino nem no conector da antena.
• Não transmita sem antena: usar um módulo PA+LNA em potência máxima sem antena força o amplificador de potência.

Controle remoto sem fio com joystick

Agora vamos montar um projeto de verdade: usar um joystick em um Arduino para controlar sem fio um servo motor e um LED em um segundo Arduino. No transmissor, o pino VRx do joystick vai ao A0, o VRy ao A1 e o botão (SW) ao D2; você encontra os detalhes em Módulo joystick. No receptor, o fio de sinal do servo vai ao D3 e o LED vai ao D4 através de um resistor de 220 Ω. A ligação do nRF24L01 dos dois lados é igual à da tabela acima.

A forma mais limpa de enviar vários valores em um pacote é uma struct. Há um detalhe importante aqui: você deve usar tipos de tamanho fixo, como int16_t e uint8_t. Um int tem 2 bytes no Arduino Uno, mas 4 bytes no ESP32, e o compilador do ESP32 também acrescenta bytes de preenchimento no fim da struct para alinhamento. Se a mesma struct tiver 5 bytes no Uno e 6 bytes no ESP32, os tamanhos de payload não batem e nenhum dado chega. __attribute__((packed)) remove esse preenchimento e deixa a struct com 5 bytes em qualquer placa. Primeiro, o transmissor:

1#include <SPI.h>
2#include <RF24.h>
3
4struct __attribute__((packed)) JoystickData {   // her kartta 5 bayt / 5 bytes on every board
5  int16_t x;
6  int16_t y;
7  uint8_t button;
8};
9
10RF24 radio(9, 10);                        // CE, CSN pinleri / CE, CSN pins
11const uint8_t address[6] = "JOY01";       // kumanda adresi / remote address
12JoystickData data;
13
14void setup() {
15  pinMode(2, INPUT_PULLUP);               // joystick butonu (SW) / joystick button (SW)
16  if (!radio.begin()) {
17    while (true) {}                       // modül yok / no module
18  }
19  radio.setChannel(76);
20  radio.setDataRate(RF24_250KBPS);
21  radio.setPALevel(RF24_PA_HIGH);         // orta-yüksek güç / medium-high power
22  radio.setPayloadSize(sizeof(data));
23  radio.stopListening(address);           // verici modu / TX mode
24}
25
26void loop() {
27  data.x = analogRead(A0);                // VRx ekseni 0-1023 / VRx axis 0-1023
28  data.y = analogRead(A1);                // VRy ekseni 0-1023 / VRy axis 0-1023
29  data.button = (digitalRead(2) == LOW);  // basılıysa 1 / 1 when pressed
30  radio.write(&data, sizeof(data));
31  delay(50);                              // saniyede 20 paket / 20 packets per second
32}

Depois, o receptor que aciona o servo e o LED:

1#include <SPI.h>
2#include <RF24.h>
3#include <Servo.h>
4
5struct __attribute__((packed)) JoystickData {   // vericiyle birebir aynı / identical to the transmitter
6  int16_t x;
7  int16_t y;
8  uint8_t button;
9};
10
11RF24 radio(9, 10);                        // CE, CSN pinleri / CE, CSN pins
12const uint8_t address[6] = "JOY01";       // vericiyle aynı / same as the transmitter
13JoystickData data;
14Servo servo;
15unsigned long lastPacket = 0;
16
17void setup() {
18  pinMode(4, OUTPUT);                     // LED çıkışı / LED output
19  servo.attach(3);                        // servo sinyal pini / servo signal pin
20  if (!radio.begin()) {
21    while (true) {}
22  }
23  radio.setChannel(76);
24  radio.setDataRate(RF24_250KBPS);
25  radio.setPALevel(RF24_PA_HIGH);
26  radio.setPayloadSize(sizeof(data));
27  radio.openReadingPipe(1, address);
28  radio.startListening();                 // alıcı modu / RX mode
29}
30
31void loop() {
32  if (radio.available()) {
33    radio.read(&data, sizeof(data));
34    servo.write(map(data.x, 0, 1023, 0, 180));   // X ekseni -> servo açısı / X axis -> servo angle
35    digitalWrite(4, data.button ? HIGH : LOW);   // buton LED'i yakar / button lights the LED
36    lastPacket = millis();
37  }
38  if (millis() - lastPacket > 500) {      // 0,5 sn paket yok: güvenli konum / no packet for 0.5 s: failsafe
39    servo.write(90);
40    digitalWrite(4, LOW);
41  }
42}

O transmissor envia 20 pacotes por segundo; para cada pacote, o receptor mapeia o eixo X para 0–180 graus e o escreve no servo. A parte de failsafe no receptor é muito importante: se a bateria do controle acabar ou você sair do alcance, o último comando não fica aplicado para sempre; quando nenhum pacote chega por 0,5 segundo, o servo volta ao centro e o LED apaga. Se você estiver montando um carrinho robô, pare os motores no mesmo lugar. Alimentar o servo com uma fonte de 5 V separada, em vez do pino 5V do Arduino, também evita que os picos de corrente do servo atrapalhem o nRF24L01. Ligue o eixo Y a um driver de motor L298N e você tem um carrinho robô sem fio; para os detalhes do servo, veja O que é um servo motor.

Comunicação nos dois sentidos e vários transmissores

O nRF24L01 não consegue transmitir e escutar ao mesmo tempo, mas há um jeito fácil de ter comunicação nos dois sentidos: um ACK payload, ou seja, dados enviados dentro do pacote de confirmação. O receptor prepara com antecedência, com writeAckPayload(), os dados que vão junto no próximo ACK (a tensão de uma bateria ou a leitura de um sensor, por exemplo), e, depois de um write() bem-sucedido, o transmissor lê essa resposta com available() e read(). Para isso, os dois lados precisam chamar enableDynamicPayloads() e enableAckPayload(). Para vários transmissores, o receptor tem 6 pipes: os pipes 0 e 1 recebem um endereço completo de 5 bytes, enquanto os pipes 2–5 compartilham o resto do endereço do pipe 1 e diferem em um único byte. Na RF24, esse byte é o primeiro caractere do array de endereço, por isso endereços como “1Node”, “2Node” e “3Node” diferem só no primeiro caractere. Para redes maiores existem as bibliotecas RF24Network e RF24Mesh.

Como ligar o nRF24L01 a um ESP32

A biblioteca RF24 funciona no ESP32 sem mudanças, e radio.begin() usa o barramento VSPI padrão: SCK = GPIO 18, MISO = GPIO 19, MOSI = GPIO 23. O GPIO 5 é uma boa escolha para o CSN e o GPIO 4 para o CE. O regulador de 3,3 V das placas ESP32 DevKit é mais forte que o do Uno, mas não dispense o capacitor de 10 µF. Em modelos como o ESP32-C3 ou o ESP32-S3, os pinos SPI padrão são diferentes, então confira o mapa de pinos da sua placa. Como o Wi-Fi do ESP32 também trabalha em 2,4 GHz, escolha um canal do nRF24L01 bem longe do canal Wi-Fi do seu roteador se usar os dois juntos. O código abaixo lê os pacotes do transmissor com joystick em um ESP32; com a mesma estrutura, você pode usar o ESP32 como gateway que repassa para a internet os dados dos nós nRF24L01. Se a placa é novidade para você, comece por O que é o ESP32.

1#include <SPI.h>
2#include <RF24.h>
3
4struct __attribute__((packed)) JoystickData {   // packed olmasa 6 bayt olurdu / 6 bytes without packed
5  int16_t x;
6  int16_t y;
7  uint8_t button;
8};
9
10RF24 radio(4, 5);                         // CE = GPIO 4, CSN = GPIO 5 pinleri / CE = GPIO 4, CSN = GPIO 5 pins
11const uint8_t address[6] = "JOY01";
12JoystickData data;
13
14void setup() {
15  Serial.begin(115200);
16  if (!radio.begin()) {                   // varsayılan VSPI: SCK 18, MISO 19, MOSI 23 / default VSPI pins
17    Serial.println("nRF24L01 bulunamadi!");
18    while (true) delay(1000);
19  }
20  radio.setChannel(76);
21  radio.setDataRate(RF24_250KBPS);
22  radio.setPALevel(RF24_PA_HIGH);
23  radio.setPayloadSize(sizeof(data));     // packed sayesinde 5 bayt / 5 bytes thanks to packed
24  radio.openReadingPipe(1, address);
25  radio.startListening();
26}
27
28void loop() {
29  if (radio.available()) {
30    radio.read(&data, sizeof(data));
31    Serial.printf("X=%d  Y=%d  Buton=%d\n", data.x, data.y, data.button);
32  }
33}

Se você só precisa ligar placas ESP32 entre si, o ESP-NOW, que não precisa de módulo extra, também é uma boa opção; a vantagem do nRF24L01 é que ele também funciona com placas baratas e de baixo consumo, como o Uno, o Nano e o Pro Mini.

nRF24L01 com o Raspberry Pi Pico e MicroPython

Para MicroPython no Pico, você usa o driver nrf24l01.py do repositório oficial micropython-lib. Você pode copiar o arquivo para o Pico com o Thonny ou instalá-lo pelo computador com mpremote mip install nrf24l01. A ligação usa o SPI0: SCK = GP2, MOSI = GP3, MISO = GP4, CSN = GP5, CE = GP6 e VCC = 3V3(OUT). Os padrões do driver são diferentes dos da RF24 (canal 46, payload de 16 bytes), então, para conversar com o Arduino, definimos explicitamente no código o canal, a taxa de dados e o tamanho do payload. O código abaixo decodifica os pacotes do transmissor com joystick no Pico:

1from machine import Pin, SPI
2import struct
3import utime
4from nrf24l01 import NRF24L01, POWER_2, SPEED_250K
5
6spi = SPI(0, sck=Pin(2), mosi=Pin(3), miso=Pin(4))   # SPI0 pinleri / SPI0 pins
7csn = Pin(5, mode=Pin.OUT, value=1)                  # CSN pini GP5 / CSN pin GP5
8ce = Pin(6, mode=Pin.OUT, value=0)                   # CE pini GP6 / CE pin GP6
9
10nrf = NRF24L01(spi, csn, ce, channel=76, payload_size=5)   # Arduino ile aynı / same as the Arduino
11nrf.set_power_speed(POWER_2, SPEED_250K)             # -6 dBm güç, 250 kbps / -6 dBm power, 250 kbps
12nrf.open_rx_pipe(1, b"JOY01")                        # vericinin adresi / transmitter address
13nrf.start_listening()                                # alıcı modu / RX mode
14print("Dinleniyor... / Listening...")
15
16while True:
17    if nrf.any():                                    # paket geldi mi? / packet waiting?
18        x, y, button = struct.unpack("<hhB", nrf.recv())   # 2 + 2 + 1 bayt / 2 + 2 + 1 bytes
19        print("X:", x, "Y:", y, "Buton:", button)
20    utime.sleep_ms(5)

struct.unpack("<hhB") transforma os 5 bytes recebidos em dois números de 16 bits com sinal e um byte; o “<” inicial define a ordem de bytes little-endian, que é a usada pelo AVR e pelo ESP32. Se o módulo não for encontrado, o driver gera “nRF24L01+ Hardware not responding”, o equivalente em MicroPython do begin() retornando false no Arduino. Se o Pico é novidade para você, leia antes O que é o Raspberry Pi Pico.

radio.begin() retorna false: solução passo a passo

Se o Monitor Serial mostra “nRF24L01 bulunamadi” ou a mensagem “radio hardware is not responding!!” dos exemplos da RF24, o Arduino não consegue conversar com o módulo por SPI de jeito nenhum. Nesse caso, o problema quase sempre é a ligação ou a alimentação, não o código. Primeiro carregue o sketch de diagnóstico abaixo; ele mostra todas as configurações do módulo de forma legível.

1#include <SPI.h>
2#include <RF24.h>
3#include "printf.h"                       // RF24 ile gelir / ships with RF24
4
5RF24 radio(9, 10);                        // kendi CE, CSN pinlerin / your CE, CSN pins
6
7void setup() {
8  Serial.begin(115200);
9  printf_begin();                         // printPrettyDetails için / needed for printPrettyDetails
10  bool ok = radio.begin();
11  Serial.print(F("begin(): "));
12  Serial.println(ok ? "true" : "false");
13  Serial.print(F("isChipConnected(): "));
14  Serial.println(radio.isChipConnected() ? "true" : "false");
15  radio.printPrettyDetails();             // tüm ayarları yazdır / print every setting
16}
17
18void loop() {
19}

1. Confira MOSI e MISO: esses são os dois fios trocados com mais frequência. No Uno e no Nano, MOSI = D11, MISO = D12 e SCK = D13; no Mega, são 51, 50 e 52.
2. CE e CSN batem com o código? Se você escreveu RF24 radio(9, 10), o CE vai ao D9 e o CSN ao D10. O exemplo GettingStarted da RF24 usa os pinos 7 e 8; se for testar o exemplo sem mudanças, ligue desse jeito.
3. A alimentação é de 3,3 V? Meça entre VCC e GND com um multímetro; você deve ver 3,0–3,6 V. Se o módulo já foi ligado em 5 V alguma vez, ele pode estar danificado.
4. Veja a saída do printPrettyDetails: se os endereços e os valores dos registradores mostrarem todos 0x00 ou 0xff, o barramento SPI não está funcionando. Se os valores parecerem coerentes, mas mesmo assim não houver link, o problema é o pino CE, as configurações ou a alimentação.
5. Encurte os fios e diminua a velocidade do SPI: com fios longos ou soltos, escreva RF24 radio(9, 10, 4000000) para baixar a velocidade do SPI dos 10 MHz padrão para 4 MHz.
6. Troque o módulo: se todo o resto estiver certo, experimente um módulo reserva; pacotes baratos com várias unidades podem trazer um com defeito.

Sem dados ou dados falhando: problemas comuns

Ideias de projetos com nRF24L01

• Controle sem fio para carrinho robô: dirija um carrinho robô a dezenas de metros de distância com um controle de dois joysticks.
• Estação de sensores no jardim: envie dados de um sensor de umidade do solo e de temperatura de um transmissor a bateria para um display dentro de casa. Com radio.powerDown(), o módulo consome cerca de 900 nA dormindo; você pode estimar a duração da bateria com a ferramenta Duração da bateria.
• Alarme sem fio de porta e movimento: toque um buzzer na central quando um sensor PIR ou um reed switch for acionado.
• Rede de temperatura em vários cômodos: junte as leituras de sensores em seis cômodos em um único receptor pelos seis pipes.
• Gateway com ESP32: repasse os dados dos nós nRF24L01 para a internet, para o seu celular ou para um painel com um ESP32.
• Placar sem fio: atualize um placar de 7 segmentos em um ginásio com controles de botão.

Apesar do preço baixo, o nRF24L01 oferece alcance maior, latência menor e suporte a vários dispositivos em comparação com o Bluetooth; tudo o que ele pede é uma alimentação limpa de 3,3 V e configurações iguais dos dois lados. Se você quer controle pelo celular, o módulo Bluetooth HC-05 pode servir melhor, e, para quilômetros de alcance, o LoRa; você encontra uma comparação das opções em Módulos de comunicação sem fio para Arduino. No app BlueGrays você encontra projetos como comunicação entre dois Arduinos, controle de servo e LED com joystick e um carrinho de controle remoto, passo a passo, com esquemas do circuito e código pronto para usar.