class I2CTarget – ein I2C-Target-Gerät¶

Ein I2C-Target ist ein Gerät, das mit einem I2C-Bus verbunden wird und von einem I2C-Controller gesteuert wird. I2C-Targets können viele Formen annehmen. Die Klasse machine.I2CTarget implementiert ein I2C-Target, das als Speicher-/Register-Gerät oder als beliebiges I2C-Gerät unter Verwendung von Callbacks konfiguriert werden kann (sofern vom Port unterstützt).

Verfügbar auf der OpenMV Cam M4 / M7 / H7 / H7 Plus / Pure Thermal / RT1062 / AE3.

Beispielverwendung für den Fall eines Speichergeräts:

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

Beachten Sie, dass einige Ports erfordern, dass eine id und gegebenenfalls scl- und sda-Pins an den I2CTarget-Konstruktor übergeben werden, um die Hardware-I2C-Instanz und die Pins auszuwählen, mit denen sie verbunden ist.

Wenn es als Speichergerät konfiguriert ist, ist es auch möglich, sich zum Empfang von Ereignissen zu registrieren. Zum Beispiel, um benachrichtigt zu werden, wenn der Speicher gelesen/geschrieben wird:

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)

Kompliziertere I2C-Geräte können unter Verwendung des vollständigen Satzes von Ereignissen implementiert werden. Zum Beispiel, um die rohen Ereignisse zu sehen, sobald sie ausgelöst werden:

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)

Konstruktoren¶

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

Konstruiert ein neues I2CTarget-Objekt mit den folgenden Parametern und gibt es zurück:

id identifiziert ein bestimmtes I2C-Peripheriegerät. Die zulässigen Werte hängen vom jeweiligen Port/Board ab. Einige Ports haben einen Standardwert, in welchem Fall dieser Parameter weggelassen werden kann.

addr ist die I2C-Adresse des Targets.

addrsize ist die Anzahl der Bits in der I2C-Target-Adresse. Gültige Werte sind 7 und 10.

mem ist ein beschreibbares Objekt mit dem Buffer-Protokoll. Wenn es nicht angegeben wird, gibt es keinen zugrundeliegenden Speicher, und Daten müssen über die Methoden I2CTarget.readinto() und I2CTarget.write() gelesen/geschrieben werden.

mem_addrsize ist die Anzahl der Bits in der Speicheradresse. Gültige Werte sind 0, 8, 16, 24 und 32.

scl ist ein Pin-Objekt, das den für SCL zu verwendenden Pin angibt.

sda ist ein Pin-Objekt, das den für SDA zu verwendenden Pin angibt.

Beachten Sie, dass einige Ports/Boards Standardwerte für scl und sda haben, die in diesem Konstruktor geändert werden können. Andere haben feste Werte für scl und sda, die nicht geändert werden können.

Allgemeine Methoden¶

deinit() → None¶: Deinitialisiert das I2C-Target. Nach dem Aufruf dieser Methode reagiert die Hardware nicht mehr auf Anfragen auf dem I2C-Bus, und es können keine anderen Methoden aufgerufen werden.

readinto(buf: bytearray) → int¶: Liest alle ausstehenden, vom I2C-Controller geschriebenen Bytes in den angegebenen Puffer. Gibt die Anzahl der gelesenen Bytes zurück.

write(buf: bytes) → int¶: Gibt die Bytes aus dem angegebenen Puffer aus, die an den I2C-Controller übergeben werden sollen, nachdem dieser eine Leseanforderung gesendet hat. Gibt die Anzahl der geschriebenen Bytes zurück. Die meisten Ports akzeptieren bei dieser Methode nur ein Byte auf einmal.

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

Installiert einen IRQ-handler, der aufgerufen wird, wenn eines der durch trigger ausgewählten Ereignisse auslöst. trigger ist eine Bitmaske aus mit ODER verknüpften IRQ_*-Konstanten; der Standard löst am Ende jedes Lese- oder Schreibvorgangs auf der Controller-Seite aus.

hard=True registriert einen Hard-Interrupt-Handler (keine Heap-Allokation im Callback). Der Standard ist ein geplanter Callback. Übergeben Sie handler=None, um den Interrupt zu deaktivieren.

Bemerkung

IRQ_ADDR_MATCH_READ, IRQ_ADDR_MATCH_WRITE, IRQ_READ_REQ und IRQ_WRITE_REQ müssen von einem Hard-IRQ-Callback (hard=True) behandelt werden, weil die Ereignisse synchron mit der Hardware bestätigt werden müssen. IRQ_END_READ und IRQ_END_WRITE können von soften oder harten Callbacks behandelt werden; alle Ereignisse teilen sich einen einzigen Handler, sodass, wenn ein Ereignis einen Hard-Callback benötigt, alle einen benötigen.

Wenn dem Konstruktor ein Speicherpuffer übergeben wird, unterdrückt der Treiber IRQ_END_WRITE für die Transaktion, die lediglich die Speicheradresse schreibt. So bleiben die Ereignisse am Transaktionsende auch dann aussagekräftig, wenn der Soft-IRQ-Scheduler den Callback verzögert.

memaddr¶: Der Ganzzahlwert der zuletzt vom I2C-Controller ausgewählten Speicheradresse (nur gültig, wenn mem im Konstruktor angegeben wurde).

Konstanten¶

Jede IRQ_*-Konstante ist ein Flag-Bit. Verknüpfen Sie sie mit ODER, um eine trigger-Maske für irq() aufzubauen. Innerhalb des Handlers kann der Satz der ausgelösten Ereignisse über self.irq().flags() UND-verknüpft mit jeder Konstante ermittelt werden.

IRQ_ADDR_MATCH_READ: int¶: Löst aus, wenn ein Controller dieses Target für eine Lesetransaktion adressiert (das Adressbyte wurde mit auf 1 gesetztem Lese-/Schreib-Bit empfangen). Nur Hard-IRQ.

IRQ_ADDR_MATCH_WRITE: int¶: Löst aus, wenn ein Controller dieses Target für eine Schreibtransaktion adressiert (das Adressbyte wurde mit auf 0 gesetztem Lese-/Schreib-Bit empfangen). Nur Hard-IRQ.

IRQ_READ_REQ: int¶: Löst aus, wenn der Controller ein Byte vom Target anfordert. Der Handler muss write() aufrufen, um das Byte bereitzustellen, bevor der Taktzyklus des Controllers abgeschlossen ist. Nur Hard-IRQ.

IRQ_WRITE_REQ: int¶: Löst aus, wenn der Controller ein Byte in das Target eingetaktet hat. Der Handler muss readinto() aufrufen, um das Byte abzurufen, bevor der Controller das nächste sendet. Nur Hard-IRQ.

IRQ_END_READ: int¶: Löst aus, wenn der Controller eine Lesetransaktion abgeschlossen hat (STOP / wiederholtes START empfangen). Kann von einem harten oder soften IRQ-Callback behandelt werden.

IRQ_END_WRITE: int¶: Löst aus, wenn der Controller eine Schreibtransaktion abgeschlossen hat (STOP / wiederholtes START empfangen). Kann von einem harten oder soften IRQ-Callback behandelt werden. Unterdrückt für die Transaktion, die die Speicheradresse schreibt, wenn dem Konstruktor ein mem-Puffer übergeben wurde.