Différences entre versions de « MicroPython-I2C »

De MCHobby - Wiki
Sauter à la navigation Sauter à la recherche
 
(18 versions intermédiaires par le même utilisateur non affichées)
Ligne 5 : Ligne 5 :
  
 
Cet article reprends différentes notes utilises à ce sujet.
 
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 https://docs.micropython.org/en/latest/library/machine.I2C.html]
  
 
== Bus I2C en quelques mots ==
 
== Bus I2C en quelques mots ==
Ligne 67 : Ligne 70 :
 
Sur le plan physique, cela consiste en deux fils: SCL et SDA, la ligne d'horloge (SCL) et ligne de donnée (SDA).
 
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:
+
Les objets I2C sont créés en étant rattaché spécifiquement sur un bus matériel (en précisant son ID) -OU- sur un bus émulé de façon logiciel (en précisant les 2 broches sda et scl de façon arbitraire).
 +
 
 +
Le bus peut être initialisé à la création de l'objet --ou-- initialisé plus tard:
  
 
Voici quelques exemples:
 
Voici quelques exemples:
 
<syntaxhighlight lang="python">
 
<syntaxhighlight lang="python">
−
from pyb import I2C
+
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>
 
−
</syntaxhighlight>
 
  
−
Afficher l'objet i2c vous permet d'avoir des informations à propos de sa configuration.
+
i2c = I2C(1)                        # créé sur le bus 1 de la Pyboard
 +
i2c = I2C( sda=Pin(2), scl=Pin(4) )  # créé sur 2 broches arbitraire d'un l'ESP8266-EVB
  
−
=== En mode esclave ===
+
# scanne les esclaves disponibles et retourne une list d'adresses 7-bits
−
Les méthodes de base pour un esclave I2C sont:
+
i2c.scan()                     
−
* {{fname|send}}
 
−
* {{fname|recv}}
 
  
−
<nowiki>i2c.send('abc')      # esclave envoyant 3 bytes/octets
+
# Ecrire 3 octets vers l'esclave à l'adresse 42 (adresse 7-bits)
−
i2c.send(0x42)      # esclave envoyant un seul byte/octet (fourni en valeur numérique)
+
i2c.writeto(42, b'123')        
−
data = i2c.recv(3)   # esclave réceptionnant 3 bytes/octets</nowiki>
 
  
−
Pour faire une réception ''in situ'', il faut premièrement créer un {{fname|bytearray}}:
+
# Lire 4 octets depuis l'esclave à l'adresse 42
 +
i2c.readfrom(42, 4)
  
−
<nowiki>data = bytearray(3) # Création d'un buffer (mémoire tampon)
+
# Lire 3 octets à partir de l'adresse mémoire (registre) 8
−
i2c.recv(data)       # Réception de 3 bytes/octets, écriture dans "data"</nowiki>
+
# de l'esclave (esclave à l'adresse 42).
 +
i2c.readfrom_mem(42, 8, 3)  
  
−
Vous pouvez spécifier un temps d'attente maximum avec le paramètre ''timeout'' (en ms):
+
# écrire 1 octet (\x10) à l'adresse mémoire (registre) 2
 +
# de l'esclave (esclave à l'adresse 42)
 +
i2c.writeto_mem(42, 2, b'\x10') </syntaxhighlight>
  
−
<nowiki>i2c.send(b'123', timeout=2000)  # timeout après 2 secondes</nowiki>
+
Afficher l'objet i2c vous permet d'avoir des informations à propos de sa configuration.
−
 
 
−
=== En mode maître ===
 
−
Lorsqu'un maître (''master'') envoi des données à un périphérique doit spécifier l'adresse du destinataire:
 
−
 
 
−
<nowiki>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</nowiki>
 
−
 
 
−
Le maître dispose également d'autres méthodes:
 
−
 
 
−
<nowiki>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)</nowiki>
 
  
 
=== Constructeur ===
 
=== Constructeur ===
−
  I2C(bus, ...)
+
  class machine.I2C(id=-1, *, scl, sda, freq=400000)
  
−
Construit un objet I2C sur le {{fname|bus}} mentionné. Le {{fname|bus}} peut recevoir la valeur 1 ou 2.  
+
Crée et retourne un nouvel objet I2C en utilisant les paramètres suivants:
 +
* '''id''' identifie un périphérique en particulier. La valeur par défaut -1 sélectionne l'implémentation logiciel du bus I2C (BitBang I2C) sur deux broches SDA, SCL arbitraires (fonctionne généralement avec toutes les broches). Les autres valeurs utilisable pour {{fname|id}} dépend de l'implémentation des ports sur la carte (dans ce cas, il n'est pas nécessaire de spécifier les paramètres scl et sda).
 +
* '''scl''' doit être un objet {{fname|Pin}} spécifiant la broche à utiliser pour SCL (signal d'horloge I2C).
 +
* '''sda''' doit être un objet {{fname|Pin}} spécifiant la broche à utiliser pour SDA (signal de donnée).
 +
* '''freq''' est un entier fixant la vitesse maximale du bus (400000 pour 400 KHz).
  
 
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).  
 
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).  
Ligne 130 : Ligne 117 :
 
* I2C(2) sur la partie Y de la carte: (SCL, SDA) = (Y9, Y10) = (PB10, PB11)
 
* I2C(2) sur la partie Y de la carte: (SCL, SDA) = (Y9, Y10) = (PB10, PB11)
  
−
=== Méthodes ===
+
=== Méthodes générales ===
 
==== i2c.deinit() ====
 
==== i2c.deinit() ====
−
Désactive le bus I2C.
+
Désactive le bus I2C (WiPy).
  
 
==== i2c.init(...) ====
 
==== i2c.init(...) ====
−
  i2c.init(mode, *, addr=0x12, baudrate=400000, gencall=False)
+
  i2c.init(scl, sda, *, freq=400000)
  
 
Initialise le bus I2C avec les paramètres suivants:
 
Initialise le bus I2C avec les paramètres suivants:
−
* '''mode''' mode du bus I2C. Soit {{fname|I2C.MASTER}} pour le mode ''maitre'' ou {{fname|I2C.SLAVE}} pour le mode ''esclave''.
+
* '''scl''' : ligne du signal d'horloge SCL du bus I2C, un objet {{fname|Pin}}
−
* '''addr''' l'adresse I2C (codée sur 7-bits, uniquement valable en mode ''esclave'')
+
* '''sda''' : ligne du signal de donnée SDA du bus I2C, un objet {{fname|Pin}}
−
* '''baudrate''' pour le débit du signal d'horloge du bus I2C (SCL, uniquement valable en mode ''maitre'')
+
* '''freq''' : la fréquence du signal d'horloge sur le bus I2C.
−
* '''gencall''' destiné au support des appels (<small>''is whether to support general call mode''</small>)
+
 
 +
==== i2c.scan() ====
 +
Scanne toutes les adresses du Bus I2C de 0x01 à 0x7f et retourne une liste Python des adresses offrant une réponse.
 +
 
 +
A noter que certains composant (comme le {{pl|932|AM2315}}) n'offrent pas de réponse et ne sont donc pas détectable par cette méthode.
 +
 
 +
Hormis ce détail, il s'agit d'une méthode fiable car la plupart des composants répondent.
 +
 
 +
=== Méthodes Primitives ===
 +
Les méthodes suivantes implémentes les primitives pour les opérations maîtres sur le bus I2C et peut être combiné avec n'importe quelle transaction I2C.
 +
 
 +
Ces fonctions sont mises à disposition si vous avez besoin de contrôler précisément le bus SINON voyez les méthodes standard d'accès au bus I2C (voir ci-dessous).
 +
 
 +
Ces méthodes ne sont disponibles que pour les bus I2C logiciels.
 +
 
 +
<div style="margin: 15px 0; background: rgba(0,192,240,.3); display: block; padding: 15px 15px 15px 15px; -webkit-border-radius: 2px; -moz-border-radius: 2px; border-radius: 2px; border: 1px solid #CCC;" >Le protocole I2C prévoit des conditions de départ (START) et d'arrêt (STOP) qui signal l'envoi d'une nouvelle trame de donnée sur le bus.
 +
 
 +
Ces conditions correspondent à des niveaux particuliers des signaux SDA et SCL.
 +
 
 +
{{underline|Condition START}}:<br />correspond au passage du signal SDA du niveau HAUT vers BAS pendant que le signal SCL reste au niveau haut.
 +
 
 +
{{underline|Condition STOP}}:<br />correspond au passage du signal SDA du niveau BAS vers HAUT pendant que le signal SCL reste au niveau haut.</div>
 +
 
 +
==== i2c.start() ====
 +
Génère une condition de démarrage/début de transaction (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(...) ====
Ligne 148 : Ligne 166 :
 
Vérifie si un périphérique I2C répond sur l'adresse donnée. Uniquement valide pour le mode ''master''.
 
Vérifie si un périphérique I2C répond sur l'adresse donnée. Uniquement valide pour le mode ''master''.
  
−
==== i2c.mem_read(....) ====
+
==== i2c.meminto(...) ====
−
  i2c.mem_read(data, addr, memaddr, timeout=5000, addr_size=8)
+
  i2c.readinto(buf, nack=True)
 +
 
 +
Lit des octets depuis le bus, données stockées dans la mémoire tempon {{fname|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 )
  
−
Effectue une lecture depuis la mémoire d'un périphérique:
+
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.
−
* '''data''' un entier ou un buffer pour stocker le résultat de la lecture
 
−
* '''addr''' est l'adresse du périphérique I2C
 
−
* '''memaddr''' est la position mémoire dans le périphérique I2C
 
−
* '''timeout''' est le temps max d'attente (en millisecondes) pour l'opération de lecture
 
−
* '''addr_size''' détermine la taille de {{fname|memaddr}}: 8 ou 16 bits
 
  
−
Retourn la donnée lue.
+
=== Opérations standard du bus ===
 +
Les méthodes suivantes implémente les opérations standard du Maître (Leader) du bus I2C. Cela concerne les opération de lecture (''read'') et d'écriture (''write'') à destination d'un périphérique Esclave (Suiveur).
  
−
Uniquement valable en mode ''master''.
+
==== I2C.readfrom(...) ====
 +
i2c.readfrom(addr, nbytes, stop=True)
  
−
==== i2c.mem_write(...) ====
+
Lecture de {{fname|nbytes}} octets depuis l'esclave identifié par son adresses {{fname|addr}}. Si le paramètre {{fname|stop}} est {{fname|True}} alors la condition d'arrêt (STOP) est générée à la fin du transfert.  
−
i2c.mem_write(data, addr, memaddr, timeout=5000, addr_size=8)
 
  
−
Ecrit dans la mémoire d'un périphérique I2C.
+
Retourne un objet {{fname|bytes}} avec les données lue sur le bus.
  
−
* '''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.
 
* '''addr''' est l'adresse du périphérique I2C.
−
* '''memaddr''' est la position mémoire (adresse mémoire) dans le périphérique I2C.
+
* '''nbytes''' le nombre d'octets à lire.
−
* '''timeout''' est le temps d'attente max (millisecondes) pour démarrer l'opération d'écriture.
+
* '''stop''' placer une condition d'arrêt en fin de transation.
−
* '''addr_size''' permet de sélectionner la taille de {{fname|memaddr}}: 8 ou 16 bits
+
 
 +
==== I2C.readfrom_into(...) ====
 +
i2c.readfrom_into(addr, buf, stop=True)
 +
 
 +
Lit des données depuis l'esclave à l'adresse {{fname|addr}} et stocke les données dans la mémoire tampon {{fname|buf}}. Le nombre d'octets lus sur le bus correspond à la taille de {{fname|buf}}.
 +
 
 +
Si le paramètre {{fname|stop}} est {{fname|True}} alors la condition d'arrêt (STOP) est généré à la fin du transfert I2C.
 +
 
 +
La méthode retourne {{fname|None}}.
 +
 
 +
* '''addr''' l'adresse de l'esclaver depuis lequel les données seront réceptionnées.
 +
* '''buf''' la mémoire tampon (type {{fname|bytes}}) dans lequel les donnéees seront écrite. La taille de {{fname|buf}} détermine le nombre d'octets lu sur le bus.
 +
* '''stop''' indique s'il faut générer une condition d'arrêt sur le bus après réception des données.
 +
 
 +
==== I2C.writeto(...) ====
 +
i2c.writeto(addr, buf, stop=True)
 +
 
 +
Ecrit les octets présents le paramètre {{fname|buf}} (objet de type {{fname|bytes}} vers l'esclave mentionné dans le paramètre {{fname|addr}}.
 +
 
 +
Si un '''NACK''' est récu suite à l'écriture d'un octet de {{fname|buf}} alors le restant des octets n'est pas envoyé sur le bus.
 +
 
 +
Si {{fname|stop}} est {{fname|True}} alors la condition d'arrêt (STOP) est généré à la fin du transfert, même si un '''NACK''' est recu durant le transfert.
 +
 
 +
La fonction retourne ne nombre de '''ACK''' réceptionné durant le transfert.
 +
 
 +
* '''addr''' l'adresse vers laquelle les données seront envoyées.
 +
* '''buf''' la mémoire tampon (type {{fname|bytes}}) depuis lequel les données seront lue. La taille de {{fname|buf}} détermine le nombre d'octets envoyé sur le bus.
 +
* '''stop''' indique s'il faut générer une condition d'arrêt sur le bus après réception des données.
  
−
Retourne {{fname|None}}.  
+
=== Opérations mémoire ===
 +
Certains périphériques I2C fonctionnent comme des mémoires (ou ensemble de registres) qu'il est possible de lire ou dans lesquels il est possible d'écrire.  
  
−
Uniquement valable en mode ''master''.
+
Dans ce cas, il y a deux adresses associées avec le périphérique I2C:
 +
* Une adresses esclave I2C
 +
* Une adresse mémoire.  
  
−
==== i2c.recv(...) ====
+
Les méthodes suivantes sont concçue pour communiquer avec de les périphériques.
−
i2c.recv(recv, addr=0x00, timeout=5000)
 
  
−
Recevoir des données sur le bus:
+
==== I2C.readfrom_mem(...) ====
−
* '''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.
+
I2C.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8)
−
* '''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 {{fname|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 {{fname|recv}}.
+
Lecture de {{fname|nbytes}} octets depuis l'esclave indiqué à l'adresse {{fname|addr}} starting from the memory address specified by {{fname|memaddr}}.  
  
−
==== i2c.scan() ====
+
L'argument {{fname|addrsize}} permet de spécifié le nombre de bits d'adresse.
−
Scanne toutes les adresses du Bus I2C de 0x01 à 0x7f et retourne la liste des adresses offrant une réponse.  
+
 
 +
Retourne un objet de type {{fname|bytes}} avec les données lue sur le bus.
 +
 
 +
==== I2C.readfrom_mem_into(...) ====
 +
i2c.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8)
 +
 
 +
Lit des octets depuis un esclave accessible à l'adresse {{fname|addr}} en débutant la lecture à l'adresse {{fname|memaddr}} et stocke les octets dans la mémoire tampon {{fname|buf}}.
 +
 
 +
Le nombre d'octers lu correspond à la taille de mémoire tampon {{fname|buf}} (objet de type {{fname|bytes}}.
 +
 
 +
L'argument {{fname|addrsize}} spécifie la taille de l'adresse (en bits). Sur un ESP8266, cet argument n'est pas reconnu et la taille de l'adresse est toujours de 8 bits.
 +
 
 +
La méthode retourne {{fname|None}}.
  
−
Cette instruction est uniquement utilisable en mode ''master''.
+
==== I2C.writeto_mem(...) ====
 +
i2c.writeto_mem(addr, memaddr, buf, *, addrsize=8)
  
−
==== i2c.send(...) ====
+
Ecrit le contenu de {{fname|buf}} (un objet de type {{fname|bytes}}) vers l'esclave identifié par l'adresse {{fname|addr}} en débutant à l'adresse mémoire indiquée par l'argument {{fname|memaddr}}.  
−
i2c.send(send, addr=0x00, timeout=5000)
 
  
−
Envoi des données sur le bus:
+
L'argument {{fname|addrsize}} mentionne la taille de l'adresse en bit (sur ESP8266 cet argument n'est pas reconnu et l'adresse est toujours en 8 bits).
−
* '''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: {{fname|None}}.
+
La méthode retourne {{fname|None}}.
  
 
=== Constantes ===
 
=== Constantes ===

Version actuelle datée du 24 mars 2019 à 19:49


MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.

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:

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.

Principes I2C

Tlogo-I2C.jpg

Comprendre les principes fondamentaux du bus I2C.

 

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.

Pybv10-I2C-pinout.jpg

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

Stop
 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 sont créés en étant rattaché spécifiquement sur un bus matériel (en précisant son ID) -OU- sur un bus émulé de façon logiciel (en précisant les 2 broches sda et scl de façon arbitraire).

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 de la Pyboard
i2c = I2C( sda=Pin(2), scl=Pin(4) )  # créé sur 2 broches arbitraire d'un l'ESP8266-EVB

# scanne les esclaves disponibles et retourne une list d'adresses 7-bits
i2c.scan()                      

# Ecrire 3 octets vers l'esclave à l'adresse 42 (adresse 7-bits)
i2c.writeto(42, b'123')         

# Lire 4 octets depuis l'esclave à l'adresse 42
i2c.readfrom(42, 4)

# Lire 3 octets à partir de l'adresse mémoire (registre) 8 
# de l'esclave (esclave à l'adresse 42).
i2c.readfrom_mem(42, 8, 3)    

# écrire 1 octet (\x10) à l'adresse mémoire (registre) 2
# de l'esclave (esclave à l'adresse 42)
i2c.writeto_mem(42, 2, b'\x10')

Afficher l'objet i2c vous permet d'avoir des informations à propos de sa configuration.

Constructeur

class machine.I2C(id=-1, *, scl, sda, freq=400000)

Crée et retourne un nouvel objet I2C en utilisant les paramètres suivants:

  • id identifie un périphérique en particulier. La valeur par défaut -1 sélectionne l'implémentation logiciel du bus I2C (BitBang I2C) sur deux broches SDA, SCL arbitraires (fonctionne généralement avec toutes les broches). Les autres valeurs utilisable pour id dépend de l'implémentation des ports sur la carte (dans ce cas, il n'est pas nécessaire de spécifier les paramètres scl et sda).
  • scl doit être un objet Pin spécifiant la broche à utiliser pour SCL (signal d'horloge I2C).
  • sda doit être un objet Pin spécifiant la broche à utiliser pour SDA (signal de donnée).
  • freq est un entier fixant la vitesse maximale du bus (400000 pour 400 KHz).

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 générales

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

Scanne toutes les adresses du Bus I2C de 0x01 à 0x7f et retourne une liste Python des adresses offrant une réponse.

A noter que certains composant (comme le AM2315) n'offrent pas de réponse et ne sont donc pas détectable par cette méthode.

Hormis ce détail, il s'agit d'une méthode fiable car la plupart des composants répondent.

Méthodes Primitives

Les méthodes suivantes implémentes les primitives pour les opérations maîtres sur le bus I2C et peut être combiné avec n'importe quelle transaction I2C.

Ces fonctions sont mises à disposition si vous avez besoin de contrôler précisément le bus SINON voyez les méthodes standard d'accès au bus I2C (voir ci-dessous).

Ces méthodes ne sont disponibles que pour les bus I2C logiciels.

Le protocole I2C prévoit des conditions de départ (START) et d'arrêt (STOP) qui signal l'envoi d'une nouvelle trame de donnée sur le bus.

Ces conditions correspondent à des niveaux particuliers des signaux SDA et SCL.

Condition START:
correspond au passage du signal SDA du niveau HAUT vers BAS pendant que le signal SCL reste au niveau haut.

Condition STOP:
correspond au passage du signal SDA du niveau BAS vers HAUT pendant que le signal SCL reste au niveau haut.

i2c.start()

Génère une condition de démarrage/début de transaction (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

Les méthodes suivantes implémente les opérations standard du Maître (Leader) du bus I2C. Cela concerne les opération de lecture (read) et d'écriture (write) à destination d'un périphérique Esclave (Suiveur).

I2C.readfrom(...)

i2c.readfrom(addr, nbytes, stop=True)

Lecture de nbytes octets depuis l'esclave identifié par son adresses addr. Si le paramètre stop est True alors la condition d'arrêt (STOP) est générée à la fin du transfert.

Retourne un objet bytes avec les données lue sur le bus.

  • addr est l'adresse du périphérique I2C.
  • nbytes le nombre d'octets à lire.
  • stop placer une condition d'arrêt en fin de transation.

I2C.readfrom_into(...)

i2c.readfrom_into(addr, buf, stop=True)

Lit des données depuis l'esclave à l'adresse addr et stocke les données dans la mémoire tampon buf. Le nombre d'octets lus sur le bus correspond à la taille de buf.

Si le paramètre stop est True alors la condition d'arrêt (STOP) est généré à la fin du transfert I2C.

La méthode retourne None.

  • addr l'adresse de l'esclaver depuis lequel les données seront réceptionnées.
  • buf la mémoire tampon (type bytes) dans lequel les donnéees seront écrite. La taille de buf détermine le nombre d'octets lu sur le bus.
  • stop indique s'il faut générer une condition d'arrêt sur le bus après réception des données.

I2C.writeto(...)

i2c.writeto(addr, buf, stop=True)

Ecrit les octets présents le paramètre buf (objet de type bytes vers l'esclave mentionné dans le paramètre addr.

Si un NACK est récu suite à l'écriture d'un octet de buf alors le restant des octets n'est pas envoyé sur le bus.

Si stop est True alors la condition d'arrêt (STOP) est généré à la fin du transfert, même si un NACK est recu durant le transfert.

La fonction retourne ne nombre de ACK réceptionné durant le transfert.

  • addr l'adresse vers laquelle les données seront envoyées.
  • buf la mémoire tampon (type bytes) depuis lequel les données seront lue. La taille de buf détermine le nombre d'octets envoyé sur le bus.
  • stop indique s'il faut générer une condition d'arrêt sur le bus après réception des données.

Opérations mémoire

Certains périphériques I2C fonctionnent comme des mémoires (ou ensemble de registres) qu'il est possible de lire ou dans lesquels il est possible d'écrire.

Dans ce cas, il y a deux adresses associées avec le périphérique I2C:

  • Une adresses esclave I2C
  • Une adresse mémoire.

Les méthodes suivantes sont concçue pour communiquer avec de les périphériques.

I2C.readfrom_mem(...)

I2C.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8)

Lecture de nbytes octets depuis l'esclave indiqué à l'adresse addr starting from the memory address specified by memaddr.

L'argument addrsize permet de spécifié le nombre de bits d'adresse.

Retourne un objet de type bytes avec les données lue sur le bus.

I2C.readfrom_mem_into(...)

i2c.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8)

Lit des octets depuis un esclave accessible à l'adresse addr en débutant la lecture à l'adresse memaddr et stocke les octets dans la mémoire tampon buf.

Le nombre d'octers lu correspond à la taille de mémoire tampon buf (objet de type bytes.

L'argument addrsize spécifie la taille de l'adresse (en bits). Sur un ESP8266, cet argument n'est pas reconnu et la taille de l'adresse est toujours de 8 bits.

La méthode retourne None.

I2C.writeto_mem(...)

i2c.writeto_mem(addr, memaddr, buf, *, addrsize=8)

Ecrit le contenu de buf (un objet de type bytes) vers l'esclave identifié par l'adresse addr en débutant à l'adresse mémoire indiquée par l'argument memaddr.

L'argument addrsize mentionne la taille de l'adresse en bit (sur ESP8266 cet argument n'est pas reconnu et l'adresse est toujours en 8 bits).

La méthode retourne 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.

Récupérée de « https://wiki.mchobby.be/index.php?title=MicroPython-I2C&oldid=28076 »