klass I2C – ett tvåtrådigt seriellt protokoll

I2C är ett tvåtrådigt protokoll för kommunikation mellan enheter. På den fysiska nivån består det av två linjer, SCL (klocka) och SDA (data). OpenMV Cam tillhandahåller inte inbyggda pull-up-motstånd på någon av linjerna – externa pull-up-motstånd krävs på både SCL och SDA för att bussen ska fungera.

I2C-objekt är anslutna till en specifik buss och kan initieras vid konstruktionstid eller senare via init().

Exempel:

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

Att skriva ut I2C-objektet visar dess konfiguration.

Grundmetoderna är send() och 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

För att ta emot på plats, skapa först en bytearray

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

Du kan ange en timeout (i ms):

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

En styrenhet måste ange mottagarens adress:

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

En styrenhet har också dessa metoder:

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

Konstruktorer

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

Skapa ett I2C-objekt på den angivna bus (ett heltalsindex för kringutrustningen, t.ex. 2 för I2C2). Utan ytterligare parametrar skapas objektet men initieras inte (det behåller de tidigare bussinställningarna, om några); om extra argument anges initieras bussen. Se init() för de tillgängliga parametrarna.

I2C(2) är kopplad till samma stift på kontakten på varje OpenMV Cam som exponerar pyb.I2C (M4 / M7 / H7 / H7 Plus / Pure Thermal):

Signal

Stift på kontakt

Anmärkningar

SCL

P4

SDA

P5

I2C(4) är dessutom tillgänglig på OpenMV Cam M7, H7, H7 Plus och Pure Thermal med SCL på stift P7 och SDA på stift P8 på kontakten.

OpenMV Cam N6 exponerar inte pyb.I2C; använd machine.I2C istället.

Metoder

deinit() → None

Stäng av I2C-bussen.

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

Initiera I2C-bussen med de angivna parametrarna:

  • mode måste vara antingen I2C.CONTROLLER eller I2C.PERIPHERAL.

  • addr är den 7-bitars adressen (endast meningsfullt för en peripheral-enhet).

  • baudrate är SCL-klockfrekvensen (endast meningsfullt för en styrenhet).

  • gencall anger om general-call-läge ska stödjas.

  • dma anger om användning av DMA för I2C-överföringarna ska tillåtas (observera att DMA-överföringar har mer exakt timing men för närvarande inte hanterar bussfel korrekt).

Den faktiska klockfrekvensen kan vara lägre än den begärda frekvensen. Detta beror på plattformens hårdvara. Den faktiska frekvensen kan fastställas genom att skriva ut I2C-objektet.

is_ready(addr: int) → bool

Kontrollera om en I2C-enhet svarar på den angivna adressen. Endast giltigt i controller-läge.

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

Läs från minnet på en I2C-enhet:

  • data kan vara ett heltal (antal bytes att läsa) eller en buffert att läsa in i

  • addr är I2C-enhetens adress

  • memaddr är minnesplatsen inom I2C-enheten

  • timeout är timeouten i millisekunder att vänta på läsningen

  • addr_size väljer bredden på memaddr: 8 eller 16 bitar

Returnerar den lästa datan. Detta är endast giltigt i controller-läge.

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

Skriv till minnet på en I2C-enhet:

  • data kan vara ett heltal eller en buffert att skriva från.

  • addr är I2C-enhetens adress.

  • memaddr är minnesplatsen inom I2C-enheten.

  • timeout är timeouten i millisekunder att vänta på skrivningen.

  • addr_size väljer bredden på memaddr: 8 eller 16 bitar.

Endast giltigt i controller-läge.

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

Ta emot data på bussen:

  • recv kan vara ett heltal, vilket är antalet bytes att ta emot, eller en muterbar buffert, som fylls med mottagna bytes

  • addr är adressen att ta emot från (krävs endast i controller-läge)

  • timeout är timeouten i millisekunder att vänta på mottagningen

Returvärde: om recv är ett heltal returneras en ny buffert med de mottagna byten, annars samma buffert som skickades in till recv.

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

Skicka data på bussen:

  • send är datan att skicka (ett heltal att skicka, eller ett buffertobjekt).

  • addr är adressen att skicka till (krävs endast i controller-läge).

  • timeout är timeouten i millisekunder att vänta på sändningen.

scan() → List[int]

Skanna alla I2C-adresser från 0x01 till 0x7f och returnera en lista med de som svarar. Endast giltigt i controller-läge.

Konstanter

CONTROLLER: int

Initierar bussen som master (styrenhet) – den driver SCL och initierar transaktioner.

PERIPHERAL: int

Initierar bussen som en slav (peripheral-enhet) som lyssnar på den addr som ställts in i init() och svarar på transaktioner som startas av en styrenhet på samma buss.