Présentation I2C dans Linux
Description
I2C signifie Inter intégré Circuit, est un protocole à bord pour la communication entre deux CI. C'est un protocole en série, deux fil. Cela suit le mode esclave maître. I2C Master initie toujours la communication et l'horloge pour la communication est également fournie par I2C Master. Sur deux lignes, il peut y avoir plusieurs appareils connectés. Sur un seul maître et de nombreuses configurations d'esclaves, chaque esclave se distinguera avec une adresse d'esclave unique.
Exemple de configuration des esclaves maître et multiples:
Dans le diagramme de bloc ci-dessus, nous pouvons voir qu'il y a un seul maître et 3 esclaves avec des adresses comme mentionné dans la boîte de chaque esclave.
Protocole I2C
La séquence des messages généraux I2C utilisés dans la communication entre le maître et l'esclave est illustré ci-dessous:
Démarrer -> Adresse + R / W Byte -> ACK -> Données Byte1 -> ACK -> Données Byte2 -> ACK -> Données Byte3 -> ACK -> STOP
Commencer: Condition générée par Master pour indiquer qu'il veut communiquer avec l'esclave.
Adresse + R / W Byte: Adresse d'esclave 7 bits et 1 bit pour indiquer si l'opération est lue ou écrivez.
Ack: L'accusé de réception est toujours envoyé pour chaque transfert d'octet. Ceci est envoyé par le dispositif de réception.
Arrêt: Une fois le transfert terminé, le contrôleur / maître enverra la condition d'arrêt pour terminer le transfert.
Dans Linux, les pilotes I2C sont organisés en trois couches logiques:
- maître / pilote d'adaptateur
- Couche I2C-Core
- esclave / client
Pilotes maître / adaptateur I2C
Ceux-ci sont situés dans l'arbre source du noyau sur le chemin: pilotes / i2c / busses /. Pour chaque maître ou contrôleur I2C, il devrait y avoir un pilote présent dans ce chemin. Ceci est le conducteur qui s'inscrit dans la couche I2C-Core et contrôle / gère les bus I2C. Ceci est le conducteur qui communique avec les appareils d'esclaves I2C sur les bus I2C présents sur la plate-forme.
Pilotes I2C-Core
Ceci est la logique de base I2C commune de Linux. Ceci est commun et indépendant de tout maître ou esclave I2C spécifique. Ceci est la mise en œuvre principale du sous-système I2C dans Linux.
I2C Slave / Client pilote
Ceci est le pilote de puce d'esclave nécessaire pour chaque appareil esclave. Tout appareil esclave I2C doit avoir un pilote ou une implémentation présente dans cette catégorie. Ceci est requis pour que tout appareil esclave s'inscrit au sous-système Linux I2C.
Activer les pilotes I2C dans le noyau Linux
L'implémentation liée au noyau I2C sera activée avec les indicateurs de configuration du noyau de base I2C. Le pilote maître I2C sera également activé avec le contrôleur spécifique de la carte I2C. De même, un indicateur de configuration devrait être activé pour le pilote d'esclave I2C.
Toutes les configurations requises peuvent être activées de deux manières. Un en tant que pilote intégré ou comme module de noyau. Les modules du noyau nous fournissent l'avantage de le charger en tant que runtime sans modifier ou compiler le noyau Linux.
L'approche du module ne peut être utilisée que si l'accès à l'appareil ne fait pas partie du chemin de démarrage. Si les données d'un appareil sont nécessaires pour démarrer le système, ces pilotes doivent être intégrés. Ces pilotes ne peuvent pas être compilés comme des modules chargés dynamiquement lors de l'exécution.
Instanciation des appareils I2C
Dans Linux, différentes manières sont présentes pour instancier les appareils I2C. Deux méthodes largement utilisées sont: statique et dynamique
Statique: Sur les systèmes ARM, l'arbre de périphérique peut être utilisé pour créer une instance du périphérique I2C.
Un nœud de périphérique spécifique peut être ajouté dans l'arborescence de l'appareil. Exemple, la déclaration d'arborescence de périphérique pour le périphérique I2C est:
I2C0: I2C @ 60000000
eeprom @ 50
compatible = "atmel, eeprom-at";
reg = <0x50>;
;
rtc @ 60
compatible = "rtc, rtc-maxim";
reg = <0x60>;
;
;
L'exemple ci-dessus crée une instance de 2 appareils d'esclaves I2C. L'un est un appareil EEPROM et un autre est un appareil RTC. Une fois le système qui apparaît, ces entrées peuvent être trouvées dans / SYS / BUS / I2C / DÉPICES / I2C-0 /. Les deux seront créés à l'intérieur du répertoire I2C-0 car ceux-ci sont placés à l'intérieur du nœud I2C 0.
Dynamique: L'instance d'exécution du périphérique I2C peut être créée via des fichiers SYSFS.
Il y a deux fichiers sysfs présents pour chaque bus I2C. new_device et delete_device, les deux fichiers sont en écriture uniquement et l'adresse d'esclave I2C peut être écrite sur ces fichiers pour créer une instance de périphérique et supprimer l'instance de périphérique.
Pour créer un périphérique I2C équivalent aux périphériques définis dans l'arborescence de l'appareil comme l'exemple précédent.
Créer une instance EEPROM avec l'adresse d'esclaves 0x50:
# echo eeprom 0x50> / sys / bus / i2c / périphériques / i2c-0 / new_device
Suppression de l'instance de dispositif EEPROM:
# Echo 0x50> / SYS / BUS / I2C / DÉPICES / I2C-0 / DELETE_DEVICE
Ensuite, le sondage de l'appareil avec le pilote peut également être fait à partir des fichiers SYSFS: il y a deux fichiers en écriture liés et dériver, associés à chaque pilote. Exportation de l'ID de l'appareil vers les résultats des fichiers de liaison et de dénigrement vers la liaison et la non-déverrouillage du pilote avec l'appareil. Par exemple, le pilote RTC-DS1307 a les fichiers ci-dessous dans les SYSFS comme discuté précédemment.
[root] $ ls / sys / bus / i2c / pilotes / rtc-dds1307 /
lier Uevent Unbind
[racine] $
Laissez-nous avoir un peu plus de discussion sur les fichiers sysfs du sous-système I2C:
I2C SYSFS est présent à l'emplacement: / SYS / BUS / I2C /
Instantané des Sysfs I2C:
Comme nous pouvons le voir, il y a deux répertoires: les appareils et les pilotes
Les appareils contiendront toutes les instances de périphérique présentes et connues du noyau Linux. Sur notre tableau, nous avons ci-dessous les appareils I2C à l'intérieur du répertoire des appareils:
Les conducteurs contiendront tous les pilotes I2C présents et connus du noyau Linux. Sur notre planche, nous avons ci-dessous les pilotes I2C à l'intérieur du répertoire des pilotes:
Pour la liaison et la non-liaison des appareils avec les pilotes, il y a deux fichiers en écriture uniquement dans chaque pilote. Pour la liaison de n'importe quel appareil avec le pilote peut être effectué en faisant écho à l'ID de périphérique dans le fichier de liaison et la non-désagréation peut être effectuée en faisant écho à l'ID de périphérique dans le fichier Unbind.
Liaison du périphérique I2C avec le pilote I2C
[root] $ echo 1-0068> / sys / bus / i2c / pilotes / rtc-dds1307 / bind
[592061.085104] RTC-DS1307 1-0068: Enregistré comme RTC0
[racine] $
La confirmation de la liaison réussie peut être effectuée en vérifiant le lien souple créé après l'opération de liaison. Un nouveau lien souple de périphérique peut être vu dans l'instance de journal ci-dessous après avoir exécuté la commande mentionnée dans la section de liaison:
[root] $ ls / sys / bus / i2c / pilotes / rtc-dds1307 /
1-0068 Bind Uevent Unbind
[racine] $
Débinding de l'appareil I2C avec le pilote I2C
[root] $ echo 1-0068> / sys / bus / i2c / pilotes / rtc-dds1307 / unbind
La confirmation de la non-liaison réussie peut être effectuée en vérifiant le nœud de périphérique de liaison souple créé précédemment dans le répertoire des pilotes sera supprimé. Si nous vérifions le contenu du répertoire des pilotes, nous devrions voir l'instantané des journaux comme ci-dessous:
[root] $ ls / sys / bus / i2c / pilotes / rtc-dds1307
lier Uevent Unbind
[racine] $
Applications I2C ou cas d'utilisation en ce qui concerne Linux
- Dispositif eeprom Pour stocker de petites données, la mémoire est de peu de KBS.
- Appareil RTC, utilisé pour conserver les données en temps réel. L'appareil est utilisé pour garder le temps même lorsque le système principal est éteint.
- De nombreux dispositifs de capteurs HW comme les capteurs thermiques, les capteurs de courant et les capteurs de tension sont disponibles en dispositifs I2C.
- Les jetons de contrôle des ventilateurs sont également des appareils I2C.
I2c-tools
Les applications d'espace utilisateur dans l'environnement Linux sont utilisées pour accéder aux appareils d'esclaves I2C. I2cdetect, i2cget, i2cset, i2cdump et i2ctransfer sont les commandes disponibles lorsque les outils i2c sont installés sur n'importe quelle plate-forme Linux. Tous les cas d'utilisation des appareils discutés dans les sections des applications I2C sont accessibles via ces outils.
Il n'y a pas besoin de pilote de périphérique d'esclaves I2C, lorsque vous essayez d'accéder à l'appareil esclave avec I2C-Tools. Ces outils peuvent nous permettre d'accéder aux appareils au format brut. Plus de détails sur ces services publics sont disponibles dans un autre article.
Conclusion
Nous avons discuté du sous-système I2C de Linux. I2C Framework avec un aperçu de l'organisation du code logique a été fourni. Nous avons également discuté des fichiers I2C SYSFS. Nous avons discuté de la séquence de messages de communication I2C. Nous avons parcouru la création d'instructions de l'appareil de la manière, je.e., statique et dynamiquement. Nous avons également exploré les pilotes de liaison / délier avec des appareils. Certaines des applications en temps réel I2C.