clasa I2C – un protocol serial pe două fire

I2C este un protocol pe două fire pentru comunicarea între dispozitive. La nivel fizic constă din două linii, SCL (ceas) și SDA (date). OpenMV Cam nu furnizează rezistențe de polarizare (pull-up) integrate pe niciuna dintre linii – sunt necesare rezistențe pull-up externe atât pe SCL cât și pe SDA pentru ca magistrala să funcționeze.

Obiectele I2C sunt atașate unei magistrale specifice și pot fi inițializate la momentul construcției sau ulterior prin init().

Exemplu:

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

Afișarea obiectului I2C arată configurația acestuia.

Metodele de bază sunt send() și 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

Pentru a recepționa pe loc, creați mai întâi un bytearray

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

Puteți specifica un timeout (în ms):

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

Un controler trebuie să specifice adresa destinatarului:

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

Un controler are și aceste metode:

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

Constructori

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

Construiește un obiect I2C pe magistrala bus dată (un indice întreg al perifericului, de ex. 2 pentru I2C2). Fără parametri suplimentari, obiectul este creat, dar nu inițializat (păstrează setările anterioare ale magistralei, dacă există); dacă se dau argumente suplimentare, magistrala este inițializată. Vezi init() pentru parametrii disponibili.

I2C(2) este conectat la aceiași pini de header pe fiecare OpenMV Cam care expune pyb.I2C (M4 / M7 / H7 / H7 Plus / Pure Thermal):

Semnal

Pin header

Note

SCL

P4

SDA

P5

I2C(4) este disponibil suplimentar pe OpenMV Cam M7, H7, H7 Plus și Pure Thermal, cu SCL pe pinul de header P7 și SDA pe pinul de header P8.

OpenMV Cam N6 nu expune pyb.I2C; folosiți machine.I2C în schimb.

Metode

deinit() → None

Oprește magistrala I2C.

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

Inițializează magistrala I2C cu parametrii dați:

  • mode trebuie să fie fie I2C.CONTROLLER, fie I2C.PERIPHERAL.

  • addr este adresa pe 7 biți (utilă doar pentru un periferic).

  • baudrate este rata ceasului SCL (utilă doar pentru un controler).

  • gencall indică dacă se suportă modul general-call.

  • dma indică dacă se permite utilizarea DMA pentru transferurile I2C (rețineți că transferurile DMA au o sincronizare mai precisă, dar în prezent nu gestionează corect erorile de magistrală).

Frecvența reală a ceasului poate fi mai mică decât frecvența solicitată. Aceasta depinde de hardware-ul platformei. Rata reală poate fi determinată prin afișarea obiectului I2C.

is_ready(addr: int) → bool

Verifică dacă un dispozitiv I2C răspunde la adresa dată. Valabilă doar în modul controler.

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

Citește din memoria unui dispozitiv I2C:

  • data poate fi un întreg (numărul de octeți de citit) sau un tampon în care se citește

  • addr este adresa dispozitivului I2C

  • memaddr este locația de memorie din interiorul dispozitivului I2C

  • timeout este timpul de așteptare în milisecunde pentru citire

  • addr_size selectează lățimea lui memaddr: 8 sau 16 biți

Returnează datele citite. Valabilă doar în modul controler.

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

Scrie în memoria unui dispozitiv I2C:

  • data poate fi un întreg sau un tampon din care se scrie.

  • addr este adresa dispozitivului I2C.

  • memaddr este locația de memorie din interiorul dispozitivului I2C.

  • timeout este timpul de așteptare în milisecunde pentru scriere.

  • addr_size selectează lățimea lui memaddr: 8 sau 16 biți.

Valabilă doar în modul controler.

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

Recepționează date pe magistrală:

  • recv poate fi un întreg, care reprezintă numărul de octeți de recepționat, sau un tampon modificabil, care va fi umplut cu octeții recepționați

  • addr este adresa de la care se recepționează (necesară doar în modul controler)

  • timeout este timpul de așteptare în milisecunde pentru recepție

Valoarea returnată: dacă recv este un întreg, atunci un nou tampon cu octeții recepționați, altfel același tampon care a fost transmis în recv.

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

Trimite date pe magistrală:

  • send reprezintă datele de trimis (un întreg de trimis sau un obiect tampon).

  • addr este adresa către care se trimite (necesară doar în modul controler).

  • timeout este timpul de așteptare în milisecunde pentru trimitere.

scan() → List[int]

Scanează toate adresele I2C de la 0x01 la 0x7f și returnează o listă cu cele care răspund. Valabilă doar în modul controler.

Constante

CONTROLLER: int

Inițializează magistrala ca master (controler) – aceasta acționează SCL și inițiază tranzacțiile.

PERIPHERAL: int

Inițializează magistrala ca slave (periferic) care ascultă pe adresa addr setată în init() și răspunde tranzacțiilor inițiate de un controler pe aceeași magistrală.