29 917
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 2 :
Ligne 2 : − {{traduction}} − + + + + Ligne 59 :
Ligne 61 : + − I2C is a two-wire protocol for communicating between devices. At the physical level it consists of 2 wires: SCL and SDA, the clock and data lines respectively.+ + + + − I2C objects are created attached to a specific bus. They can be initialised when created, or initialised later on:+ − <nowiki>from pyb import I2C+ − i2c = I2C(1) # create on bus 1+ − i2c = I2C(1, I2C.MASTER) # create and init as a master − i2c.init(I2C.MASTER, baudrate=20000) # init as a master − i2c.init(I2C.SLAVE, addr=0x42) # init as a slave with given address − i2c.deinit() # turn off the peripheral</nowiki> − Printing the i2c object gives you information about its configuration.+ + + − Basic methods for slave are send and recv:+ + − <nowiki>i2c.send('abc') # send 3 bytes+ − + − data = i2c.recv(3) # receive 3 bytes</nowiki> − To receive inplace, first create a bytearray:+ + − <nowiki>data = bytearray(3) # create a buffer+ − + − You can specify a timeout (in ms):+ + + − <nowiki>i2c.send(b'123', timeout=2000) # timout after 2 seconds</nowiki>+ + + − A master must specify the recipient's address:+ − − <nowiki>i2c.init(I2C.MASTER) − i2c.send('123', 0x42) # send 3 bytes to slave with address 0x42 − i2c.send(b'456', addr=0x42) # keyword for address</nowiki> − − Master also has other methods: − − <nowiki>i2c.is_ready(0x42) # check if slave 0x42 is ready − i2c.scan() # scan for slaves on the bus, returning − # a list of valid addresses − i2c.mem_read(3, 0x42, 2) # read 3 bytes from memory of slave 0x42, − # starting at address 2 in the slave − i2c.mem_write('abc', 0x42, 2, timeout=1000)</nowiki> − + − Construit un objet I2C sur le {{fname|bus}} mentionné. Le {{fname|bus}} peut recevoir la valeur 1 ou 2. + + + + + Ligne 117 :
Ligne 117 : − + − + − + − + − + − * '''baudrate''' pour le débit du signal d'horloge du bus I2C (SCL, uniquement valable en mode ''maitre'')+ − * '''gencall''' destiné au support des appels (<small>''is whether to support general call mode''</small>)+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Ligne 135 :
Ligne 166 : − + − + + + + + + − Effectue une lecture depuis la mémoire d'un périphérique:+ − * '''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.+ + − Uniquement valable en mode ''master''.+ + − ==== i2c.mem_write(...) ====+ − − 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_size''' permet de sélectionner la taille de {{fname|memaddr}}: 8 ou 16 bits+ + + − Retourne {{fname|None}}. + − Uniquement valable en mode ''master''.+ − ==== i2c.recv(...) ====+ − − Recevoir des données sur le bus:+ − + − + − − Return value: if recv is an integer then a new buffer of the bytes received, otherwise the same buffer that was passed in to recv.+ − + − + − 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(...) ====+ − − 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 − Return value: None.+
→Introduction
== Introduction ==
== 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.
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.
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 ==
== La classe I2C ==
== La classe I2C ==
{{ambox-stop|text=Depuis MicroPython 1.7 (et surtout 1.8), le bus I2C est défini dans le module {{fname|machine}}. Ceci étant, le module {{fname|pyb}} expose toujours l'interface I2C et surtout les constantes comme I2C.MASTER
N'hésitez pas consulter [[MicroPython.Pyboard.mise-a-jour|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:
<syntaxhighlight lang="python">
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.send(0x42) # send a single byte, given by the number
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.recv(data) # receive 3 bytes, writing them into data</nowiki>
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') </syntaxhighlight>
Afficher l'objet i2c vous permet d'avoir des informations à propos de sa configuration.
=== Constructeur ===
=== Constructeur ===
I2C(bus, ...)
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 {{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).
* 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}}
* '''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 {{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(...) ====
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 )
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 {{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.
{{fname|i2c.mem_write(data, addr, memaddr, timeout=5000, addr_size=8)}}
Retourne un objet {{fname|bytes}} avec les données lue sur le bus.
* '''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.
==== 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}}.
{{fname|i2c.recv(recv, addr=0x00, timeout=5000)}}
* '''addr''' l'adresse de l'esclaver depuis lequel les données seront réceptionnées.
* '''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.
* '''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.
* '''addr''' l'adresse depuis laquelle les données seront reçues (uniquement valable en mode ''master'')
* '''stop''' indique s'il faut générer une condition d'arrêt sur le bus après réception des données.
* '''timeout''' le temps d'attente max pour recevoir les données. ''TimeOut'' s'exprimant en millisecondes.
==== I2C.writeto(...) ====
i2c.scan()
i2c.writeto(addr, buf, stop=True)
==== i2c.scan() ====
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.
=== 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 {{fname|nbytes}} octets depuis l'esclave indiqué à l'adresse {{fname|addr}} starting from the memory address specified by {{fname|memaddr}}.
L'argument {{fname|addrsize}} permet de spécifié le nombre de bits d'adresse.
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}}.
==== I2C.writeto_mem(...) ====
i2c.writeto_mem(addr, memaddr, buf, *, addrsize=8)
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}}.
{{fname|i2c.send(send, addr=0x00, timeout=5000)}}
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).
La méthode retourne {{fname|None}}.
=== Constantes ===
=== Constantes ===