Ligne 6 : |
Ligne 6 : |
| Cet article reprends différentes notes utilises à ce sujet. | | Cet article reprends différentes notes utilises à ce sujet. |
| | | |
− | {{traduction}}
| |
| Revoir la définition des finitions | | 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] | | [https://docs.micropython.org/en/latest/library/machine.I2C.html https://docs.micropython.org/en/latest/library/machine.I2C.html] |
Ligne 71 : |
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: |
Ligne 77 : |
Ligne 78 : |
| from machine import I2C | | from machine import I2C |
| | | |
− | i2c = I2C(1) # créé sur le bus 1 | + | i2c = I2C(1) # créé sur le bus 1 de la Pyboard |
− | i2c = I2C(1, I2C.MASTER) # Créé et initialisé comme maître (master) | + | i2c = I2C( sda=Pin(2), scl=Pin(4) ) # créé sur 2 broches arbitraire d'un l'ESP8266-EVB |
− | 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.
| + | # scanne les esclaves disponibles et retourne une list d'adresses 7-bits |
| + | i2c.scan() |
| | | |
− | === En mode esclave ===
| + | # Ecrire 3 octets vers l'esclave à l'adresse 42 (adresse 7-bits) |
− | Les méthodes de base pour un esclave I2C sont:
| + | i2c.writeto(42, b'123') |
− | * {{fname|send}}
| |
− | * {{fname|recv}}
| |
| | | |
− | <nowiki>i2c.send('abc') # esclave envoyant 3 bytes/octets
| + | # Lire 4 octets depuis l'esclave à l'adresse 42 |
− | i2c.send(0x42) # esclave envoyant un seul byte/octet (fourni en valeur numérique)
| + | i2c.readfrom(42, 4) |
− | 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 3 octets à partir de l'adresse mémoire (registre) 8 |
| + | # de l'esclave (esclave à l'adresse 42). |
| + | i2c.readfrom_mem(42, 8, 3) |
| | | |
− | <nowiki>data = bytearray(3) # Création d'un buffer (mémoire tampon)
| + | # écrire 1 octet (\x10) à l'adresse mémoire (registre) 2 |
− | i2c.recv(data) # Réception de 3 bytes/octets, écriture dans "data"</nowiki> | + | # de l'esclave (esclave à l'adresse 42) |
| + | i2c.writeto_mem(42, 2, b'\x10') </syntaxhighlight> |
| | | |
− | Vous pouvez spécifier un temps d'attente maximum avec le paramètre ''timeout'' (en ms):
| + | Afficher l'objet i2c vous permet d'avoir des informations à propos de sa configuration. |
− | | |
− | <nowiki>i2c.send(b'123', timeout=2000) # timeout après 2 secondes</nowiki>
| |
− | | |
− | === 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 134 : |
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 (WiPy). | | Désactive le bus I2C (WiPy). |
Ligne 145 : |
Ligne 128 : |
| * '''sda''' : ligne du signal de donnée SDA du bus I2C, un objet {{fname|Pin}} | | * '''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. | | * '''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() ==== | | ==== i2c.start() ==== |
− | Génère une condition de démarrage (START) sur le bus. | + | 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. | | Le signal SDA passe au niveau bas pendant que SCL est au niveau haut. |
Ligne 172 : |
Ligne 177 : |
| | | |
| === Opérations standard du bus === | | === Opérations standard du bus === |
− | {{traduction}}
| + | 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). |
− | Travail à poursuivre à [https://docs.micropython.org/en/latest/library/machine.I2C.html#standard-bus-operations partir d'ici]
| |
| | | |
| + | ==== 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
| |
| | | |
− | Retourne {{fname|None}}.
| + | ==== I2C.readfrom_into(...) ==== |
| + | i2c.readfrom_into(addr, buf, stop=True) |
| | | |
− | Uniquement valable en mode ''master''.
| + | 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}}. |
| | | |
− | ==== i2c.recv(...) ====
| + | 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. |
− | i2c.recv(recv, addr=0x00, timeout=5000)
| |
| | | |
− | Recevoir des données sur le bus:
| + | La méthode retourne {{fname|None}}. |
− | * '''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 {{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}}.
| + | * '''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.scan() ==== | + | ==== I2C.writeto(...) ==== |
− | Scanne toutes les adresses du Bus I2C de 0x01 à 0x7f et retourne la liste des adresses offrant une réponse.
| + | 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. |
| + | |
| + | === 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}}. |
| | | |
− | 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 === |