Il s’agit d’un automate programmable, c’est à dire une carte de contrôle conçue à la base pour le milieu industriel. Cependant elle peut tout à fait intéresser les étudiants qui souhaitent réaliser un projet professionnel ou les Makers qui recherchent une carte fiable et robuste.
La carte PyMate a été créée par Frédéric Pierson ingénieur en électronique et informatique embarquée (et aussi CEO de Garatronic). Il l’avait présentée avec moi à la Maker Faire de Paris en Avril 2026.
Même si je ne suis pas payé pour écrire cet article (et que je n’ai pas de liens affiliés) je tiens à préciser que Fred m’a envoyé gratuitement la carte de base ainsi que les cartes d’extensions (dont je parlerai dans les prochains articles). De plus c’est un ami et j’admire beaucoup son travail (même si je ne comprend pas forcément tout). Je risque donc de manquer un peu d’objectivité mais comme d’habitude je vous dirai sincèrement ce que j’en pense et bien sûr, je ne vous cacherai pas les aspects négatifs (si j’en vois).
Doit-on dire « Le » ou « La » PyMate ?
Grave question, alors j’ai posé la question à Fred et voilà sa réponse :
Donc à vous de voir puisqu’un automate, c’est masculin et une carte de contrôle, c’est féminin. 😉
Quelle est la différence avec une carte comme l’Arduino ?
L’automate programmable a des Entrées/Sorties (IO) et des bus de communications robustes (RS485, bus CAN) par rapport à une carte Arduino. On peut directement piloter la bobine d’un relais en 24V avec une sortance de 250mA, soit 6W. Les entrées sont aussi en 24V, et la lecture pleine échelle analogique est de 0-10V. Mais il y a aussi le port d’extension qui est lui assez similaire a ce que peut faire un Arduino : RS232, I2C, SPI, le tout en 3.3V.
La PyMate en détail
Le microcontrôleur est situé au dos de la carte.
Il s’agit d’un STM32 (ARM Cortex M4) qui fonctionne à 100 MHz, possède 256 ko de RAM et 512 ko de mémoire flash. C’est quasiment le même microcontrôleur que celui de la PYBStick26 ce qui niveau puissance situe la PyMate entre un Arduino Uno R4 et un ESP32.
A coté des connecteurs d’alimentation (9 à 28 V), vous trouverez les bus RS485 et CAN.
Contrairement à l’Arduino, les entrées (Input) sont seulement des entrées (analogiques ou numériques).
Et les sorties (Output) seulement des sorties (analogiques ou numériques).
Mais chacune possède une LED qui indique son état et nous disposons également d’une LED d’alimentation et de 2 LED programmables.
La pile permet à l’horloge RTC de conserver la date quand l’alimentation est débranchée.
A droite de la carte une rangée de connecteurs permet d’accéder aux bus de communication CAN (5 V), I2C (3,3 V), SPI (3,3 V) et UART (3,3 V), à une pin d’interruption et à une alimentation 5 V.
Vous pouvez y branchez directement vos fils (équipés de connecteurs Dupont) ou relier la PyMate à une carte d’extension.
Mais dans ce cas il faudra retirer cette partie (située sous la carte).
A coté de la prise USB-C, nous avons 2 boutons (très agréables au toucher), le classique bouton RESET et un autre programmable.
Attention, la prise USB permet de reprogrammer la PyMate mais elle n’est pas destinée à l’alimenter. Pour cela, vous avez les connecteurs d’alimentation (que je vous ai montré tout à l’heure).
Méfiez-vous également des alimentations Power Delivery qui peuvent envoyer des tensions supérieures à 5 V. Elles sont susceptibles d’endommager le convertisseur DC-DC.
Les connecteurs spéciaux
La PyMate utilise des connecteurs qui s’insèrent par groupe de 8 sur la carte. Une fois introduit dans le connecteur, le câble est bloqué. Il faut alors appuyer sur le petit bouton orange pour le libérer.
Même s’ils sont utilisable avec certains connecteurs Dupont (les plus longs), les connecteurs de la PyMate sont conçus pour des câbles sertis avec une ferrule.
Ensuite, utilisez des connecteurs Wago (ou compatibles) pour réaliser vos branchements. Le résultat est beaucoup plus fiable qu’avec des connecteurs Duponts qui se débranchent facilement.
Supports imprimés et rail DIN
Pour manipuler en tout sécurité la PyMate (et ses cartes d’extensions) lors de mes tests, j’ai conçu des supports imprimés en 3D. Si cela vous intéresse vous pouvez les télécharger sur Printables.
Mais bien sûr pour un branchement durable, privilégiez le boitier officiel. Il se fixe à un rail DIN et ça c’est quand même beaucoup plus pro. 😉
Premier programme (Blink)
Pour programmer la carte en MicroPython, téléchargez et installez Thonny (que vous trouverez ici). Lancez le logiciel, allez ensuite dans Exécuter – Configurer l’interprétateur…, sélectionnez MicroPython (générique) et laissez « Essayer de détecter le port automatiquement » (sauf si une fois branchée la carte n’est pas reconnue, dans ce cas, il faudra retourner ici pour sélectionner manuellement le port).
Commençons par un programme simple, il s’agit de faire clignoter alternativement les 2 LED utilisateur (LED_1 et LED_2).
# Blink (LED internes)# Importation des fonctions Pin et sleepfrom machine import Pinfrom time import sleep# Création des objets led1 et led2led1 = Pin('LED_1', Pin.OUT)led2 = Pin('LED_2', Pin.OUT)# Boucle infiniewhile True: # Allume la LED 1 led1.on() # Éteint la LED 2 led2.off() # Pause d'une seconde sleep(1) # Éteint la LED 1 led1.off() # Allume la LED 2 led2.on() # Pause d'une seconde sleep(1)
Appuyez sur le bouton « Stop » (le rond rouge avec un carré blanc) pour redémarrer l’interpréteur. Il est possible de rentrer les instructions ligne par ligne dans la console, mais pour ce type de programme il est plus facile de copiez le code ci-dessus dans l’éditeur.
Appuyez ensuite sur le bouton « Exécuter » (le bouton vert avec un triangle blanc) et les LED utilisateur se mettent à clignoter.
Pour que le programme s’exécute automatiquement à la mise sous tension :
- Stoppez l’exécution du programme (bouton rouge)
- Cliquez sur le bouton « Enregistrer » (disquette)
- Choisissez appareil MicroPython
- Nommez le fichier main.py
Plus tard, vous pourrez retrouver votre fichier en cliquant sur le bouton « Ouvrir » et en sélectionnant de nouveau appareil MicroPython.
Sorties numériques
En modifiant légèrement le code, vous pouvez faire clignoter une LED externe reliée par exemple à la sortie n°2 de la PyMate (nommée « Out2« ). Vous pouvez bien sûr choisir n’importe quelle autre (à condition d’adapter votre programme).
# Blink (LED externe)# Faire clignoter une LED reliée à une résistance de 1,5 KΩ sous 12V# Importation des fonctions Pin et sleepfrom machine import Pinfrom time import sleep# Création de l'objet ledled = Pin('Out2', Pin.OUT)while True: # Allume la LED led.on() # ou led.value(1) # Pause d'une seconde sleep(1) # Éteint la LED led.off() # ou led.value(0) # Pause d'une seconde sleep(1)
Reproduisez ce branchement en ajoutant une résistance de 1,5 KΩ (pour une alimentation de 12 V) et connectez la prise USB-C de la PyMate à l’ordinateur.
Pour l’alimentation, utilisez n’importe quel transformateur de récupération d’une tension de 9 à 24 V (en adaptant la valeur de la résistance en fonction de la tension).
La LED interne de la sortie clignote en même temps (même si sur la photo, elle est cachée par les connecteurs).
Sorties analogiques (PWM)
Les sorties peuvent aussi être configurées en mode (pseudo) analogique avec une résolution de 16 bits (de 0 à 65535). Cela permet par exemple de modifier la luminosité de la LED (le branchement est le même que précédemment).
# LED Externe PWM# Importation des fonctionsfrom machine import PWMfrom time import sleep# Création de l'objet ledPWMledPWM=PWM('Out2', freq=120)# Boucle infiniewhile True: # Modification de l'intensité lumineuse (entre 0 et 65536) for lum in range(0, 65536, 1024): ledPWM.duty_u16(lum) sleep(0.03) for lum in range(65535, -1, -1024): ledPWM.duty_u16(lum) sleep(0.03)
Bouton utilisateur
Le bouton utilisateur est relié à une résistance de tirage vers le haut (pull up). Il envoie donc la valeur 1 au repos et la valeur 0 lorsqu’on appuie dessus. Vous pouvez tester cela avec le programme suivant, qui affiche la valeur du bouton dans la console toutes les 0,5 secondes.
# Test bouton# Importation des fonctionsfrom machine import Pinfrom time import sleep# Création de l'objet boutonbouton = Pin("USER_SW", Pin.IN)while True: # Affichage de la valeur du bouton print(bouton.value()) # Pause 1/2 seconde sleep( 0.5 )
Pour allumer une des LED internes en appuyant sur le bouton, il suffit d’inverser la valeur (booléenne) du bouton avec l’opérateur not.
# Bouton utilisateur# Importation des fonctionsfrom machine import Pinfrom time import sleep# Création des objets bouton et led2bouton = Pin("USER_SW", Pin.IN)led2 = Pin('LED_2', Pin.OUT)while True: # Allume la LED lorqu'on appuie sur le bouton led2.value(not bouton.value()) # Pause de 0,2 seconde sleep( 0.2 )
Entrées numériques
Les entrées de la PyMate sont reliées à une résistance de tirage vers le bas (pull down). En mode numérique, elles envoient donc la valeur 0 par défaut et la valeur 1 si elles sont reliées à une tension supérieure à 8 V.
Pour tester cela, vous pouvez utiliser le branchement et le code suivant.
# Bouton externe# Importation des fonctionsfrom machine import Pinfrom time import sleep# Création des objets bouton et ledbouton = Pin('In3', Pin.IN)led = Pin('Out2', Pin.OUT)while True: # Allume la LED lorqu'on appuie sur le bouton led.value(bouton.value()) # Affiche la valeur du bouton print(bouton.value()) # Pause de 0,2 seconde sleep( 0.2 )
Vous remarquerez que les LED internes de l’entrée n°3 et de la sortie n°2 s’allument lorsqu’on appuie sur le bouton.
Entrées numériques
Les entrées analogiques de la PyMate fonctionnent sous 10 V maximum, mais vous pouvez sans risque dépasser cette tension (jusqu’à 24 V). Simplement à partir de 10 V, vous obtiendrez la valeur maximum.
Je vous invite à reproduire ce branchement.
Le code suivant permet de modifier la luminosité de la LED avec le potentiomètre. Il affiche aussi la valeur mesurée (par l’entrée n°3) sur la console.
# Entrées numériques# Importation des fonctionsfrom machine import PWM, ADCfrom time import sleep# Création des objets potentiometre et ledPWMpotentiometre = ADC('In3')ledPWM=PWM('Out2', freq=120)while True: # Modifie la luminosite la LED ledPWM.duty_u16(potentiometre.read_u16()) # Affiche la valeur du potentiometre print(potentiometre.read_u16()) # Pause de 0,2 seconde sleep( 0.2 )
Cependant, j’ai rencontré un problème à cette étape : Lorsque le potentiomètre est réglé au minimum, la valeur détectée devrait être à zéro (ou alors à une valeur très proche). Malheureusement, ce n’est pas du tout le cas, elle oscille entre 1792 et 1824.
D’ailleurs à cause de ça, la LED n’est jamais complètement éteinte.
Ce problème est évoqué par Dominique Meurisse dans la documentation officielle de la PyMate. La résolution des entrées analogiques de la PyMate est de 12 bit (valeur de 0 à 4095) alors que la fonction read_u16() est en 16 bits (entre 0 et 65536). La valeur mesurée est donc automatiquement convertie de 12 bit à 16 bit.
Pour cela, il suffirait de multiplier par 16 la valeur en 12 bit (ce qui donnerait éventuellement une valeur minimum de 16 ou 32). Alors comment expliquer qu’on aboutisse à une valeur de 1792 ?
De mon coté, j’ai contourné le problème en remplaçant la fonction read_u16() du module machine par la fonction read() du module pyb. Mais ça reste du bricolage, j’en ai parlé à Dominique et il m’a indiqué qu’il ne faut plus utiliser cette fonction parce qu’elle est obsolète.
Il existe certainement une meilleure solution alors n’hésitez pas à l’indiquer dans les commentaires et je ferrai évoluer l’article.
# Entrées numériques v2# Importation des fonctionsfrom pyb import ADCfrom machine import PWMfrom time import sleeppotentiometre = ADC('In3')ledPWM=PWM('Out2', freq=120)while True: # Modifie la luminosite la LED ledPWM.duty_u16(potentiometre.read()*16) # Affiche la valeur du potentiometre print(potentiometre.read()) # Pause de 0,2 seconde sleep( 0.2 )
Une valeur de 1 ou 2 est tout à fait acceptable.
Dans les prochains épisodes…
Cet article est déjà très long et pourtant il reste encore énormément de choses à vous dire sur la PyMate. J’ai à peine évoqué les cartes d’extension ou des bus de communication et je ne vous ai même pas montré d’exemples concrets de réalisations.
Je vais donc consacrer d’autres articles à la PyMate, alors à bientôt pour de nouvelles aventures 😉
arduiblog 