classe SPI – um protocolo de barramento Serial Peripheral Interface (lado do controlador)¶

SPI é um protocolo serial síncrono que é conduzido por um controlador. No nível físico, um barramento consiste em 3 linhas: SCK, MOSI, MISO. Vários dispositivos podem compartilhar o mesmo barramento. Cada dispositivo deve ter um quarto sinal separado, CS (Chip Select), para selecionar um dispositivo específico em um barramento com o qual a comunicação ocorre. O gerenciamento de um sinal CS deve acontecer no código do usuário (via classe machine.Pin).

Existem implementações de SPI tanto por hardware quanto por software através das classes SPI e SoftSPI. O SPI por hardware usa o suporte de hardware subjacente do sistema para realizar as leituras/escritas e geralmente é eficiente e rápido, mas pode ter restrições sobre quais pinos podem ser usados. O SPI por software é implementado por bit-banging e pode ser usado em qualquer pino, mas não é tão eficiente. Essas classes têm os mesmos métodos disponíveis e diferem principalmente na forma como são construídas.

Exemplo de uso:

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.

Construtores¶

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

Constrói um objeto SPI no barramento dado, id. Os valores de id dependem de uma porta específica e de seu hardware. Os valores 0, 1, etc. são comumente usados para selecionar o bloco SPI de hardware nº 0, nº 1, etc.

Sem parâmetros adicionais, o objeto SPI é criado mas não inicializado (ele tem as configurações da última inicialização do barramento, se houver). Se argumentos extras forem fornecidos, o barramento é inicializado. Veja init para os parâmetros de inicialização.

Métodos¶

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¶

Inicializa o barramento SPI com os parâmetros dados:

baudrate é a taxa de clock do SCK.

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 é a largura em bits de cada transferência. Apenas 8 é garantido de ser suportado por todo o hardware.

firstbit pode ser SPI.MSB ou SPI.LSB.

sck, mosi, miso são objetos de pinos (machine.Pin) a serem usados para os sinais do barramento. Para a maioria dos blocos SPI de hardware (conforme selecionado pelo parâmetro id do construtor), os pinos são fixos e não podem ser alterados. Em alguns casos, os blocos de hardware permitem 2-3 conjuntos alternativos de pinos para um bloco SPI de hardware. Atribuições arbitrárias de pinos só são possíveis para um driver SPI por bitbanging (id = -1).

No caso do SPI por hardware, a frequência de clock real pode ser menor que a baudrate solicitada. Isso depende do hardware da plataforma. A taxa real pode ser determinada imprimindo o objeto SPI.

deinit() → None¶: Desliga o barramento SPI.

read(nbytes: int, write: int = 0x00) → bytes¶: Lê um número de bytes especificado por nbytes enquanto escreve continuamente o byte único dado por write. Retorna um objeto bytes com os dados que foram lidos.

readinto(buf: bytearray, write: int = 0x00) → None¶: Lê para o buffer especificado por buf enquanto escreve continuamente o byte único dado por write. Retorna None.

write(buf: bytes) → None¶: Escreve os bytes contidos em buf. Retorna None.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Escreve os bytes de write_buf enquanto lê para read_buf. Os buffers podem ser o mesmo ou diferentes, mas ambos os buffers devem ter o mesmo comprimento. Retorna None.

Constantes¶

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.

classe SoftSPI – barramento SPI emulado por software¶

A classe SoftSPI implementa o SPI por bit-banging de pinos GPIO arbitrários. Ela expõe a mesma superfície de métodos que SPI, de modo que código existente que tem como alvo o SPI por hardware pode mudar para software apenas alterando o construtor. Use-a quando os pinos de que você precisa não estão conectados a um bloco SPI de hardware, quando você precisa de mais barramentos do que os de hardware disponíveis, ou quando um periférico requer um fasamento de clock não padrão que o hardware não consegue produzir.

Construtores¶

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

Constrói um objeto SPI por software. sck, mosi e miso devem ser fornecidos – não há seleção implícita de pinos. Veja SPI.init() para o significado dos outros parâmetros. A baudrate padrão é menor que a do SPI por hardware porque o laço de bit-bang tem mais sobrecarga.

Métodos¶

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¶: Reinicializa o barramento SPI por software com os parâmetros dados. Apenas os argumentos fornecidos são atualizados; os demais mantêm seus valores anteriores. Veja SPI.init() para o significado de cada argumento.

deinit() → None¶: Libera os pinos GPIO reservados pelo driver de bit-bang e para de conduzir o barramento.

read(nbytes: int, write: int = 0x00) → bytes¶: Lê nbytes bytes enquanto escreve continuamente o byte único write. Retorna um objeto bytes contendo os dados recebidos.

readinto(buf: bytearray, write: int = 0x00) → None¶: Lê para buf enquanto escreve continuamente o byte único write. Retorna None.

write(buf: bytes) → None¶: Escreve buf no barramento. Os bytes recebidos são descartados.

write_readinto(write_buf: bytes, read_buf: bytearray) → None¶: Escreve write_buf e lê para read_buf simultaneamente. Ambos os buffers devem ter o mesmo comprimento; eles podem coincidir.

Constantes¶

MSB: int¶: Passe para firstbit para transmitir/receber o bit mais significativo primeiro.

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