class SPI – ett bussprotokoll för Serial Peripheral Interface (styrenhetssidan)¶

SPI är ett synkront seriellt protokoll som drivs av en styrenhet. På fysisk nivå består en buss av 3 ledningar: SCK, MOSI, MISO. Flera enheter kan dela samma buss. Varje enhet bör ha en separat, fjärde signal, CS (Chip Select), för att välja en viss enhet på en buss som kommunikationen sker med. Hanteringen av en CS-signal bör ske i användarkod (via klassen machine.Pin).

Det finns både hårdvaru- och mjukvaruimplementeringar av SPI via klasserna SPI och SoftSPI. Hårdvaru-SPI använder systemets underliggande hårdvarustöd för att utföra läsningar/skrivningar och är vanligtvis effektivt och snabbt men kan ha begränsningar i fråga om vilka stift som kan användas. Mjukvaru-SPI implementeras genom bit-banging och kan användas på vilket stift som helst men är inte lika effektivt. Dessa klasser har samma metoder tillgängliga och skiljer sig huvudsakligen i hur de konstrueras.

Exempel på användning:

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.

Konstruktorer¶

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)¶

Konstruera ett SPI-objekt på den angivna bussen, id. Värdena på id beror på en viss port och dess hårdvara. Värdena 0, 1 osv. används vanligtvis för att välja hårdvaru-SPI-block nr 0, nr 1 osv.

Utan ytterligare parametrar skapas SPI-objektet men initieras inte (det har inställningarna från den senaste initieringen av bussen, om någon). Om extra argument anges initieras bussen. Se init för initieringsparametrar.

Metoder¶

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¶

Initiera SPI-bussen med de angivna parametrarna:

baudrate är klockfrekvensen för SCK.

polarity kan vara 0 eller 1, och är den nivå som den inaktiva klockledningen ligger på.

phase kan vara 0 eller 1 för att sampla data på respektive första eller andra klockflanken.

bits är bredden i bitar för varje överföring. Endast 8 garanteras stödjas av all hårdvara.

firstbit kan vara SPI.MSB eller SPI.LSB.

sck, mosi, miso är stift (machine.Pin-objekt) som ska användas för bussignaler. För de flesta hårdvaru-SPI-block (som väljs med parametern id till konstruktorn) är stiften fasta och kan inte ändras. I vissa fall tillåter hårdvarublock 2-3 alternativa stiftuppsättningar för ett hårdvaru-SPI-block. Godtyckliga stifttilldelningar är möjliga endast för en bit-banging-SPI-drivrutin (id = -1).

I fallet med hårdvaru-SPI kan den faktiska klockfrekvensen vara lägre än den begärda baudhastigheten. Detta beror på plattformens hårdvara. Den faktiska frekvensen kan fastställas genom att skriva ut SPI-objektet.

deinit() → None¶: Stäng av SPI-bussen.

read(nbytes: int, write: int = 0x00) → bytes¶: Läs ett antal byte som anges av nbytes medan den enskilda byte som anges av write skrivs kontinuerligt. Returnerar ett bytes-objekt med de data som lästes.

readinto(buf: bytearray, write: int = 0x00) → None¶: Läs in i bufferten som anges av buf medan den enskilda byte som anges av write skrivs kontinuerligt. Returnerar None.

write(buf: bytes) → None¶: Skriv de byte som finns i buf. Returnerar None.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Skriv de byte från write_buf medan läsning sker in i read_buf. Buffertarna kan vara samma eller olika, men båda buffertarna måste ha samma längd. Returnerar None.

Konstanter¶

MSB: int¶: Skicka till firstbit för att sända/ta emot den mest signifikanta biten först (den vanligaste ordningen).

LSB: int¶: Skicka till firstbit för att sända/ta emot den minst signifikanta biten först.

class SoftSPI – mjukvaruemulerad SPI-buss¶

Klassen SoftSPI implementerar SPI genom bit-banging av godtyckliga GPIO-stift. Den exponerar samma metoduppsättning som SPI så att befintlig kod som riktar sig mot hårdvaru-SPI kan byta till mjukvara med endast en konstruktorändring. Använd den när de stift du behöver inte är kopplade till ett hårdvaru-SPI-block, när du behöver fler än de tillgängliga hårdvarubussarna, eller när en kringutrustning kräver en icke-standardiserad klockfasning som hårdvaran inte kan producera.

Konstruktorer¶

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)¶

Konstruera ett mjukvaru-SPI-objekt. sck, mosi och miso måste anges – det finns inget implicit stiftval. Se SPI.init() för betydelsen av de övriga parametrarna. Standardvärdet för baudrate är lägre än för hårdvaru-SPI eftersom bit-bang-loopen har mer omkostnad.

Metoder¶

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¶: Återinitiera mjukvaru-SPI-bussen med de angivna parametrarna. Endast de argument som anges uppdateras; de övriga behåller sina tidigare värden. Se SPI.init() för betydelsen av varje argument.

deinit() → None¶: Frigör de GPIO-stift som bit-bang-drivrutinen gjort anspråk på och sluta driva bussen.

read(nbytes: int, write: int = 0x00) → bytes¶: Läs nbytes byte medan den enskilda byte write skrivs kontinuerligt. Returnerar ett bytes-objekt som innehåller de mottagna data.

readinto(buf: bytearray, write: int = 0x00) → None¶: Läs in i buf medan den enskilda byte write skrivs kontinuerligt. Returnerar None.

write(buf: bytes) → None¶: Skriv buf till bussen. Mottagna byte kastas bort.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Skriv samtidigt write_buf och läs in i read_buf. Båda buffertarna måste ha samma längd; de får överlappa.

Konstanter¶

MSB: int¶: Skicka till firstbit för att sända/ta emot den mest signifikanta biten först.

LSB: int¶: Skicka till firstbit för att sända/ta emot den minst signifikanta biten först.