class SPI – um protocolo serial acionado por um controlador¶

SPI é um protocolo serial síncrono acionado por um controlador. No nível físico, ele usa três linhas (SCK, MOSI, MISO) mais uma linha de chip-select por periférico.

O uso é semelhante ao de I2C; a principal diferença são os parâmetros passados ao inicializar o barramento:

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

O único parâmetro obrigatório é mode (SPI.CONTROLLER ou SPI.PERIPHERAL). polarity é o nível de repouso de SCK (0 ou 1). phase seleciona se os dados são amostrados na primeira (0) ou na segunda (1) borda de clock. crc é None (sem CRC) ou um polinômio de CRC.

Transferindo dados:

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

Construtores¶

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

Constrói um objeto SPI no bus fornecido (um índice inteiro de periférico SPI, por exemplo 2 para SPI2). Sem parâmetros adicionais, o objeto é criado mas não inicializado (ele mantém as configurações de barramento anteriores, se houver); se argumentos extras forem fornecidos, o barramento é inicializado com eles. Veja init() para os parâmetros disponíveis.

SPI(2) está conectado aos mesmos pinos do header em todas as OpenMV Cams STM32; a OpenMV Cam N6 expõe adicionalmente SPI(4):

Barramento	NSS	SCK	MISO	MOSI
`SPI(2)` (todas as OpenMV Cams STM32)	`P3`	`P2`	`P1`	`P0`
`SPI(4)` (somente OpenMV Cam N6)	`P15`	`P16`	`P17`	`P18`

NSS não é acionado pelo periférico SPI em nenhum dos barramentos; ele fica livre para uso como um chip-select GPIO normal.

Métodos¶

deinit() → None¶: Desliga o barramento 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¶

Inicializa o barramento SPI com os parâmetros fornecidos:

mode deve ser SPI.CONTROLLER ou SPI.PERIPHERAL.

baudrate é a taxa de clock de SCK (só faz sentido para um controlador).

prescaler é o prescaler usado para derivar SCK da frequência do barramento APB; o uso de prescaler sobrepõe baudrate.

polarity pode ser 0 ou 1, e é o nível em que a linha de clock fica em repouso.

phase pode ser 0 ou 1 para amostrar os dados na primeira ou na segunda borda de clock, respectivamente.

bits pode ser 8 ou 16, e é o número de bits em cada palavra transferida.

firstbit pode ser SPI.MSB ou SPI.LSB.

ti True indica as convenções de sinal da Texas Instruments, em oposição às da Motorola.

crc pode ser None para nenhum CRC, ou um especificador de polinômio.

A frequência de clock do SPI pode não corresponder exatamente a baudrate. O hardware suporta apenas clocks que são a frequência do barramento APB pai dividida por um prescaler de potência de dois (2, 4, 8, 16, 32, 64, 128 ou 256); o driver escolhe o maior que não exceda o baudrate solicitado. SPI(2) está no APB1. Para controle preciso sobre o clock, defina prescaler diretamente em vez de baudrate.

Imprimir o objeto SPI mostra a taxa de transmissão (baud rate) calculada e o prescaler escolhido.

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

Recebe dados no barramento:

recv pode ser um inteiro, que é o número de bytes a receber, ou um buffer mutável, que será preenchido com os bytes recebidos.

timeout é o tempo limite em milissegundos para aguardar a recepção.

Valor de retorno: se recv for um inteiro, então um novo buffer com os bytes recebidos, caso contrário o mesmo buffer que foi passado em recv.

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

Envia dados no barramento:

send é o dado a enviar (um inteiro a enviar, ou um objeto buffer).

timeout é o tempo limite em milissegundos para aguardar o envio.

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

Envia e recebe dados no barramento ao mesmo tempo:

send é o dado a enviar (um inteiro a enviar, ou um objeto buffer).

recv é um buffer mutável que será preenchido com os bytes recebidos. Ele pode ser o mesmo que send, ou ser omitido. Se omitido, um novo buffer será criado.

timeout é o tempo limite em milissegundos para aguardar a recepção.

Valor de retorno: o buffer com os bytes recebidos.

Constantes¶

CONTROLLER: int¶: Inicializa o barramento SPI como mestre (controlador) – a OpenMV Cam aciona SCK e MOSI e está no comando da transação.

PERIPHERAL: int¶: Inicializa o barramento SPI como escravo (periférico) – a OpenMV Cam responde aos pulsos de clock acionados por um controlador remoto.

MSB: int¶: Passe para firstbit para transmitir/receber o bit mais significativo primeiro (a ordenação mais comum).

LSB: int¶: Passe para firstbit para transmitir/receber o bit menos significativo primeiro.