class I2C – protocolo série de dois fios

I2C é um protocolo de dois fios para comunicação entre dispositivos. Ao nível físico, é constituído por duas linhas, SCL (relógio) e SDA (dados). O OpenMV Cam não fornece resistências de pull-up integradas em nenhuma das linhas – são necessárias resistências de pull-up externas em SCL e SDA para o bus funcionar.

Os objetos I2C estão associados a um bus específico e podem ser inicializados no momento da construção ou posteriormente através de init().

Exemplo:

from pyb import I2C

i2c = I2C(2)                              # create on bus 2 (uninitialised)
i2c = I2C(2, I2C.CONTROLLER)              # create and init as a controller
i2c.init(I2C.CONTROLLER, baudrate=20000)  # init as a controller
i2c.init(I2C.PERIPHERAL, addr=0x42)       # init as a peripheral with the given address
i2c.deinit()                              # turn off the peripheral

Imprimir o objeto I2C mostra a sua configuração.

Os métodos básicos são send() e recv()

i2c.send("abc")      # send 3 bytes
i2c.send(0x42)       # send a single byte, given by the number
data = i2c.recv(3)   # receive 3 bytes

Para receber no local, crie primeiro um bytearray

data = bytearray(3)  # create a buffer
i2c.recv(data)       # receive 3 bytes, writing them into data

Pode especificar um timeout (em ms):

i2c.send(b"123", timeout=2000)   # timeout after 2 seconds

Um controlador deve especificar o endereço do destinatário:

i2c.init(I2C.CONTROLLER)
i2c.send("123", 0x42)        # send 3 bytes to peripheral with address 0x42
i2c.send(b"456", addr=0x42)  # keyword for address

Um controlador também dispõe destes métodos:

# Check if peripheral 0x42 is ready.
i2c.is_ready(0x42)

# Scan the bus and return a list of responding addresses.
i2c.scan()

# Read 3 bytes from peripheral 0x42 starting at memaddr 2.
i2c.mem_read(3, 0x42, 2)

# Write 3 bytes to peripheral 0x42 at memaddr 2.
i2c.mem_write("abc", 0x42, 2, timeout=1000)

Construtores

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

Constrói um objeto I2C no bus indicado (um índice inteiro de periférico, por ex. 2 para I2C2). Sem parâmetros adicionais, o objeto é criado mas não inicializado (mantém as definições anteriores do bus, se existirem); se forem fornecidos argumentos adicionais, o bus é inicializado. Consulte init() para os parâmetros disponíveis.

I2C(2) está ligado aos mesmos pinos do conector em todos os OpenMV Cam que expõem pyb.I2C (M4 / M7 / H7 / H7 Plus / Pure Thermal):

Sinal

Pino do conector

Notas

SCL

P4

SDA

P5

I2C(4) está adicionalmente disponível no OpenMV Cam M7, H7, H7 Plus e Pure Thermal com SCL no pino do conector P7 e SDA no pino do conector P8.

O OpenMV Cam N6 não expõe pyb.I2C; utilize machine.I2C em alternativa.

Métodos

deinit() → None

Desliga o bus I2C.

init(mode: int, *, addr: int = 0x12, baudrate: int = 400000, gencall: bool = False, dma: bool = False) → None

Inicializa o bus I2C com os parâmetros indicados:

  • mode deve ser I2C.CONTROLLER ou I2C.PERIPHERAL.

  • addr é o endereço de 7 bits (apenas relevante para um periférico).

  • baudrate é a frequência de relógio SCL (apenas relevante para um controlador).

  • gencall indica se o modo general-call deve ser suportado.

  • dma indica se é permitido o uso de DMA para as transferências I2C (note que as transferências DMA têm temporização mais precisa, mas atualmente não tratam corretamente os erros de bus).

A frequência de relógio real pode ser inferior à frequência pedida. Isto depende do hardware da plataforma. A frequência real pode ser determinada imprimindo o objeto I2C.

is_ready(addr: int) → bool

Verifica se um dispositivo I2C responde ao endereço indicado. Válido apenas em modo controlador.

mem_read(data: int | bytearray, addr: int, memaddr: int, *, timeout: int = 5000, addr_size: int = 8) → bytes

Lê da memória de um dispositivo I2C:

  • data pode ser um inteiro (número de bytes a ler) ou um buffer para ler

  • addr é o endereço do dispositivo I2C

  • memaddr é a localização de memória dentro do dispositivo I2C

  • timeout é o timeout em milissegundos para aguardar a leitura

  • addr_size seleciona a largura de memaddr: 8 ou 16 bits

Devolve os dados lidos. Válido apenas em modo controlador.

mem_write(data: int | bytes | bytearray, addr: int, memaddr: int, *, timeout: int = 5000, addr_size: int = 8) → None

Escreve na memória de um dispositivo I2C:

  • data pode ser um inteiro ou um buffer a partir do qual escrever.

  • addr é o endereço do dispositivo I2C.

  • memaddr é a localização de memória dentro do dispositivo I2C.

  • timeout é o timeout em milissegundos para aguardar a escrita.

  • addr_size seleciona a largura de memaddr: 8 ou 16 bits.

Válido apenas em modo controlador.

recv(recv: int | bytearray, addr: int = 0x00, *, timeout: int = 5000) → bytes

Recebe dados no bus:

  • 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

  • addr é o endereço do qual receber (apenas necessário em modo controlador)

  • timeout é o timeout em milissegundos para aguardar a receção

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

send(send: int | bytes | bytearray, addr: int = 0x00, *, timeout: int = 5000) → None

Envia dados no bus:

  • send são os dados a enviar (um inteiro a enviar, ou um objeto buffer).

  • addr é o endereço para o qual enviar (apenas necessário em modo controlador).

  • timeout é o timeout em milissegundos para aguardar o envio.

scan() → List[int]

Percorre todos os endereços I2C de 0x01 a 0x7f e devolve uma lista dos que respondem. Válido apenas em modo controlador.

Constantes

CONTROLLER: int

Inicializa o bus como mestre (controlador) – aciona SCL e inicia transações.

PERIPHERAL: int

Inicializa o bus como escravo (periférico) que escuta no addr definido em init() e responde a transações iniciadas por um controlador no mesmo bus.