I2C -Dienstprogramme unter Linux
Beschreibung
Heutzutage sind die meisten Linux -Systeme mit diesen Befehlen ausgestattet. Wenn ein System diese Befehle nicht hat, können diese für das System selbst kompiliert werden. Die Kompilierung für das System selbst kann nur durchgeführt werden, wenn die Compiler -Einrichtung verfügbar ist. Wenn der Compiler nicht verfügbar ist, müssen diese cross zusammengestellt werden. Der Quellcode dieser Tools ist Open-Source- und Kompilierungsschritte wie anderer Linux-Tools.
Weit verbreitete Befehle im i2c-tools-Paket sind: I2CDETECT, I2CDUMP, I2CGET, I2CSET, I2Ctransfer. Lassen Sie uns diese Befehle ausführlich besprechen.
I2CDETECT
Dieser Befehl wird verwendet, um alle verfügbaren I2C -Busse zu erkennen und aufzulisten, die dem Linux verfügbar sind.
Im System können mehrere i2C -Controller/-busse verfügbar sein, und alle Busse können mit dem Befehl i2cdetekte aufgeführt werden. Die Beispielverwendung des i2cdetekten ist: I2CDETECT -L
Dieser Befehl gibt die folgende Ausgabe eines Systems an:
[root] $ i2cdetekt -l
I2C-1 I2C 0B234500.I2C-Bus I2C-Adapter
I2C-2 I2C 0B234580.I2C-Bus I2C-Adapter
I2C-0 I2C 0B234580.I2C-Bus I2C-Adapter
I2C-5 I2C 0B234500.I2C-Bus I2C-Adapter
[Root] $
In der obigen Ausgabe können wir sehen, dass wenn wir diesen Befehl mit -L -Option ausführen, alle i2C -Busse des Systems auflistet. In der Ausgabe können wir sehen, dass 4 Busse verfügbar und dem Linux bekannt sind. 0, 1, 2 und 5 sind die vom Linux -Kernel zugewiesene Busse -Nummer. Dies sind die Zahlen, die in anderen Befehlsoperationen benötigt werden.
Weitere Informationen zu allen Sklaven, die mit dem jeweiligen Bus verbunden sind. Wenn wir beispielsweise die Details im Bus Nr. 0 erhalten möchten, können wir den Befehl als i2cget -y 0 ausgeben.
Die Ausgabe des Befehls auf unserem System ist:
[root] $ I2CDETECT -Y 0
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: 30 - - - - - 36 -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: 50 - 52 -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
[Root] $
Wie wir in den oben genannten Protokollen sehen können, gibt es 4 Sklaven im Bus 0. Sklavenadresse dieser I2C -Slave -Geräte im Bus 0 sind 0x30, 0x36, 0x50, 0x52. Diese I2C -Slave -Adresse ist auch für i2cget, i2cget, i2cdump -Befehle benötigt.
i2cget
I2Cget kann verwendet werden, um das I2C -Slave -Gerät zu lesen. Jede interne lesbare Adresse kann mit dem Befehl i2cget gelesen werden. Die Auslastung dieses Befehls kann mit einer Instanz demonstriert werden, sagen wir, wir möchten die Offset/Interne -Adresse als 0x0 I2C -Slave -Gerät mit Slave -Adresse (0x50) im Bus Nr. 0 lesen. Protokolle des Betriebs vom Gerät lautet:
[root] $ i2cget -y 0 0x50 0
0x23
[Root] $
In den Ausgabeprotokollen. Wir können die Daten zu Offset 0 sehen, ist 0x23. In ähnlicher Weise kann dieser Befehl verwendet werden, um ein Slave -Gerät in jedem i2C -Bus oder einer internen Adresse des I2C -Slave -Geräts zu lesen.
i2cset
Der Befehl i2cget kann verwendet werden, um die Daten an einer bestimmten internen Adresse des I2C -Slave -Geräts zu schreiben. I2C Die interne Geräteadresse sollte beschreibbar sein. Der I2C-Schreibvorgang kann auf Geräteebene geschützt werden oder eine interne Adresse kann nur schreiben. Mit allen beschreibbaren Berechtigungen kann der Befehl i2cset das Gerät aktualisieren.
Beispiel Verwendung des Befehls, nehmen wir ein Beispiel für das Schreiben eines Datenwerts 0x12 an RTC -Slave -Gerät mit Slave -Adresse 0x68 beim Offset 0x2. Wir werden den Schreibvorgang in der folgenden Sequenz demonstrieren:
- Lesen Sie das Gerät bei Offset 0x2
- Schreiben Sie den 0x12 bei Offset 0x2 des Slave -Geräts 0x68
- Lesen Sie das Gerät bei Offset 0x2 zurück und überprüfen Sie, ob die Daten 0x12 sein sollten.
1.Lesen Sie das Gerät bei Offset 0x2.
[root] $ i2cget -y 1 0x68 0x2
0x14
[Root] $
2.Schreiben Sie den 0x12 bei Offset 0x2 des Slave -Geräts 0x68
[root] $ i2cset -y 1 0x68 0x2 0x12
[Root] $
3.Lesen Sie das Gerät bei Offset 0x2 zurück und überprüfen Sie, ob die Daten 0x12 sein sollten.
[root] $ i2cget -y 1 0x68 0x2
0x12
[Root] $
Oben Beispielschritte/Ausgabe im Box zeigt den Schreibvorgang auf dem I2C -Slave -Gerät. Ähnliche Schritte können befolgt werden, um Daten an das I2C -Slave -Gerät zu schreiben. Sklavenadresse, Daten oder Busnummer können gemäß System und Bedarf geändert werden.
I2CDUMP
Der Befehl i2cdump kann verwendet werden, um Daten von jedem I2C -Slave -Gerät abzugeben. Nur für diese Befehlsausführung benötigte Eingabe ist die I2C -Busnummer, Slave -Adresse. Der Adressbereich kann auch mit dem Befehl angegeben werden. Nehmen wir ein Beispiel für das Lesen von Bytes von Offset 0x0 bis 0xf i.e., Erste 16 Bytes.
[Root] $ I2CDUMP -Y -r 0x0-0xf 1 0x68
Keine Größe angegeben (unter Verwendung von Byte-Daten-Zugriff)
0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
00: 58 29 12 06 08 10 21 00 00 00 00 00 00 00 18 00 x)????!… ?.
[Root] $
Die Bereichsadresse ist optional. Wenn dieser Bereich standardmäßig nicht angegeben ist, wird er zuerst 0xff -Bytes abgelegt. ich.e., 256 Bytes.
I2Ctransfer
Der Befehl i2Ctransfer ist sehr nützlich und kann zum Lesen oder Schreiben einer Vielzahl von Bytes in demselben Befehl verwendet werden.
I2Ctransfer, um 14 Bytes ab 0ffsset 0x2 zu lesen. Der Befehl lautet wie folgt:
[Root] $ I2Ctransfer -y 1 W1@0x68 2 R14
0x12 0x06 0x08 0x10 0x21 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x18 0x00
[Root] $
I2Ctransfer zum Schreiben von 2 Bytes -Daten 0x10, 0x16 bei Offset 0x1 und 0x2 ist der Befehl wie folgt:
[Root] $ I2Ctransfer -y 1 W3@0x68 1 0x10 0x16
[Root] $
Readback; Um die Schreibdaten zu bestätigen:
[Root] $ I2Ctransfer -y 1 W1@0x68 1 R2
0x10 0x16
[Root] $
Oben Beispiele zeigten die I2Ctransfer -Verwendung mit einer Instanz. Mit Hilfe dieser Verwendung kann ein weiterer Anwendungsfälle leicht durchgeführt werden. Jedes Sklavengerät und jede interne Adresse können mit Hilfe dieses Befehls gelesen werden.
Was ist, wenn das Sklavengerät 2-Byte adressierbar ist?
Es gibt nur wenige I2C-Slave-Geräte, insbesondere EEPROM-Geräte, die 2 Byteadressibel sind. Die I2C -Übertragung bietet einen einfacheren Weg, um in einem solchen Szenario auf das Gerät zuzugreifen. Wenn dieses Gerät, möchten wir mit i2cget/i2cset zugreifen, müssen wir die 2 Bytes berücksichtigen.
Ich habe ein EEPROM-Gerät bei mir, das 2-Byte adressierbar ist. Beobachten wir das i2cget/i2cset mit EEPROM und dann werden wir den I2Ctransfer beobachten:
Wir werden versuchen, Byte von Offset 0 zu lesen. Wir werden es mit demselben Befehl versuchen wie im vorherigen Abschnitt von i2cget i.e., Befehl ist: i2cget -y 1 0x50 0
[root] $ i2cget -y 1 0x50 0
0xff
[Root] $
Wir können sehen, dass die zurückgegebenen Daten 0xff sind, daher sind dies nicht die richtigen Daten.
Um erfolgreich ab Offset 0 zu lesen, müssen wir zuerst eine 2-Byte-Adresse mit i2Cset-Befehl schreiben. Auf diese Weise lesen Sie die Daten aus 2 byteadressivem Gerät. Beispiel Anwendungsfall:
[root] $ i2cset -y 1 0x50 0x0 0x0
[Root] $ I2CGet -y 1 0x50
0x45
[Root] $
Im Befehl i2cset müssen wir die 2-Byte-interne EEPROM-Adresse schreiben. Zwei 0 nach Slave -Adresse 0x50 sind die interne EEPROM -Adresse als 0x0000.
Wenn wir die Daten mit I2Cget lesen, erhalten wir die richtigen Daten. Wir können in unserem Beispiel sehen, dass es 0x45 ist. Früher war es 0xff, was ein ungültiges Daten ist.
I2Ctransfer im 2-Byte-Adressgerät
I2Ctransfer kann die Daten mit demselben Befehl liefern. Betrachten Sie denselben Beispielgebrauchsfall wie oben von i2cget/i2cset.
[Root] $ I2Ctransfer -y 1 W2@0x50 0x0 0x0 R1
0x45
[Root] $
Mit diesem Befehl können wir die Daten zu Offset 0000 lesen. Beachten Sie, dass wir nach der Aufteilung in 2 Bytes eine interne Adresse schreiben müssen.
Ein weiteres Beispiel: 16 Bytes vom Offset 0x0000 lesen:
[Root] $ I2Ctransfer -y 1 W2@0x50 0x0 0x0 R16
0x45 0x41 0x3d 0x41 0x41 0x42 0x42 0x43 0x43 0x44 0x44 0x44 0x45 0x45 0x30 0x0a
[Root] $
Ein weiteres Beispiel zum Lesen von 4 Bytes vom Offset 0x0004:
[Root] $ I2Ctransfer -y 1 W2@0x50 0x0 0x4 R4
0x41 0x42 0x42 0x43
[Root] $
Dieses Beispiel kann mit dem vorherigen Lesevorgang überprüft werden, bei dem wir 16 Bytes von Offset 0000 gelesen haben. Jetzt haben wir die Untergruppe gelesen. Wenn wir die Ergebnisse dieser Lesevorrichtung vergleichen und mit dem vorherigen überprüfen, stimmen die Ergebnisse genau überein. Daher können wir zu dem Schluss kommen, dass diese Lektüre erfolgreich ist.
Abschluss
Wir haben das I2C -Toolpaket unter Linux besprochen. In diesem I2C-Tools-Paket sind verschiedene Befehle erhältlich. Einige besondere Anwendungsfälle wie 2-Bytes-Adressierung, Verwenden von Befehlen in diesen speziellen Szenarien. Viele Beispiele haben wir bisher gesehen. Wir haben alle Befehle bestätigt, die mit dem Beispiel und den Demonstrationen funktionieren. I2CSET, I2CGET, I2CDUMP, I2CDETECT und I2Ctransfer sind die Befehle des i2c -Tools -Pakets.