I2C osztály – kétvezetékes soros protokoll

Az I2C egy kétvezetékes protokoll az eszközök közötti kommunikációhoz. Fizikai szinten két vonalból áll: SCL (órajel) és SDA (adat). Az OpenMV Cam nem biztosít beépített felhúzóellenállásokat egyik vonalon sem – a busz működéséhez külső felhúzóellenállásokra van szükség mind az SCL, mind az SDA vonalon.

Az I2C objektumok egy adott buszhoz kapcsolódnak, és inicializálhatók a létrehozáskor vagy később az init() segítségével.

Példa:

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

Az I2C objektum kiírása megmutatja annak konfigurációját.

Az alapvető metódusok a send() és a 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

A helyben történő fogadáshoz először hozzon létre egy bytearray-t:

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

Megadhat időtúllépést is (ms-ban):

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

A vezérlőnek meg kell adnia a címzett címét:

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

A vezérlő ezekkel a metódusokkal is rendelkezik:

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

Konstruktorok

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

I2C objektum létrehozása az adott bus-on (egy egész szám perifériaindex, pl. 2 az I2C2 esetén). További paraméterek nélkül az objektum létrejön, de nem inicializálódik (megtartja a korábbi buszbeállításokat, ha voltak ilyenek); ha további argumentumokat ad meg, a busz inicializálódik. Az elérhető paramétereket lásd az init() metódusnál.

Az I2C(2) minden olyan OpenMV Cam esetében ugyanazokra a tűsoros lábakra van bekötve, amely elérhetővé teszi a pyb.I2C osztályt (M4 / M7 / H7 / H7 Plus / Pure Thermal):

Jel

Tűsoros láb

Megjegyzések

SCL

P4

SDA

P5

Az I2C(4) ezenfelül elérhető az OpenMV Cam M7, H7, H7 Plus és Pure Thermal kamerán, ahol az SCL a P7 tűsoros lábon, az SDA pedig a P8 tűsoros lábon található.

Az OpenMV Cam N6 nem teszi elérhetővé a pyb.I2C osztályt; helyette használja a machine.I2C osztályt.

Metódusok

deinit() → None

Az I2C busz kikapcsolása.

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

Az I2C busz inicializálása a megadott paraméterekkel:

  • A mode értéke vagy I2C.CONTROLLER vagy I2C.PERIPHERAL kell legyen.

  • Az addr a 7 bites cím (csak perifériánál van értelme).

  • A baudrate az SCL órajel-sebessége (csak vezérlőnél van értelme).

  • A gencall azt jelzi, hogy támogatva legyen-e az általános hívás (general-call) mód.

  • A dma azt jelzi, hogy engedélyezve legyen-e a DMA használata az I2C átvitelekhez (vegye figyelembe, hogy a DMA-átvitelek időzítése pontosabb, de jelenleg nem kezelik megfelelően a busz hibáit).

A tényleges órajel-frekvencia alacsonyabb lehet a kérthez képest. Ez a platform hardverétől függ. A tényleges sebesség az I2C objektum kiírásával állapítható meg.

is_ready(addr: int) → bool

Ellenőrzi, hogy egy I2C eszköz válaszol-e a megadott címre. Csak vezérlő módban érvényes.

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

Olvasás egy I2C eszköz memóriájából:

  • A data lehet egy egész szám (az olvasandó bájtok száma) vagy egy puffer, amelybe az olvasás történik

  • Az addr az I2C eszköz címe

  • A memaddr a memóriahely az I2C eszközön belül

  • A timeout az ezredmásodpercben megadott időtúllépés, ameddig az olvasásra várni kell

  • Az addr_size a memaddr szélességét választja ki: 8 vagy 16 bit

Visszaadja a beolvasott adatokat. Ez csak vezérlő módban érvényes.

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

Írás egy I2C eszköz memóriájába:

  • A data lehet egy egész szám vagy egy puffer, amelyből az írás történik.

  • Az addr az I2C eszköz címe.

  • A memaddr a memóriahely az I2C eszközön belül.

  • A timeout az ezredmásodpercben megadott időtúllépés, ameddig az írásra várni kell.

  • Az addr_size a memaddr szélességét választja ki: 8 vagy 16 bit.

Csak vezérlő módban érvényes.

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

Adatok fogadása a buszon:

  • A recv lehet egy egész szám, amely a fogadandó bájtok száma, vagy egy módosítható puffer, amely a fogadott bájtokkal lesz feltöltve

  • Az addr az a cím, amelyről fogadni kell (csak vezérlő módban szükséges)

  • A timeout az ezredmásodpercben megadott időtúllépés, ameddig a fogadásra várni kell

Visszatérési érték: ha a recv egész szám, akkor egy új puffer a fogadott bájtokkal, ellenkező esetben ugyanaz a puffer, amelyet a recv paraméternek átadtak.

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

Adatok küldése a buszon:

  • A send a küldendő adat (egy küldendő egész szám vagy egy pufferobjektum).

  • Az addr az a cím, amelyre küldeni kell (csak vezérlő módban szükséges).

  • A timeout az ezredmásodpercben megadott időtúllépés, ameddig a küldésre várni kell.

scan() → List[int]

Végigvizsgálja az összes I2C címet 0x01-től 0x7f-ig, és visszaadja azok listáját, amelyek válaszolnak. Csak vezérlő módban érvényes.

Konstansok

CONTROLLER: int

A buszt mesterként (vezérlőként) inicializálja – ez vezérli az SCL vonalat, és kezdeményezi a tranzakciókat.

PERIPHERAL: int

A buszt alárendeltként (perifériaként) inicializálja, amely az init() metódusban beállított addr címen figyel, és válaszol az ugyanazon a buszon lévő vezérlő által indított tranzakciókra.