Unable to Send Response NRF24L01

[Marin-Johnson]

I am using two NRF24L01 radios on two Raspberry Pi Picos. I am able to send data from Pico1 to Pico2 just fine, but when I try to send a response from Pico2 back to Pico1, Pico1 doesn't receive the response. I am using this library. Here is my code:

Transmitter

import usys
import ustruct as struct
import utime
from machine import Pin, SPI
from nrf24l01 import NRF24L01
from micropython import const

cfg = {"spi": 0, "miso": 4, "mosi": 7, "sck": 6, "csn": 14, "ce": 17}

# Addresses are in little-endian format. They correspond to big-endian
# 0xf0f0f0f0e1, 0xf0f0f0f0d2
pipes = (b"\xe1\xf0\xf0\xf0\xf0", b"\xd2\xf0\xf0\xf0\xf0")


csn = Pin(cfg["csn"], mode=Pin.OUT, value=1)
ce = Pin(cfg["ce"], mode=Pin.OUT, value=0)
if cfg["spi"] == -1:
    spi = SPI(-1, sck=Pin(cfg["sck"]), mosi=Pin(cfg["mosi"]), miso=Pin(cfg["miso"]))
    nrf = NRF24L01(spi, csn, ce, payload_size=32)
else:
    nrf = NRF24L01(SPI(cfg["spi"]), csn, ce, payload_size=32)

nrf.open_tx_pipe(pipes[0])
nrf.open_rx_pipe(1, pipes[1])
nrf.start_listening()


while True:
    # stop listening and send packet
    nrf.stop_listening()
    millis = utime.ticks_ms()
    print("sending...")
    
    temperature = 83.12
    humidity = 54.21
    battery = 0.87
    
    try:
        nrf.send(struct.pack("ifff", millis, temperature, humidity, battery))
    except OSError:
        pass

    # start listening again
    nrf.start_listening()

    # wait for response, with 250ms timeout
    start_time = utime.ticks_ms()
    timeout = False
    while not nrf.any() and not timeout:
        if utime.ticks_diff(utime.ticks_ms(), start_time) > 250:
            timeout = True

    if timeout:
        print("failed, response timed out")
    else:
        # recv packet
        (got_millis,) = struct.unpack("i", nrf.recv())

        # print response and round-trip delay
        print("got response:", got_millis)

    # delay then loop
    utime.sleep_ms(250)

Receiver

import usys
import ustruct as struct
import utime
from machine import Pin, SPI
from nrf24l01 import NRF24L01
from micropython import const

# Slave pause between receiving data and checking for further packets.
_RX_POLL_DELAY = const(15)
# Slave pauses an additional _SLAVE_SEND_DELAY ms after receiving data and before
# transmitting to allow the (remote) master time to get into receive mode. The
# master may be a slow device. Value tested with Pyboard, ESP32 and ESP8266.
_SLAVE_SEND_DELAY = const(10)

cfg = {"spi": 0, "miso": 4, "mosi": 7, "sck": 6, "csn": 14, "ce": 17}

# Addresses are in little-endian format. They correspond to big-endian
# 0xf0f0f0f0e1, 0xf0f0f0f0d2
pipes = (b"\xe1\xf0\xf0\xf0\xf0", b"\xd2\xf0\xf0\xf0\xf0")



csn = Pin(cfg["csn"], mode=Pin.OUT, value=1)
ce = Pin(cfg["ce"], mode=Pin.OUT, value=0)
if cfg["spi"] == -1:
    spi = SPI(-1, sck=Pin(cfg["sck"]), mosi=Pin(cfg["mosi"]), miso=Pin(cfg["miso"]))
    nrf = NRF24L01(spi, csn, ce, payload_size=32)
else:
    nrf = NRF24L01(SPI(cfg["spi"]), csn, ce, payload_size=32)

nrf.open_tx_pipe(pipes[1])
nrf.open_rx_pipe(1, pipes[0])
nrf.start_listening()

print("Waiting for packets...")

while True:
    if nrf.any():
        while nrf.any():
            buf = nrf.recv()
            millis, temperature, humidity, battery = struct.unpack("ifff", buf)
            
            print("Received --------------")
            print("- temperature: ", temperature)
            print("- humidity: ", humidity)
            print("- battery: ", battery)
            print("-----------------------")
            print("")
            
            utime.sleep_ms(_RX_POLL_DELAY)

        # Give master time to get into receive mode.
        utime.sleep_ms(_SLAVE_SEND_DELAY)
        nrf.stop_listening()
        try:
            nrf.send(struct.pack("i", millis))
        except OSError:
            pass
        print("sent response")
        nrf.start_listening()

When I run both, the receiver side receives the data and seems to send a response, but on the transmitter side I continually get this:

sending...
failed, response timed out

The example file for this library works fine. I tried to compare it with my code, but I could not find the problem. What is wrong with my code?

Thanks.

[peterhinch]

Please note that the latest driver is here - this version has been tested with the Pico. The driver was moved here after the release of V1.19.

I can't see an obvious bug. I would use the latest driver. Assuming it still fails you could increase the delays and timeouts to slow the interchange down and insert print statements. This might help you see where it's going wrong.

[peterhinch]

With the latest driver your code works fine here.

You might be interested in an alternative approach. This library hides all the gory details and makes the NRF24l01 look like a stream device like a UART. You don't have to worry about packet sizes, timing, waiting for a device to change modes - you can JSON encode a Python object and send it. This file asconfig.py is shared by both radios:

from machine import SPI, Pin
# config file instantiates a RadioSetup for each end of the link
class RadioSetup:  # Configuration for an nRF24L01 radio
    channel = 97  # Necessarily shared by both instances
    tx_ms = 200  # Max ms either end waits for successful transmission

    def __init__(self, spi, csn, ce, stats=False):
        self.spi = spi
        self.csn = csn
        self.ce = ce
        self.stats = stats

config_pico = RadioSetup(SPI(0, mosi=Pin(7), miso=Pin(4), sck=Pin(6)), Pin(14), Pin(17), True)
config_master = config_pico  # Allow for the possibility that master and slave
config_slave = config_pico  # may use different hardware. Here they don't.

Your transmitter now looks like this:

# as_tx.py Test script for as_nrf_stream

# (C) Peter Hinch 2022
# Released under the MIT licence

import uasyncio as asyncio
import ujson
import time
from machine import Pin
from as_nrf_stream import Master
from asconfig import config_master  # Hardware configuration


led = Pin(25, Pin.OUT)  # Red lit during an outage.

data = {"temperature" : 83.12,  "humidity" : 54.21, "battery" : 0.87}

async def sender(device):
    swriter = asyncio.StreamWriter(device, {})
    while True:
        s = ''.join((ujson.dumps(data), '\n'))
        swriter.write(s.encode())  # convert to bytes
        await swriter.drain()
        await asyncio.sleep(2)

async def receiver(device):
    sreader = asyncio.StreamReader(device)
    while True:
        res = await sreader.readline()  # Can return b''
        if res:
            try:
                dat = ujson.loads(res)
            except ValueError:  # Extremely rare case of data corruption. See docs.
                pass
            else:
                print('Received values: {:5d} {:5d}'.format(*dat))

async def fail_detect(device):
    while True:
        if device.t_last_ms() > 5000:
            print('Remote outage')
            led.on()
            while device.t_last_ms() > 5000:
                await asyncio.sleep(1)
            print('Remote has reconnected')
            led.off()
        await asyncio.sleep(1)


async def main():
    global tstart
    tstart = time.time()
    # This line is the only *necessary* diffference between master and slave:
    device = Master(config_master)
    asyncio.create_task(sender(device))
    asyncio.create_task(receiver(device))
    await fail_detect(device)

def test():
    try:
        asyncio.run(main())
    finally:  # Reset uasyncio case of KeyboardInterrupt
        asyncio.new_event_loop()

and the receiver like this:

# as_rx.py Test script for as_nrf_stream

# (C) Peter Hinch 2022
# Released under the MIT licence

import uasyncio as asyncio
import ujson
import time
from machine import Pin
from as_nrf_stream import Slave
from asconfig import config_slave  # Hardware configuration


led = Pin(25, Pin.OUT)  # Red lit during an outage.

async def sender(device):
    ds = [0, 0]  # Data object for transmission
    swriter = asyncio.StreamWriter(device, {})
    while True:
        s = ''.join((ujson.dumps(ds), '\n'))
        swriter.write(s.encode())  # convert to bytes
        await swriter.drain()
        await asyncio.sleep(2)
        ds[0] += 1  # Record number
        ds[1] = device.t_last_ms()

async def receiver(device):
    sreader = asyncio.StreamReader(device)
    while True:
        res = await sreader.readline()  # Can return b''
        if res:
            try:
                dat = ujson.loads(res)
            except ValueError:  # Extremely rare case of data corruption. See docs.
                pass
            else:
                print("Received:", dat)

async def fail_detect(device):
    while True:
        if device.t_last_ms() > 5000:
            print('Remote outage')
            led.on()
            while device.t_last_ms() > 5000:
                await asyncio.sleep(1)
            print('Remote has reconnected')
            led.off()
        await asyncio.sleep(1)


async def main():
    global tstart
    tstart = time.time()
    # This line is the only *necessary* diffference between master and slave:
    device = Slave(config_slave)
    asyncio.create_task(sender(device))
    asyncio.create_task(receiver(device))
    await fail_detect(device)

def test():
    try:
        asyncio.run(main())
    finally:  # Reset uasyncio case of KeyboardInterrupt
        asyncio.new_event_loop()

Note that you can interrupt and restart either script and the link will be re-established.