class SPI – un protocol de magistrală Serial Peripheral Interface (partea de controler)¶

SPI este un protocol serial sincron condus de un controler. La nivel fizic, o magistrală constă din 3 linii: SCK, MOSI, MISO. Mai multe dispozitive pot partaja aceeași magistrală. Fiecare dispozitiv ar trebui să aibă un al patrulea semnal separat, CS (Chip Select), pentru a selecta un anumit dispozitiv de pe magistrală cu care are loc comunicarea. Gestionarea unui semnal CS ar trebui să se realizeze în codul utilizatorului (prin clasa machine.Pin).

Există implementări SPI atât hardware, cât și software, prin clasele SPI și SoftSPI. SPI hardware utilizează suportul hardware subiacent al sistemului pentru a efectua citirile/scrierile și este de obicei eficient și rapid, dar poate avea restricții privind pinii care pot fi folosiți. SPI software este implementat prin bit-banging și poate fi folosit pe orice pin, dar nu este la fel de eficient. Aceste clase au aceleași metode disponibile și diferă în principal prin modul în care sunt construite.

Exemplu de utilizare:

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.

Constructori¶

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

Construiește un obiect SPI pe magistrala dată, id. Valorile lui id depind de un anumit port și de hardware-ul său. Valorile 0, 1 etc. sunt utilizate frecvent pentru a selecta blocul SPI hardware #0, #1 etc.

Fără parametri suplimentari, obiectul SPI este creat, dar nu este inițializat (are setările de la ultima inițializare a magistralei, dacă există). Dacă sunt furnizate argumente suplimentare, magistrala este inițializată. Consultați init pentru parametrii de inițializare.

Metode¶

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¶

Inițializează magistrala SPI cu parametrii dați:

baudrate este rata de ceas SCK.

polarity poate fi 0 sau 1 și reprezintă nivelul la care se află linia de ceas în repaus.

phase poate fi 0 sau 1 pentru a eșantiona datele pe primul, respectiv pe al doilea front de ceas.

bits este lățimea în biți a fiecărui transfer. Doar valoarea 8 este garantat suportată de toate dispozitivele hardware.

firstbit poate fi SPI.MSB sau SPI.LSB.

sck, mosi, miso sunt obiecte pin (machine.Pin) folosite pentru semnalele magistralei. Pentru majoritatea blocurilor SPI hardware (selectate prin parametrul id al constructorului), pinii sunt fixați și nu pot fi modificați. În unele cazuri, blocurile hardware permit 2-3 seturi alternative de pini pentru un bloc SPI hardware. Atribuirile arbitrare de pini sunt posibile doar pentru un driver SPI cu bitbanging (id = -1).

În cazul SPI hardware, frecvența reală de ceas poate fi mai mică decât rata baud solicitată. Acest lucru depinde de hardware-ul platformei. Rata reală poate fi determinată afișând obiectul SPI.

deinit() → None¶: Oprește magistrala SPI.

read(nbytes: int, write: int = 0x00) → bytes¶: Citește un număr de octeți specificat prin nbytes în timp ce scrie continuu singurul octet dat prin write. Returnează un obiect bytes cu datele care au fost citite.

readinto(buf: bytearray, write: int = 0x00) → None¶: Citește în tamponul (buffer) specificat prin buf în timp ce scrie continuu singurul octet dat prin write. Returnează None.

write(buf: bytes) → None¶: Scrie octeții conținuți în buf. Returnează None.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Scrie octeții din write_buf în timp ce citește în read_buf. Tampoanele (buffers) pot fi identice sau diferite, dar ambele trebuie să aibă aceeași lungime. Returnează None.

Constante¶

MSB: int¶: Se transmite la firstbit pentru a transmite/recepționa mai întâi bitul cel mai semnificativ (ordinea cea mai comună).

LSB: int¶: Se transmite la firstbit pentru a transmite/recepționa mai întâi bitul cel mai puțin semnificativ.

class SoftSPI – magistrală SPI emulată software¶

Clasa SoftSPI implementează SPI prin bit-banging pe pini GPIO arbitrari. Expune aceeași suprafață de metode ca SPI, astfel încât codul existent care vizează SPI hardware poate trece la software doar printr-o modificare a constructorului. Folosiți-o atunci când pinii de care aveți nevoie nu sunt conectați la un bloc SPI hardware, când aveți nevoie de mai multe magistrale decât cele hardware disponibile sau când un periferic necesită o fazare a ceasului nestandard pe care hardware-ul nu o poate produce.

Constructori¶

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

Construiește un obiect SPI software. sck, mosi și miso trebuie furnizate – nu există nicio selecție implicită a pinilor. Consultați SPI.init() pentru semnificația celorlalți parametri. Valoarea implicită a lui baudrate este mai mică decât pentru SPI hardware, deoarece bucla de bit-banging are o supraîncărcare mai mare.

Metode¶

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¶: Reinițializează magistrala SPI software cu parametrii dați. Doar argumentele furnizate sunt actualizate; celelalte își păstrează valorile anterioare. Consultați SPI.init() pentru semnificația fiecărui argument.

deinit() → None¶: Eliberează pinii GPIO revendicați de driverul de bit-banging și oprește controlul magistralei.

read(nbytes: int, write: int = 0x00) → bytes¶: Citește nbytes octeți în timp ce scrie continuu singurul octet write. Returnează un obiect bytes care conține datele recepționate.

readinto(buf: bytearray, write: int = 0x00) → None¶: Citește în buf în timp ce scrie continuu singurul octet write. Returnează None.

write(buf: bytes) → None¶: Scrie buf pe magistrală. Octeții recepționați sunt ignorați.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Scrie simultan write_buf și citește în read_buf. Ambele tampoane (buffers) trebuie să aibă aceeași lungime; ele pot face referire la aceeași zonă (alias).

Constante¶

MSB: int¶: Se transmite la firstbit pentru a transmite/recepționa mai întâi bitul cel mai semnificativ.

LSB: int¶: Se transmite la firstbit pentru a transmite/recepționa mai întâi bitul cel mai puțin semnificativ.