How to restore the settings of SPI interface?

[mishal]

I have a SPI device connected to my RPI Pico (rfm transciever). The user may connect another SPI device which may use different SPI settings (baudrate...).

When communicating with the specific module, I may have to setup different baudrate. I came with an idea to have SPI context manager which would revert SPI settings back as they were before using the SPI interface... Something like:

with SpiContext(spi, baudrate=100_000) as _:
    spi.write(b"something")

I'm hw newbie so please be kind to me :) I saw that several drivers in Arduino are doing this like: https://github.com/sparkfun/RFM69HCW_Breakout/blob/master/Libraries/Arduino/RFM69/RFM69.cpp#L440

The micropython library for SDCard (https://github.com/micropython/micropython-lib/blob/master/micropython/drivers/storage/sdcard/sdcard.py#L56) seems to just reconfigure the interface and leave it that way.

What is the recommended practice for this?

I tried to implement the context manager, but realized that:

1. there is no access to SPI properties /properties do not exist nor any methods to get the values/ of initialized object (baudrate, polarity, phase...)
2. I tried to extract the settings from str representation of spi (str(spi)), but the firstbit info is missing: SPI(1, baudrate=122070, polarity=0, phase=0, bits=8, sck=10, mosi=11, miso=8) - is the information about the firstbit missing on purpose or is it a bug?

The firstbit is not supported as per #11404 Can this be related?

from machine import SPI, Pin
import re

_BAUDRATE_REGEX = re.compile("baudrate=(\d+)")
_POLARITY_REGEX = re.compile("polarity=(\d)")
_PHASE_REGEX = re.compile("phase=(\d)")
_BITS_REGEX = re.compile("bits=(\d)")
# not used
# _FIRST_BIT_REGEX = re.compile("firstbit=(\d)")


class SPIContext:
    def __init__(self, spi: SPI, baudrate=None, polarity=None, phase=None):
        self.spi = spi

        self.baudrate = baudrate
        self.polarity = polarity
        self.phase = phase

    def __enter__(self):
        # FIXME: there is no direct access to original attributes, this hack retrieves it from str representation of the object
        # The firstbit is missing in the str() of SPI object
        # SPI(1, baudrate=122070, polarity=0, phase=0, bits=8, sck=10, mosi=11, miso=8)
        _repr = str(self.spi)

        self.baudrate_current = int(_BAUDRATE_REGEX.search(_repr).group(1))
        self.polarity_current = int(_POLARITY_REGEX.search(_repr).group(1))
        self.phase_current = int(_PHASE_REGEX.search(_repr).group(1))

        print("ENTER")
        print(_repr)
        print("baudrate", self.baudrate_current)
        print("polarity", self.polarity_current)
        print("phase", self.phase_current)

        self.spi.deinit()
        self.spi.init(
            baudrate=self.baudrate if self.baudrate is not None else self.baudrate_current,
            polarity=self.polarity if self.polarity is not None else self.polarity_current,
            phase=self.phase if self.phase is not None else self.phase_current,
        )

        print("ENTER REINIT")
        print(str(self.spi))

        return None

    def __exit__(self, exc_type, exc_val, exc_tb):

        self.spi.deinit()
        self.spi.init(
            baudrate=self.baudrate_current,
            polarity=self.polarity_current,
            phase=self.phase_current
        )

        print("EXIT CONTEXT")
        print(str(self.spi))


spi = SPI(1, sck=Pin(10), mosi=Pin(11), miso=Pin(8), baudrate=100_000,)

with SPIContext(spi, baudrate=10000) as _:
    print(dir(spi))
    spi.write(b"1")

Another approach may be to setup the required SPI settings right before using it and leave it in this state, but this looks incomplete to me.

How do you guys deal with this?

Thank you

[scruss]

There are a couple of attempts at an RFM69 library already out there:

• arkorobotics/rfm69-micropython: Micropython library for the RFM69 - rather old, and may have a lot of pyboard dependencies
• PicoW with RFM69 library compatible with LowPower Labs - Raspberry Pi Forums
• nohcpy/MicroPython_RFM69: CircuitPython module for the RFM69 series of 433/915 mhz packet radios. - despite it saying CircuitPython, this one is for MicroPython

[mishal]

Thanks for the links... I'm playing with the last one :)

My question was more about the common usage of SPI bus (in context of asyncio)

I have a task which speaks to the radio module and another task with the sd card. In my undestanding of the code, the SPI bus baudrate is changed (by sd card driver) and never reverted back. The RFM driver just don't care that the baudrate (or other properties) may be different in the next call...

Circuitpython tutorial states:

The busio.SPI.configure() function is called to configure the speed, phase, and polarity of the SPI bus. It’s important to always call configure after locking the bus and before talking to your device as communication with other devices might have changed the speed, polarity, etc. You’ll need to look up the exact speed and other values from your device’s datasheet. For the MAX31855 we’ll use a speed of 5mhz and a polarity and phase of 0 (sometimes called mode 0). Taken from: https://learn.adafruit.com/circuitpython-basics-i2c-and-spi/spi-devices

That took me to the idea of the context manager (above)...

[peterhinch]

@mishal There are a number of ways of approaching this. One approach I use is that a device driver constructor takes a 2-tuple arg. Elements are as follows:

1. The initialised SPI bus instance.
2. A dict containing init args e.g. {"baudrate": 1_000_000, "polarity": 1}

Whenever the device driver needs to use the SPI it does something like

spi = arb[0]
spi.init(**arb[1])  # Init works fine with a subset of args
cs(0)  # Assert the CS\ line (possibly after a brief delay)
# Do the transfers
cs(1)

I don't interrogate the SPI bus as every device "knows" what settings it needs.

[mishal]

thanks, simple and straightforward.