Utilitaires I2C à Linux
Description
De nos jours, la plupart des systèmes Linux sont équipés de ces commandes. Si un système n'a pas ces commandes, celles-ci peuvent être compilées pour le système lui-même. La compilation pour le système lui-même ne peut être effectué que si l'installation de compilateur est disponible. Si le compilateur n'est pas disponible, alors ceux-ci doivent être compilés en croix. Le code source de ces outils est les étapes open-source et de compilation sont les mêmes que les autres outils Linux.
Les commandes largement utilisées disponibles dans le package I2C-Tools sont: i2cdetect, i2cdump, i2cget, i2cset, i2ctransfer. Discutons en détail de ces commandes.
i2cdetect
Cette commande est utilisée pour détecter et répertorier tous les bus I2C disponibles et connus du Linux.
Il peut y avoir plusieurs contrôleurs / bus I2C disponibles dans le système et tous les bus peuvent être répertoriés avec la commande i2cdetect. L'exemple d'utilisation de l'I2CDetect est: i2cdetect -l
Cette commande donne la sortie ci-dessous sur un système:
[root] $ i2cdetect -l
I2C-1 I2C 0B234500.Adaptateur I2C-BUS I2C
I2C-2 I2C 0B234580.Adaptateur I2C-BUS I2C
I2C-0 I2C 0B234580.Adaptateur I2C-BUS I2C
I2C-5 I2C 0B234500.Adaptateur I2C-BUS I2C
[racine] $
Dans la sortie ci-dessus, nous pouvons voir que lorsque nous exécutons cette commande avec -l option, il répertorie tous les bus I2C du système. Dans la sortie, nous pouvons voir qu'il y a 4 bus disponibles et connus du Linux. 0, 1, 2 et 5 sont le numéro de bus attribué par le noyau Linux. Ce sont les nombres nécessaires dans d'autres opérations de commande.
De plus amples informations sur tous les esclaves connectés au bus spécifique peuvent également être recherchés avec cette commande. Par exemple, si nous voulons obtenir les détails sur le bus no 0, nous pouvons émettre la commande comme i2cget -y 0.
La sortie de la commande sur notre système est:
[root] $ i2cdetect -y 0
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
dix: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: 30 - - - - - 36 -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: 50 - 52 -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
[racine] $
Comme nous pouvons le voir dans les journaux ci-dessus, il y a 4 esclaves sur le bus 0. L'adresse esclave de ces dispositifs d'esclaves I2C sur le bus 0 est 0x30, 0x36, 0x50, 0x52. Cette adresse d'esclave I2C est également nécessaire pour les commandes i2cget, i2cget, i2cdump.
I2CGET
I2CGET peut être utilisé pour lire l'appareil esclave I2C. Toute adresse lisible interne peut être lue avec la commande i2cget. L'utilisation de cette commande peut être démontrée avec une instance, disons que nous voulons lire l'adresse décalée / interne comme 0x0 de l'appareil esclave I2C avec adresse d'esclave (0x50) sur le bus no 0. Les journaux de l'opération depuis l'appareil sont:
[root] $ i2cget -y 0 0x50 0
0x23
[racine] $
Dans les journaux de sortie. on peut voir les données à l'offset 0 est 0x23. De la même manière, cette commande peut être utilisée pour lire n'importe quel appareil esclave sur n'importe quel bus I2C ou toute adresse interne de l'appareil esclave I2C.
i2cset
La commande I2CGET peut être utilisée pour écrire les données à n'importe quelle adresse interne spécifiée du périphérique esclave I2C. L'adresse du périphérique interne I2C doit être écrivable. L'opération d'écriture I2C peut être protégée au niveau de l'appareil ou toute adresse interne peut être écrite uniquement. Avec toutes les autorisations en écriture, la commande i2CSet peut mettre à jour l'appareil.
Exemple d'utilisation de la commande, prenons un exemple d'écriture d'une valeur de données 0x12 à un appareil esclave RTC avec l'adresse d'esclave 0x68 à décalage 0x2. Nous démontrerons l'opération d'écriture dans la séquence suivante:
- Lisez l'appareil à Offset 0x2
- Écrivez le 0x12 au décalage 0x2 de l'appareil esclave 0x68
- Lisez l'appareil à Offset 0x2 et vérifiez que les données doivent être 0x12.
1.Lisez l'appareil à Offset 0x2.
[root] $ i2cget -y 1 0x68 0x2
0x14
[racine] $
2.Écrivez le 0x12 au décalage 0x2 de l'appareil esclave 0x68
[root] $ i2cset -y 1 0x68 0x2 0x12
[racine] $
3.Lisez l'appareil à Offset 0x2 et vérifiez que les données doivent être 0x12.
[root] $ i2cget -y 1 0x68 0x2
0x12
[racine] $
Ci-dessus Exemple étapes / sortie dans la case montre l'opération d'écriture sur le dispositif d'esclave I2C. Des étapes similaires peuvent être suivies pour rédiger des données sur l'appareil esclave I2C. L'adresse d'esclaves, les données ou le numéro de bus peuvent être modifiés selon le système et le besoin.
i2cdump
La commande I2CDump peut être utilisée pour vider les données de n'importe quel appareil esclave I2C. Seule la saisie nécessaire pour cette exécution de commande est le numéro de bus I2C, adresse d'esclave. Une gamme d'adresse peut également être spécifiée avec la commande. Prenons un exemple de lecture des octets de décalage 0x0 à 0xf i.e., 16 octets premiers.
[root] $ i2cdump -y -r 0x0-0xf 1 0x68
Aucune taille spécifiée (en utilisant l'accès aux données octets)
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)????!… ?.
[racine] $
L'adresse de plage est facultative, si cette plage n'est pas spécifiée par défaut, il vide les premiers octets 0xFF. je.e., 256 octets.
i2ctransfert
La commande i2ctransfer est très utile et peut être utilisée pour lire ou écrire plusieurs nombres d'octets dans la même commande.
i2ctransfer Pour lire 14 octets de 0ffset 0x2, la commande sera la suivante:
[root] $ i2ctransfer -y 1 w1 @ 0x68 2 r14
0x12 0x06 0x08 0x10 0x21 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x18 0x00
[racine] $
i2ctransfer Pour écrire 2 octets Data 0x10, 0x16 à Offset 0x1 et 0x2, la commande sera la suivante:
[root] $ i2ctransfer -y 1 w3 @ 0x68 1 0x10 0x16
[racine] $
Relire; Pour confirmer les données d'écriture:
[root] $ i2ctransfer -y 1 w1 @ 0x68 1 r2
0x10 0x16
[racine] $
Des exemples ci-dessus ont démontré l'utilisation de I2Ctransfer avec une instance. À l'aide de ces usages, un autre cas d'utilisation peut être facilement effectué. Tout appareil esclave et toute adresse interne peuvent être lus à l'aide de cette commande.
Et si le dispositif esclave est adressable de 2 octets?
Il y a peu de dispositifs d'esclaves I2C, en particulier un dispositif EEPROM qui est adhéchant à 2 octets. Le transfert I2C offre le moyen plus facile d'accéder à l'appareil dans un tel scénario. Si cet appareil, nous voulons accéder à I2CGET / I2CSET, nous devons considérer les 2 octets adressant.
J'ai un appareil EEPROM avec moi qui est adressable de 2 octets. Observons le I2CGET / I2CSET avec EEPROM, puis nous observerons le I2CTRANSFER:
Nous essaierons de lire l'octet à partir de décalage 0. Nous essaierons avec la même commande que celle discutée dans la section précédente de I2CGET I.e., La commande sera: i2cget -y 1 0x50 0
[root] $ i2cget -y 1 0x50 0
0xff
[racine] $
Nous pouvons voir que les données renvoyées sont 0xff, donc ce ne sont pas les données correctes.
Pour lire avec succès à partir de Offset 0, nous devons d'abord écrire une adresse de 2 octets avec la commande I2CSET. C'est la façon de lire les données à partir d'un appareil adhérent à 2 octets. Exemple de cas d'utilisation:
[root] $ i2cset -y 1 0x50 0x0 0x0
[root] $ i2cget -y 1 0x50
0x45
[racine] $
Dans la commande i2cset, nous devons écrire l'adresse EEPROM interne de 2 octets. Deux 0 après l'adresse d'esclaves 0x50 sont l'adresse EEPROM interne comme 0x0000.
Après cela, si nous lisons les données avec I2CGET, nous obtiendrons les données correctes. On peut voir dans notre exemple c'est 0x45. Auparavant, c'était 0xff, qui est une données non valide.
I2CTRANSFER dans le dispositif d'adressage de 2 octets
i2ctransfer peut fournir aux données la même commande. Considérez le même exemple de cas d'utilisation à partir de i2cget / i2cset comme ci-dessus.
[root] $ i2ctransfer -y 1 w2 @ 0x50 0x0 0x0 R1
0x45
[racine] $
Avec cette commande, nous pouvons lire les données à Offset 0000. Notez que nous devons écrire une adresse interne après avoir divisé en 2 octets.
Un autre exemple, en lisant 16 octets à partir du décalage 0x0000:
[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
[racine] $
Un autre exemple pour lire 4 octets à partir du décalage 0x0004:
[root] $ i2ctransfer -y 1 w2 @ 0x50 0x0 0x4 r4
0x41 0x42 0x42 0x43
[racine] $
Cet exemple peut être vérifié avec l'opération de lecture précédente où nous avons lu 16 octets à partir du décalage 0000. Maintenant, nous avons lu le sous-ensemble. Si nous comparons les résultats de cette opération de lecture et vérifions avec la précédente, les résultats correspondent exactement. Par conséquent, nous pouvons conclure que cette lecture est réussie.
Conclusion
Nous avons discuté du package d'outils I2C dans Linux. Diverses commandes sont disponibles dans ce package I2C-Tools. Quelques cas d'utilisation spéciaux comme l'adresse de 2 octets, comment utiliser les commandes dans ces scénarios spéciaux. Beaucoup d'exemples que nous avons vus jusqu'à présent. Nous avons confirmé toutes les commandes fonctionnant avec l'exemple et les démonstrations. I2cset, i2cget, i2cdump, i2cdetect et i2ctransfer sont les commandes du package i2c -tools.