Microcontrôleurs populaires

Le microcontrôleur (en anglais microcontroller, abrégé MCU) est un ordinateur complet réduit à une seule puce : processeur, mémoire vive, mémoire flash et périphériques cohabitent sur quelques millimètres carrés de silicium. C'est lui qui fait battre le cœur de presque tous les objets qui vous entourent. Cette page explique son architecture, le modèle setup/loop, les broches GPIO et leurs limites électriques, puis compare les cartes populaires — Arduino UNO, ESP32, Raspberry Pi Pico, STM32.

1. C'est quoi ?

Un microcontrôleur est un ordinateur entier dans une seule puce. Sur le même morceau de silicium cohabitent : un processeur (CPU) qui exécute les instructions, une mémoire vive (RAM) pour les variables, une mémoire flash qui conserve le programme même hors tension, et des périphériques — broches d'entrées-sorties, timers, convertisseur ADC, bus de communication. Les datasheets le nomment MCU ; on le distingue du microprocessor, le processeur seul d'un PC, dont la mémoire et les entrées-sorties sont ajoutées autour, sur la carte.

La comparaison avec un PC donne l'échelle : 2 Ko de RAM — un million de fois moins qu'un ordinateur de bureau —, 16 MHz contre 3 GHz, pas d'écran, pas de clavier, pas de système d'exploitation. Inutile, en effet : son monde, ce sont des broches. Il envoie des niveaux électriques (allumer une LED, commander un transistor), il en lit (un bouton, la tension d'un capteur), des millions de fois par seconde sans jamais se lasser.

Sa programmation suit le modèle setup/loop : la fonction setup s'exécute une seule fois à la mise sous tension (configurer les broches), puis la fonction loop est répétée indéfiniment — lire, décider, agir, recommencer. Ce couple remplace tout le système d'exploitation : pas de fenêtres, pas de fichiers, juste une boucle qui tourne.

On en croise des milliards chaque année, invisibles :

• dans l'électroménager (lave-linge, four : programmes, touches, afficheur) ;
• dans les voitures, qui en embarquent souvent une centaine (airbag, injection, vitres, tableau de bord) ;
• dans les périphériques du PC : clavier, souris, webcam ;
• dans la domotique et l'IoT : thermostats, volets, capteurs connectés ;
• dans les jouets, les drones, les montres, les chargeurs USB.

2. Comment ça marche ?

À l'intérieur, on retrouve les organes d'un ordinateur, en miniature et soudés ensemble. Le processeur lit ses instructions dans la flash via un bus interne, place ses variables en RAM, et dialogue avec des périphériques autonomes : de petits modules logiques posés sur le même bus, qui travaillent sans le déranger en permanence. GPIO, ADC, timers et UART sont de ces modules — on les configure en écrivant dans leurs registres, comme on adresserait des services internes.

SchémaArchitecture interne d'un microcontrôleur

Le modèle setup/loop devient une évidence : setup configure les modules, puis loop tourne indéfiniment. Et il tourne vite :

t ≈ n / f

Une broche GPIO — general purpose input/output, entrée-sortie à usage général — a trois métiers. En sortie, elle impose un niveau : 0 (proche de 0 V) ou 1 (5 V ou 3,3 V selon la carte) — de quoi allumer une LED munie de sa résistance. En entrée numérique, elle lit un niveau : un bouton poussoir, une fin de course. En entrée analogique, elle est reliée au convertisseur ADC, qui transforme une tension en nombre :

cran = Vref / 2¹⁰

Le cas de l'entrée mérite une pause, car c'est le premier piège du débutant. Une broche en entrée n'a rien d'imposé quand le bouton est relâché : elle « flotte », capte le moindre champ électrique (votre main, le secteur d'à côté) et sa lecture dérive entre 0 et 1 au hasard. La parade est une résistance de rappel : tirée doucement vers VCC (pull-up) ou vers la masse (pull-down), la broche a un niveau de repos défini, que le bouton vient inverser. Presque tous les microcontrôleurs intègrent ces résistances (20 à 50 kΩ) : le mode INPUT_PULLUP les engage sans aucun composant externe, au prix d'une logique inversée — bouton pressé, on lit 0.

Les broches restent fragiles : une broche d'ATmega328P fournit au plus 40 mA en régime absolu — 20 mA de confort — et la puce entière plafonne vers 200 mA. D'où la règle qui sauve des cartes :

L'horloge fait tourner tout cela : un quartz de 16 MHz sur l'UNO, une PLL qui monte à 240 MHz sur l'ESP32. Plus vite, c'est plus de calcul, mais plus de consommation : des dizaines de milliampères à plein régime, quelques microampères en veille (modes deep-sleep, horloge ralentie) — c'est cette nuit du microcontrôleur qui donne des années d'autonomie aux objets sur pile, et les datasheets publient le courant de chaque mode.

Restent les moteurs d'assistance du processeur. Les interruptions suspendent le programme quand un événement survient — front sur une broche, échéance d'un timer — appelant une fonction courte puis reprenant le cours normal : réaction en microsecondes, sans scruter la boucle. Les temporisations attendent : delay() bloque tout simplement, les timers déclenchent sans bloquer. Et quand il faut faire varier une luminosité ou une vitesse de moteur, c'est le PWM — la largeur d'impulsion vue dans moteurs-cc, couche 2 — que les timers produisent tout seuls. Enfin, pour parler aux capteurs et aux écrans, le microcontrôleur embarque des bus de communication :

Bus	Fils	Vitesse typique	À quoi ça sert
UART	2 (TX, RX)	9 600 à 115 200 bauds	console de l'IDE, GPS, modules radio
I2C	2 (SDA, SCL)	100 à 400 kHz	capteurs, horloge RTC, petit écran
SPI	4 (SCK, MOSI, MISO, CS)	1 à 20 MHz	carte SD, écran rapide, mémoire
USB	2 différentielles	12 Mbit/s	dialogue avec le PC, reprogrammation

Ces quatre autoroutes mériteraient chacune leur page ; retenez pour l'instant que l'UART pilote la console du prochain chapitre.

3. Dans le vrai monde

L'amateur ne soude presque jamais le microcontrôleur nu : il l'achète posé sur une carte qui règle alimentation, USB, quartz et connectique. Le marché s'est cristallisé autour de quelques familles :

Carte	Puce	Fréquence	RAM	Flash	Broches	Prix indicatif
Arduino UNO R3	ATmega328P	16 MHz	2 Ko	32 Ko	14 + 6 analogiques	25 € (clones ≈ 8 €)
ESP32 DevKit	ESP32 (2 cœurs)	240 MHz	520 Ko	4 Mo	≈ 30 + Wi-Fi et Bluetooth	≈ 8 €
Raspberry Pi Pico	RP2040 (2 cœurs)	133 MHz	264 Ko	2 Mo	26	≈ 5 €
STM32 (Nucleo, Blue Pill)	STM32F103	72 MHz	20 Ko	64 Ko	37	4 à 20 €

Lire ce tableau : la RAM va de quelques kilooctets à un demi-mégaoctet, la flash contient tout le programme, et la fréquence ne fait pas tout — le RP2040 doit sa réputation à ses blocs PIO, des mini-machines d'états programmables, plutôt qu'à son horloge. Les prix sont tirés vers le bas par les clones chinois : une UNO « vraie » coûte le quadruple d'un clone fonctionnellement identique.

Côté formats, tout a été miniaturisé : les versions à pattes DIP insérables sur plaque d'essai (les débuts, avec le Basic Stamp) ont laissé la place à des modules CMS soudés de la taille d'un timbre. Les usines emploient les mêmes puces en versions industrielles — températures garanties, watchdog matériel — : un lave-linge et un atelier d'amateur tournent avec la même famille de silicium, seule la rigueur change.

4. Exemple pratique

Le « Hello world » de l'embarqué, c'est le clignotement d'une LED : le programme est court, le résultat est visible, et la chaîne complète — écrire, compiler, transférer — est exercée une fois pour toutes. Un logiciel sur le PC (l'IDE Arduino) compile le programme en instructions machine, puis l'envoie dans la flash de la puce par le câble USB — la liaison est un UART piloté par une puce USB, d'où les ports « COM » sous Windows. Le même câble sert de console : Serial.print depuis le programme s'affiche dans le moniteur série de l'IDE.

Le programme minimal, LED et résistance de 220 Ω branchées de la broche 7 vers la masse :

const int LED = 7;          // LED + résistance 220 ohm sur la broche 7

void setup() {
  pinMode(LED, OUTPUT);     // la broche 7 devient une sortie
}

void loop() {
  digitalWrite(LED, HIGH);  // niveau haut : la LED s'allume
  delay(500);               // attente d'une demi-seconde
  digitalWrite(LED, LOW);   // niveau bas : la LED s'éteint
  delay(500);               // attente d'une demi-seconde
}

Sur une UNO, la broche 13 embarque déjà une LED sur la carte : le montage peut se réduire à zéro fil. Les calculs de résistance et les limites des LED se trouvent dans leds, de la même couche. Avant de câbler pour de vrai, explorez le comportement des broches :

SchémaExplorateur de broches GPIO

InteractifExplorateur de broches GPIO

b0 ?b1 ?b2 1b3 ?b4 ?b5 ?b6 ?b7 1

broche 7 = 1, broche 2 = 1

LED : allumée — la broche fournit le courant.

Poussoir : relâché ; le pull-up interne impose un 1 stable au repos.

Broches flottantes : 0, 1, 3, 4, 5, 6 — leur lecture ne vaut rien tant que rien ne la fixe.

Broche de la LEDbroche 0broche 1broche 2broche 3broche 4broche 5broche 6broche 7Broche du poussoirbroche 0broche 1broche 2broche 3broche 4broche 5broche 6broche 7

Broche 0INPUT — entrée nueINPUT_PULLUP — entrée + rappelOUTPUT LOW — sortie à 0OUTPUT HIGH — sortie à 1Broche 1INPUT — entrée nueINPUT_PULLUP — entrée + rappelOUTPUT LOW — sortie à 0OUTPUT HIGH — sortie à 1Broche 2 · poussoirINPUT — entrée nueINPUT_PULLUP — entrée + rappelOUTPUT LOW — sortie à 0OUTPUT HIGH — sortie à 1Broche 3INPUT — entrée nueINPUT_PULLUP — entrée + rappelOUTPUT LOW — sortie à 0OUTPUT HIGH — sortie à 1Broche 4INPUT — entrée nueINPUT_PULLUP — entrée + rappelOUTPUT LOW — sortie à 0OUTPUT HIGH — sortie à 1Broche 5INPUT — entrée nueINPUT_PULLUP — entrée + rappelOUTPUT LOW — sortie à 0OUTPUT HIGH — sortie à 1Broche 6INPUT — entrée nueINPUT_PULLUP — entrée + rappelOUTPUT LOW — sortie à 0OUTPUT HIGH — sortie à 1Broche 7 · LEDINPUT — entrée nueINPUT_PULLUP — entrée + rappelOUTPUT LOW — sortie à 0OUTPUT HIGH — sortie à 1

Appuyer le poussoirRappels internes (pull-up) : activés

Modèle pédagogique : la broche flottante est simulée par une tension qui dérive lentement autour du seuil de lecture (chaque broche a sa phase) ; le curseur « pull-up » engage ou coupe les résistances de rappel internes, comme l'instruction INPUT_PULLUP. Lecture figée quand le système demande la réduction des animations.

Exercice résolu — le budget de courant d'une guirlande de LED

On allume dix LED à 15 mA chacune, pilotées broche par broche sur une UNO alimentée par USB. Ce courant dépasse-t-il le débit du port ? Est-ce raisonnable ?

1. Courant des LED : 10 × 15 mA = 150 mA. Réponse à la question : non, 150 mA est inférieur à 500 mA — mais le calcul ne s'arrête pas là.
2. Ajouter la carte elle-même : régulateur, puce USB, microcontrôleur, environ 50 mA. Total : ≈ 200 mA, sous les 500 mA garantis par le port — marge de 300 mA. C'est la budgétisation de puissance : on additionne tout ce que la carte alimente, jamais seulement la nouveauté.
3. Vérifier les limites locales : 15 mA par broche, sous les 20 mA de confort et les 40 mA absolus de l'ATmega328P. Par broche, tout va bien.
4. Vérifier la limite globale : l'ensemble des broches de la puce plafonne vers 200 mA — on y est pile. Une treizième LED, ou des LED de 20 mA, et les limites sautent. La réponse d'ingénieur : au-delà de quelques LED, basculer sur des transistors ou un driver dédié, et laisser les broches ne commander que le signal.

Exercice résolu — la finesse d'un ADC sur un potentiomètre de 10 kΩ

Un potentiomètre de 10 kΩ monté en diviseur entre 3,3 V et la masse alimente l'ADC 10 bits d'une ESP32 ou d'un Pico. Que vaut un cran du convertisseur sur la course du potentiomètre ?

1. Nombre de crans : 2¹⁰ = 1024 niveaux, du plus bas au plus haut.
2. Taille d'un cran : 3,3 V / 1024 ≈ 3,2 mV. Sur une UNO (référence 5 V) : 4,9 mV ; avec une référence de précision de 4,096 V : 4,0 mV ronds. L'ordre de grandeur reste toujours le millivolt.
3. Traduire sur la piste : 10 000 Ω / 1024 ≈ 9,8 Ω par cran, soit 0,1 % de la course. Ce crantement électrique est invisible — personne ne distingue 3,2 mV au doigt ni à l'oreille — et la précision réelle du potentiomètre (usinage de la piste, bruit, voir potentiometres) est souvent moins bonne que la résolution de l'ADC.
4. Leçon : sur un potentiomètre de 10 kΩ, l'ADC 10 bits n'est jamais le maillon limitant. Pour mesurer plus fin, il faut monter en résolution (12 bits : 0,8 mV), filtrer le bruit ou amplifier — sinon le dernier cran se perd dans le bruit.

5. Vérifier sa compréhension

Réfléchissez avant de dérouler les réponses.

1. Pourquoi ne branche-t-on jamais un moteur ou un relais directement sur une broche GPIO, et quel composant interpose-t-on ?
2. Une broche configurée en INPUT sans pull-up, avec un bouton relâché : que lit-on exactement, et pourquoi ?
3. On appuie le bouton branché sur une broche en INPUT_PULLUP et la lecture tombe à 0. Pourquoi la logique est-elle inversée ?
4. Un ADC 10 bits relié à un potentiomètre de 10 kΩ sous 3,3 V : que vaut un cran, et ce crantement se ressent-il sur la course du potentiomètre ?
5. Dans le modèle setup/loop, où place-t-on la configuration des broches ? Et par quel mécanisme réagit-on à un événement sans surveiller la boucle en permanence ?

6. Pour aller plus loin

• Microchip — datasheet de l'ATmega328P (architecture AVR, limites de courant par broche, ADC 10 bits, modes veille), sur microchip.com.
• Espressif — datasheet et guides techniques de l'ESP32 (Wi-Fi, ADC, deep-sleep), sur espressif.com.
• Arduino — documentation officielle : référence du langage, exemples intégrés dont Blink et Serial, sur docs.arduino.cc.
• Raspberry Pi — datasheet du RP2040 et manuel du Pico, sur raspberrypi.com.
• STMicroelectronics — documentation STM32 et notes d'application (GPIO, horloges, basse consommation), sur st.com.