SD Card and LoRa module on same SPI bus

[B00mb0x]

Hi,
i am using an ESP32-S3-WROOM-1 with Micropython v1.20.0. I have a custom made PCB with a LoRa Module (AI-Thinker Ra-01H) and an SD card on the same SPI bus. The used pins are:
cs_lora=21
cs_sd=10
sck=12
mosi=11
miso=13
Both modules on their own work, however if I want to use both in the same code, I get some Errors.

I made some Testcode to illustrate the issue:

from machine import Pin, SDCard
from ulora import uLoRa, TTN
import machine
import uos
import array

#SPI pins
cs_lora = Pin(21, Pin.OUT, value=1)
cs_sd = Pin(10, Pin.OUT, value=1)
sck_pin = machine.Pin(12)
mosi_pin = machine.Pin(11)
miso_pin = machine.Pin(13)

# Setup LoRaWAN
# LoRaWAN device address, 4 Bytes, MSB (REPLACE WITH YOUR OWN!!!)
LoRaWAN_DEVADDR = bytearray([0x00, 0x00, 0x00, 0x00])
# LoRaWAN network session key, 16 Bytes, MSB (REPLACE WITH YOUR OWN!!!)
LoRaWAN_NWKEY = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
# LoRaWAN application session key, 16 Bytes, MSB (REPLACE WITH YOUR OWN!!!)
LoRaWAN_APP = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
LoRaWAN_CONFIG = TTN(LoRaWAN_DEVADDR, LoRaWAN_NWKEY, LoRaWAN_APP, country="EU")

#set datarate
LORA_DATARATE = "SF10BW125"

#Message
msg = bytes(array.array('f', [420.0, 10.01, 53.5, 8.5, 12.77, 22.15])) + bytes(array.array('i', [1695039826]))

state = 1

if state == 1:
    #setup sd
    sd = SDCard(slot=3, sck=12, miso=13, mosi=11, cs=10, freq=200_000)
    uos.mount(sd, '/sd')

    #setup lorawan
    lorawan = uLoRa(
        cs=21,
        sck=12,
        mosi=11,
        miso=13,
        irq=45,
        rst=46,
        ttn_config=LoRaWAN_CONFIG,
        datarate=LORA_DATARATE,
        fport=1
    )

    #send message
    lorawan.send_data(msg, len(msg), lorawan.frame_counter)
    lorawan.frame_counter += 1

    #test sd card
    with open('/sd/sdtest.txt', 'a') as f:
        f.write("This is just a test transmission\n")
    with open('/sd/sdtest.txt', 'r') as f:
        print(f.read())

    lorawan.spi_deinit()
    uos.umount('/sd')
    sd.deinit()

if state == 2:
    #setup sd
    sd = SDCard(slot=3, sck=12, miso=13, mosi=11, cs=10, freq=200_000)
    uos.mount(sd, '/sd')

    #test sd card
    with open('/sd/sdtest.txt', 'a') as f:
        f.write("This is just a test transmission\n")
    with open('/sd/sdtest.txt', 'r') as f:
        print(f.read())

    #deinit sd
    uos.umount('/sd')
    sd.deinit()

    #setup lorawan
    lorawan = uLoRa(
        cs=21,
        sck=12,
        mosi=11,
        miso=13,
        irq=45,
        rst=46,
        ttn_config=LoRaWAN_CONFIG,
        datarate=LORA_DATARATE,
        fport=1
    )

    #send message
    lorawan.send_data(msg, len(msg), lorawan.frame_counter)
    lorawan.frame_counter += 1

    #deinit
    lorawan.spi_deinit()

sd = SDCard(slot=3, sck=12, miso=13, mosi=11, cs=10, freq=200_000)
uos.mount(sd, '/sd')
uos.remove('/sd/sdtest.txt')
uos.umount('/sd')

I used the uLoRa library (https://github.com/fantasticdonkey/uLoRa) and added the spi_init() and spi_deinit() functions:

    def spi_init(self):
        self._device = machine.SPI(1,
            baudrate=200_000,
            polarity=0,
            phase=0,
            sck=self.sck_pin,
            mosi=self.mosi_pin,
            miso=self.miso_pin
        )

    def spi_deinit(self):
        self._device.deinit()

In state 1 the message is sent properly, but communication with the sd card doesn't work. Output:

PHYPayload b'406f5cca010000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
PHYPayload with FRMPayload b'406f5cca01000000016d9637937d0b972f0c4e9c5e1830c79866d7351d64e5c19f554147c2000000000000000000000000000000000000000000000000000000'
PHYPayload with FRMPayload + MIC b'406f5cca01000000016d9637937d0b972f0c4e9c5e1830c79866d7351d64e5c19f554147c2fb8415c60000000000000000000000000000000000000000000000'
E (1030) sdmmc_cmd: sdmmc_read_sectors_dma: sdmmc_send_cmd returned 0x107
E (1030) sdmmc_cmd: sdmmc_write_sectors_dma: sdmmc_send_cmd returned 0x105
E (1040) sdmmc_cmd: sdmmc_read_sectors_dma: sdmmc_send_cmd returned 0x107
E (1040) sdmmc_cmd: sdmmc_write_sectors_dma: sdmmc_send_cmd returned 0x105
E (1050) sdmmc_cmd: sdmmc_write_sectors_dma: sdmmc_send_cmd returned 0x105
E (1060) sdmmc_cmd: sdmmc_write_sectors_dma: sdmmc_send_cmd returned 0x105
E (1070) sdmmc_cmd: sdmmc_read_sectors_dma: sdmmc_send_cmd returned 0x107
E (1070) sdmmc_cmd: sdmmc_write_sectors_dma: sdmmc_send_cmd returned 0x105
E (1080) sdmmc_cmd: sdmmc_write_sectors_dma: sdmmc_send_cmd returned 0x105
E (1090) sdmmc_cmd: sdmmc_read_sectors_dma: sdmmc_send_cmd returned 0x107
Traceback (most recent call last):
  File "main.py", line 56, in <module>
OSError: [Errno 2] ENOENT

In state 2 everything works as expected, but it feels hacky.
I think the main issue is that in state 1 the LoRa library occupies the SPI bus and does not allow communication with the sd card. Is there a way to get the SPI object back from the SDCard function so I can hand it over to the LoRa library?
Thanks in advance and sorry for the long post.

[peterhinch]

This is puzzling because electrically an SPI peripheral should never hold the bus. The CS, SCK and TX pins are host outputs. The only pin that the peripheral can grab is RX, and it should never do so if CS is False, to allow bus sharing.

I would examine the Lora driver (or put a meter/scope on the CS line) to make sure the driver is deasserting CS after a transmission. If it's not, maybe you can force it to by issuing lorawan.spi_deinit(); you could try issuing that prior to accessing the SD card. If the driver is deasserting CS and the hardware is still holding on to RX, then the hardware is suspect.

[B00mb0x]

I looked at it with an oscilloscope last week and the cs pins were both deasserted after transmission and the sd card setup also looked fine to me.

I tried running the code above again, but changing the SPI id in the LoRa library to 2 self._device = machine.SPI(2,... this time I got the error:

E (970) spi: spi_bus_initialize(756): SPI bus already initialized.
Traceback (most recent call last):
  File "main.py", line 37, in <module>
  File "/lib/ulora.py", line 120, in __init__
  File "/lib/ulora.py", line 177, in spi_init
OSError: SPI host already in use

So what I think happens in the example I posted is sd = SDCard(slot=3, sck=12, miso=13, mosi=11, cs=10, freq=200_000) initializes spi bus 2.
Then the LoRa library initializes spi bus 1 at the same pins in line self._device = machine.SPI(1,....
Then the LoRa transmission works without any issues, but the sd card access fails, because spi bus 1 overwrote the access to the pins of spi bus 2.
Is there any way for me initialize both devices at the same spi bus? For example by either creating the spi object in my main code and handing it over to machine.SDCard or by returning the created spi object from machine.SDCard?

[amitrao17]

Hi,
Were you able to solve this problem more cleanly? I have the same problem (haven't figured out a workaround) using the M5 Core2 which has an ESP32, and an RA-01H module, although I'm using Arduino currently. I haven't probed the board yet, but based on what you found above, it's a software problem. One way to get around this would be to move the RA-01H interface to completely different pins but that would be a shame and require some surgery in my setup.
Thanks!

[B00mb0x]

It seems that you can't initialize the same SPI bus twice. So you would have to put the SD card on a different SPI bus or even use the SD protocol to use the built-in library. Since this wasn't an option, I decided to use the Micropython SD library: https://github.com/micropython/micropython-lib/blob/master/micropython/drivers/storage/sdcard/sdcard.py. This way it was possible to create a single SPI object and share it with the LoRaWAN library and the SD card library. In the next hardware revision, I will use the SD protocol instead of SPI to save flash by using an external library.

[mendenm]

@B00mb0x Could you try out the PR for my updated SD driver:
micropython/micropython-lib#765
It should work more efficiently than the default one, and also just gets more testing done on this code base. This should be compatible with a wide variety of SD cards, and be a little faster than the standard one.

[amitrao17]

I hate when this happens, but now SD and LoRa are both working and I can't get it back to the broken state any more (so I can confirm that what I changed in the code made the difference).

My suspicion is that the CS pin of the SD card was not explicitly called out, and somehow when there was only one slave on the bus there was no problem, but when there were two, it broke. When I explicitly called out which pin to use as the CS in the SD.begin(4, SPI, 4000000, "/sd", 5, false); call, it started to work, but now when I use the defaults SD_begin() it still works.

Maybe I did something else different.

Bottom line is that, at least for arduino, it didn't work initially, but it can work; I may try microPython at some point.