Programmer un microcontrôleur
Systèmes embarqués - SNT Seconde
Programmer un microcontrôleur
Objectifs
- Comprendre ce qu'est un microcontrôleur et son architecture de base.
- Découvrir les principes de la programmation embarquée (entrées/sorties, boucles).
- Écrire et tester un premier programme simple pour faire clignoter une LED.
Introduction
Imaginez un objet qui clignote, qui mesure la température, qui réagit à votre toucher. Derrière ces objets intelligents qui nous entourent se cache un petit cerveau électronique : le microcontrôleur. Aujourd'hui, nous allons découvrir comment lui donner des instructions pour qu'il réalise des actions concrètes.
Comment programmer un microcontrôleur pour qu'il interagisse avec son environnement physique ?
Qu'est-ce qu'un microcontrôleur ? Le cerveau de l'objet connecté
Un microcontrôleur est un circuit intégré qui rassemble sur une seule puce tous les éléments essentiels d'un ordinateur simplifié : un processeur (CPU), de la mémoire (RAM et ROM/Flash), et des interfaces d'entrées/sorties (E/S). Contrairement à l'ordinateur de votre salle de classe qui est généraliste, le microcontrôleur est conçu pour une tâche spécifique, répétitive et en temps réel. Il est au cœur des objets embarqués : la carte qui gère le cycle de votre lave-linge, le système qui affiche la température sur votre thermostat, ou le module qui fait clignoter les lumières d'un jouet. Un exemple très répandu en éducation est la carte Arduino Uno, qui embarque un microcontrôleur ATmega328P. Cette carte possède des broches numérotées qui servent d'interfaces avec le monde extérieur. On distingue les broches d'entrée (pour lire une information, comme l'état d'un bouton) et les broches de sortie (pour envoyer une commande, comme allumer une LED). La programmation consiste à écrire une suite d'instructions que le microcontrôleur exécutera en boucle pour piloter ces broches.
Points clés
- C'est un système complet sur puce (CPU, mémoire, E/S).
- Il est dédié à une tâche spécifique et fonctionne en temps réel.
- Il communique avec le monde extérieur via des broches d'entrée et de sortie.
Les bases de la programmation embarquée : setup() et loop()
Pour programmer un microcontrôleur comme celui d'une carte Arduino, on utilise souvent un langage basé sur le C/C++, simplifié dans un environnement de développement intégré (IDE). La structure d'un programme, qu'on appelle un 'sketch', repose sur deux fonctions obligatoires. Premièrement, la fonction `setup()`. Elle n'est exécutée qu'une seule fois, au démarrage du microcontrôleur. C'est ici qu'on initialise les paramètres : on définit si une broche sera utilisée en entrée (pour lire) ou en sortie (pour commander). Par exemple, `pinMode(13, OUTPUT);` indique que la broche numérique 13 sera une sortie. Deuxièmement, la fonction `loop()`. Après le `setup()`, le microcontrôleur entre dans cette fonction et l'exécute en boucle, indéfiniment, jusqu'à ce qu'il soit éteint. C'est le cœur du programme où l'on place les instructions principales : lire un capteur, effectuer un calcul, allumer ou éteindre un actionneur. Par exemple, `digitalWrite(13, HIGH);` met la broche 13 à l'état haut (+5V), ce qui allume une LED connectée. `delay(1000);` demande au microcontrôleur d'attendre 1000 millisecondes (1 seconde). La combinaison de ces commandes permet de créer des comportements dynamiques.
Points clés
- La fonction `setup()` initialise le programme une seule fois.
- La fonction `loop()` contient le code exécuté en boucle indéfiniment.
- Les commandes `pinMode()`, `digitalWrite()` et `delay()` sont fondamentales pour les E/S.
Applications pratiques
Prenons l'exemple concret de la 'LED clignotante', le 'Hello World' de l'embarqué. Matériel nécessaire : une carte Arduino, une LED, une résistance de 220 ohms et des fils de connexion. La LED est connectée à la broche 13 (sortie) et à la masse (GND), avec la résistance en série pour la protéger. Le programme est le suivant : Dans `setup()`, on configure la broche 13 en sortie avec `pinMode(13, OUTPUT);`. Dans `loop()`, on écrit une séquence qui allume la LED (`digitalWrite(13, HIGH);`), attend une seconde (`delay(1000);`), éteint la LED (`digitalWrite(13, LOW);`), attend une seconde (`delay(1000);`). Une fois téléversé (upload) sur la carte, le programme tourne en autonomie : la LED clignote indéfiniment. On peut complexifier en ajoutant un bouton poussoir en entrée sur la broche 2. On modifie le `setup()` pour déclarer la broche 2 en `INPUT`. Dans la `loop()`, on utilise `digitalRead(2)` pour connaître l'état du bouton. On peut alors écrire une condition : `if(digitalRead(2) == HIGH) { digitalWrite(13, HIGH); } else { digitalWrite(13, LOW); }`. La LED s'allume uniquement quand le bouton est pressé. Cela illustre l'interaction entre une entrée (le bouton) et une sortie (la LED).
Points clés
- Le montage LED clignotante est l'exemple de base pour comprendre le cycle d'exécution.
- L'ajout d'un bouton poussoir introduit la lecture d'une entrée et les structures conditionnelles.
- Le programme est téléversé et s'exécute de manière autonome sur la carte.
À retenir
Un microcontrôleur est un ordinateur miniature dédié au contrôle d'un système. On le programme en définissant des broches en entrée ou sortie dans la fonction `setup()`, puis en écrivant la logique de commande dans la fonction `loop()`, qui s'exécute en continu. Cela permet de créer des interactions simples avec le monde physique, comme allumer une LED ou réagir à l'appui sur un bouton.
- Un microcontrôleur exécute en boucle un programme stocké dans sa mémoire.
- La structure de base d'un programme embarqué repose sur les fonctions `setup()` (initialisation) et `loop()` (exécution principale).
- La communication avec les composants externes se fait via les broches configurées en `INPUT` (digitalRead) ou `OUTPUT` (digitalWrite).
