Différences entre versions de « MicroPython-I2C »
Ligne 75 : | Ligne 75 : | ||
Voici quelques exemples: | Voici quelques exemples: | ||
<syntaxhighlight lang="python"> | <syntaxhighlight lang="python"> | ||
− | from | + | from machine import I2C |
i2c = I2C(1) # créé sur le bus 1 | i2c = I2C(1) # créé sur le bus 1 |
Version du 15 décembre 2018 à 15:01
Introduction
Voila, je me suis mis en tête de supporter quelques breakout I2C d'Adafruit sur la PyBoard. C'est un projet intéressant et captivant.
Cet article reprends différentes notes utilises à ce sujet.
Revoir la définition des finitions https://docs.micropython.org/en/latest/library/machine.I2C.html
Bus I2C en quelques mots
I2C est la contraction de "Inter Integrated Circuit".
Ce dernier permet d'établir des connexions asynchrones entre plusieurs composants intelligents pour partager des informations via un "bus commun".
Si ce bus est utilisé pour permettre à un microcontroleur (PyBoard,Arduino,Raspberry-Pi) de communiquer avec des senseurs (un réseau de senseur), il permet aussi à des microcontrôleurs de communiquer directement ensembles.
- PyBoard dispose d'une class pour I2C, ce qui rend la mise en oeuvre très facile.
- Principalement développé pour la Domotique et l'électronique domestique, ce bus est très populaire et donc utilisé par de nombreux composants. Les PC, lecteurs DVD, télévisions, etc disposent généralement d'un tel bus.
- Le protocole I2C ne requière que 3 fils pour fonctionner et peut être implémenté sur n'importe quel microcontrôleur.
- La longueur du bus est de l'ordre de 1 mètre... mais il est possible de l'étendre jusqu'à 30 mètres à l'aide d'un simple composant nommé "I2C extender".
- Il dispose d'un mécanisme d'adressage à la fois simple et efficace permettant à plusieurs senseurs de fonctionner sur un seul bus.
- Supporte plusieurs maître (Attention: dans ce cas il y a donc risque de collisions).
Quelques documents sur le net:
- Document Inter Integrated Circuit sur Wikipédia (fr)
Incluant des informations sur le protocole de communication I2C. - Autre article sur Inter Integrated Circuit paru sur Aurel32.net (très bonne référence)
Aborde le processus d'adressage dans son ensemble et présente également quelques circuit utilisant le protocole I2C.
Les concepts associés au bus I2C
Il y a quelques concepts de base à maîtriser autour de l'I2C:
- Le concept de "maître et esclave"
- Le principe d'adressage (adresse unique pour chaque esclave).
- Le concept de régulation de communication comme "Master Reader" et "Master Writer"
Nous avons rédigé une page d'explication autour du Bus I2C d'Arduino... mais un bus I2C reste avant tout un bus I2C, qu'il soit sur Arduino, PyBoard, Raspberry-Pi, ...
Nous ne saurions que trop vous recommander de parcourir cette page pour vous familiariser avec ces concepts.
Les Bus I2C de la PyBoard
Pour Rappel, les signaux sont:
- SDA - Signal DATA (donnée) du bus I2C.
- SCL - Signal CLOCK (horloge) du bus I2C.
Tolérance 5V
Petit rappel, toutes les broches du PyBoard sont tolérantes à 5V sauf PA4 & PA5 (dixit PYBv10b.pdf)
Par conséquent, le bus SPI du skin X n'est pas tolérant à 5 Volts.
La classe I2C
Depuis MicroPython 1.7 (et surtout 1.8), le bus I2C est défini dans le module machine. Ceci étant, le module pyb expose toujours l'interface I2C et surtout les constantes comme I2C.MASTER N'hésitez pas consulter notre tutoriel sur la mise-à-jour du Firmware micropython. |
I2C est un protocole de communication 2-fils permettant à des périphérique de communiquer ensembles.
Sur le plan physique, cela consiste en deux fils: SCL et SDA, la ligne d'horloge (SCL) et ligne de donnée (SDA).
Les objets I2C son créés en étant rattaché spécifiquement sur un bus. Le bus peut être initialisé à la création de l'objet --ou-- initialisé plus tard:
Voici quelques exemples:
from machine import I2C
i2c = I2C(1) # créé sur le bus 1
i2c = I2C(1, I2C.MASTER) # Créé et initialisé comme maître (master)
i2c.init(I2C.MASTER, baudrate=20000) # Initialisé comme maître (master)
i2c.init(I2C.SLAVE, addr=0x42) # Initialisé comme esclave (à l'adresse 0x42)
i2c.deinit() # Désactive le périphérique (bus I2C)</nowiki>
Afficher l'objet i2c vous permet d'avoir des informations à propos de sa configuration.
En mode esclave
Les méthodes de base pour un esclave I2C sont:
- send
- recv
i2c.send('abc') # esclave envoyant 3 bytes/octets i2c.send(0x42) # esclave envoyant un seul byte/octet (fourni en valeur numérique) data = i2c.recv(3) # esclave réceptionnant 3 bytes/octets
Pour faire une réception in situ, il faut premièrement créer un bytearray:
data = bytearray(3) # Création d'un buffer (mémoire tampon) i2c.recv(data) # Réception de 3 bytes/octets, écriture dans "data"
Vous pouvez spécifier un temps d'attente maximum avec le paramètre timeout (en ms):
i2c.send(b'123', timeout=2000) # timeout après 2 secondes
En mode maître
Lorsqu'un maître (master) envoi des données à un périphérique doit spécifier l'adresse du destinataire:
i2c.init(I2C.MASTER) i2c.send('123', 0x42) # envoyer 3 bytes/octets à l'esclave ayant l'adresse 0x42 i2c.send(b'456', addr=0x42) # Utilisation du mot clé "addr" pour indiquer l'adresse
Le maître dispose également d'autres méthodes:
i2c.is_ready(0x42) # vérifié si l'esclave 0x42 est prêt i2c.scan() # Scanne les esclaves du bus et retourne une # liste avec les adresses valides i2c.mem_read(3, 0x42, 2) # Lecture de 3 bytes/octets depuis la mémoire # de l'esclave 0x42, en démarrant à l'adresse # 2 dans l'esclave i2c.mem_write('abc', 0x42, 2, timeout=1000)
Constructeur
I2C(bus, ...)
Construit un objet I2C sur le bus mentionné. Le bus peut recevoir la valeur 1 ou 2.
Sans paramètre additionnel, l'objet I2C est créé mais pas initialisé (il dispose des paramètres de la dernière initialisation du bus, s'il cela est applicable).
Si des paramètres complémentaires sont fourni alors le bus est initialisé. Voyez la méthode init pour les paramètres d'initialisation.
Les broches physique du bus I2C sont:
- I2C(1) sur la partie X de la carte: (SCL, SDA) = (X9, X10) = (PB6, PB7)
- I2C(2) sur la partie Y de la carte: (SCL, SDA) = (Y9, Y10) = (PB10, PB11)
Méthodes
i2c.deinit()
Désactive le bus I2C (WiPy).
i2c.init(...)
i2c.init(scl, sda, *, freq=400000)
Initialise le bus I2C avec les paramètres suivants:
- scl : ligne du signal d'horloge SCL du bus I2C, un objet Pin
- sda : ligne du signal de donnée SDA du bus I2C, un objet Pin
- freq : la fréquence du signal d'horloge sur le bus I2C.
i2c.start()
Génère une condition de démarrage (START) sur le bus.
Le signal SDA passe au niveau bas pendant que SCL est au niveau haut.
i2c.stop()
Génère une condition d'arrêt (STOP) sur le bus I2C.
Le signal SDA passe au niveau haut pendant que SCL est au niveau haut.
i2c.is_ready(...)
i2c.is_ready(addr)
Vérifie si un périphérique I2C répond sur l'adresse donnée. Uniquement valide pour le mode master.
i2c.meminto(...)
i2c.readinto(buf, nack=True)
Lit des octets depuis le bus, données stockées dans la mémoire tempon buff. Un ACK sera envoyé sur le bus à la réception de chaque octets (sauf le dernier). Lorsque le dernier octet est réceptionné, si nack iest True alors un NACK sera envoyé, sinon ACK sera envoyé (dans ce cas, l'esclave sait que d'autres octets seront lus lors d'un prochain appel).
i2c.write(...)
i2c.write( buf )
Envoi les octets disponibles dans buf sur le bus I2C. Vérifie qu'un ACK est reçu après chaque octet. Cesse la transmission des derniers octets si un NACK est réçu en réponse. La fonction retourne ne nombre d' ACK reçu.
Opérations standard du bus
Travail à poursuivre à partir d'ici
i2c.mem_write(...)
i2c.mem_write(data, addr, memaddr, timeout=5000, addr_size=8)
Ecrit dans la mémoire d'un périphérique I2C.
- data est entier ou un buffer contenant les données à envoyer au périphérique I2C.
- addr est l'adresse du périphérique I2C.
- memaddr est la position mémoire (adresse mémoire) dans le périphérique I2C.
- timeout est le temps d'attente max (millisecondes) pour démarrer l'opération d'écriture.
- addr_size permet de sélectionner la taille de memaddr: 8 ou 16 bits
Retourne None.
Uniquement valable en mode master.
i2c.recv(...)
i2c.recv(recv, addr=0x00, timeout=5000)
Recevoir des données sur le bus:
- recv peut être un entier représentant le nombre d'octets/bytes à recevoir --OU-- un buffer mutable (modifiable) qui sera remplis avec les octets reçus.
- addr l'adresse depuis laquelle les données seront reçues (uniquement valable en mode master)
- timeout le temps d'attente max pour recevoir les données. TimeOut s'exprimant en millisecondes.
Valeur retournée: si recv est un entier alors la fonction retourne un nouveau buffer (mémoire tampon) avec les octets/bytes reçu --sinon-- ce sera la même buffer que celui passé dans le paramètre recv.
i2c.scan()
Scanne toutes les adresses du Bus I2C de 0x01 à 0x7f et retourne la liste des adresses offrant une réponse.
Cette instruction est uniquement utilisable en mode master.
i2c.send(...)
i2c.send(send, addr=0x00, timeout=5000)
Envoi des données sur le bus:
- send est la donnée à envoyer (un entier/integer ou un objet buffer)
- addr est l'adresse du destinataire (uniquement nécessaire en mode master)
- timeout est le temps d'attente max (timeout) pour l'envoi des données. Temps en millisecondes
Valeur retournée: None.
Constantes
- I2C.MASTER - pour l'initialisation du bus en mode master (maître).
- I2C.SLAVE - pour l'initialisation du bus en mode slave (esclave).
Source: class I2C écrit par/written by Damien P.George et autres sources.
Traduit/composé par Meurisse D. pour MCHobby.be - Translated/assembled by Meurisse D. for MCHobby.be
Traduit avec l'autorisation de micropython.org - Translated with the authorisation of micropython.org
Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : « Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.
L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.