Dans mon précédent article, je vous ai présenté la carte ainsi que l’utilisation des entrées et des sorties. Maintenant, nous allons découvrir les possibilités offertes par les connecteurs d’extensions (et notamment le bus I2C).
Le bus I2C
Le bus I2C est très pratique pour communiquer avec les modules compatibles car il nécessite seulement 4 fils (2 de données et 2 pour alimenter le module).
Malheureusement, le firmware actuel de la PyMate ne permet pas encore d’utiliser l’I2C matériel. Alors en attendant qu’une mise à jour règle le problème, nous utiliserons I2C logiciel (sur le mêmes ports). Il est donc possible que certaines bibliothèques demandent quelques modifications pour fonctionner correctement.
Les pins n°3 (SCL) et n°4 (SDA) fonctionnent sous 3,3 V mais tolèrent une tension de 5 V. Vous pouvez donc utiliser les modules 5 V de l’Arduino Uno. Cependant certains modules (conçus pour des cartes plus récentes, comme le Raspberry Pi Pico ou l’ESP32) ne supportent pas le 5 V, il faudra dans ce cas veiller à les alimenter en 3,3 V.
Afficheur LCD I2C
Chaque caractère est affiché dans une case de 40 pixels (8 lignes x 5 colonnes).
Ce module existe en plusieurs versions (multicolore, 4 lignes x 20 caractères etc…). Mais la version monochrome avec 2 lignes de 16 caractères est sans doute la plus courante. Mais ne vous inquiétez pas si vous possédez un autre modèle. Vous pourrez très facilement adapter le programme.
Le branchement est assez simple mais fiez-vous aux indications figurant sur le module plutôt qu’à ce schéma parce que l’ordre des pins peut différer d’un module à l’autre (heureusement, c’est toujours clairement indiqué).
Vous trouverez la bibliothèque MicroPython ici. Téléchargez et copiez le contenu du répertoire DIYables_MicroPython_LCD_I2 dans le dossier lib de la PYMATE (qui apparait comme une clé USB dans l’explorateur Windows).
Pour adapter la bibliothèque à l’I2C logiciel, ouvrez le fichier DIYables_MicroPython_LCD_I2C.py avec un éditeur de texte (comme par exemple Notepad++) et à la ligne 39 remplacez :
from machine import I2C, Pinpar :
from machine import SoftI2C, Pin
Sauvegardez le fichier, fermez le et redémarrez la PyMate pour que la modification de la bibliothèque soit prise en compte.
Utilisez le code suivant afin de connaitre l’adresse I2C de l’afficheur LCD (0x3f dans cet exemple).
from machine import SoftI2C, Pini2c = SoftI2C(scl=Pin('I2C4_SCL'), sda=Pin('I2C4_SDA'), freq=100000)print("Scanning I2C bus...")devices = i2c.scan()if len(devices) == 0: print("Nothing found! Check wiring and pull-ups.")else: print("Devices found:", len(devices)) for device in devices: print("Decimal Address:", device, " | Hexadecimal:", hex(device))
Voilà un exemple de programme qui montre comment afficher des données et créer une petite animation (avec un caractère spécialisé). N’oubliez pas d’adapter le programme en fonction de l’adresse I2C de l’afficheur LCD et bien sûr de modifier le nombre de ligne et/ou de colonnes si vous possédez un autre type d’afficheur LCD.
# Importation des fonctionsfrom machine import SoftI2C, Pinfrom DIYables_MicroPython_LCD_I2C import LCD_I2Cfrom time import sleep# Adresse I2C de l'afficheur LCD (à modifier éventuellement)ADDR_I2C = 0x3f# Définition du nb de lignes et de colonnes de l'afficheurLIGNES = 2COLONNES = 16# Création des objets i2c et lcdi2c = SoftI2C(scl=Pin('I2C4_SCL'), sda=Pin('I2C4_SDA'), freq=100000)lcd = LCD_I2C(i2c, ADDR_I2C, LIGNES, COLONNES)# Définition du caractère personalisé 0 (pixel par pixel)coeur = [ 0b00000, 0b01010, 0b11111, 0b11111, 0b01110, 0b00100, 0b00000, 0b00000]# Création du caractère perso à l'emplacement 0lcd.custom_char(0, coeur)while True: # Efface l'écran lcd.clear() # Place le curseur colonne 0, ligne 0 lcd.set_cursor(0, 0) # Affiche un message lcd.print("Salut les Makers") # Place le curseur colonne 0, ligne 1 lcd.set_cursor(0, 1) # Affiche un message lcd.print("www.pymate.io") # Pause de 2 secondes sleep(2) # Efface l'écran lcd.clear() # Petite annimation avec le coeur for i in range(0, 16): lcd.set_cursor(i, 0) lcd.print_custom_char(0) lcd.set_cursor(15-i, 1) lcd.print_custom_char(0) sleep(0.2) # Pause de 2 secondes sleep(2)
Capteur DHT11
En ajoutant le capteur de température et d’humidité DHT11 sur la Pin n°5 (SMB) vous obtenez un thermomètre/hygromètre.
Voilà le code correspondant, je ne rentre pas trop dans les détails mais si vous voulez en savoir plus, sachez que j’explique cela dans le chapitre MicroPython de mon livre sur l’Arduino. 😉
# Importation des fonctionsfrom machine import SoftI2C, Pinfrom DIYables_MicroPython_LCD_I2C import LCD_I2Cfrom time import sleepimport dht# Adresse I2C de l'afficheur LCD (à modifier éventuellement)ADDR_I2C = 0x3f# Définition du nb de lignes et de colonnes de l'afficheurLIGNES = 2COLONNES = 16# Création des objets I2C, lcd et dhti2c = SoftI2C(scl=Pin('I2C4_SCL'), sda=Pin('I2C4_SDA'), freq=100000)lcd = LCD_I2C(i2c, ADDR_I2C, LIGNES, COLONNES)dht = dht.DHT11(Pin('I2C4_SMB'))while True: try: # Pause de 2 secondes sleep(2) # Mesure température et humidité dht.measure() # Conversion des données en texte temp = str(round(dht.temperature())) hum = str(round(dht.humidity())) # Efface l'écran lcd.clear() # Place le curseur colonne 0, ligne 0 lcd.home() # Affiche la température lcd.print('Temperature : ') lcd.print(temp) # Place le curseur colonne 0, ligne 1 lcd.set_cursor(0, 1) # Affiche l'humidité lcd.print('Humidite : ') lcd.print(hum) # Si la PyMate ne reçoit pas les données du capteur except OSError as e: lcd.home() lcd.print('Probleme de') lcd.set_cursor(0, 1) lcd.print('transmission')
Afficheur LED 4 chiffres 7 segments (version I2C)
Chacun des 4 chiffres de l’afficheur LED est composé de 7 LED. Il serait possible de les contrôler directement avec les sorties de la PyMate (ou d’un Arduino), mais généralement ce type de module est équipé d’une puce électronique qui s’en charge.
Il existe d’autres versions de l’afficheur LED avec des registres de décalage (74HC595) ou une puce HT16K33 mais dans cet exemple j’utilise le contrôleur I2C TM1637. Le branchement est similaire à celui de l’afficheur LCD.
Vous trouverez la bibliothèque MicroPython ici. Téléchargez et copiez le contenu du répertoire DIYables_MicroPython_4Digit7Segment_TM1637 dans le dossier lib de la PYMATE (qui apparait comme une clé USB dans l’explorateur Windows).
Voilà par exemple un compte à rebours (qui se déclenche en appuyant sur le bouton utilisateur).
# Importation des fonctionsfrom DIYables_MicroPython_4Digit7Segment_TM1637 import Display4Digit7SegmentTM1637from time import sleepfrom machine import Pinminuteur = 15 * 60 affichage = 1# Création des objets afficheur et boutonafficheur = Display4Digit7SegmentTM1637(clk_pin='I2C4_SCL', dio_pin='I2C4_SDA')bouton = Pin("USER_SW", Pin.IN)def clignotement(): global affichage if affichage == 1: afficheur.on() else: afficheur.off() affichage = abs(affichage - 1)# Affichage du temps de départafficheur.print_time(minuteur//60,minuteur%60)# Attends que l'on appuie sur le boutonwhile bouton.value() == 1: clignotement() sleep( 0.2 )#Allume l'écranafficheur.on()# Boucle infiniewhile True: if minuteur >= 0: afficheur.print_time(minuteur//60,minuteur%60) minuteur = minuteur - 1 else: clignotement() sleep( 1 )
Horloge en temps réel
La pile bouton (3V) permet à l’horloge de la PyMate de rester synchronisée (lorsque la carte est éteinte). Pour interroger l’horloge utilisez simplement ce petit programme :
from machine import RTCrtc = RTC()print( rtc.datetime() )
Nous obtenons un tuple contenant les éléments suivant (année, mois, jour, n° de jour de la semaine, heure, minute, seconde, micro seconde). Chaque élément possède un indice (en commençant par 0) :
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| année | mois | jour | Jour sem | heure | minute | seconde | micro sec |
Ensuite, il possible de récupérer l’heure avec le code suivant
heure = rtc.datetime()[4]print(heure)
ou
heure, minute, seconde = rtc.datetime()[4:7]print(heure)print(minute)print(seconde)
Avec [4:7], on récupère les indices 4, 5 et 6, mais pas 7 parce que le dernier indice est exclu (c’est la règle de tranchage des tuples en MicroPython 😉).
Pour modifier l’heure, utilisez la même fonction en indiquant simplement le nouveau tuple.
from machine import RTCrtc = RTC()nouvelleHeure = (2026, 9, 21, 0, 12, 32, 10, 0)rtc.datetime( nouvelleHeure )
Et si nous fabriquions une pendule en envoyant les données vers l’afficheur LED ?
# Importation des fonctionsfrom DIYables_MicroPython_4Digit7Segment_TM1637 import Display4Digit7SegmentTM1637from machine import RTCfrom time import sleep# Création des objets afficheur et rtcafficheur = Display4Digit7SegmentTM1637(clk_pin='I2C4_SCL', dio_pin='I2C4_SDA')rtc = RTC()# Boucle infiniewhile True: # Récupération de l'heure heure, minute = rtc.datetime()[4:6] # Affichage de l'heure afficheur.print_time(heure,minute) # Petite pause sleep( 0.2 )
PyMate, la montre des Makers élégants 😂
Carte de prototypage
Elle permet de créer vos propres modules. Bien sûr il faut sortir le fer à souder, mais ensuite cela simplifie énormément les branchements.
La carte de prototypage s’insère facilement, assure la continuité des connecteurs (ce qui permet de chainer plusieurs cartes d’extension) et ajoute même une alimentation 3,3 V.
Elle n’est pas encore commercialisée par nos amis de MC Hobby mais j’imagine que ce sera bientôt le cas. 😍
Dans le prochain épisode…
Je vous parlerai de la PyMate 16ADI16DO, une carte d’extension qui permet de disposer de 16 entrées et de 16 sorties supplémentaires.
