Qu'est-ce que MicroPython ?

MicroPython est une implémentation compacte du langage Python, conçue pour fonctionner directement sur des microcontrôleurs et de petits systèmes embarqués. Contrairement au C ou au C++, qui doivent être compilés en code machine avant exécution, MicroPython agit comme un interpréteur sur le matériel cible. Il convient donc particulièrement au prototypage rapide, à l’expérimentation et à l’apprentissage.

MicroPython est largement utilisé sur des plateformes modernes comme le Raspberry Pi Pico, l'ESP32 et certaines cartes Arduino. Il permet aux développeurs d'écrire un code lisible et de haut niveau tout en interagissant directement avec le matériel.

MicroPython respecte autant que possible la syntaxe et la sémantique standard de Python, avec quelques restrictions liées aux ressources limitées en mémoire et en calcul.

Caractéristiques principales :
 

• l'indentation définit les blocs de code (pas d'accolades)
• typage dynamique (les variables ne nécessitent pas de déclaration explicite)
• gestion automatique de la mémoire (ramasse-miettes)
• structures de données de haut niveau comme les listes, tuples et dictionnaires

  Comparé au code C/C++ équivalent, cet exemple est plus court et plus lisible, au prix d’une exécution plus lente.

Structure du programme et exécution

Les programmes MicroPython s'exécutent généralement de deux façons :
 

1. Exécution interactive : basée sur le paradigme Read–Eval–Print Loop (REPL), où les commandes sont saisies directement dans une invite puis exécutées immédiatement. Cette méthode est utile pour tester le matériel et expérimenter.
2. Exécution par script : les programmes sont stockés sous forme de fichiers dans le système de fichiers interne du microcontrôleur. Un fichier nommé main.py s’exécute automatiquement au démarrage ou à la réinitialisation de la carte.

Accès au matériel

MicroPython donne accès au matériel via des modules intégrés, notamment le module machine . Ce module donne accès aux périphériques du microcontrôleur de manière portable.

Les fonctionnalités courantes comprennent :
 

• entrée et sortie numériques (GPIO)
• conversion analogique-numérique (ADC)
• modulation de largeur d'impulsion (PWM)
• timers
• interfaces de communication (I²C, SPI, UART)

  Bien que MicroPython masque de nombreux détails matériels, les numéros de broches et leurs fonctions dépendent toujours de la carte utilisée.

Performances et gestion de la mémoire

Comme MicroPython est interprété, il est intrinsèquement plus lent que le C/C++ compilé. Cela ne pose généralement pas de problème pour :
 

• la lecture de capteurs
• les interfaces utilisateur
• la communication
• la logique de contrôle générale

En revanche, MicroPython est moins adapté pour :
 

• le traitement de signaux à très haute vitesse
• les boucles de contrôle en temps réel strict
• les applications gourmandes en mémoire

Les microcontrôleurs exécutant MicroPython doivent réserver de la mémoire pour l’interpréteur lui-même, ce qui laisse moins de RAM disponible pour les programmes utilisateur que dans un environnement entièrement en C/C++.

Bibliothèques et écosystème

MicroPython inclut une bibliothèque standard et de nombreux modules spécifiques au matériel. Les pilotes supplémentaires (pour capteurs, écrans, etc.) sont généralement distribués sous forme de fichiers .py copiés directement sur l’appareil. Il n’existe pas de gestionnaire de paquets centralisé, ce qui rend la gestion des bibliothèques et dépendances plus manuelle, mais aussi plus transparente.
 

Gestion des erreurs et débogage

L’un des principaux atouts de MicroPython réside dans ses messages d’erreur clairs et informatifs. Les erreurs de syntaxe et exceptions d’exécution sont signalées immédiatement, souvent avec des numéros de ligne et des messages descriptifs. Associé au REPL interactif, cela simplifie nettement le débogage par rapport à de nombreux environnements C/C++.

Quand utiliser MicroPython

MicroPython est un excellent choix lorsque :
 

• la rapidité de développement est importante
• la clarté et la lisibilité du code comptent
• l'application n'est pas critique en termes de performances
• l'apprentissage et l'expérimentation sont les objectifs principaux

Le C ou le C++ est généralement préférable lorsque :
 

• un timing précis est requis
• la mémoire est extrêmement limitée
• la vitesse d'exécution maximale est critique
• des projets importants et de longue durée exigent un contrôle strict des ressources

Types de données

MicroPython utilise le typage dynamique, ce qui signifie que les variables n’ont pas de type fixe déclaré à l’avance. Le type d’une variable est déterminé automatiquement selon la valeur qui lui est affectée.

Les types de données courants comprennent :
 

• int – nombres entiers
• float – nombres à virgule flottante
• bool – valeurs booléennes (True ou False)
• str – chaînes de caractères (texte)
• list – collections ordonnées
• tuple – collections ordonnées immuables
• dict – paires clé–valeur

 
Il n'y a pas de distinction entre les tailles de int, long ou float au niveau du langage ; ces détails sont gérés en interne par l'interpréteur.

Variables et constantes

Les variables en MicroPython sont créées par assignation. Il n'y a pas d'étape de déclaration séparée.
 
MicroPython n'impose pas de constantes au niveau du langage. Par convention, les variables écrites en majuscules sont traitées comme des constantes et ne doivent pas être modifiées.
 
Cette convention améliore la lisibilité du code, mais n'est pas appliquée par l'interpréteur.

Structures de contrôle

MicroPython fournit les mêmes structures de contrôle fondamentales que le Python standard.

Instructions conditionnelles
 
L'indentation est significative en MicroPython et remplace les accolades {} utilisées en C/C++.

Boucles
Une boucle while :
 
Une boucle for :
 
Il n'existe pas de boucle for (init; condition; increment) traditionnelle comme en C/C++ ; l'itération repose sur des séquences et des plages.

Fonctions

Les fonctions sont définies à l'aide du mot-clé def. Elles peuvent accepter des paramètres et retourner des valeurs.
 
Les fonctions ne nécessitent pas de déclarations de type pour les paramètres ou les valeurs de retour. Cela facilite l'écriture des fonctions, mais transfère la responsabilité de l'exactitude au programmeur.

Conclusion

MicroPython offre une approche moderne et accessible de la programmation de microcontrôleurs avec un langage de haut niveau. S’il ne remplace pas totalement le C ou le C++ dans les applications critiques en performances, il abaisse fortement le seuil d’entrée et accélère le développement pour un large éventail de projets embarqués. En maîtrisant les deux approches, les développeurs peuvent choisir l’outil adapté à chaque tâche et même les combiner dans un même projet lorsque cela est pertinent..

---

Note de la rédaction : cet article est un extrait du livre Programming Microcontrollers in MicroPython (C. Valens, Elektor 2026), accompagnant le cours Elektor Raspberry Pi Pico with MicroPython (Programming Course). Le livre introduit la programmation embarquée via MicroPython sur des plateformes populaires, dont le Raspberry Pi Pico et l'ESP32. Les lecteurs découvrent comment utiliser des microcontrôleurs pour lire des entrées, traiter des données et contrôler des sorties dans une boucle prévisible en temps réel. Avec un code simple, il est possible de faire clignoter des LED, lire des capteurs, piloter des moteurs et communiquer avec l'environnement. L'interface de programmation REPL interactive favorise l'expérimentation et un apprentissage rapide.