classe SPI – protocolo de barramento de interface periférica série (lado do controlador)¶

SPI é um protocolo série síncrono controlado por um dispositivo mestre. Ao nível físico, um barramento é composto por 3 linhas: SCK, MOSI, MISO. Vários dispositivos podem partilhar o mesmo barramento. Cada dispositivo deve ter um quarto sinal separado, CS (Chip Select), para selecionar um dispositivo específico no barramento com o qual a comunicação tem lugar. A gestão do sinal CS deve ser feita no código do utilizador (através da classe machine.Pin).

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

Exemplo de utilização:

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 indicado, id. Os valores de id dependem do porto específico e do seu hardware. Os valores 0, 1, etc. são normalmente 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 (mantém as definições da última inicialização do barramento, se existir). Se forem fornecidos argumentos extra, o barramento é inicializado. Consulte 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 indicados:

baudrate é a taxa de relógio SCK.

polarity pode ser 0 ou 1, e é o nível em que a linha de relógio permanece em repouso.

phase pode ser 0 ou 1 para amostrar os dados na primeira ou segunda transição de relógio, respetivamente.

bits é a largura em bits de cada transferência. Apenas 8 é garantido como suportado por todo o hardware.

firstbit pode ser SPI.MSB ou SPI.LSB.

sck, mosi, miso são objetos de pinos (machine.Pin) a usar para os sinais do barramento. Para a maioria dos blocos SPI de hardware (selecionados 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 de pinos alternativos para um bloco SPI de hardware. Atribuições de pinos arbitrárias apenas são possíveis para um controlador SPI por bit-banging (id = -1).

No caso do SPI por hardware, a frequência de relógio real pode ser inferior à taxa de baud solicitada. Isto depende do hardware da plataforma. A taxa real pode ser determinada imprimindo o objeto SPI.

deinit() → None¶: Desativa 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 indicado por write. Devolve um objeto bytes com os dados lidos.

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

write(buf: bytes) → None¶: Escreve os bytes contidos em buf. Devolve 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 iguais ou diferentes, mas ambos devem ter o mesmo comprimento. Devolve None.

Constantes¶

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

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

classe SoftSPI – barramento SPI emulado por software¶

A classe SoftSPI implementa SPI por bit-banging em pinos GPIO arbitrários. Expõe a mesma interface de métodos que SPI, pelo que o código existente direcionado para SPI por hardware pode migrar para software apenas com uma alteração no construtor. Use-a quando os pinos necessários não estão ligados a um bloco SPI de hardware, quando precisa de mais barramentos do que os disponíveis em hardware, ou quando um periférico requer uma fase de relógio 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. Consulte SPI.init() para o significado dos outros parâmetros. A baudrate predefinida é inferior à do hardware SPI porque o ciclo de bit-bang tem maior 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 indicados. Apenas os argumentos fornecidos são atualizados; os restantes mantêm os valores anteriores. Consulte SPI.init() para o significado de cada argumento.

deinit() → None¶: Liberta os pinos GPIO reclamados pelo controlador de bit-bang e para de controlar o barramento.

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

readinto(buf: bytearray, write: int = 0x00) → None¶: Lê para buf enquanto escreve continuamente o byte único write. Devolve 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 simultaneamente write_buf e lê para read_buf. Ambos os buffers devem ter o mesmo comprimento; podem ser o mesmo objeto.

Constantes¶

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

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