Périphériques I2C¶

Côté programme, machine.I2C fait du microcontrôleur le maître d'un vrai bus I2C électrique : il génère l'horloge sur SCL et échange les données sur SDA (API). Peripherals fournit trois périphériques esclaves à brancher sur ce bus. Leur comportement est toujours décrit par un script Python. Un autre MCU peut aussi être l'esclave, avec machine.I2CTarget (API, exemples MultiMcu.I2c et MultiMcu.I2cIrq).

Lignes SCL et SDA de l'exemple I2c.Echo : START, octet d'adresse, acquittement de l'esclave, puis premier octet de données.

Câblage¶

Deux fils partagés par tous les acteurs du bus, plus la masse :

from machine import Pin, I2C

i2c = I2C(0, scl=Pin(4), sda=Pin(5), freq=100000)
print(i2c.scan())                    # adresses présentes, ex. [66]
i2c.writeto(0x42, b'Hello')
print(i2c.readfrom(0x42, 5))

Le bus est en drain ouvert : chaque acteur ne sait que tirer une ligne à la masse ou la relâcher, et ce sont des résistances de tirage qui remontent les lignes. Au moins un périphérique du bus doit porter ces résistances (usePullUp = true). I2C() active bien les tirages internes du microcontrôleur sur SCL et SDA, comme sur le Pico, mais 50 kΩ face aux capacités d'entrée des périphériques, c'est beaucoup trop lent : une ligne relâchée n'a pas le temps de remonter, et chaque transaction lève OSError(ETIMEDOUT), comme sur un montage où on a oublié les résistances (exemple I2c.NoPullUp). L'écran Grove les porte par défaut, comme le module réel.

Autant de périphériques qu'on veut se partagent les deux fils ; chacun ne répond qu'à ses adresses (exemple I2c.MultiDevice).

Les périphériques fournis¶

Les scripts par défaut sont dans Resources/Scripts/Device/.

L'écran Grove LCD RGB¶

Le module réel porte deux circuits, d'où deux adresses pour un seul composant ; le script les émule d'après leurs fiches techniques :

• JHD1313 (0x3E, contrôleur d'écran compatible HD44780) : effacement, retour au début, position d'écriture, écran allumé ou éteint, décalage. Écran éteint à la mise sous tension, comme le vrai : le driver doit l'allumer.
• PCA9633 (0x62, driver du rétroéclairage) : intensités rouge, vert, bleu.

L'icône affiche les deux lignes et prend la couleur du rétroéclairage pendant la relecture du résultat. valueOut rend (rouge, vert, bleu, écran allumé), intensités de 0 à 255.

L'exemple I2c.GroveLcd pilote cet écran avec un driver MicroPython du commerce, exécuté sans modification : driver_grove_lcd_rgb.py, posé à côté du programme qui l'importe.

Connecteurs¶

Paramètres¶

Bus et comportement (onglet General)¶

Entrées / sorties (onglet Inputs / outputs)¶

Électrique (onglet Electrical)¶

Écrire le script d'un périphérique¶

Le script ne voit que des transactions : ni bits, ni START/STOP, ni acquittements. Quatre fonctions, toutes facultatives :

registres = bytearray(16)
pointeur = 0

def on_write(addr, data, t, v):     # le maître vient d'écrire data (bytes, jamais vide)
    global pointeur
    pointeur = data[0] % 16
    for octet in data[1:]:
        registres[pointeur] = octet
        pointeur = (pointeur + 1) % 16

def on_read(addr, t, v):            # le maître commence à lire
    return bytes(registres[pointeur:])   # bytes, str, liste d'entiers ou entier

def outputs():                      # relue après chaque appel -> valueOut
    return registres[0]

def lines():                        # relue après chaque appel -> deux lignes de texte (écrans)
    return ('ligne 1', 'ligne 2')

addr permet à un composant à plusieurs adresses de savoir à quel circuit on s'adresse. Mêmes règles que pour les appareils série : un script chargé une fois par composant, des variables qui persistent d'un appel à l'autre, pas d'attente ni d'accès à machine, print() dans le journal, arrêt de la simulation sur exception.

Pour créer un nouveau périphérique : copier Resources/Scripts/Device/i2c_generic.py et le désigner dans un I2cGenericDevice.

Grandeurs à tracer¶

Exemples¶