class I2C – een tweedraads serieel protocol¶

I2C is een tweedraads protocol voor communicatie tussen apparaten. Op fysiek niveau bestaat het uit twee lijnen, SCL (klok) en SDA (data). De OpenMV Cam levert op geen van beide lijnen ingebouwde pull-ups – er zijn externe pull-ups vereist op zowel SCL als SDA om de bus te laten werken.

I2C-objecten zijn gekoppeld aan een specifieke bus en kunnen tijdens de constructie of later via init() worden geïnitialiseerd.

Voorbeeld:

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

Het afdrukken van het I2C-object toont de configuratie ervan.

De basismethoden zijn send() en 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

Om ter plaatse te ontvangen, maakt u eerst een bytearray aan:

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

U kunt een time-out (in ms) opgeven:

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

Een controller moet het adres van de ontvanger opgeven:

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

Een controller heeft daarnaast deze methoden:

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

Constructors¶

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

Construeer een I2C-object op de gegeven bus (een geheel getal als randapparaatindex, bijv. 2 voor I2C2). Zonder aanvullende parameters wordt het object aangemaakt maar niet geïnitialiseerd (het behoudt de vorige businstellingen, indien aanwezig); als er extra argumenten worden opgegeven, wordt de bus geïnitialiseerd. Zie init() voor de beschikbare parameters.

I2C(2) is op elke OpenMV Cam die pyb.I2C blootstelt (M4 / M7 / H7 / H7 Plus / Pure Thermal) bedraad naar dezelfde header-pinnen:

Signaal	Header-pin	Opmerkingen
`SCL`	`P4`
`SDA`	`P5`

I2C(4) is daarnaast beschikbaar op de OpenMV Cam M7, H7, H7 Plus en Pure Thermal, met SCL op header-pin P7 en SDA op header-pin P8.

De OpenMV Cam N6 stelt pyb.I2C niet beschikbaar; gebruik in plaats daarvan machine.I2C.

Methods¶

deinit() → None¶: Schakel de I2C-bus uit.

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

Initialiseer de I2C-bus met de gegeven parameters:

mode moet ofwel I2C.CONTROLLER ofwel I2C.PERIPHERAL zijn.

addr is het 7-bits adres (alleen zinvol voor een peripheral).

baudrate is de SCL-kloksnelheid (alleen zinvol voor een controller).

gencall geeft aan of de general-call-modus moet worden ondersteund.

dma geeft aan of het gebruik van DMA voor de I2C-overdrachten is toegestaan (let op: DMA-overdrachten hebben een nauwkeurigere timing maar verwerken busfouten momenteel niet correct).

De feitelijke klokfrequentie kan lager zijn dan de gevraagde frequentie. Dit hangt af van de platformhardware. De feitelijke snelheid kan worden bepaald door het I2C-object af te drukken.

is_ready(addr: int) → bool¶: Controleer of een I2C-apparaat reageert op het gegeven adres. Alleen geldig in de controllermodus.

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

Lees uit het geheugen van een I2C-apparaat:

data kan een geheel getal zijn (aantal te lezen bytes) of een buffer om in te lezen

addr is het I2C-apparaatadres

memaddr is de geheugenlocatie binnen het I2C-apparaat

timeout is de time-out in milliseconden om op de leesbewerking te wachten

addr_size selecteert de breedte van memaddr: 8 of 16 bits

Geeft de gelezen data terug. Dit is alleen geldig in de controllermodus.

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

Schrijf naar het geheugen van een I2C-apparaat:

data kan een geheel getal of een buffer zijn om uit te schrijven.

addr is het I2C-apparaatadres.

memaddr is de geheugenlocatie binnen het I2C-apparaat.

timeout is de time-out in milliseconden om op de schrijfbewerking te wachten.

addr_size selecteert de breedte van memaddr: 8 of 16 bits.

Alleen geldig in de controllermodus.

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

Ontvang data op de bus:

recv kan een geheel getal zijn, namelijk het aantal te ontvangen bytes, of een muteerbare buffer, die met ontvangen bytes wordt gevuld

addr is het adres om van te ontvangen (alleen vereist in de controllermodus)

timeout is de time-out in milliseconden om op de ontvangst te wachten

Retourwaarde: als recv een geheel getal is, dan een nieuwe buffer met de ontvangen bytes, anders dezelfde buffer die aan recv is doorgegeven.

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

Verzend data op de bus:

send is de te verzenden data (een geheel getal om te verzenden, of een bufferobject).

addr is het adres om naar te verzenden (alleen vereist in de controllermodus).

timeout is de time-out in milliseconden om op de verzending te wachten.

scan() → List[int]¶: Scan alle I2C-adressen van 0x01 tot 0x7f en geef een lijst terug van degene die reageren. Alleen geldig in de controllermodus.

Constants¶

CONTROLLER: int¶: Initialiseert de bus als de master (controller) – deze stuurt SCL aan en initieert transacties.

PERIPHERAL: int¶: Initialiseert de bus als een slave (peripheral) die luistert op het addr dat is ingesteld in init() en reageert op transacties die door een controller op dezelfde bus zijn gestart.