class SPI – un protocole série piloté par un contrôleur¶

SPI est un protocole série synchrone piloté par un contrôleur. Au niveau physique, il utilise trois lignes (SCK, MOSI, MISO) plus une ligne de sélection de puce par périphérique.

L’utilisation est similaire à I2C ; la principale différence réside dans les paramètres passés lors de l’initialisation du bus

from pyb import SPI
spi = SPI(2, SPI.CONTROLLER, baudrate=600000, polarity=1, phase=0, crc=0x7)

Le seul paramètre requis est mode (SPI.CONTROLLER ou SPI.PERIPHERAL). polarity est le niveau au repos de SCK (0 ou 1). phase détermine si les données sont échantillonnées sur le premier (0) ou le second (1) front d’horloge. crc vaut soit None (pas de CRC), soit un polynôme CRC.

Transfert de données

data = spi.send_recv(b"1234")        # send 4 bytes and receive 4 bytes
buf = bytearray(4)
spi.send_recv(b"1234", buf)          # send 4 bytes and receive 4 into buf
spi.send_recv(buf, buf)              # send/receive 4 bytes through buf

Constructeurs¶

class pyb.SPI(bus: int | str, *args, **kwargs)¶

Construit un objet SPI sur le bus donné (un index entier de périphérique SPI, par exemple 2 pour SPI2). Sans paramètres supplémentaires, l’objet est créé mais non initialisé (il conserve les réglages précédents du bus, le cas échéant) ; si des arguments supplémentaires sont fournis, le bus est initialisé avec ceux-ci. Voir init() pour les paramètres disponibles.

SPI(2) est câblé aux mêmes broches du connecteur sur toutes les OpenMV Cam STM32 ; l’OpenMV Cam N6 expose en plus SPI(4) :

Bus	NSS	SCK	MISO	MOSI
`SPI(2)` (toutes les OpenMV Cam STM32)	`P3`	`P2`	`P1`	`P0`
`SPI(4)` (OpenMV Cam N6 uniquement)	`P15`	`P16`	`P17`	`P18`

NSS n’est piloté par le périphérique SPI sur aucun des deux bus ; il est libre d’être utilisé comme une sélection de puce GPIO normale.

Méthodes¶

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

init(mode: int, baudrate: int = 328125, *, prescaler: int = -1, polarity: int = 1, phase: int = 0, bits: int = 8, firstbit: int = SPI.MSB, ti: bool = False, crc: int | None = None) → None¶

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

mode doit être soit SPI.CONTROLLER, soit SPI.PERIPHERAL.

baudrate est la fréquence d’horloge SCK (n’a de sens que pour un contrôleur).

prescaler est le diviseur utilisé pour dériver SCK de la fréquence du bus APB ; l’utilisation de prescaler prévaut sur baudrate.

polarity peut valoir 0 ou 1, et correspond au niveau auquel se trouve la ligne d’horloge au repos.

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

bits peut valoir 8 ou 16, et correspond au nombre de bits dans chaque mot transféré.

firstbit peut valoir SPI.MSB ou SPI.LSB.

ti à True indique les conventions de signaux Texas Instruments, par opposition à Motorola.

crc peut valoir None pour aucun CRC, ou un spécificateur de polynôme.

La fréquence d’horloge SPI peut ne pas correspondre exactement à baudrate. Le matériel ne prend en charge que des horloges correspondant à la fréquence du bus APB parent divisée par un diviseur en puissance de deux (2, 4, 8, 16, 32, 64, 128 ou 256) ; le pilote choisit la valeur la plus élevée qui ne dépasse pas le baudrate demandé. SPI(2) est sur APB1. Pour un contrôle précis de l’horloge, définissez directement prescaler plutôt que baudrate.

L’affichage de l’objet SPI montre le débit en bauds calculé et le diviseur choisi.

recv(recv: int | bytearray, *, timeout: int = 5000) → bytes¶

Reçoit des données sur le bus :

recv peut être un entier, qui est le nombre d’octets à recevoir, ou un tampon modifiable, qui sera rempli avec les octets reçus.

timeout est le délai d’attente en millisecondes pour la réception.

Valeur de retour : si recv est un entier, alors un nouveau tampon contenant les octets reçus, sinon le même tampon que celui passé à recv.

send(send: int | bytes | bytearray, *, timeout: int = 5000) → None¶

Envoie des données sur le bus :

send est la donnée à envoyer (un entier à envoyer, ou un objet tampon).

timeout est le délai d’attente en millisecondes pour l’envoi.

send_recv(send: int | bytes | bytearray, recv: bytearray | None = None, *, timeout: int = 5000) → bytes¶

Envoie et reçoit des données sur le bus en même temps :

send est la donnée à envoyer (un entier à envoyer, ou un objet tampon).

recv est un tampon modifiable qui sera rempli avec les octets reçus. Il peut être le même que send, ou être omis. S’il est omis, un nouveau tampon sera créé.

timeout est le délai d’attente en millisecondes pour la réception.

Valeur de retour : le tampon contenant les octets reçus.

Constantes¶

CONTROLLER: int¶: Initialise le bus SPI en maître (contrôleur) – l’OpenMV Cam pilote SCK et MOSI et est responsable de la transaction.

PERIPHERAL: int¶: Initialise le bus SPI en esclave (périphérique) – l’OpenMV Cam répond aux impulsions d’horloge pilotées par un contrôleur distant.

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.