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 118 : |
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 générale === | + | === Méthodes générales === |
| ==== i2c.deinit() ==== | | ==== i2c.deinit() ==== |
| Désactive le bus I2C (WiPy). | | Désactive le bus I2C (WiPy). |
Ligne 129 : |
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 156 : |
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). |
− | | |
− | The following methods implement the standard I2C master read and write operations that target a given slave device.
| |
| | | |
| ==== I2C.readfrom(...) ==== | | ==== I2C.readfrom(...) ==== |
| i2c.readfrom(addr, nbytes, stop=True) | | i2c.readfrom(addr, nbytes, stop=True) |
| | | |
− | Read {{fname|nbytes}} from the slave specified by {{fname|addr}}. If {{fname|stop}} is {{fname|True}} then a STOP condition is generated at the end of the transfer.
| + | 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. |
| | | |
− | Returns a {{fname|bytes}} object with the data read.
| + | 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. |
− | * '''nbytes''' xxx . | + | * '''nbytes''' le nombre d'octets à lire. |
− | * '''stop''' xxx . | + | * '''stop''' placer une condition d'arrêt en fin de transation. |
| | | |
| ==== I2C.readfrom_into(...) ==== | | ==== I2C.readfrom_into(...) ==== |
| i2c.readfrom_into(addr, buf, stop=True) | | i2c.readfrom_into(addr, buf, stop=True) |
| | | |
− | Read into {{fname|buf}} from the slave specified by {{fname|addr}}. The number of bytes read will be the length of buf.
| + | 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}}. |
| | | |
− | If {{fname|stop}} is {{fname|True}} then a STOP condition is generated at the end of the transfer.
| + | 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. |
| | | |
− | The method returns {{fname|None}}.
| + | La méthode retourne {{fname|None}}. |
| | | |
− | * '''addr''' l'adresse depuis laquelle les données seront réceptionnées. | + | * '''addr''' l'adresse de l'esclaver depuis lequel les données seront réceptionnées. |
− | * '''buf''' | + | * '''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'''& xxx . | + | * '''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(...) ==== |
| i2c.writeto(addr, buf, stop=True) | | i2c.writeto(addr, buf, stop=True) |
| | | |
− | Write the bytes from {{fname|buf}} (objet de type {{fname|bytes}} to the slave specified by {{fname|addr}}.
| + | 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}}. |
| | | |
− | If a '''NACK''' is received following the write of a byte from buf then the remaining bytes are not sent.
| + | 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. |
| | | |
− | If {{fname|stop}} is {{fname|True}} then a STOP condition is generated at the end of the transfer, even if a '''NACK''' is received.
| + | 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. |
| | | |
− | The function returns the number of '''ACK'''s that were received.
| + | La fonction retourne ne nombre de '''ACK''' réceptionné durant le transfert. |
| | | |
| * '''addr''' l'adresse vers laquelle les données seront envoyées. | | * '''addr''' l'adresse vers laquelle les données seront envoyées. |
− | * '''buf''' | + | * '''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''' xxx . | + | * '''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 === | | === Opérations mémoire === |
− | Some I2C devices act as a memory device (or set of registers) that can be read from and written to. In this case there are two addresses associated with an I2C transaction: the slave address and the memory address. The following methods are convenience functions to communicate with such devices.
| + | 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(...) ==== |
| I2C.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8) | | I2C.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8) |
| | | |
− | Read {{fname|nbytes}} from the slave specified by {{fname|addr}} starting from the memory address specified by {{fname|memaddr}}.
| + | Lecture de {{fname|nbytes}} octets depuis l'esclave indiqué à l'adresse {{fname|addr}} starting from the memory address specified by {{fname|memaddr}}. |
| | | |
− | The argument {{fname|addrsize}} specifies the address size in bits.
| + | L'argument {{fname|addrsize}} permet de spécifié le nombre de bits d'adresse. |
| | | |
− | Returns a {{fname|bytes}} object with the data read.
| + | Retourne un objet de type {{fname|bytes}} avec les données lue sur le bus. |
| | | |
| ==== I2C.readfrom_mem_into(...) ==== | | ==== I2C.readfrom_mem_into(...) ==== |
| i2c.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8) | | i2c.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8) |
| | | |
− | Read into {{fname|buf}} from the slave specified by {{fname|addr}} starting from the memory address specified by {{fname|memaddr}}.
| + | 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}}. |
| | | |
− | The number of bytes read is the length of {{fname|buf}}.
| + | Le nombre d'octers lu correspond à la taille de mémoire tampon {{fname|buf}} (objet de type {{fname|bytes}}. |
| | | |
− | The argument {{fname|addrsize}} specifies the address size in bits (on ESP8266 this argument is not recognised and the address size is always 8 bits).
| + | 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. |
| | | |
− | The method returns {{fname|None}}.
| + | La méthode retourne {{fname|None}}. |
| | | |
| ==== I2C.writeto_mem(...) ==== | | ==== I2C.writeto_mem(...) ==== |
| i2c.writeto_mem(addr, memaddr, buf, *, addrsize=8) | | i2c.writeto_mem(addr, memaddr, buf, *, addrsize=8) |
| | | |
− | Write {{fname|buf}} to the slave specified by {{fname|addr}} starting from the memory address specified by {{fname|memaddr}}.
| + | 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}}. |
− | | |
− | The argument {{fname|addrsize}} specifies the address size in bits (on ESP8266 this argument is not recognised and the address size is always 8 bits).
| |
− | | |
− | The method returns {{fname|None}}.
| |
− | | |
− | === Autres opérations ===
| |
− | ==== 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.
| + | 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). |
| | | |
− | Hormis ce détail, il s'agit d'une méthode fiable car la plupart des composants répondent.
| + | La méthode retourne {{fname|None}}. |
| | | |
| === Constantes === | | === Constantes === |