I2CTarget osztály – egy I2C céleszköz¶

Az I2C céleszköz olyan eszköz, amely egy I2C buszhoz csatlakozik, és amelyet egy I2C vezérlő irányít. Az I2C céleszközök sokféle formát ölthetnek. A machine.I2CTarget osztály egy olyan I2C céleszközt valósít meg, amely memória/regiszter eszközként, vagy visszahívások használatával tetszőleges I2C eszközként konfigurálható (ha a port támogatja).

Elérhető az OpenMV Cam M4 / M7 / H7 / H7 Plus / Pure Thermal / RT1062 / AE3 modelleken.

Példa a használatra memóriaeszköz esetén:

from machine import I2CTarget

# Create the backing memory for the I2C target.
mem = bytearray(8)

# Create an I2C target.  Depending on the port, extra parameters
# may be required to select the peripheral and/or pins to use.
i2c = I2CTarget(addr=67, mem=mem)

# At this point an I2C controller can read and write `mem`.
...

# Deinitialise the I2C target.
i2c.deinit()

Vegye figyelembe, hogy egyes portok megkövetelik egy id, és esetleg az scl és sda lábak átadását az I2CTarget konstruktornak, hogy kiválaszthassa a hardveres I2C példányt és a hozzá csatlakozó lábakat.

Memóriaeszközként konfigurálva események fogadására is fel lehet iratkozni. Például hogy értesülj arról, amikor a memóriát olvassák/írják:

from machine import I2CTarget

# Define an IRQ handler, for I2C events.
def irq_handler(i2c_target):
    flags = i2c_target.irq().flags()
    if flags & I2CTarget.IRQ_END_READ:
        print("controller read target at addr", i2c_target.memaddr)
    if flags & I2CTarget.IRQ_END_WRITE:
        print("controller wrote target at addr", i2c_target.memaddr)

# Create the I2C target and register to receive default events.
mem = bytearray(8)
i2c = I2CTarget(addr=67, mem=mem)
i2c.irq(irq_handler)

Bonyolultabb I2C eszközök az események teljes készletével valósíthatók meg. Például a nyers események megtekintéséhez, ahogy kiváltódnak:

from machine import I2CTarget

# Define an IRQ handler that prints the event id and responds to reads/writes.
def irq_handler(i2c_target, buf=bytearray(1)):
    flags = i2c_target.irq().flags()
    print(flags)
    if flags & I2CTarget.IRQ_READ_REQ:
        i2c_target.write(buf)
    if flags & I2CTarget.IRQ_WRITE_REQ:
        i2c_target.readinto(buf)

# Create the I2C target and register to receive all events.
i2c = I2CTarget(addr=67)
all_triggers = (
    I2CTarget.IRQ_ADDR_MATCH_READ
    | I2CTarget.IRQ_ADDR_MATCH_WRITE
    | I2CTarget.IRQ_READ_REQ
    | I2CTarget.IRQ_WRITE_REQ
    | I2CTarget.IRQ_END_READ
    | I2CTarget.IRQ_END_WRITE
)
i2c.irq(irq_handler, trigger=all_triggers, hard=True)

Konstruktorok¶

class machine.I2CTarget(id: int, addr: int, *, addrsize: int = 7, mem: bytearray | None = None, mem_addrsize: int = 8, scl: Pin | None = None, sda: Pin | None = None)¶

Hozzon létre és adjon vissza egy új I2CTarget objektumot a következő paraméterekkel:

Az id egy adott I2C perifériát azonosít. Az engedélyezett értékek az adott porttól/kártyától függenek. Egyes portoknak van alapértelmezett értékük, ebben az esetben ez a paraméter elhagyható.

Az addr a céleszköz I2C címe.

Az addrsize az I2C céleszköz címében lévő bitek száma. Az érvényes értékek a 7 és a 10.

A mem egy írható, puffer protokollt megvalósító objektum. Ha nincs megadva, akkor nincs háttérmemória, és az adatokat az I2CTarget.readinto() és I2CTarget.write() metódusokkal kell olvasni/írni.

A mem_addrsize a memóriacímben lévő bitek száma. Az érvényes értékek a 0, 8, 16, 24 és 32.

Az scl egy láb objektum, amely megadja az SCL-hez használandó lábat.

Az sda egy láb objektum, amely megadja az SDA-hoz használandó lábat.

Vegye figyelembe, hogy egyes portoknál/kártyáknál az scl és sda alapértelmezett értékei ebben a konstruktorban módosíthatók. Másoknál az scl és sda rögzített értékűek, amelyek nem módosíthatók.

Általános metódusok¶

deinit() → None¶: Megszünteti az I2C céleszköz inicializálását. A metódus meghívása után a hardver már nem válaszol az I2C buszon érkező kérésekre, és más metódus sem hívható meg.

readinto(buf: bytearray) → int¶: Beolvassa a megadott pufferbe az I2C vezérlő által írt függőben lévő bájtokat. Visszaadja az olvasott bájtok számát.

write(buf: bytes) → int¶: Kiírja a megadott pufferből a bájtokat, amelyek az I2C vezérlőnek lesznek átadva, miután az olvasási kérést küld. Visszaadja a kiírt bájtok számát. A legtöbb port egyszerre csak egy bájtot fogad el ennél a metódusnál.

irq(handler: Callable[[I2CTarget], None] | None = None, trigger: int = IRQ_END_READ | IRQ_END_WRITE, hard: bool = False) → None¶

Telepít egy handler IRQ-kezelőt, amely akkor hívódik meg, amikor a trigger által kiválasztott események egyike kiváltódik. A trigger egy IRQ_* konstansokból VAGY-olással összeállított bitmaszk; az alapértelmezés minden vezérlőoldali olvasás vagy írás végén kivált.

A hard=True egy hardveres megszakítás-kezelőt regisztrál (nincs heap-allokáció a visszahívásban). Az alapértelmezés egy ütemezett visszahívás. A megszakítás letiltásához add át a handler=None értéket.

Megjegyzés

Az IRQ_ADDR_MATCH_READ, IRQ_ADDR_MATCH_WRITE, IRQ_READ_REQ és IRQ_WRITE_REQ eseményeket hardveres IRQ visszahívással (hard=True) kell kezelni, mert ezeket az eseményeket a hardverrel szinkronban kell nyugtázni. Az IRQ_END_READ és IRQ_END_WRITE eseményeket szoftveres vagy hardveres visszahívás is kezelheti; minden esemény egyetlen kezelőn osztozik, így ha bármelyik eseménynek hardveres visszahívásra van szüksége, akkor mindegyiknek arra van.

Amikor egy memóriapuffert ad át a konstruktornak, az illesztőprogram elnyomja az IRQ_END_WRITE eseményt annál a tranzakciónál, amely éppen a memóriacímet írja. Ez akkor is értelmessé teszi a tranzakció végét jelző eseményeket, ha a szoftveres IRQ-ütemező késlelteti a visszahívást.

memaddr¶: Az I2C vezérlő által legutóbb kiválasztott memóriacím egész értéke (csak akkor érvényes, ha a mem meg volt adva a konstruktorban).

Konstansok¶

Minden IRQ_* konstans egy jelzőbit. VAGY-old össze őket egy trigger maszk létrehozásához az irq() számára. A kezelőn belül a kiváltott események halmaza a self.irq().flags() és az egyes konstansok ÉS-elésével nyerhető vissza.

IRQ_ADDR_MATCH_READ: int¶: Akkor vált ki, amikor egy vezérlő egy olvasási tranzakcióhoz megcímzi ezt a céleszközt (a címbájt megérkezett, és az olvasás/írás bit 1 értékre van állítva). Csak hardveres IRQ.

IRQ_ADDR_MATCH_WRITE: int¶: Akkor vált ki, amikor egy vezérlő egy írási tranzakcióhoz megcímzi ezt a céleszközt (a címbájt megérkezett, és az olvasás/írás bit 0 értékre van állítva). Csak hardveres IRQ.

IRQ_READ_REQ: int¶: Akkor vált ki, amikor a vezérlő egy bájtot kér a céleszköztől. A kezelőnek meg kell hívnia a write() metódust, hogy a vezérlő órajel-ciklusának befejeződése előtt szolgáltassa a bájtot. Csak hardveres IRQ.

IRQ_WRITE_REQ: int¶: Akkor vált ki, amikor a vezérlő beírt egy bájtot a céleszközbe. A kezelőnek meg kell hívnia a readinto() metódust, hogy lekérje a bájtot, mielőtt a vezérlő a következőt küldi. Csak hardveres IRQ.

IRQ_END_READ: int¶: Akkor vált ki, amikor a vezérlő befejezett egy olvasási tranzakciót (STOP / ismételt START érkezett). Hardveres vagy szoftveres IRQ visszahívás is kezelheti.

IRQ_END_WRITE: int¶: Akkor vált ki, amikor a vezérlő befejezett egy írási tranzakciót (STOP / ismételt START érkezett). Hardveres vagy szoftveres IRQ visszahívás is kezelheti. Elnyomódik annál a tranzakciónál, amely a memóriacímet írja, ha egy mem puffer volt megadva a konstruktorban.