Histoire, cartes Uno et Mega 2560, IDE et premier programme
Ce premier chapitre présente l’environnement Arduino : son histoire, les cartes et leurs microcontrôleurs, les outils de programmation et un premier programme complet. Il peut être parcouru dans son intégralité ou consulté de manière ciblée pour approfondir certains sujets et enrichir ses connaissances.
Objectifs du chapitre
Situer Arduino dans son histoire et distinguer la plateforme, le matériel libre, le logiciel libre et la marque.
Choisir une carte selon son microcontrôleur, ses mémoires, sa tension et ses entrées-sorties.
Connaître les caractéristiques et le brochage des cartes Uno et Mega 2560.
Utiliser l’IDE 2 : écrire, compiler et téléverser un croquis, ajouter bibliothèques et cartes.
Comprendre le chemin d’un croquis jusqu’à la mémoire du microcontrôleur, avec ou sans bootloader.
D’où vient Arduino, ce qu’il est exactement – une carte, un logiciel, une communauté – et à quoi ressemble son écosystème aujourd’hui. Cette partie donne le vocabulaire et les repères historiques indispensables avant d’aborder le matériel.
Chapitre 1 · Section 1.1
Aux origines d’Arduino
Arduino n’est pas né dans un laboratoire d’électronique mais dans une école de design. Ce point de départ explique presque tous ses choix : un matériel bon marché, un logiciel simple, une documentation ouverte. Comprendre cette histoire, c’est comprendre pourquoi Arduino est devenu l’outil de prototypage le plus répandu au monde.
1.1.1Un besoin pédagogique
Au début des années 2000, l’Interaction Design Institute Ivrea (IDII), dans le nord de l’Italie, forme des designers au « design interactif » : concevoir des objets qui réagissent à leur environnement – une lampe qui s’allume quand on s’approche, une installation qui réagit au son. Les étudiants ne sont pas électroniciens. Il leur faut un outil qui leur permette de relier capteurs et actionneurs à un programme sans passer des semaines sur la théorie.
L’outil de l’époque est le BASIC Stamp de Parallax, un petit module programmable en BASIC. Il présente trois défauts pour une école : son prix (environ 100 $ avec les accessoires, ce qui est beaucoup pour un étudiant), sa faible puissance de calcul et son environnement de développement réservé à Windows, alors que les designers travaillent majoritairement sur Mac.
1.1.2De Processing à Wiring, puis à Arduino
Deux projets ont préparé le terrain. Processing (Casey Reas et Ben Fry, 2001) est un langage et un éditeur conçus pour que des artistes puissent programmer des images et des animations : un éditeur minimal, un bouton « exécuter », et un programme structuré en deux fonctions, l’une d’initialisation, l’autre répétée en boucle.
En 2003, Hernando Barragán, étudiant à l’IDII, transpose cette idée au matériel avec Wiring : une carte à microcontrôleur et un environnement dérivé de Processing. On retrouve déjà la structure setup() / loop() et des fonctions simples comme digitalWrite().
Arduino reprend cette approche en 2005, avec une carte plus simple et moins chère, construite autour d’un microcontrôleur AVR d’Atmel (ATmega8, puis ATmega168 et ATmega328). La filiation avec Wiring est directe : l’environnement Arduino en est une dérivation.
Définition – Prototypage
Réalisation rapide d’une première version fonctionnelle d’un objet, pour valider une idée avant d’en concevoir la version définitive. Un prototype privilégie la rapidité et la facilité de modification sur le coût unitaire ou la miniaturisation.
1.1.3Le pari de l’ouverture
L’équipe fondatrice – Massimo Banzi, David Cuartielles, Gianluca Martino, Tom Igoe et David Mellis – fait un choix inhabituel en 2005 : publier les schémas de la carte sous licence libre (Creative Commons). N’importe qui peut donc fabriquer et vendre une carte compatible. Ce choix, qui semble se priver d’une source de revenus, a en réalité fait le succès du projet : les clones à bas prix ont multiplié le nombre d’utilisateurs, et ces utilisateurs ont écrit des tutoriels, des bibliothèques et des projets qui profitent à tout l’écosystème.
Le prix visé, environ 30 $, correspond au coût d’une sortie au restaurant pour un étudiant : assez bas pour que l’on ose expérimenter. Quant au nom, il vient du Bar di Re Arduino, où se retrouvait l’équipe – lui-même nommé d’après Arduin d’Ivrée, roi d’Italie au début du XIe siècle.
1.1.4Les grandes étapes
Figure 1.1 – Frise chronologique d’Arduino, de 2002 à 2025.
Année
Événement
Ce qui change
2002
Massimo Banzi cherche un outil d’enseignement
Constat : le BASIC Stamp est trop cher et fermé.
2003
Wiring (H. Barragán)
Le modèle carte + éditeur simple est posé.
2005
Premières cartes Arduino
300 cartes distribuées aux étudiants de l’IDII.
2010
Arduino Uno
Puce USB programmable (ATmega16U2) ; la Uno devient la carte de référence.
2023
Uno R4
Passage à un microcontrôleur 32 bits (Renesas RA4M1, Arm Cortex-M4) dans le même format.
2025
Annonce du rachat par Qualcomm, Uno Q
Arduino s’ouvre aux cartes hybrides : microcontrôleur + processeur sous Linux.
À retenir
Arduino est né en 2005 à Ivrea, pour enseigner l’électronique à des non-spécialistes.
Il s’inspire de Processing (le logiciel) et de Wiring (la carte et son environnement).
Le choix de l’open source et d’un prix bas explique sa diffusion massive.
Exercices
1. Citez trois raisons pour lesquelles le BASIC Stamp ne convenait pas à l’IDII.
Son prix (≈ 100 $ avec les accessoires), sa faible puissance, et son logiciel incompatible avec Mac, alors que les étudiants en design utilisaient surtout des Mac.
2. Pourquoi publier les schémas d’une carte sous licence libre peut-il être une bonne stratégie, alors que cela autorise les concurrents à la copier ?
La copie fait baisser les prix et multiplie le nombre d’utilisateurs. Plus d’utilisateurs signifie plus de tutoriels, de bibliothèques et de projets partagés : l’écosystème devient plus riche que celui des concurrents fermés, et la marque d’origine en profite (cartes officielles, logiciels, services).
Dire « j’ai programmé un Arduino » est un raccourci. Arduino désigne à la fois des cartes électroniques, un logiciel pour les programmer, un ensemble de fonctions prêtes à l’emploi et une marque déposée. Cette section explore et clarifie les différentes facettes du sujet.
1.2.1Une plateforme, pas seulement une carte
Arduino est une plateforme de prototypage composée de trois éléments indissociables :
Des cartes électroniques, construites autour d’un microcontrôleur, avec tout ce qu’il faut pour l’utiliser immédiatement : alimentation, horloge, connecteur USB, connecteurs pour brancher des composants.
Un environnement de développement (l’IDE), qui permet d’écrire le programme, de le compiler et de programmer la carte.
Une bibliothèque de fonctions (le « cœur » Arduino) qui masque la complexité du microcontrôleur : digitalWrite(13, HIGH) au lieu d’une manipulation de registres.
Définition – Microcontrôleur
Circuit intégré qui réunit sur une seule puce un processeur, de la mémoire programme (Flash), de la mémoire de données (SRAM) et des périphériques d’entrées-sorties (ports, convertisseur analogique-numérique, temporisateurs, liaisons série). Il est conçu pour piloter un système, pas pour faire tourner un système d’exploitation.
Il ne faut pas confondre microcontrôleur et microprocesseur. Le processeur d’un ordinateur est très puissant mais dépend de composants externes (mémoire vive, disque, contrôleurs) ; un microcontrôleur est modeste – l’ATmega328P de la Uno fonctionne à 16 MHz avec 2 Ko de mémoire vive – mais autonome, peu gourmand et capable de réagir en quelques microsecondes à un événement extérieur.
Les cartes Arduino utilisent deux grandes familles de microcontrôleurs : les AVR 8 bits (ATmega328P de la Uno, ATmega2560 de la Mega) et les ARM 32 bits (Cortex-M3 de la Due, Cortex-M4 de la Uno R4, etc.).
1.2.2Matériel libre, logiciel libre
Le matériel est publié sous licence Creative Commons Attribution – Partage dans les mêmes conditions (CC BY-SA 2.5). Les schémas et les typons – les dessins des pistes du circuit imprimé – sont téléchargeables. On peut les modifier et vendre le résultat, à condition de citer l’original et de publier ses modifications sous la même licence.
Le logiciel est également libre : l’environnement de développement est sous licence GPL et les bibliothèques sous LGPL, ce qui permet de les utiliser dans un projet sans être obligé d’en publier tout le code. Le code source est hébergé sur github.com/arduino.
1.2.3Un nom protégé
Si les plans sont libres, le nom ne l’est pas : « Arduino » est une marque déposée. Un fabricant peut produire une carte identique à la Uno, mais ne peut pas l’appeler « Arduino ». D’où l’apparition de noms comme Funduino, Elegoo ou Arduiboy, et la mention fréquente « compatible Arduino ». Entre 2015 et 2017, un différend entre deux sociétés fondatrices a même conduit à vendre les cartes officielles sous le nom Genuino hors des États-Unis.
Attention
Une carte « compatible » utilise souvent une autre puce USB que l’original (CH340 au lieu de l’ATmega16U2). Elle fonctionne de la même façon, mais peut demander l’installation d’un pilote sur l’ordinateur pour être reconnue.
1.2.4Quel langage ?
On parle parfois de « langage Arduino », mais il s’agit en réalité de C++, compilé par le compilateur GCC. Ce que l’on appelle « langage Arduino » est un ensemble de fonctions (pinMode, digitalRead, analogRead, delay…) et une légère préparation automatique du fichier avant compilation (voir section 1.10). Tout ce que l’on apprend en Arduino se transpose donc à la programmation en C/C++ de n’importe quel microcontrôleur.
Figure 1.2 – Les quatre facettes d’Arduino : plateforme open source, matériel libre, logiciel libre, nom protégé.
À retenir
Arduino = cartes + IDE + bibliothèque de fonctions.
Matériel sous CC BY-SA, logiciel sous GPL/LGPL, nom protégé par une marque.
On programme en C/C++, avec des fonctions qui simplifient l’accès au matériel.
Exercices
1. Un collègue affirme qu’un ordinateur portable « est un gros microcontrôleur ». Qu’en pensez-vous ?
C’est inexact. Le processeur d’un ordinateur a besoin de composants externes (RAM, stockage, chipset) et exécute un système d’exploitation. Un microcontrôleur intègre processeur, mémoires et périphériques sur une même puce et pilote directement du matériel.
2. Une entreprise peut-elle vendre une copie exacte de la Uno ? Sous quel nom ?
Oui, la licence CC BY-SA l’autorise, à condition de citer l’original et de publier ses éventuelles modifications sous la même licence. Mais elle ne peut pas utiliser le nom « Arduino », qui est une marque : elle la vendra sous son propre nom, éventuellement avec la mention « compatible Arduino ».
Vingt ans après les premières cartes, Arduino est devenu un écosystème : plusieurs logiciels, des dizaines de cartes officielles, des centaines de cartes compatibles et des milliers de bibliothèques. Ce qui relie l’ensemble, c’est une même façon de programmer.
Figure 1.3 – Panorama de l’écosystème : logiciels, cartes officielles, cartes compatibles et communauté.
1.3.1Les logiciels
Arduino IDE 2 est l’outil de base, installé sur l’ordinateur : éditeur de code, gestionnaire de cartes et de bibliothèques, moniteur série, débogueur. Il est détaillé à la section 1.11. Arduino Cloud propose un éditeur dans le navigateur et des tableaux de bord pour les objets connectés. Arduino CLI offre les mêmes fonctions de compilation et de téléversement en ligne de commande, pour l’automatisation. Enfin, Arduino App Lab est l’environnement de la carte Uno Q, qui associe un programme Arduino classique et des programmes Python s’exécutant sous Linux.
1.3.2Les cartes officielles
On peut classer les cartes officielles en trois groupes :
Les classiques 8 bits – Uno, Mega 2560, Nano – simples, robustes, très documentées : le meilleur point de départ.
Les cartes 32 bits – Uno R4, Nano R4, GIGA R1 – plus rapides et dotées de plus de mémoire, pour le traitement du signal, l’affichage ou les calculs.
Les cartes connectées – Nano ESP32 (Wi-Fi, Bluetooth), Nano Matter (domotique), Uno Q (Linux, vision, IA) – pour l’Internet des objets.
1.3.3Cartes compatibles et cœurs tiers
Grâce à l’ouverture du matériel, de nombreux fabricants (Adafruit, SparkFun, Seeed, Elegoo…) proposent des cartes compatibles, souvent moins chères ou spécialisées. Plus important encore, l’IDE peut programmer des microcontrôleurs qui n’ont rien à voir avec Arduino : il suffit d’installer, via le gestionnaire de cartes, le « cœur » correspondant. Les plus utilisés sont ceux de l’ESP32 (Espressif), du RP2040 (Raspberry Pi Pico) et des STM32 (STMicroelectronics).
Définition – Cœur (core)
Ensemble de fichiers qui implémente les fonctions Arduino (pinMode, digitalWrite, Serial…) pour une famille de microcontrôleurs donnée, accompagné du compilateur et de l’outil de téléversement adaptés.
1.3.4Les bibliothèques
Une bibliothèque est un ensemble de fonctions prêtes à l’emploi pour piloter un composant (écran, capteur, moteur) ou un protocole (I²C, Wi-Fi, MQTT). Le gestionnaire de bibliothèques de l’IDE en référence plusieurs milliers. On les utilise avec une directive #include, et chacune est livrée avec des exemples, accessibles par le menu Fichier › Exemples – c’est souvent la meilleure façon de démarrer avec un nouveau composant.
1.3.5Même langage, même IDE : la portabilité
Les fonctions Arduino forment une couche d’abstraction : digitalWrite(13, HIGH) s’écrit de la même façon sur une Uno (AVR 8 bits), une Uno R4 (ARM 32 bits) ou une ESP32, chaque cœur se chargeant de la traduire pour son microcontrôleur. Un programme écrit pour une carte se porte donc souvent sur une autre en changeant seulement la carte sélectionnée dans l’IDE.
Attention – les limites de la portabilité
Les numéros et fonctions des broches diffèrent d’une carte à l’autre.
Les tensions diffèrent : 5 V pour la Uno, 3,3 V pour la Nano ESP32 (voir section 1.4).
Le code qui accède directement aux registres du microcontrôleur (par exemple PORTB) n’est valable que pour l’AVR concerné.
Exercices
1. Vous voulez programmer un ESP32 avec l’IDE Arduino. Que devez-vous installer ?
Le cœur ESP32 d’Espressif, par le gestionnaire de cartes (en ajoutant l’adresse de son index dans les préférences si nécessaire). On peut ensuite sélectionner la carte ESP32 et utiliser les mêmes fonctions Arduino.
2. Un programme écrit pour la Uno utilise PORTB |= 0x20;. Fonctionnera-t-il sur une Nano ESP32 ?
Non : PORTB est un registre propre aux AVR. Il faut le remplacer par la fonction portable digitalWrite(13, HIGH); (en vérifiant aussi la broche à utiliser sur la nouvelle carte).
Comment choisir une carte, comment elles se répartissent en familles, puis une étude détaillée des cartes Uno et Mega 2560 : caractéristiques, architecture interne du microcontrôleur et rôle de chacune de leurs broches.
Chapitre 1 · Section 1.4
Choisir une carte : les critères
Le tableau comparatif de la figure 1.4 rassemble beaucoup de chiffres. Cette section explique ce que signifie chaque colonne et comment s’en servir pour choisir la carte adaptée à un projet.
Figure 1.4interactif – Comparatif des cartes Arduino : filtrez par famille ou par tension, triez en cliquant sur un en-tête.
1.4.1Le microcontrôleur
Deux caractéristiques comptent d’abord. L’architecture : un microcontrôleur 8 bits (AVR) manipule les nombres par octets ; un microcontrôleur 32 bits (ARM Cortex-M, ESP32) traite des mots de 4 octets en une instruction et dispose souvent d’une unité de calcul en virgule flottante. La fréquence d’horloge : 16 MHz pour la Uno R3, 48 MHz pour la Uno R4, 240 MHz pour l’ESP32-S3. À fréquence égale, un 32 bits est nettement plus rapide pour les calculs.
1.4.2Les mémoires
Trois mémoires sont indiquées pour chaque carte :
La Flash contient le programme. Elle est non volatile : le programme reste en place quand on coupe l’alimentation.
La SRAM contient les variables pendant l’exécution. Elle est volatile et c’est souvent la ressource la plus rare : 2 Ko seulement sur la Uno R3.
L’EEPROM (ou son équivalent émulé en Flash) conserve de petites données après coupure : réglages, compteurs, calibration.
1.4.3La tension des entrées-sorties
C’est le critère le plus important pour la sécurité du matériel. Les cartes historiques (Uno, Mega) fonctionnent en 5 V ; la plupart des cartes récentes (Due, Nano ESP32, GIGA, famille MKR) fonctionnent en 3,3 V.
Attention
Appliquer 5 V sur une broche d’une carte 3,3 V peut détruire définitivement le microcontrôleur. Pour relier un capteur ou un afficheur 5 V à une carte 3,3 V, il faut un adaptateur de niveau logique (ou, pour un simple signal entrant, un pont diviseur de tension).
Dans l’autre sens, une sortie 3,3 V reliée à une entrée 5 V est en général lue correctement – un AVR alimenté en 5 V considère comme « haut » toute tension supérieure à 3 V environ – mais la marge est faible et il vaut mieux vérifier la fiche technique.
1.4.4Entrées-sorties et connectivité
On compte ensuite les broches nécessaires : entrées-sorties numériques, sorties PWM (pour faire varier la luminosité d’une LED ou la vitesse d’un moteur), entrées analogiques (pour lire un capteur de température ou un potentiomètre), liaisons série, I²C, SPI. Enfin la connectivité sans fil (Wi-Fi, Bluetooth Low Energy, LoRa) est intégrée sur certaines cartes et évite d’ajouter un module.
1.4.5Une méthode de choix
Besoin principal
Carte conseillée
Apprendre, suivre un tutoriel, utiliser des shields
Uno R3 ou Uno R4 Minima
Beaucoup de capteurs et d’actionneurs, plusieurs liaisons série
Mega 2560
Encombrement réduit, montage sur plaque d’essai
Nano, Nano Every
Objet connecté en Wi-Fi ou Bluetooth
Nano ESP32, Uno R4 WiFi
Calcul intensif, audio, écran
GIGA R1 WiFi
Linux, vision, intelligence artificielle
Uno Q
Ces conseils sont des points de départ. Avant tout achat, on vérifie les caractéristiques sur la fiche produit officielle, qui fait foi.
Toujours vérifier la tension des E/S : 5 V et 3,3 V ne se mélangent pas sans précaution.
Choisir la carte d’après le besoin : nombre de broches, puissance, connectivité, format.
Exercices
1. Un projet de station météo doit envoyer ses mesures en Wi-Fi et utilise un capteur alimenté en 5 V. Quelle carte proposez-vous et quelle précaution prenez-vous ?
Une Uno R4 WiFi (E/S en 5 V) évite le problème de niveau. Avec une Nano ESP32 (3,3 V), il faudrait alimenter le capteur en 3,3 V s’il le supporte, ou placer un adaptateur de niveau sur ses lignes de données.
2. Un programme compile mais la carte redémarre de façon aléatoire. Le message de l’IDE indique « Les variables globales utilisent 1 950 octets (95 %) de mémoire dynamique ». Quelle est la cause probable ?
La SRAM (2 Ko sur la Uno) est presque pleine : la pile, qui grandit pendant l’exécution, finit par écraser les variables. Il faut réduire les variables globales, par exemple en plaçant les chaînes constantes en Flash avec F("texte").
Arduino range ses cartes en familles qui partagent un format physique et un usage. Connaître ces familles permet de s’orienter rapidement dans le catalogue et de savoir quels modules d’extension seront compatibles.
Figure 1.5interactif – Les quatre familles de cartes Arduino et leurs shields : cliquez sur une famille.
1.5.1La famille Classic
Ce sont les cartes au format Uno (68,6 × 53,4 mm) : Uno R3, Uno R4 Minima et WiFi, Leonardo, Zero… Leur intérêt principal est la compatibilité avec les shields, des cartes d’extension qui s’enfichent directement sur les connecteurs : shield moteurs, shield Ethernet, shield relais. C’est la famille de l’enseignement et du prototypage rapide.
Définition – Shield
Carte d’extension au format d’une carte Arduino, qui s’empile sur ses connecteurs et lui ajoute une fonction (commande de moteurs, réseau, affichage…) sans câblage. On peut souvent empiler plusieurs shields, à condition qu’ils n’utilisent pas les mêmes broches.
1.5.2La famille Nano
Des cartes de 45 × 18 mm, avec des broches au pas de 2,54 mm qui s’enfichent sur une plaque d’essai ou se soudent sur un circuit. La Nano d’origine reprend le microcontrôleur de la Uno ; les variantes récentes ajoutent un microcontrôleur 32 bits et des fonctions sans fil ou des capteurs intégrés (Nano 33 BLE Sense : accéléromètre, microphone, capteur de température…). C’est la famille idéale pour intégrer une carte dans un objet fini.
1.5.3La famille MKR
Des cartes compactes, toutes en 3,3 V, pensées pour l’Internet des objets. Chaque modèle intègre une connectivité particulière : Wi-Fi (MKR WiFi 1010), LoRa longue portée (MKR WAN 1310), réseau cellulaire (MKR GSM 1400, MKR NB 1500). Elles disposent d’un connecteur pour batterie lithium et de leurs propres shields au format MKR.
1.5.4La famille Mega
Des cartes grand format (101,5 × 53,3 mm) pour les projets qui demandent beaucoup de broches et de mémoire : la Mega 2560 (AVR 8 bits, 54 E/S), la Due (ARM Cortex-M3, 3,3 V) et la GIGA R1 WiFi (double cœur Cortex-M7/M4). Leur partie haute reprend la disposition de la Uno, ce qui permet d’y enficher la plupart des shields Classic.
Pour aller plus loin
Le catalogue compte aussi des familles professionnelles : Portenta (modules industriels haute performance), Nicla (capteurs intelligents miniatures) et Opta (automates programmables pour l’industrie). Elles se programment avec les mêmes outils.
À retenir
Classic : format Uno, shields, apprentissage.
Nano : très petit format, intégration.
MKR : IoT compact, 3,3 V.
Mega : beaucoup d’E/S et de mémoire.
Exercice
1. Un capteur de niveau doit être installé dans une cuve isolée, sans Wi-Fi, et transmettre une mesure par heure à plusieurs kilomètres. Quelle famille et quelle carte choisir ?
La famille MKR, avec la MKR WAN 1310 : la liaison LoRa porte à plusieurs kilomètres avec une très faible consommation, compatible avec une alimentation sur batterie.
La Uno et la Mega 2560 sont deux cartes souvent utilisées en travaux pratiques. Elles partagent la même tension, la même fréquence et les mêmes limites électriques ; elles diffèrent surtout par le nombre de broches et la quantité de mémoire. Cette section explique chaque ligne du tableau de la figure 1.6.
Figure 1.6 – Caractéristiques comparées des cartes Arduino Uno et Mega 2560.
1.6.1L’alimentation
Le microcontrôleur fonctionne en 5 V. Trois sources sont possibles :
Le port USB, qui fournit directement 5 V (environ 500 mA au maximum, protégés par un fusible réarmable).
Le connecteur jack ou la broche VIN, qui accepte 7 à 12 V. Un régulateur abaisse cette tension à 5 V. En dessous de 7 V, le régulateur ne parvient plus à fournir 5 V stables ; au-dessus de 12 V, il dissipe trop de chaleur. Les limites absolues sont 6 et 20 V.
La broche 5V, avec une alimentation externe déjà régulée – sans aucune protection, donc à réserver aux utilisateurs avertis.
Une broche 3,3 V fournit au maximum 50 mA pour alimenter de petits modules.
1.6.2Entrées-sorties numériques et PWM
Une broche numérique ne connaît que deux états : LOW (0 V) ou HIGH (5 V). Configurée en entrée, elle lit un bouton ou un signal logique ; en sortie, elle commande une LED ou un transistor.
Certaines broches (marquées ~ sur la carte) peuvent produire un signal PWM. La fonction analogWrite(broche, valeur), avec une valeur de 0 à 255, règle le rapport cyclique : 0 donne 0 %, 127 environ 50 %, 255 donne 100 %. La fréquence est d’environ 490 Hz (980 Hz sur les broches 5 et 6 de la Uno).
Définition – PWM (modulation de largeur d’impulsion)
Signal rectangulaire de fréquence fixe dont on fait varier la durée à l’état haut. Le rapport cyclique α est la proportion du temps passée à l’état haut. La valeur moyenne de la tension vaut α × 5 V : une LED alimentée en PWM à 25 % paraît donc moins lumineuse, car l’œil ne perçoit que la moyenne.
1.6.3Entrées analogiques
Les entrées A0 à A5 (A0 à A15 sur la Mega) sont reliées à un convertisseur analogique-numérique de 10 bits. La fonction analogRead() renvoie un entier N compris entre 0 et 1023, proportionnel à la tension d’entrée :
N = U × 1024 / 5 V ⇔ U ≈ N × 5 V / 1024
La résolution, c’est-à-dire le plus petit écart de tension détectable, vaut 5 V / 1024 ≈ 4,9 mV.
1.6.4Les mémoires
Mémoire
Uno (ATmega328P)
Mega (ATmega2560)
Rôle
Flash
32 Ko (dont 0,5 Ko de bootloader)
256 Ko (dont 8 Ko de bootloader)
Programme, non volatile
SRAM
2 Ko
8 Ko
Variables, volatile
EEPROM
1 Ko
4 Ko
Données conservées (≈ 100 000 écritures par case)
Le bootloader est un petit programme placé en fin de Flash qui permet de recevoir un nouveau programme par l’USB, sans programmateur (voir section 1.13). Celui de la Uno (Optiboot) n’occupe que 512 octets : l’IDE annonce un maximum de 32 256 octets pour le croquis. Celui de la Mega 2560 (STK500v2) en réserve 8 Ko : le maximum est de 253 952 octets.
1.6.5Les limites en courant
C’est la remarque essentielle de la figure 1.6. Chaque broche peut fournir ou absorber 20 mA en fonctionnement normal (40 mA est la limite absolue, à ne jamais atteindre), et l’ensemble des broches ne doit pas dépasser environ 200 mA. Une LED avec sa résistance consomme 10 à 15 mA : c’est acceptable. Un moteur, un relais ou un ruban de LED consomment des centaines de milliampères : il faut les commander par un transistor, un module relais ou un driver, alimentés séparément.
Attention
Ne jamais brancher un moteur directement sur une broche d’E/S : outre le courant excessif, le moteur produit des surtensions à la coupure qui peuvent détruire le microcontrôleur. On utilise un transistor et une diode de roue libre, ou un shield moteur.
Exercices
1. Un capteur de température délivre 0,75 V. Quelle valeur renvoie analogRead() ?
N = 0,75 × 1024 / 5 ≈ 153,6, soit 153 ou 154 selon l’arrondi du convertisseur.
2. On veut allumer 16 LED à 15 mA chacune, directement sur les broches d’une Mega. Est-ce raisonnable ?
Chaque broche reste sous 20 mA, mais le total atteint 16 × 15 = 240 mA, au-delà des 200 mA admissibles. Il faut réduire le courant (résistances plus fortes, ≈ 10 mA par LED) ou utiliser un circuit de commande (registre à décalage, driver de LED).
3. Quelle valeur faut-il passer à analogWrite() pour obtenir une tension moyenne de 2 V ?
α = 2 / 5 = 0,4, et 0,4 × 255 = 102. On écrit analogWrite(broche, 102);
Pour programmer efficacement, il est utile de savoir ce qui se passe à l’intérieur de la puce. Le schéma de la figure 1.7 représente l’organisation d’un AVR comme l’ATmega328P : un bloc de traitement et de contrôle, des mémoires et des registres, des périphériques, le tout relié par un bus de données de 8 bits.
Pour aller plus loin
Cette section donne une première vue d’ensemble. Le chapitre 2 reprend en détail l’architecture des AVR : mémoires, démarrage du microcontrôleur et premiers pas en assembleur.
Figure 1.7 – Architecture interne d’un microcontrôleur AVR.
1.7.1Une architecture Harvard
Dans un ordinateur classique (architecture von Neumann), instructions et données partagent la même mémoire et le même bus : le processeur doit alterner entre lire une instruction et lire une donnée. Les AVR utilisent une architecture Harvard : la mémoire programme (Flash) et la mémoire de données (SRAM) ont des bus séparés. Le processeur peut ainsi lire l’instruction suivante pendant qu’il exécute l’instruction en cours.
Définition – Architecture Harvard
Organisation dans laquelle les instructions et les données sont stockées dans des mémoires distinctes, accessibles par des chemins séparés. Elle permet de lire une instruction et une donnée simultanément.
1.7.2Le cycle d’exécution
Le traitement d’une instruction suit trois étapes, représentées par les blocs de gauche du schéma :
Lecture (fetch) : le compteur ordinal contient l’adresse de la prochaine instruction ; celle-ci est lue en Flash et placée dans le registre d’instruction.
Décodage : le décodeur d’instructions analyse le code et active les lignes de commande, des signaux internes qui indiquent à chaque bloc ce qu’il doit faire pendant ce cycle (lire tel registre, effectuer une addition, écrire en mémoire…).
Exécution : l’UAL (unité arithmétique et logique) effectue l’opération sur les registres, et le résultat est réécrit.
Grâce à l’architecture Harvard, la lecture de l’instruction suivante se fait pendant l’exécution de la précédente : c’est un pipeline à deux étages. La plupart des instructions s’exécutent ainsi en un seul cycle d’horloge, soit près de 16 millions d’instructions par seconde à 16 MHz.
1.7.3Les registres et l’UAL
L’AVR dispose de 32 registres de travail de 8 bits (R0 à R31), directement reliés à l’UAL. C’est là que se font tous les calculs : pour additionner deux variables situées en SRAM, le processeur les charge dans deux registres, les additionne, puis range le résultat. Le registre d’état (SREG) conserve des indicateurs sur le dernier résultat : retenue (C), résultat nul (Z), résultat négatif (N), dépassement (V), ainsi que le bit I qui autorise les interruptions.
Les AVR sont des processeurs RISC : un jeu d’instructions réduit et simple (environ 130 instructions), conçu pour être exécuté rapidement.
1.7.4Les modes d’adressage
Pour accéder à une donnée en mémoire, l’instruction doit indiquer son adresse. En adressage direct, l’adresse est écrite dans l’instruction elle-même (« lire la case 0x0100 »). En adressage indirect, l’adresse est contenue dans une paire de registres – les registres X, Y et Z, formés de R26 à R31 – ce qui permet de parcourir un tableau en incrémentant simplement le pointeur. C’est ce que fait le compilateur lorsqu’il traduit une boucle sur un tableau en C.
1.7.5Les périphériques
Autour du cœur, la puce intègre des périphériques qui travaillent en parallèle du programme : ports d’entrées-sorties, temporisateurs (timers, utilisés par delay(), millis() et la PWM), convertisseur analogique-numérique, liaisons série USART, SPI et I²C, comparateur analogique, chien de garde (watchdog) qui redémarre la puce si le programme se bloque, et contrôleur d’interruptions.
Chaque périphérique se pilote par des registres spéciaux, accessibles comme des cases mémoire. Ainsi, l’appel digitalWrite(13, HIGH) revient finalement à mettre à 1 le bit 5 du registre PORTB :
// Équivalent "bas niveau" de digitalWrite(13, HIGH) sur la Uno
PORTB |= (1 << PB5);
Définition – Interruption
Mécanisme par lequel un événement (front sur une broche, fin de conversion, débordement d’un timer…) suspend le programme principal pour exécuter immédiatement une fonction dédiée, puis lui rend la main. Il permet de réagir à un événement sans le surveiller en permanence.
Lecture → décodage → exécution, avec recouvrement : environ une instruction par cycle.
Les périphériques se commandent par des registres ; les fonctions Arduino les manipulent pour nous.
Exercices
1. Quelle est la durée d’un cycle d’horloge à 16 MHz ? Combien d’instructions simples s’exécutent pendant delay(1) ?
T = 1 / 16 MHz = 62,5 ns. En 1 ms, il y a 16 000 cycles, soit environ 16 000 instructions d’un cycle « perdues » à attendre.
2. Pourquoi une architecture Harvard est-elle plus rapide qu’une architecture von Neumann à fréquence égale ?
Parce que la lecture de l’instruction suivante (en Flash) et l’accès aux données (en SRAM) utilisent des bus différents et peuvent avoir lieu en même temps, ce qui permet le recouvrement lecture/exécution.
Un diagramme de brochage (pinout) indique, pour chaque broche de la carte, son numéro Arduino, la broche du microcontrôleur à laquelle elle est reliée et ses fonctions secondaires. C’est le document que l’on garde sous les yeux pendant tout montage.
Figure 1.8 – Diagramme de brochage de la carte Arduino Uno : broches de la carte, ports du microcontrôleur et fonctions associées.Source : devboards.info
1.8.1Des broches de la carte aux ports du microcontrôleur
Les broches de l’ATmega328P sont regroupées en ports de 8 bits, nommés B, C et D. Chaque broche de la carte est reliée à un bit de l’un de ces ports :
Broches de la carte
Port du microcontrôleur
D0 à D7
PD0 à PD7
D8 à D13
PB0 à PB5
A0 à A5
PC0 à PC5
Figure 1.9 – Brochage du microcontrôleur ATmega328P en boîtier DIP 28 broches.Source : devboards.info
Chaque port est piloté par trois registres : DDRx fixe le sens (1 = sortie), PORTx fixe l’état d’une sortie (ou active la résistance de tirage d’une entrée) et PINx permet de lire l’état des broches. Les fonctions pinMode(), digitalWrite() et digitalRead() ne font que manipuler ces registres.
1.8.2Les fonctions secondaires
La plupart des broches ont, en plus de leur rôle d’E/S, une fonction liée à un périphérique :
Broches
Fonction
Usage
D0 (RX), D1 (TX)
Liaison série (USART)
Communication avec l’ordinateur par l’USB, Serial
D2, D3
Interruptions externes INT0, INT1
attachInterrupt()
D3, D5, D6, D9, D10, D11
PWM (~)
analogWrite()
D10 (SS), D11 (MOSI), D12 (MISO), D13 (SCK)
Bus SPI
Carte SD, écrans, modules radio
A4 (SDA), A5 (SCL)
Bus I²C
Capteurs, afficheurs, horloges
D13
LED intégrée
LED_BUILTIN
On trouve aussi les broches d’alimentation (5V, 3.3V, GND, VIN), AREF (référence externe du convertisseur analogique), IOREF (indique aux shields la tension de la carte), RESET, et le connecteur ICSP à six broches qui permet de programmer le microcontrôleur directement (voir section 1.10).
Attention
D0 et D1 sont utilisées par l’USB : un composant branché dessus peut empêcher le téléversement. Mieux vaut les laisser libres.
Une entrée laissée « en l’air » lit des valeurs aléatoires. Pour un bouton, on utilise pinMode(broche, INPUT_PULLUP), qui active une résistance de tirage interne : la broche lit alors HIGH au repos et LOW quand le bouton, relié à la masse, est appuyé.
// Lire un bouton branché entre D2 et GND
void setup() {
pinMode(2, INPUT_PULLUP);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
bool appuye = (digitalRead(2) == LOW); // logique inversée
digitalWrite(LED_BUILTIN, appuye ? HIGH : LOW);
}
Exercices
1. À quel bit de quel port correspond la broche D9 ?
D8 à D13 correspondent à PB0 à PB5 : D9 est donc PB1, le bit 1 du port B.
2. Vous devez brancher un afficheur I²C et un module SPI. Quelles broches restent disponibles pour 3 LED en PWM ?
L’I²C occupe A4 et A5, le SPI occupe D10 à D13. Parmi les broches PWM (3, 5, 6, 9, 10, 11), il reste D3, D5, D6 et D9 : trois d’entre elles conviennent.
La Mega 2560 prolonge la Uno : même tension, même fréquence, même façon de programmer, mais quatre fois plus de broches. Son brochage se lit en deux parties, et quelques différences avec la Uno méritent l’attention.
Figure 1.10 – Diagramme de brochage de l’Arduino Mega 2560 : en haut, les E/S identiques à la Uno ; en bas, les E/S supplémentaires.Source : devboards.info
1.9.1Une partie haute compatible avec la Uno
La partie de la carte située du côté de l’USB reprend exactement la disposition de la Uno : D0 à D13, A0 à A5, les broches d’alimentation. Les shields conçus pour la Uno s’y enfichent donc mécaniquement. La Mega ajoute les broches D14 à D53, deux entrées analogiques A6 et A7 à la suite de A0–A5, et un second connecteur pour les entrées A8 à A15.
Attention – compatibilité des shields
Sur la Mega, le bus I²C n’est pas sur A4/A5 mais sur D20 (SDA) et D21 (SCL), et le bus SPI est sur D50 à D53 (et sur le connecteur ICSP), pas sur D10 à D13. Un shield qui utilise ces bus par les broches de la Uno ne fonctionnera pas sans adaptation – sauf s’il passe par les connecteurs SDA/SCL dédiés et par l’ICSP, comme les shields récents.
1.9.2Quatre liaisons série
La Mega possède quatre USART matérielles. La première (Serial, broches 0 et 1) est reliée à l’USB ; les trois autres sont libres pour dialoguer avec des modules GPS, Bluetooth, des afficheurs ou d’autres cartes :
Objet
TX
RX
Serial (USB)
1
0
Serial1
18
19
Serial2
16
17
Serial3
14
15
// Relais entre un module GPS (Serial1) et le moniteur série
void setup() {
Serial.begin(115200);
Serial1.begin(9600);
}
void loop() {
if (Serial1.available()) Serial.write(Serial1.read());
}
Sur la Uno, qui n’a qu’une liaison série matérielle, il faudrait recourir à une émulation logicielle (SoftwareSerial), moins fiable à haut débit.
1.9.3Six interruptions externes
Les broches 2, 3, 18, 19, 20 et 21 peuvent déclencher une interruption externe (INT0 à INT5). La correspondance entre numéro de broche et numéro d’interruption n’étant pas intuitive, on utilise toujours digitalPinToInterrupt() :
Mega = Uno « étendue » : 54 E/S dont 15 PWM, 16 entrées analogiques.
4 liaisons série (Serial à Serial3), 6 interruptions externes.
I²C sur 20/21 et SPI sur 50–53 : attention aux shields.
Exercice
1. Un projet doit lire un GPS, un lecteur RFID série et communiquer avec un PC. Pourquoi la Mega est-elle préférable à la Uno ?
Il faut trois liaisons série. La Mega en offre quatre en matériel (Serial pour le PC, Serial1 et Serial2 pour les modules) ; la Uno n’en a qu’une, déjà utilisée par l’USB.
Les outils disponibles, la prise en main de l’IDE 2, l’ajout de bibliothèques et de cartes, le chemin suivi par un programme depuis l’éditeur jusqu’à la mémoire du microcontrôleur, la programmation par ISP, un premier programme complet analysé ligne par ligne, et enfin l’environnement VS Code + PlatformIO.
Chapitre 1 · Section 1.10
Les outils de programmation
Plusieurs outils permettent de programmer une carte Arduino. Tous reposent sur la même chaîne de compilation ; ils diffèrent par leur interface et par le type de projet qu’ils visent.
Figure 1.11 – Les outils de programmation et le chemin du croquis jusqu’à la carte.
1.10.1Quel outil pour quel usage ?
Outil
Points forts
Pour qui ?
Arduino IDE 2
Simple, complet, hors ligne
Débutants, TP, la plupart des projets
Cloud Editor
Rien à installer, projets synchronisés, tableaux de bord IoT
Postes partagés, objets connectés
Arduino CLI
Scriptable, intégrable à d’autres outils
Automatisation, intégration continue
App Lab
Sketch Arduino et Python dans une même application
Utilisateurs de la Uno Q
VS Code + PlatformIO
Projets en plusieurs fichiers, dépendances versionnées, des centaines de cartes
Projets importants, développeurs confirmés
Programmeur ISP
Écriture directe dans la Flash, sans bootloader
Puce vierge, récupération, production
1.10.2La chaîne de compilation
Quel que soit l’outil, le croquis suit le même chemin, illustré en bas de la figure 1.11 :
Prétraitement. Le fichier .ino n’est pas du C++ tout à fait standard. L’outil ajoute la ligne #include <Arduino.h>, génère les prototypes des fonctions et produit un vrai fichier .cpp.
Compilation. Le compilateur avr-gcc (pour les cartes AVR) traduit chaque fichier source – le croquis, le cœur Arduino, les bibliothèques – en code machine, dans des fichiers objets .o.
Édition de liens. Les fichiers objets sont assemblés en un programme unique, le fichier .elf, dans lequel toutes les adresses sont fixées.
Conversion. L’outil avr-objcopy extrait du .elf l’image de la mémoire Flash au format Intel HEX.
Téléversement. L’outil avrdude envoie le fichier .hex à la carte.
Définition – Fichier Intel HEX
Format texte qui décrit le contenu d’une mémoire. Chaque ligne commence par « : » et contient le nombre d’octets, l’adresse de départ, un type d’enregistrement, les données en hexadécimal et une somme de contrôle qui permet de détecter les erreurs de transmission.
1.10.3Bootloader ou programmeur ISP ?
Normalement, le téléversement se fait par l’USB grâce au bootloader : un petit programme résident qui, au démarrage, écoute la liaison série pendant un court instant et, s’il reçoit un programme, l’écrit dans la Flash. Cette méthode ne demande aucun matériel supplémentaire.
Un programmeur ISP (In-System Programming) écrit au contraire directement dans la Flash par le connecteur ICSP, via le bus SPI. Il sert à programmer une puce vierge, à réinstaller un bootloader endommagé (menu Outils › Graver la séquence d’initialisation) ou à récupérer l’espace occupé par le bootloader. Un USBasp ou une autre carte Arduino chargée du croquis ArduinoISP peuvent jouer ce rôle.
1. Une carte refuse tout téléversement par l’USB alors que le port est bien reconnu. Le bootloader a pu être effacé. Comment la remettre en service ?
Avec un programmeur ISP (USBasp, ou une seconde Arduino chargée d’ArduinoISP) branché sur le connecteur ICSP, on utilise Outils › Graver la séquence d’initialisation pour réécrire le bootloader. La carte accepte ensuite de nouveau les programmes par l’USB.
L’IDE 2, sorti en 2022, remplace l’ancien IDE 1.8. Il en conserve la simplicité tout en ajoutant l’autocomplétion, la navigation dans le code et le débogage. Cette section décrit son interface et la structure d’un croquis.
1.11.1L’interface
Figure 1.12 – L’interface de l’IDE 2 et son utilisation en quatre étapes.
En haut de la fenêtre, trois boutons commandent l’essentiel : Vérifier (✓) compile le croquis sans l’envoyer, Téléverser (→) compile puis envoie le programme à la carte, Déboguer lance une session de débogage sur les cartes compatibles. À côté, le sélecteur de carte indique la carte et le port utilisés.
La barre latérale gauche donne accès au carnet de croquis, au gestionnaire de cartes (installer un cœur), au gestionnaire de bibliothèques, au débogueur et à la recherche. En bas, le panneau Sortie affiche les messages de compilation, et l’on ouvre depuis le menu Outils le moniteur série et le traceur série.
1.11.2La structure d’un croquis
Tout croquis contient au moins deux fonctions :
setup() s’exécute une seule fois, à la mise sous tension ou après un reset. On y configure les broches, la liaison série, les bibliothèques.
loop() s’exécute ensuite indéfiniment. Elle contient le comportement permanent du système : lire les capteurs, décider, commander les actionneurs.
Il n’y a pas de fonction main() dans le croquis : elle est fournie par le cœur Arduino et ressemble à ceci :
int main() {
init(); // configure les timers, l’ADC, la PWM…
setup(); // votre initialisation
for (;;) {
loop(); // votre programme, appelé sans fin
}
}
Un microcontrôleur n’a pas de système d’exploitation vers lequel « revenir » : un programme embarqué ne se termine jamais, d’où cette boucle infinie.
1.11.3Utiliser l’IDE en quatre étapes
Choisir la carte et le port dans le sélecteur. Si la carte n’apparaît pas, vérifier le câble (certains ne transportent que l’alimentation) et le pilote.
Écrire le croquis : setup() et loop().
Vérifier : la compilation signale les erreurs avec leur numéro de ligne.
Téléverser : le message « Téléversement terminé » confirme l’envoi.
1.11.4Lire les messages de l’IDE
Après une compilation réussie, l’IDE indique l’occupation des mémoires : « Le croquis utilise 924 octets (2 %) de l’espace de stockage de programmes » (Flash) et « Les variables globales utilisent 9 octets (0 %) de mémoire dynamique » (SRAM). Au-delà de 75 % de SRAM, l’IDE avertit d’un risque d’instabilité.
Message d’erreur
Cause habituelle
expected ';' before …
Point-virgule oublié à la fin de la ligne précédente
'xxx' was not declared in this scope
Faute de frappe, variable non déclarée, bibliothèque non incluse
No such file or directory
Bibliothèque non installée
Port introuvable ou occupé
Mauvais port, moniteur série ouvert dans un autre logiciel, câble défectueux
1.11.5Le moniteur série
Le moniteur série affiche ce que la carte envoie par Serial.print(). C’est l’outil de mise au point le plus simple : on affiche la valeur d’une variable pour comprendre ce que fait le programme. Le traceur série trace ces valeurs sous forme de courbes.
void setup() {
Serial.begin(9600); // débit en bauds
}
void loop() {
int n = analogRead(A0);
Serial.print("A0 = ");
Serial.println(n);
delay(200);
}
Attention
Le débit choisi dans le moniteur série doit être identique à celui de Serial.begin(), sinon l’affichage est illisible (caractères aléatoires).
Exercices
1. Où placer l’instruction Serial.begin(9600); ? Pourquoi ?
Dans setup() : l’initialisation de la liaison série ne doit être faite qu’une fois, au démarrage.
2. L’IDE affiche « 'ledPin' was not declared in this scope » alors que la variable s’appelle LedPin. Pourquoi ?
Le C++ distingue majuscules et minuscules : ledPin et LedPin sont deux noms différents.
L’IDE installé ne connaît que les cartes AVR officielles et une poignée de bibliothèques. Deux gestionnaires intégrés permettent d’étendre ces possibilités : l’un ajoute des bibliothèques pour piloter capteurs et afficheurs, l’autre ajoute la prise en charge de nouvelles cartes.
1.12.1Installer une bibliothèque
Une bibliothèque est un ensemble de fichiers de code prêts à l’emploi qui cache les détails d’un composant : protocole d’un capteur, commandes d’un afficheur, calculs d’un moteur pas à pas. Il existe trois façons de l’installer (figure 1.13) :
le gestionnaire de bibliothèques (icône 📚 dans la barre latérale, ou Croquis › Inclure une bibliothèque › Gérer les bibliothèques) : on recherche la bibliothèque par son nom, puis on clique sur Installer. C’est la méthode à privilégier ;
un fichier .ZIP téléchargé, sur GitHub par exemple : Croquis › Inclure une bibliothèque › Ajouter la bibliothèque .ZIP ;
la copie manuelle du dossier de la bibliothèque dans Documents/Arduino/libraries, puis le redémarrage de l’IDE.
Figure 1.13interactif – Installer la bibliothèque « DHT sensor library » avec le gestionnaire de bibliothèques, puis l’utiliser dans un croquis.
Une fois installée, la bibliothèque s’inclut en tête du croquis avec #include. Les exemples fournis, accessibles par Fichier › Exemples, sont le meilleur point de départ :
Bibliothèque dont une autre bibliothèque a besoin pour fonctionner. Le gestionnaire propose de l’installer en même temps (« Tout installer ») ; sans elle, la compilation échoue avec un message du type « Adafruit_Sensor.h: No such file or directory ».
Attention
Vérifiez qu’une bibliothèque est compatible avec votre carte : sa page indique les architectures prises en charge (avr pour la Uno et la Mega). Une bibliothèque écrite pour l’ESP32 ne compilera pas pour une Uno. L’annexe 3 présente les bibliothèques les plus utilisées et leurs conflits connus.
1.12.2Ajouter une carte
Les cartes AVR (Uno, Mega 2560, Nano) sont installées avec l’IDE. Les autres cartes officielles, comme l’UNO R4 ou la Nano ESP32, s’ajoutent par le gestionnaire de cartes (icône ▦, ou Outils › Carte › Gestionnaire de carte). Pour la carte d’un autre fabricant (ESP32, RP2040, STM32…), il faut d’abord indiquer à l’IDE l’adresse du catalogue de ce fabricant (figure 1.14) :
Fichier › Préférences, champ URL de gestionnaire de cartes supplémentaires : on colle l’adresse, par exemple pour l’ESP32 https://espressif.github.io/arduino-esp32/package_esp32_index.json. Plusieurs adresses peuvent être ajoutées, une par ligne ;
dans le gestionnaire de cartes, on installe le paquet de la carte, appelé cœur : compilateur, fonctions Arduino adaptées et outils de téléversement ;
on choisit la carte et le port avec le sélecteur de la barre d’outils (ou Outils › Carte et Outils › Port) ;
on téléverse : le même croquis est compilé pour le nouveau microcontrôleur.
Figure 1.14interactif – Les quatre étapes pour programmer une carte ESP32 depuis l’IDE Arduino.
À retenir
Choisir la bonne carte est indispensable : l’IDE compile pour ce microcontrôleur et utilise sa méthode de téléversement. Une carte mal choisie produit, au mieux, une erreur de téléversement ; au pire, un programme qui ne fonctionne pas. Attention aussi aux tensions : les broches de l’ESP32 fonctionnent en 3,3 V.
Exercices
1. La compilation d’un croquis s’arrête sur « Adafruit_Sensor.h: No such file or directory ». Que s’est-il passé et comment corriger ?
La bibliothèque utilisée dépend de la bibliothèque Adafruit Unified Sensor, qui n’a pas été installée. On l’installe depuis le gestionnaire de bibliothèques (ou l’on réinstalle la première en acceptant « Tout installer »).
2. Pourquoi faut-il ajouter une URL dans les préférences pour programmer une ESP32, mais pas pour une Mega 2560 ?
Le cœur AVR, qui gère la Mega, est fourni avec l’IDE et figure dans le catalogue officiel d’Arduino. Le cœur ESP32 est publié par Espressif dans son propre catalogue : l’IDE doit connaître son adresse pour pouvoir le proposer au téléchargement.
L’animation de la figure 1.15 suit un programme depuis l’éditeur jusqu’à la LED qui clignote. Cette section détaille l’étape la plus mystérieuse pour un débutant : comment le programme passe de l’ordinateur à la mémoire du microcontrôleur.
Figure 1.15interactif – Du croquis à la carte, en sept étapes : utilisez Précédent / Suivant ou laissez défiler.
1.13.1Le rôle de l’USB
Le microcontrôleur ATmega328P ne parle pas l’USB : il ne connaît que la liaison série (TX/RX). Sur la Uno, un second petit microcontrôleur, l’ATmega16U2, sert de convertisseur USB-série. Pour l’ordinateur, la carte apparaît comme un port série virtuel (COM3 sous Windows, /dev/ttyACM0 sous Linux).
1.13.2Le reset automatique
Le bootloader n’écoute la liaison série que pendant une courte durée après le démarrage. Il faut donc redémarrer la carte au bon moment. C’est automatique : à l’ouverture du port, l’ordinateur fait basculer le signal DTR, relié à la broche RESET par un condensateur. Le microcontrôleur redémarre et le bootloader prend la main.
1.13.3Le dialogue avec le bootloader
avrdude dialogue alors avec le bootloader à 115 200 bauds selon le protocole STK500 : il identifie le microcontrôleur, envoie le programme page par page (128 octets à la fois pour l’ATmega328P), puis relit la mémoire pour vérifier qu’elle correspond au fichier. Pendant cet échange, les LED TX et RX de la carte clignotent rapidement.
Une fois l’écriture terminée, le bootloader saute à l’adresse 0 de la Flash, où commence le programme de l’utilisateur. La carte exécute setup() une fois, puis loop() en boucle. Le programme reste en mémoire après coupure de l’alimentation : il redémarrera à chaque mise sous tension.
1.13.4Quand le téléversement échoue
Symptôme
Pistes
Aucun port proposé
Câble USB « charge seule », pilote manquant (CH340 sur les clones), autre câble ou autre port USB
not in sync / programmer is not responding
Mauvaise carte sélectionnée, composant branché sur D0/D1, bootloader absent
Port occupé
Un autre logiciel (moniteur série, terminal) utilise le port : le fermer
Le programme ne fait rien
Erreur de logique ou de câblage : afficher des messages avec le moniteur série
À retenir
L’USB est converti en liaison série par une puce dédiée.
Un reset automatique lance le bootloader, qui reçoit le .hex et l’écrit en Flash.
Le programme est conservé hors tension et redémarre à chaque mise sous tension.
Exercice
1. Le programme .hex d’un croquis fait 2 600 octets. Combien de pages de 128 octets le bootloader devra-t-il écrire ?
2 600 / 128 ≈ 20,3, donc 21 pages (la dernière est partiellement remplie). Remarque : le fichier .hex, en texte, est environ 2,8 fois plus volumineux que les octets réellement écrits ; c’est la taille du programme binaire qui compte.
Le téléversement habituel repose sur le bootloader. Lorsqu’il est absent – microcontrôleur neuf, bootloader effacé, ATtiny sans liaison série – il faut écrire directement dans la mémoire Flash par la liaison ISP. Une carte Uno peut jouer ce rôle de programmateur.
1.14.1Le principe
Le croquis d’exemple ArduinoISP transforme une carte en programmateur ISP (In-System Programming). Elle programme la mémoire Flash d’un autre AVR par la liaison série synchrone SPI, sans passer par l’USB ni par le bootloader de la cible. C’est utile pour graver le bootloader d’un ATmega328P neuf, réparer une carte qui ne répond plus ou programmer un ATmega ou un ATtiny monté sur plaque d’essai.
Figure 1.16interactif – Câblage d’une Uno utilisée comme programmateur ISP : cliquez sur une étape ou sur un fil pour afficher l’explication.
1.14.2Les quatre étapes
Sur la carte programmateur, ouvrir Fichier › Exemples › 11.ArduinoISP › ArduinoISP et le téléverser normalement, par l’USB.
Câbler les deux cartes (figure 1.16) et ajouter un condensateur de 10 µF entre RESET et GND du programmateur : il l’empêche de redémarrer quand l’IDE ouvre le port série.
Choisir Outils › Programmateur › Arduino as ISP, et la carte cible dans Outils › Carte : l’IDE compile pour elle.
Lancer Outils › Graver la séquence d’initialisation pour installer le bootloader, ou Croquis › Téléverser avec un programmateur pour écrire directement le croquis.
Programmateur
RESET cible
MOSI
MISO
SCK
Uno, Nano
D10
D11
D12
D13
Mega 2560
D10
D51
D50
D52
Les broches MOSI, MISO et SCK du programmateur sont reliées aux broches de même nom de la cible ; la broche D10 du programmateur pilote le RESET de la cible ; 5 V et GND sont communs. Les broches 11, 12 et 13 du connecteur ICSP conviennent aussi. Trois LED facultatives (avec résistance de 220 Ω) sur D9, D8 et D7 indiquent respectivement que le programmateur fonctionne, qu’une erreur s’est produite et qu’une programmation est en cours.
Attention
« Téléverser avec un programmateur » efface le bootloader de la cible : pour la reprogrammer ensuite par l’USB, il faudra graver de nouveau la séquence d’initialisation.
Exercices
1. On veut programmer un ATmega328P neuf placé sur une plaque d’essai à l’aide d’une Mega 2560. Quelles broches de la Mega relier aux broches SCK, MISO, MOSI et RESET de l’ATmega ?
SCK ← D52, MISO ← D50, MOSI ← D51, RESET ← D10, sans oublier 5 V et GND. On peut aussi utiliser le connecteur ICSP de la Mega, dont les broches SPI sont identiques à celles de la Uno.
2. Sans le condensateur de 10 µF, la programmation échoue systématiquement. Pourquoi ?
À l’ouverture du port série, le reset automatique redémarre le programmateur : son bootloader attend un nouveau croquis au lieu d’exécuter ArduinoISP, et l’IDE ne trouve pas le programmateur attendu. Le condensateur maintient RESET au niveau haut pendant cette impulsion.
Faire clignoter une LED est le « Bonjour, monde » de l’électronique embarquée. Ce programme minuscule met en jeu tout ce qui a été vu : une broche configurée en sortie, un changement d’état, une temporisation, une boucle infinie et un calcul électrique simple.
Figure 1.17interactif – Exécution du programme Blink : ligne en cours, état de la LED et tension sur la broche 13.
1.15.1Le montage
La LED est reliée à la broche 13 à travers une résistance de 220 Ω, sa cathode (patte courte, côté méplat) étant reliée à la masse GND. La Uno possède aussi une LED intégrée sur la broche 13 : le programme fonctionne même sans montage.
La résistance limite le courant. Une LED rouge présente à ses bornes une tension directe UF d’environ 2 V ; la résistance supporte donc le reste :
I = (5 V − UF) / R = (5 − 2) / 220 ≈ 13,6 mA
Ce courant est inférieur aux 20 mA admissibles par une broche : le montage est sûr.
Attention
Sans résistance, seule la résistance interne de la broche limiterait le courant : on dépasserait largement 20 mA, au risque de détruire la LED et la sortie du microcontrôleur.
1.15.2Le programme ligne par ligne
const int LED = 13; // (1) nom donné à la broche
void setup() {
pinMode(LED, OUTPUT); // (2) broche 13 en sortie
}
void loop() {
digitalWrite(LED, HIGH); // (3) 5 V : LED allumée
delay(1000); // (4) attendre 1000 ms
digitalWrite(LED, LOW); // (5) 0 V : LED éteinte
delay(1000); // (6) attendre 1000 ms
}
const int LED = 13; donne un nom à la broche. Si l’on change de broche, on ne modifie qu’une ligne ; le mot-clé const empêche toute modification accidentelle.
pinMode(LED, OUTPUT) configure la broche en sortie (le bit 5 du registre DDRB passe à 1). Cette configuration n’est faite qu’une fois, d’où sa place dans setup().
digitalWrite(LED, HIGH) porte la broche à 5 V : la LED s’allume.
delay(1000) suspend le programme pendant 1000 millisecondes.
Les lignes (5) et (6) éteignent la LED et attendent à nouveau 1 s. Puis loop() recommence.
1.15.3Le chronogramme
La tension sur la broche 13 est un signal rectangulaire : 1 s à 5 V, 1 s à 0 V. Sa période est T = 2 s, sa fréquence f = 1/T = 0,5 Hz et son rapport cyclique 50 %. Les instructions digitalWrite elles-mêmes ne durent que quelques microsecondes : le temps est presque entièrement passé dans delay().
1.15.4Les limites de delay()
Pendant un delay(), le microcontrôleur ne fait rien d’autre : si l’on appuie sur un bouton à ce moment, le programme ne le verra pas. Pour faire plusieurs choses « en même temps », on remplace l’attente par un test du temps écoulé avec millis(), qui renvoie le nombre de millisecondes depuis le démarrage :
const int LED = 13;
unsigned long dernier = 0;
bool etat = LOW;
void setup() { pinMode(LED, OUTPUT); }
void loop() {
if (millis() - dernier >= 1000) { // 1 s écoulée ?
dernier = millis();
etat = !etat;
digitalWrite(LED, etat);
}
// … ici, le programme reste libre de lire des boutons, des capteurs…
}
Pour aller plus loin
Cette technique est l’amorce de la programmation non bloquante et des machines à états, indispensables dès qu’un système embarqué doit gérer plusieurs tâches. L’exemple BlinkWithoutDelay de l’IDE (Fichier › Exemples › 02.Digital) la présente en détail.
À retenir
Une LED se branche toujours avec une résistance série (≈ 220 Ω en 5 V).
pinMode dans setup(), digitalWrite et delay dans loop().
delay() bloque le programme ; millis() permet d’attendre sans bloquer.
Exercices
1. Modifiez le programme pour que la LED clignote à 2 Hz avec un rapport cyclique de 25 %.
À 2 Hz, T = 500 ms ; 25 % à l’état haut donne 125 ms allumée et 375 ms éteinte : digitalWrite(LED, HIGH); delay(125); digitalWrite(LED, LOW); delay(375);
2. Quelle résistance choisir pour une LED bleue (UF ≈ 3,2 V) parcourue par 10 mA ?
R = (5 − 3,2) / 0,010 = 180 Ω. On prend la valeur normalisée la plus proche par excès, 180 Ω (série E12), ou 220 Ω pour un courant un peu plus faible.
3. Écrivez un programme qui fait clignoter alternativement deux LED, sur D12 et D13.
L’IDE Arduino convient parfaitement aux premiers projets. Lorsque les programmes grossissent et se répartissent sur plusieurs fichiers, un éditeur plus complet devient utile : Visual Studio Code associé à l’extension PlatformIO est l’alternative la plus répandue.
1.16.1Un éditeur complet pour l’embarqué
VS Code est un éditeur de code gratuit de Microsoft, disponible sous Windows, macOS et Linux. PlatformIO est une extension qui lui ajoute la compilation, le téléversement, le moniteur série et la gestion des cartes et des bibliothèques, pour plus d’un millier de cartes. Le code reste du C++ Arduino : on y retrouve setup(), loop(), digitalWrite() et toutes les fonctions du cours.
Figure 1.18interactif – Un projet PlatformIO : explorez les fichiers et cliquez sur les boutons de la barre d’état pour voir la sortie correspondante.
1.16.2Créer un projet
Installer VS Code, puis l’extension PlatformIO IDE depuis le gestionnaire d’extensions.
New Project : choisir la carte (Arduino Uno, Arduino Mega 2560…) et le framework Arduino.
Écrire le programme dans src/main.cpp, puis utiliser les boutons de la barre d’état : ✓ compiler, → téléverser, moniteur série, nettoyer.
Les réglages du projet sont rassemblés dans le fichier platformio.ini. Un même projet peut cibler plusieurs cartes, chacune décrite par un environnement ; les bibliothèques listées dans lib_deps sont téléchargées automatiquement à la première compilation :
; un environnement par carte
[env:uno]
platform = atmelavr
board = uno
framework = arduino
monitor_speed = 9600
[env:mega]
platform = atmelavr
board = megaatmega2560
framework = arduino
monitor_speed = 9600
lib_deps = adafruit/DHT sensor library
1.16.3Les différences avec l’IDE Arduino
Un fichier .ino est préparé par l’IDE avant la compilation : il ajoute #include <Arduino.h> et les prototypes des fonctions (section 1.13). PlatformIO compile directement du C++ standard. Il faut donc écrire soi-même la ligne #include <Arduino.h> en tête de main.cpp, et déclarer chaque fonction avant de l’appeler. En contrepartie, on dispose de la complétion intelligente du code, de la navigation entre fichiers, d’un gestionnaire de versions intégré et de la possibilité de compiler pour plusieurs cartes à la fois.
Exercices
1. Un croquis qui compile dans l’IDE Arduino est copié dans src/main.cpp et provoque l’erreur « 'clignoter' was not declared in this scope ». Pourquoi ?
La fonction clignoter() est définie après loop(), qui l’appelle. L’IDE Arduino ajoute automatiquement son prototype ; PlatformIO non. On ajoute void clignoter(); avant loop() (ou l’on déplace la fonction), sans oublier #include <Arduino.h>.
2. D’après la sortie de compilation de la figure 1.18 (« RAM : 194 bytes from 2048 », « Flash : 1972 bytes from 32256 »), quels pourcentages de mémoire le programme utilise-t-il ?
SRAM : 194 / 2 048 ≈ 9,5 %. Flash : 1 972 / 32 256 ≈ 6,1 %. Ce sont les mêmes informations que celles données par l’IDE Arduino en fin de compilation.
Un questionnaire pour vérifier ses connaissances, puis les sources qui ont servi à construire ce cours et qui permettent d’aller plus loin.
Chapitre 1 · Section 1.17
Se tester avec le QCM
Le QCM interactif comporte vingt questions qui couvrent l’ensemble du cours. Il n’est pas noté : c’est un outil d’auto-évaluation, à utiliser pour repérer les notions à revoir.
1.17.1Mode d’emploi
Choisissez une réponse à la souris ou avec les touches 1 à 4, puis validez avec Entrée. Après chaque réponse, une explication s’affiche (figure 1.19). En fin de questionnaire, la liste des questions manquées renvoie directement à la section qui donne les explications détaillées. Le bouton Recommencer propose les questions dans un nouvel ordre.
Figure 1.19interactif – QCM de vingt questions sur l’ensemble du chapitre.
Visez au moins 16 bonnes réponses sur 20. En dessous, relisez les encadrés « À retenir » des sections concernées, puis refaites le questionnaire quelques jours plus tard : l’espacement des révisions est la méthode la plus efficace pour mémoriser durablement.
Un cours d’introduction ne peut pas tout dire. Les sources listées en fin de chapitre permettent de vérifier une information, d’approfondir un point ou de résoudre un problème concret. Encore faut-il savoir laquelle consulter.
1.18.1Une hiérarchie des sources
Les fiches techniques du fabricant (Microchip pour l’ATmega328P et l’ATmega2560) font foi pour tout ce qui concerne le microcontrôleur : tensions, courants, registres, chronogrammes. Elles sont longues (plusieurs centaines de pages), mais on y cherche une information précise grâce à la table des matières.
La documentation officielle Arduino (docs.arduino.cc) décrit chaque carte (schémas, brochage, caractéristiques) et chaque fonction du langage, avec des exemples.
Les livres présentent les notions de façon progressive et structurée. Démarrez avec Arduino (Banzi et Shiloh) est l’introduction écrite par le cofondateur du projet ; l’ouvrage de C. Tavernier va plus loin dans la programmation et les shields.
Les sites spécialisés et les forums sont précieux pour un problème pratique, mais leurs informations doivent être recoupées avec les sources précédentes.
1.18.2Références
Bibliographie
M. Banzi, M. Shiloh, Démarrez avec Arduino, 4e éd., trad. G. Samblancat, Dunod, 2023.ISBN 978-2-10-084534-7
M. Banzi, M. Shiloh, Getting Started with Arduino, 4th ed., Make: Community, 2022.ISBN 978-1-68045-692-9
C. Tavernier, Arduino : maîtrisez sa programmation et ses cartes d’interface (shields), 2e éd., Dunod, 2019.ISBN 978-2-10-080715-4
D. Kushner, « The Making of Arduino », IEEE Spectrum, 26 octobre 2011.
Après ce cours, l’étape naturelle est de parcourir les exemples intégrés à l’IDE (Fichier › Exemples) dans l’ordre : 01.Basics, 02.Digital, 03.Analog, 04.Communication. Chacun est commenté et correspond à une page de la documentation officielle.