class I2CTarget – en I2C-målenhet¶

Ett I2C-mål är en enhet som ansluter till en I2C-buss och styrs av en I2C-styrenhet. I2C-mål kan ta många former. Klassen machine.I2CTarget implementerar ett I2C-mål som kan konfigureras som en minnes-/registerenhet, eller som en godtycklig I2C-enhet genom att använda återanrop (om porten stöder det).

Tillgänglig på OpenMV Cam M4 / M7 / H7 / H7 Plus / Pure Thermal / RT1062 / AE3.

Exempel på användning för fallet med en minnesenhet:

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

Observera att vissa portar kräver att ett id, och kanske scl- och sda-stift, skickas till I2CTarget-konstruktorn för att välja den hårdvaru-I2C-instans och de stift som den ansluter till.

När den är konfigurerad som en minnesenhet är det också möjligt att registrera sig för att ta emot händelser. Till exempel för att bli meddelad när minnet läses/skrivs:

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)

Mer komplicerade I2C-enheter kan implementeras med hjälp av den fullständiga uppsättningen händelser. Till exempel för att se de råa händelserna när de utlöses:

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)

Konstruktorer¶

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

Konstruera och returnera ett nytt I2CTarget-objekt med följande parametrar:

id identifierar en viss I2C-kringutrustning. Tillåtna värden beror på den specifika porten/kortet. Vissa portar har ett standardvärde, i vilket fall denna parameter kan utelämnas.

addr är målets I2C-adress.

addrsize är antalet bitar i I2C-måladressen. Giltiga värden är 7 och 10.

mem är ett objekt med buffertprotokollet som är skrivbart. Om det inte anges finns det inget bakomliggande minne och data måste läsas/skrivas med metoderna I2CTarget.readinto() och I2CTarget.write().

mem_addrsize är antalet bitar i minnesadressen. Giltiga värden är 0, 8, 16, 24 och 32.

scl är ett stiftobjekt som anger vilket stift som ska användas för SCL.

sda är ett stiftobjekt som anger vilket stift som ska användas för SDA.

Observera att vissa portar/kort har standardvärden för scl och sda som kan ändras i denna konstruktor. Andra har fasta värden för scl och sda som inte kan ändras.

Allmänna metoder¶

deinit() → None¶: Avinitialisera I2C-målet. Efter att denna metod har anropats svarar hårdvaran inte längre på förfrågningar på I2C-bussen, och inga andra metoder kan anropas.

readinto(buf: bytearray) → int¶: Läs in i den angivna bufferten eventuella väntande byte som skrivits av I2C-styrenheten. Returnerar antalet lästa byte.

write(buf: bytes) → int¶: Skriv ut byten från den angivna bufferten, som ska skickas till I2C-styrenheten efter att den skickat en läsförfrågan. Returnerar antalet skrivna byte. De flesta portar accepterar bara en byte i taget till denna metod.

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

Installera en IRQ-handler som anropas när någon av händelserna som väljs av trigger utlöses. trigger är en bitmask av IRQ_*-konstanter OR-ade tillsammans; standardvärdet utlöses vid slutet av varje styrenhetssidig läsning eller skrivning.

hard=True registrerar en hård-avbrottshanterare (ingen heap-allokering i återanropet). Standardvärdet är ett schemalagt återanrop. Skicka handler=None för att inaktivera avbrottet.

Anteckning

IRQ_ADDR_MATCH_READ, IRQ_ADDR_MATCH_WRITE, IRQ_READ_REQ och IRQ_WRITE_REQ måste hanteras av ett hårt IRQ-återanrop (hard=True) eftersom händelserna måste kvitteras synkront med hårdvaran. IRQ_END_READ och IRQ_END_WRITE kan hanteras av antingen mjuka eller hårda återanrop; alla händelser delar en enda hanterare, så om någon händelse behöver ett hårt återanrop behöver alla det.

När en minnesbuffert tillhandahålls till konstruktorn undertrycker drivrutinen IRQ_END_WRITE för den transaktion som endast skriver minnesadressen. Detta håller transaktionsslutshändelserna meningsfulla även när mjuk-IRQ-schemaläggaren skjuter upp återanropet.

memaddr¶: Heltalsvärdet för den senaste minnesadressen som valdes av I2C-styrenheten (endast giltigt om mem angavs i konstruktorn).

Konstanter¶

Varje IRQ_*-konstant är en flaggbit. OR:a dem tillsammans för att bygga en trigger-mask för irq(). Inuti hanteraren kan uppsättningen utlösta händelser återställas via self.irq().flags() AND-ad med varje konstant.

IRQ_ADDR_MATCH_READ: int¶: Utlöses när en styrenhet adresserar detta mål för en lästransaktion (adressbyten har tagits emot med läs/skriv-biten satt till 1). Endast hård-IRQ.

IRQ_ADDR_MATCH_WRITE: int¶: Utlöses när en styrenhet adresserar detta mål för en skrivtransaktion (adressbyten har tagits emot med läs/skriv-biten satt till 0). Endast hård-IRQ.

IRQ_READ_REQ: int¶: Utlöses när styrenheten begär en byte från målet. Hanteraren måste anropa write() för att tillhandahålla byten innan styrenhetens klockcykel slutförs. Endast hård-IRQ.

IRQ_WRITE_REQ: int¶: Utlöses när styrenheten har klockat in en byte till målet. Hanteraren måste anropa readinto() för att hämta byten innan styrenheten skickar nästa. Endast hård-IRQ.

IRQ_END_READ: int¶: Utlöses när styrenheten har avslutat en lästransaktion (mottagit STOP / upprepad START). Kan hanteras av antingen ett hårt eller mjukt IRQ-återanrop.

IRQ_END_WRITE: int¶: Utlöses när styrenheten har avslutat en skrivtransaktion (mottagit STOP / upprepad START). Kan hanteras av antingen ett hårt eller mjukt IRQ-återanrop. Undertrycks för den transaktion som skriver minnesadressen när en mem-buffert tillhandahölls till konstruktorn.