29 917
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 6 :
Ligne 6 : − {{traduction}} Ligne 118 :
Ligne 117 : − + Ligne 129 :
Ligne 128 : + + + + + + + + + + + + + + + + + + + + + + − + Ligne 156 :
Ligne 177 : − {{traduction}}+ − − The following methods implement the standard I2C master read and write operations that target a given slave device. − 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. + − Returns a {{fname|bytes}} object with the data read.+ − + − + − Read into {{fname|buf}} from the slave specified by {{fname|addr}}. The number of bytes read will be the length of buf. + − If {{fname|stop}} is {{fname|True}} then a STOP condition is generated at the end of the transfer.+ − The method returns {{fname|None}}.+ − + − + − + − Write the bytes from {{fname|buf}} (objet de type {{fname|bytes}} to the slave specified by {{fname|addr}}. + − If a '''NACK''' is received following the write of a byte from buf then the remaining bytes are not sent. + − If {{fname|stop}} is {{fname|True}} then a STOP condition is generated at the end of the transfer, even if a '''NACK''' is received. + − The function returns the number of '''ACK'''s that were received.+ − + − + − 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.+ + + + + + + − Read {{fname|nbytes}} from the slave specified by {{fname|addr}} starting from the memory address specified by {{fname|memaddr}}. + − The argument {{fname|addrsize}} specifies the address size in bits. + − Returns a {{fname|bytes}} object with the data read.+ − Read into {{fname|buf}} from the slave specified by {{fname|addr}} starting from the memory address specified by {{fname|memaddr}}. + − The number of bytes read is the length of {{fname|buf}}. + − 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}}.+ − Write {{fname|buf}} to the slave specified by {{fname|addr}} starting from the memory address specified by {{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.+ − Hormis ce détail, il s'agit d'une méthode fiable car la plupart des composants répondent.+
→Introduction
Cet article reprends différentes notes utilises à ce sujet.
Cet article reprends différentes notes utilises à ce sujet.
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]
* 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).
* '''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.
=== Opérations standard du bus ===
=== 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(...) ====
i2c.readfrom(addr, nbytes, stop=True)
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.
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)
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 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)
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.
* '''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 ===
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)
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(...) ====
i2c.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8)
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(...) ====
i2c.writeto_mem(addr, memaddr, buf, *, addrsize=8)
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}}.
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 ===