CircuitPython on nRF52840 with RFM9x (LoRa) and an SD card sharing the same SPI bus.

[muhammadawais92]

Issue

I’m using CircuitPython on nRF52840 with RFM9x (LoRa) and an SD card sharing the same SPI bus, stacked all boards one another.

My device behaves like a Class C gateway:

• LoRa is in continuous receive mode (receive(timeout=0.1))
• Incoming sensor data is queued and logged to an SD card
• I tried to use separate SPI buses, but it gives the error "SPI in USE."

SD writes frequently fail with:
OSError: [Errno 5] Input/output error

This happens even when:

• Logs are queued in RAM
• SD writes are retried later
• spi.try_lock() / spi.unlock() are used

It appears that the LoRa radio accesses SPI so frequently that the SD card never gets a clean window.

---

Question

What is the recommended approach in CircuitPython to safely share SPI between:

• A continuously listening RFM9x
• An SD card used for logging?

Specifically:

• Should LoRa RX be temporarily stopped while writing to SD?
• Is batching SD writes required?
• Is there a known SPI access pattern or timing strategy for this case?

---

Context

This project is a LoRa controller/gateway that must:

• Always listen for packets (Class C–like behavior)
• Reliably log data to an SD card

Any guidance or best practices would be appreciated.

Below is my code:

import time
import board
import busio
import digitalio
import adafruit_rfm9x
import adafruit_ssd1306
import neopixel
import json
import storage
import adafruit_sdcard
import os
from adafruit_pcf8523.pcf8523 import PCF8523
from collections import deque

# ----------------------------
# LoRa setup
# ----------------------------
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
cs = digitalio.DigitalInOut(board.D11)
reset = digitalio.DigitalInOut(board.D12)
rfm9x = adafruit_rfm9x.RFM9x(spi, cs, reset, 433.0)

# ----------------------------
# OLED setup
# ----------------------------
i2c = busio.I2C(board.SCL, board.SDA)
oled = adafruit_ssd1306.SSD1306_I2C(128, 32, i2c)

# ----------------------------
# NeoPixel setup
# ----------------------------
pixels = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.3)
pixels.fill((0,0,0))

# ----------------------------
# Buttons setup
# ----------------------------
button_a = digitalio.DigitalInOut(board.D9)
button_a.switch_to_input(pull=digitalio.Pull.UP)
button_b = digitalio.DigitalInOut(board.D6)
button_b.switch_to_input(pull=digitalio.Pull.UP)
button_c = digitalio.DigitalInOut(board.D5)
button_c.switch_to_input(pull=digitalio.Pull.UP)

# ----------------------------
# SD Card setup
# ----------------------------
SD_CS = board.D10
cs_sd = digitalio.DigitalInOut(SD_CS)
sdcard = adafruit_sdcard.SDCard(spi, cs_sd)
vfs = storage.VfsFat(sdcard)
storage.mount(vfs, "/sd")

csv_file = "/sd/waste_controller_logs.csv"
if "waste_controller_logs.csv" not in os.listdir("/sd"):
    with open(csv_file, "w") as f:
        f.write("Timestamp,Fill,Temperature,Humidity,Period_Sent,ACK_Received\n")
    print(f"[INFO] Created log file: {csv_file}")

# ----------------------------
# RTC setup
# ----------------------------
rtc = PCF8523(i2c)
def get_timestamp():
    t = rtc.datetime
    return "{:04}-{:02}-{:02} {:02}:{:02}:{:02}".format(
        t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec
    )

# ----------------------------
# Logging queue
# ----------------------------
LOG_QUEUE_MAX = 100
log_queue = []

def queue_log(period_sent=None, ack=None):
    ts = get_timestamp()
    log_line = f"{ts},{fill},{temperature},{humidity},{period_sent if period_sent else ''},{ack if ack else ''}"
    log_queue.append(log_line)
    print(f"[QUEUE] {log_line}")
    print(f"[QUEUE LENGTH] {len(log_queue)}")

def flush_log_queue():
    """Attempt to write queued logs to SD card sequentially"""
    while log_queue:
        line = log_queue[0]  # peek first item
        try:
            print(f"confirming sd write")
            with open(csv_file, "a") as f:
                print(f"confirming sd file open")
                f.write(line + "\n")
            print(f"[LOG] {line}")
            log_queue.pop(0)  # remove after successful write
        except OSError as e:
            print(f"SD write failed, will retry: {e}")
            break  # stop on first failure to retry later

# ----------------------------
# State variables
# ----------------------------
mode = "MAIN"               
current_period = 5           
pending_period = 5           
waiting_for_ack = False
last_cmd_time = 0
RETRY_INTERVAL = 3           

last_button_check = 0
BUTTON_INTERVAL = 0.1        

fill = 0
temperature = 0
humidity = 0

temp_message = ""      
temp_message_end = 0

# ----------------------------
# Helper functions
# ----------------------------
def update_led(fill):
    if fill < 35:
        pixels.fill((0,255,0))
    elif fill < 80:
        pixels.fill((255,150,0))
    else:
        pixels.fill((255,0,0))

def update_oled():
    oled.fill(0)
    oled.text(f"P:{current_period}s", 0, 0, 1)
    if mode=="SET_PERIOD":
        oled.text(f"SET:{pending_period}s", 64, 0, 1)
    oled.text(f"F:{fill}%", 0, 12, 1)
    oled.text(f"T:{temperature}C", 42, 12, 1)
    oled.text(f"H:{humidity}%", 84, 12, 1)
    if time.monotonic() < temp_message_end:
        oled.text(temp_message, 0, 22, 1)
    oled.show()

def send_period_command():
    global temp_message, temp_message_end, last_cmd_time
    msg = {"type":"SET_PERIOD","period":pending_period}
    rfm9x.send(json.dumps(msg).encode())
    print("SET_PERIOD sent:", pending_period)
    temp_message = f"SET_PERIOD sent: {pending_period}"
    temp_message_end = time.monotonic() + 3
    last_cmd_time = time.monotonic()
    queue_log(period_sent=pending_period)

# ----------------------------
# Main loop
# ----------------------------
try:
    while True:
        now = time.monotonic()

        # ---- Buttons (non-blocking) ----
        if now - last_button_check > BUTTON_INTERVAL:
            last_button_check = now

            if not button_a.value:
                mode = "SET_PERIOD" if mode=="MAIN" else "MAIN"
                time.sleep(0.2)

            if not button_b.value and mode=="SET_PERIOD":
                pending_period += 5
                if pending_period > 30:
                    pending_period = 5
                time.sleep(0.2)

            if not button_c.value and mode=="SET_PERIOD":
                waiting_for_ack = True
                last_cmd_time = 0
                send_period_command()
                time.sleep(0.2)

        # ---- Retry SET_PERIOD if waiting for ACK ----
        if waiting_for_ack and (now - last_cmd_time > RETRY_INTERVAL):
            send_period_command()

        # ---- Receive LoRa packets ----
        packet = rfm9x.receive(timeout=0.1)
        if packet:
            try:
                data = json.loads(packet.decode())
                if data["type"]=="DATA":
                    fill = data["fill"]
                    temperature = data["temperature"]
                    humidity = data["humidity"]
                    update_led(fill)
                    queue_log()  # log regular sensor data
                elif data["type"]=="ACK":
                    if data["period"] == pending_period:
                        current_period = pending_period
                        waiting_for_ack = False
                        temp_message = "ACK received"
                        temp_message_end = time.monotonic() + 3
                        print("ACK received")
                        queue_log(ack=current_period)
            except Exception as e:
                print("Decode error:", e)

        # ---- Flush queued logs to SD ----
        flush_log_queue()

        # ---- Update OLED ----
        update_oled()

except KeyboardInterrupt:
    oled.fill(0)
    oled.show()
    pixels.fill((0,0,0))
    print("Program stopped, OLED cleared.")

[bablokb]

It appears that the LoRa radio accesses SPI so frequently that the SD card never gets a clean window.

This is a wrong assumption. The LoRa radio does not access the SPI-bus. It is the MCU (or to be more specific: your program running on the MCU) that is in charge of the SPI-bus. The program pulls the CS-line of the respective device low when it wants to talk to that device. So while you are busy with the SD-card, the LoRa radio is not into play.

One thing you should know when sharing SPI: make sure that you have weak pullups on the CS-lines. This is only relevant during initial setup, since while setting up the first device the CS of the second could be floating and the second device might receive wrong commands. A workaround I used for hardware which I don't control myself: add a digitalio with pullup for the CS of the second device. Then initiate the first device, deinit the digitalio you just created and then initiate the second device.

Things to try: use a different SD-card, use a different card-reader. Check powering. There are a lot of issues with SD-cards that can be tracked down to power.

[muhammadawais92]

@bablokb I tried your suggestion for setting CS with pullups, but it still fails. It enters the loop and opens the file, but on "f.write ()", it throws the error.

    with open("/sd/waste_controller_logs.csv", "a") as f:
        while log_queue:
            f.write(log_queue.pop() + "\n")

Error;

 [SD ERROR] [Errno 5] Input/output error

I have attached the LoRa RX side of my setup for your review. TX is only nrf42840 with RFM9x, which is working fine. The RX setup is working fine without Addalogger. And if I only use nrf52840 and Addalogger together, the file read/write/append works fine, which ensures the card id Ok, and file creation/read/write/append works fine.

[muhammadawais92]

@dhalbert can you provide some suggestions on this? Thank you.

[muhammadawais92]

@bablokb I am not sure about the power issues and how to track them because i dont have access to any stuff to confirm it. I just have this hardware stuff with me.

[bablokb]

You are powering a lot of stuff from the 3V3-pin of your MCU: LoRa-chip, OLED, Adalogger. Check the datasheet of your NRF on how much peak it provides. And as far as I know, the Adalogger does not have a bypass cap for the SD-slot. So I would still guess it is a power issue. But this is hard to diagnose from far away.

[dhalbert]

The nRF52840 has three possible SPI buses. You can create another busio.SPI() on different pins, so the Adalogger and the RFM use different buses. But as @bablokb notes, it is not clear there is any contention for the bus.

The bus operations are blocking.

[dhalbert]

I also think there is a small possibility there is some radio interference to the data lines going to the Adalogger. There is some transmitting going on in the LoRa protocol.

[bablokb]

True, and a second device on the bus adds capacitance and the signals might deteriorate.

@muhammadawais92 : you could try to lower the bus-speed as well. Ruling out bus-issues by using a second bus is a good first approach.

BTW: I am using the Adafruit LoRa-RFM95x-Bonnet (which also has an OLED-display) together with a Pico-2W and a SD-card socket. The SD-card and the LoRa are on the same bus. So the setup is very similar, even the software boils down to basically the same logic. One difference is that the buck-boost converter of the Pico-2W has some more headroom than the regulator on the NRF (but this is partly speculating, since I don't know which exact device you have).

[muhammadawais92]

@bablokb I also believe it to be some interference on the port due to added capacitance/radio interference. I am still figuring out the way around, btw, I am using the following NRF. Thanks for your valuable advice.

https://www.adafruit.com/product/4516

[bablokb]

The regulator of that NRF should be ok, it provides 600mA peak and you are far below. But load transients could still be a problem.

You will have to experiment a bit and try to change various things. Please replace adafruit_sdcard with sdcardio. Try to get the second spi-bus working. Change the bus-speed. Maybe change the stacking. Put the radio into sleep-mode before flushing data to the sd-card (not a good idea for productive use, but for testing).

[muhammadawais92]

@bablokb I tried the different solutions. Even putting the radio to sleep did not solve the issue. As long as I remove the RFM9x and use adalogger with nrf52840 (just to check everything is working fine), the read/write to sd card works normally. Tried sdcardio, changed the bus speed, but nothing worked. Also changed the stacking order.

SD write failed, will retry: [Errno 5] Input/output error: /waste_controller_logs.csv