Chapitre 1Livre « Arduino sous le capot »

Découverte d’Arduino

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.
  • Écrire, analyser et modifier le programme Blink.

Plan du chapitre

  1. Partie I – Découvrir Arduino
  2. 1.1Aux origines d’Arduino
  3. 1.2Qu’est-ce qu’Arduino ?
  4. 1.3L’écosystème Arduino aujourd’hui
  5. Partie II – Les cartes
  6. 1.4Choisir une carte : les critères
  7. 1.5Les familles de cartes
  8. 1.6Les cartes Uno et Mega en détail
  9. 1.7Architecture interne d’un microcontrôleur AVR
  10. 1.8Le brochage de l’Arduino Uno
  11. 1.9Le brochage de l’Arduino Mega 2560
  12. Partie III – Programmer
  13. 1.10Les outils de programmation
  14. 1.11Prendre en main l’IDE 2
  15. 1.12Bibliothèques et cartes supplémentaires
  16. 1.13Du croquis à la carte : le téléversement
  17. 1.14Programmer une carte avec une autre carte
  18. 1.15Premier programme : faire clignoter une LED
  19. 1.16Un autre environnement : VS Code et PlatformIO
  20. Partie IV – Évaluation et ressources
  21. 1.17Se tester avec le QCM
  22. 1.18Exploiter les sources

Chapitre 1 · Partie I

Découvrir Arduino

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

Frise chronologique 2002–2025
Figure 1.1 – Frise chronologique d’Arduino, de 2002 à 2025.
AnnéeÉvénementCe qui change
2002Massimo Banzi cherche un outil d’enseignementConstat : le BASIC Stamp est trop cher et fermé.
2003Wiring (H. Barragán)Le modèle carte + éditeur simple est posé.
2005Premières cartes Arduino300 cartes distribuées aux étudiants de l’IDII.
2010Arduino UnoPuce USB programmable (ATmega16U2) ; la Uno devient la carte de référence.
2023Uno R4Passage à un microcontrôleur 32 bits (Renesas RA4M1, Arm Cortex-M4) dans le même format.
2025Annonce du rachat par Qualcomm, Uno QArduino 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).

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.2

Qu’est-ce qu’Arduino ?

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 :

  1. 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.
  2. Un environnement de développement (l’IDE), qui permet d’écrire le programme, de le compiler et de programmer la carte.
  3. 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.

Synthèse : plateforme, matériel libre, logiciel libre, nom protégé
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 ».

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.3

L’écosystème Arduino aujourd’hui

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.

Écosystème Arduino
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).

✎ Signaler une erreur dans cette section

Chapitre 1 · Partie II

Les cartes

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.4 interactif – 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 principalCarte conseillée
Apprendre, suivre un tutoriel, utiliser des shieldsUno R3 ou Uno R4 Minima
Beaucoup de capteurs et d’actionneurs, plusieurs liaisons sérieMega 2560
Encombrement réduit, montage sur plaque d’essaiNano, Nano Every
Objet connecté en Wi-Fi ou BluetoothNano ESP32, Uno R4 WiFi
Calcul intensif, audio, écranGIGA R1 WiFi
Linux, vision, intelligence artificielleUno 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.

À retenir

  • Flash = programme, SRAM = variables, EEPROM = données conservées.
  • 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").

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.5

Les familles de cartes

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.5 interactif – 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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.6

Les cartes Uno et Mega en détail

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.

Photos et caractéristiques des cartes Uno et Mega
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émoireUno (ATmega328P)Mega (ATmega2560)Rôle
Flash32 Ko (dont 0,5 Ko de bootloader)256 Ko (dont 8 Ko de bootloader)Programme, non volatile
SRAM2 Ko8 KoVariables, volatile
EEPROM1 Ko4 KoDonné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);

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.7

Architecture interne d’un microcontrôleur AVR

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.

Schéma-bloc de l’architecture AVR
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 :

  1. 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.
  2. 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…).
  3. 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.

À retenir

  • AVR = architecture Harvard, RISC, 8 bits, 32 registres de travail.
  • 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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.8

Le brochage de l’Arduino Uno

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.

Pinout Arduino Uno R3
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 cartePort du microcontrôleur
D0 à D7PD0 à PD7
D8 à D13PB0 à PB5
A0 à A5PC0 à PC5
Brochage ATmega328P DIP 28
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 :

BrochesFonctionUsage
D0 (RX), D1 (TX)Liaison série (USART)Communication avec l’ordinateur par l’USB, Serial
D2, D3Interruptions externes INT0, INT1attachInterrupt()
D3, D5, D6, D9, D10, D11PWM (~)analogWrite()
D10 (SS), D11 (MOSI), D12 (MISO), D13 (SCK)Bus SPICarte SD, écrans, modules radio
A4 (SDA), A5 (SCL)Bus I²CCapteurs, afficheurs, horloges
D13LED intégréeLED_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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.9

Le brochage de l’Arduino Mega 2560

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.

Pinout Arduino Mega 2560
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 :

ObjetTXRX
Serial (USB)10
Serial11819
Serial21617
Serial31415
// 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() :

volatile unsigned long impulsions = 0;
void compter() { impulsions++; }          // fonction d’interruption : courte !

void setup() {
  pinMode(18, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(18), compter, FALLING);
}

À retenir

  • 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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Partie III

Programmer

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.

Outils de programmation et chaîne de compilation
Figure 1.11 – Les outils de programmation et le chemin du croquis jusqu’à la carte.

1.10.1Quel outil pour quel usage ?

OutilPoints fortsPour qui ?
Arduino IDE 2Simple, complet, hors ligneDébutants, TP, la plupart des projets
Cloud EditorRien à installer, projets synchronisés, tableaux de bord IoTPostes partagés, objets connectés
Arduino CLIScriptable, intégrable à d’autres outilsAutomatisation, intégration continue
App LabSketch Arduino et Python dans une même applicationUtilisateurs de la Uno Q
VS Code + PlatformIOProjets en plusieurs fichiers, dépendances versionnées, des centaines de cartesProjets importants, développeurs confirmés
Programmeur ISPÉcriture directe dans la Flash, sans bootloaderPuce 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 :

  1. 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.
  2. 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.
  3. Édition de liens. Les fichiers objets sont assemblés en un programme unique, le fichier .elf, dans lequel toutes les adresses sont fixées.
  4. Conversion. L’outil avr-objcopy extrait du .elf l’image de la mémoire Flash au format Intel HEX.
  5. 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.

À retenir

.ino → prétraitement → .cpp → avr-gcc → .o → édition de liens → .elf → avr-objcopy → .hex → avrdude → carte.

Exercice

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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.11

Prendre en main l’IDE 2

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

Maquette de l’IDE 2
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

  1. 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.
  2. Écrire le croquis : setup() et loop().
  3. Vérifier : la compilation signale les erreurs avec leur numéro de ligne.
  4. 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’erreurCause habituelle
expected ';' before …Point-virgule oublié à la fin de la ligne précédente
'xxx' was not declared in this scopeFaute de frappe, variable non déclarée, bibliothèque non incluse
No such file or directoryBibliothè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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.12

Bibliothèques et cartes supplémentaires

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) :

  1. 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 ;
  2. un fichier .ZIP téléchargé, sur GitHub par exemple : Croquis › Inclure une bibliothèque › Ajouter la bibliothèque .ZIP ;
  3. la copie manuelle du dossier de la bibliothèque dans Documents/Arduino/libraries, puis le redémarrage de l’IDE.
Figure 1.13 interactif – 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 :

#include <DHT.h>             // bibliothèque installée
DHT capteur(2, DHT22);        // capteur DHT22 sur la broche 2

void setup() {
  Serial.begin(9600);
  capteur.begin();
}
void loop() {
  float t = capteur.readTemperature();
  Serial.println(t);
  delay(2000);
}

Définition – Dépendance

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) :

  1. 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 ;
  2. 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 ;
  3. on choisit la carte et le port avec le sélecteur de la barre d’outils (ou Outils › Carte et Outils › Port) ;
  4. on téléverse : le même croquis est compilé pour le nouveau microcontrôleur.
Figure 1.14 interactif – 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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.13

Du croquis à la carte : le téléversement

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.15 interactif – 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ômePistes
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 respondingMauvaise 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 rienErreur 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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.14

Programmer une carte avec une autre carte

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.16 interactif – 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

  1. Sur la carte programmateur, ouvrir Fichier › Exemples › 11.ArduinoISP › ArduinoISP et le téléverser normalement, par l’USB.
  2. 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.
  3. Choisir Outils › Programmateur › Arduino as ISP, et la carte cible dans Outils › Carte : l’IDE compile pour elle.
  4. 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.
ProgrammateurRESET cibleMOSIMISOSCK
Uno, NanoD10D11D12D13
Mega 2560D10D51D50D52

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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.15

Premier programme : faire clignoter une LED

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.17 interactif – 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
}
  1. 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.
  2. 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().
  3. digitalWrite(LED, HIGH) porte la broche à 5 V : la LED s’allume.
  4. delay(1000) suspend le programme pendant 1000 millisecondes.
  5. 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.
void setup() { pinMode(12, OUTPUT); pinMode(13, OUTPUT); }
void loop() {
  digitalWrite(12, HIGH); digitalWrite(13, LOW);  delay(500);
  digitalWrite(12, LOW);  digitalWrite(13, HIGH); delay(500);
}

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.16

Un autre environnement : VS Code et PlatformIO

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.18 interactif – 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

  1. Installer VS Code, puis l’extension PlatformIO IDE depuis le gestionnaire d’extensions.
  2. New Project : choisir la carte (Arduino Uno, Arduino Mega 2560…) et le framework Arduino.
  3. É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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Partie IV

Évaluation et ressources

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.19 interactif – QCM de vingt questions sur l’ensemble du chapitre.

1.17.2Correspondance entre questions et sections

QuestionsThèmeSections
1 à 5Histoire, licences, écosystèmesection 1.1, section 1.2, section 1.3
6 à 11Cartes, tensions, familles, caractéristiquessection 1.4, section 1.5, section 1.6
12 à 14Architecture et brochagesection 1.7, section 1.8, section 1.9
15 à 20Outils, IDE, téléversement, Blinksection 1.10 à section 1.15

Conseil

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.

✎ Signaler une erreur dans cette section

Chapitre 1 · Section 1.18

Exploiter les sources

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

  1. 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.
  2. La documentation officielle Arduino (docs.arduino.cc) décrit chaque carte (schémas, brochage, caractéristiques) et chaque fonction du langage, avec des exemples.
  3. 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.
  4. 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.
  • Microchip Technology, fiches techniques des microcontrôleurs ATmega328P et ATmega2560.microchip.com/en-us/product/ATmega328P · …/ATmega2560

Documentation officielle Arduino

Histoire

Comparatif des cartes

Brochages

Pour aller plus loin

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.

✎ Signaler une erreur dans cette section