class SPI – un protocole de bus Serial Peripheral Interface (côté contrôleur)¶

SPI est un protocole série synchrone piloté par un contrôleur. Au niveau physique, un bus se compose de 3 lignes : SCK, MOSI, MISO. Plusieurs périphériques peuvent partager le même bus. Chaque périphérique doit disposer d’un quatrième signal distinct, CS (Chip Select), pour sélectionner sur le bus le périphérique particulier avec lequel la communication a lieu. La gestion d’un signal CS doit être effectuée dans le code utilisateur (via la classe machine.Pin).

Il existe des implémentations SPI matérielles et logicielles via les classes SPI et SoftSPI. Le SPI matériel utilise le support matériel sous-jacent du système pour effectuer les lectures/écritures ; il est généralement efficace et rapide, mais peut imposer des restrictions sur les broches utilisables. Le SPI logiciel est implémenté par bit-banging et peut être utilisé sur n’importe quelle broche, mais est moins efficace. Ces classes proposent les mêmes méthodes et diffèrent principalement par leur mode de construction.

Exemple d’utilisation

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.

Constructeurs¶

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

Construit un objet SPI sur le bus indiqué, id. Les valeurs de id dépendent du port particulier et de son matériel. Les valeurs 0, 1, etc. sont couramment utilisées pour sélectionner le bloc SPI matériel n°0, n°1, etc.

Sans paramètre supplémentaire, l’objet SPI est créé mais non initialisé (il conserve les réglages de la dernière initialisation du bus, le cas échéant). Si des arguments supplémentaires sont fournis, le bus est initialisé. Voir init pour les paramètres d’initialisation.

Méthodes¶

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¶

Initialise le bus SPI avec les paramètres indiqués :

baudrate est la fréquence d’horloge SCK.

polarity peut valoir 0 ou 1 ; c’est le niveau auquel la ligne d’horloge se trouve au repos.

phase peut valoir 0 ou 1 pour échantillonner les données respectivement sur le premier ou le second front d’horloge.

bits est la largeur en bits de chaque transfert. Seule la valeur 8 est garantie comme prise en charge par tout le matériel.

firstbit peut valoir SPI.MSB ou SPI.LSB.

sck, mosi, miso sont des objets broches (machine.Pin) à utiliser pour les signaux du bus. Pour la plupart des blocs SPI matériels (tels que sélectionnés par le paramètre id du constructeur), les broches sont fixes et ne peuvent pas être modifiées. Dans certains cas, les blocs matériels autorisent 2 à 3 ensembles de broches alternatifs pour un bloc SPI matériel. Des affectations de broches arbitraires ne sont possibles que pour un pilote SPI par bit-banging (id = -1).

Dans le cas du SPI matériel, la fréquence d’horloge réelle peut être inférieure au débit en bauds demandé. Cela dépend du matériel de la plateforme. La fréquence réelle peut être déterminée en affichant l’objet SPI.

deinit() → None¶: Désactive le bus SPI.

read(nbytes: int, write: int = 0x00) → bytes¶: Lit un nombre d’octets indiqué par nbytes tout en écrivant continuellement l’octet unique donné par write. Renvoie un objet bytes contenant les données lues.

readinto(buf: bytearray, write: int = 0x00) → None¶: Lit dans le tampon indiqué par buf tout en écrivant continuellement l’octet unique donné par write. Renvoie None.

write(buf: bytes) → None¶: Écrit les octets contenus dans buf. Renvoie None.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Écrit les octets de write_buf tout en lisant dans read_buf. Les tampons peuvent être identiques ou différents, mais les deux doivent avoir la même longueur. Renvoie None.

Constantes¶

MSB: int¶: À passer à firstbit pour transmettre/recevoir le bit de poids fort en premier (l’ordre le plus courant).

LSB: int¶: À passer à firstbit pour transmettre/recevoir le bit de poids faible en premier.

class SoftSPI – bus SPI émulé de manière logicielle¶

La classe SoftSPI implémente le SPI par bit-banging de broches GPIO arbitraires. Elle expose la même surface de méthodes que SPI, de sorte que du code existant ciblant le SPI matériel peut passer au logiciel en ne modifiant que le constructeur. Utilisez-la lorsque les broches dont vous avez besoin ne sont pas câblées à un bloc SPI matériel, lorsque vous avez besoin de plus de bus que ceux disponibles en matériel, ou lorsqu’un périphérique exige un phasage d’horloge non standard que le matériel ne peut pas produire.

Constructeurs¶

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

Construit un objet SPI logiciel. sck, mosi et miso doivent être fournis – il n’y a aucune sélection implicite de broches. Voir SPI.init() pour la signification des autres paramètres. Le baudrate par défaut est plus faible que pour le SPI matériel, car la boucle de bit-banging entraîne davantage de surcharge.

Méthodes¶

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¶: Réinitialise le bus SPI logiciel avec les paramètres indiqués. Seuls les arguments fournis sont mis à jour ; les autres conservent leurs valeurs précédentes. Voir SPI.init() pour la signification de chaque argument.

deinit() → None¶: Libère les broches GPIO occupées par le pilote de bit-banging et cesse de piloter le bus.

read(nbytes: int, write: int = 0x00) → bytes¶: Lit nbytes octets tout en écrivant continuellement l’octet unique write. Renvoie un objet bytes contenant les données reçues.

readinto(buf: bytearray, write: int = 0x00) → None¶: Lit dans buf tout en écrivant continuellement l’octet unique write. Renvoie None.

write(buf: bytes) → None¶: Écrit buf sur le bus. Les octets reçus sont ignorés.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Écrit simultanément write_buf et lit dans read_buf. Les deux tampons doivent avoir la même longueur ; ils peuvent se chevaucher.

Constantes¶

MSB: int¶: À passer à firstbit pour transmettre/recevoir le bit de poids fort en premier.

LSB: int¶: À passer à firstbit pour transmettre/recevoir le bit de poids faible en premier.