class SPI – een Serial Peripheral Interface-busprotocol (controllerzijde)¶

SPI is een synchroon serieel protocol dat door een controller wordt aangestuurd. Op fysiek niveau bestaat een bus uit 3 lijnen: SCK, MOSI, MISO. Meerdere apparaten kunnen dezelfde bus delen. Elk apparaat moet een afzonderlijk, 4e signaal hebben, CS (Chip Select), om een bepaald apparaat op een bus te selecteren waarmee de communicatie plaatsvindt. Het beheer van een CS-signaal moet in gebruikerscode gebeuren (via de machine.Pin-klasse).

Er bestaan zowel hardware- als software-SPI-implementaties via de klassen SPI en SoftSPI. Hardware-SPI gebruikt de onderliggende hardware-ondersteuning van het systeem om de lees-/schrijfacties uit te voeren en is meestal efficiënt en snel, maar kan beperkingen hebben op welke pinnen kunnen worden gebruikt. Software-SPI wordt geïmplementeerd door bit-banging en kan op elke pin worden gebruikt, maar is niet zo efficiënt. Deze klassen hebben dezelfde methoden beschikbaar en verschillen voornamelijk in de manier waarop ze worden geconstrueerd.

Voorbeeldgebruik:

from machine import SPI, Pin

spi = SPI(0, baudrate=400000)           # Create SPI peripheral 0 at frequency of 400kHz.
                                        # Depending on the use case, extra parameters may be required
                                        # to select the bus characteristics and/or pins to use.
cs = Pin(4, mode=Pin.OUT, value=1)      # Create chip-select on pin 4.

try:
    cs(0)                               # Select peripheral.
    spi.write(b"12345678")              # Write 8 bytes, and don't care about received data.
finally:
    cs(1)                               # Deselect peripheral.

try:
    cs(0)                               # Select peripheral.
    rxdata = spi.read(8, 0x42)          # Read 8 bytes while writing 0x42 for each byte.
finally:
    cs(1)                               # Deselect peripheral.

rxdata = bytearray(8)
try:
    cs(0)                               # Select peripheral.
    spi.readinto(rxdata, 0x42)          # Read 8 bytes inplace while writing 0x42 for each byte.
finally:
    cs(1)                               # Deselect peripheral.

txdata = b"12345678"
rxdata = bytearray(len(txdata))
try:
    cs(0)                               # Select peripheral.
    spi.write_readinto(txdata, rxdata)  # Simultaneously write and read bytes.
finally:
    cs(1)                               # Deselect peripheral.

Constructors¶

class machine.SPI(id: int, baudrate: int = 1000000, *, polarity: int = 0, phase: int = 0, bits: int = 8, firstbit: int = MSB, sck: Pin | None = None, mosi: Pin | None = None, miso: Pin | None = None)¶

Construeert een SPI-object op de gegeven bus, id. Waarden van id zijn afhankelijk van een bepaalde port en de hardware ervan. Waarden 0, 1, enz. worden vaak gebruikt om hardware-SPI-blok #0, #1, enz. te selecteren.

Zonder aanvullende parameters wordt het SPI-object aangemaakt maar niet geïnitialiseerd (het heeft de instellingen van de laatste initialisatie van de bus, indien aanwezig). Als er extra argumenten worden gegeven, wordt de bus geïnitialiseerd. Zie init voor de parameters van de initialisatie.

Methods¶

init(baudrate: int = 1000000, *, polarity: int = 0, phase: int = 0, bits: int = 8, firstbit: int = SPI.MSB, sck: Pin | None = None, mosi: Pin | None = None, miso: Pin | None = None) → None¶

Initialiseert de SPI-bus met de gegeven parameters:

baudrate is de SCK-kloksnelheid.

polarity kan 0 of 1 zijn, en is het niveau waarop de inactieve kloklijn zich bevindt.

phase kan 0 of 1 zijn om gegevens respectievelijk op de eerste of tweede klokflank te bemonsteren.

bits is de breedte in bits van elke transfer. Alleen 8 wordt gegarandeerd door alle hardware ondersteund.

firstbit kan SPI.MSB of SPI.LSB zijn.

sck, mosi, miso zijn pin-objecten (machine.Pin) die voor de bussignalen worden gebruikt. Voor de meeste hardware-SPI-blokken (zoals geselecteerd door de id-parameter aan de constructor) zijn de pinnen vast en kunnen ze niet worden gewijzigd. In sommige gevallen staan hardwareblokken 2-3 alternatieve pinsets toe voor een hardware-SPI-blok. Willekeurige pintoewijzingen zijn alleen mogelijk voor een bitbanging-SPI-stuurprogramma (id = -1).

In het geval van hardware-SPI kan de werkelijke klokfrequentie lager zijn dan de gevraagde baudrate. Dit is afhankelijk van de platformhardware. De werkelijke snelheid kan worden bepaald door het SPI-object af te drukken.

deinit() → None¶: Schakelt de SPI-bus uit.

read(nbytes: int, write: int = 0x00) → bytes¶: Leest een aantal bytes zoals opgegeven door nbytes terwijl er continu de enkele byte wordt geschreven die door write is gegeven. Geeft een bytes-object terug met de gelezen gegevens.

readinto(buf: bytearray, write: int = 0x00) → None¶: Leest in de buffer die door buf is opgegeven terwijl er continu de enkele byte wordt geschreven die door write is gegeven. Geeft None terug.

write(buf: bytes) → None¶: Schrijft de bytes die in buf zitten. Geeft None terug.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Schrijft de bytes uit write_buf terwijl er in read_buf wordt gelezen. De buffers kunnen hetzelfde of verschillend zijn, maar beide buffers moeten dezelfde lengte hebben. Geeft None terug.

Constants¶

MSB: int¶: Geef dit door aan firstbit om de meest significante bit eerst te verzenden/ontvangen (de meest voorkomende volgorde).

LSB: int¶: Geef dit door aan firstbit om de minst significante bit eerst te verzenden/ontvangen.

class SoftSPI – softwarematig geëmuleerde SPI-bus¶

De klasse SoftSPI implementeert SPI door willekeurige GPIO-pinnen te bit-bangen. Het stelt hetzelfde methodeoppervlak beschikbaar als SPI, zodat bestaande code die op hardware-SPI is gericht met alleen een wijziging in de constructor naar software kan overschakelen. Gebruik het wanneer de pinnen die je nodig hebt niet aan een hardware-SPI-blok zijn bedraad, wanneer je meer dan de beschikbare hardwarebussen nodig hebt, of wanneer een randapparaat een niet-standaard klokfasering vereist die de hardware niet kan produceren.

Constructors¶

class machine.SoftSPI(baudrate: int = 500000, *, polarity: int = 0, phase: int = 0, bits: int = 8, firstbit: int = MSB, sck: Pin | None = None, mosi: Pin | None = None, miso: Pin | None = None)¶

Construeert een software-SPI-object. sck, mosi en miso moeten worden opgegeven – er is geen impliciete pinselectie. Zie SPI.init() voor de betekenis van de overige parameters. De standaard baudrate is lager dan voor hardware-SPI omdat de bit-bang-lus meer overhead heeft.

Methods¶

init(baudrate: int = 500000, *, polarity: int = 0, phase: int = 0, bits: int = 8, firstbit: int = SoftSPI.MSB, sck: Pin | None = None, mosi: Pin | None = None, miso: Pin | None = None) → None¶: Herinitialiseert de software-SPI-bus met de gegeven parameters. Alleen de opgegeven argumenten worden bijgewerkt; de overige behouden hun vorige waarden. Zie SPI.init() voor de betekenis van elk argument.

deinit() → None¶: Geeft de GPIO-pinnen vrij die door het bit-bang-stuurprogramma in beslag zijn genomen en stopt met het aansturen van de bus.

read(nbytes: int, write: int = 0x00) → bytes¶: Leest nbytes bytes terwijl er continu de enkele byte write wordt geschreven. Geeft een bytes-object terug met de ontvangen gegevens.

readinto(buf: bytearray, write: int = 0x00) → None¶: Leest in buf terwijl er continu de enkele byte write wordt geschreven. Geeft None terug.

write(buf: bytes) → None¶: Schrijft buf naar de bus. Ontvangen bytes worden weggegooid.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Schrijft tegelijkertijd write_buf en leest in read_buf. Beide buffers moeten dezelfde lengte hebben; ze mogen aliassen zijn.

Constants¶

MSB: int¶: Geef dit door aan firstbit om de meest significante bit eerst te verzenden/ontvangen.

LSB: int¶: Geef dit door aan firstbit om de minst significante bit eerst te verzenden/ontvangen.