Microcontrôleur et carte, architecture Harvard, mémoires, démarrage et premiers pas en assembleur
Derrière la simplicité des fonctions Arduino se cache un microcontrôleur : l’ATmega328P. Comprendre son organisation interne – où est rangé le programme, où vivent les variables, comment une instruction est lue puis exécutée – permet d’écrire des programmes plus rapides, plus économes en mémoire, et surtout de comprendre ce qui se passe quand quelque chose ne marche pas.
Ce chapitre part de la carte Uno pour descendre progressivement dans le microcontrôleur. On y découvre l’architecture Harvard des AVR, les trois mémoires et leur rôle, la séquence de démarrage qui précède setup(), puis les premiers éléments du langage assembleur, celui que le processeur exécute réellement. L’objectif n’est pas de programmer en assembleur au quotidien, mais de savoir lire ce que le compilateur produit et d’en tirer des règles d’écriture efficaces en C.
Objectifs du chapitre
Distinguer microprocesseur et microcontrôleur, et identifier les blocs d’un ATmega328P.
Expliquer l’intérêt d’une architecture Harvard par rapport à une architecture de von Neumann.
Situer le programme, les constantes, les variables et la pile dans les mémoires Flash, SRAM et EEPROM.
Décrire les étapes qui mènent du reset à l’appel de setup().
Lire un court programme en assembleur AVR et estimer sa durée en cycles d’horloge.
Prérequis
Le chapitre 1 : cartes Uno et Mega, IDE et premier programme. Les notions de bit, d’octet et de numération hexadécimale sont supposées connues.
Avant d’entrer dans la puce, on fait le tour de ce que la carte ajoute autour d’elle, puis on ouvre le boîtier pour en découvrir les blocs internes. On termine par un panorama de la famille AVR, à laquelle appartiennent les microcontrôleurs des cartes Arduino classiques.
Chapitre 2 · Section 2.1
Du microcontrôleur à la carte
Une carte Arduino Uno n’est pas un microcontrôleur : c’est un microcontrôleur entouré des quelques composants qui le rendent immédiatement utilisable. Tout le travail de calcul est fait par une seule puce, l’ATmega328P ; le reste sert à l’alimenter, à lui donner une horloge et à le relier au PC.
Figure 2.1interactif – De l’ATmega328P à la carte Uno : cliquez sur un élément de la carte pour afficher son rôle.
2.1.1Ce que la carte ajoute au microcontrôleur
Sur la Uno R3, l’ATmega328P est un boîtier DIP de 28 broches monté sur support : on peut le retirer et le placer sur une plaque d’essai, à condition de lui fournir les mêmes éléments que la carte. Ceux-ci sont peu nombreux (figure 2.1) :
un oscillateur à quartz à 16 MHz qui cadence le processeur : 16 millions de cycles par seconde, soit un cycle toutes les 62,5 ns. Le cœur Arduino connaît cette valeur grâce à la constante F_CPU, utilisée par delay(), millis() et le calcul des débits série ;
un second microcontrôleur, l’ATmega16U2, programmé en convertisseur USB ↔ série. Il est relié aux broches RX (D0) et TX (D1) de l’ATmega328P : c’est par lui que passent le téléversement et les échanges du moniteur série ;
l’alimentation : le connecteur USB-B fournit 5 V, le jack accepte une tension de 7 à 12 V abaissée par un régulateur ;
le bouton Reset, qui met la broche RESET au niveau bas : le microcontrôleur redémarre, le bootloader s’exécute, puis le croquis reprend au début de setup() ;
deux connecteurs ICSP à six broches. Celui situé près de l’ATmega328P permet de programmer directement sa mémoire Flash par la liaison SPI, sans bootloader, avec un programmateur ou une autre carte (ArduinoISP, chapitre 1). L’autre sert à reprogrammer l’ATmega16U2 ;
quatre LED : L, reliée à D13 (PB5) et utilisée par l’exemple Blink ; TX et RX, qui signalent l’activité de la liaison USB ; ON, qui indique que la carte est alimentée.
2.1.2Le reset automatique
Lorsque l’IDE ouvre le port série pour téléverser un croquis, l’ATmega16U2 met brièvement la broche RESET de l’ATmega328P au niveau bas. Le microcontrôleur redémarre, et le petit programme placé en fin de mémoire Flash – le bootloader – attend pendant une fraction de seconde l’arrivée d’un nouveau programme. C’est ce mécanisme qui évite d’avoir à appuyer sur le bouton Reset à chaque téléversement. Il a une conséquence parfois surprenante : ouvrir le moniteur série redémarre le croquis.
2.1.3Des numéros de broches conventionnels
Les numéros D0 à D13 et A0 à A5 imprimés sur la carte sont une convention du cœur Arduino. Le microcontrôleur, lui, ne connaît que des ports de 8 bits (B, C et D) et des numéros de bits : D13 est le bit 5 du port B, noté PB5 ; A0 est PC0. Le cœur Arduino contient des tables de correspondance qui traduisent les numéros de la carte en couples (port, bit). On retrouvera ces ports au chapitre 3, quand on programmera les broches directement par leurs registres.
2.1.4Microprocesseur ou microcontrôleur ?
Un microprocesseur – celui d’un PC, par exemple – ne contient que l’unité de traitement : il lui faut une mémoire vive, une mémoire de stockage et des circuits d’entrées-sorties externes, reliés par des bus sur la carte mère. Un microcontrôleur réunit tout cela dans un seul boîtier (figure 2.2). Il est moins puissant, mais il ne coûte que quelques euros, consomme très peu et peut fonctionner avec une poignée de composants autour de lui.
Définition – Microcontrôleur
Circuit intégré qui réunit dans un même boîtier un processeur (le cœur), des mémoires pour le programme et les données, et des périphériques d’entrées-sorties. Il est conçu pour piloter un système à lui seul.
Figure 2.2interactif – Architecture de l’ATmega328P : cliquez sur un bloc pour voir son rôle et ce qui l’utilise côté Arduino.
2.1.5Les blocs de l’ATmega328P
La figure 2.2 sépare le cœur et les mémoires, à gauche, des périphériques, à droite ; tous communiquent par un bus de données de 8 bits.
Le cœur AVR 8 bits lit les instructions dans la mémoire Flash et les exécute. Il comporte 32 registres de travail de 8 bits (r0 à r31), une unité arithmétique et logique (UAL) et un registre d’état, SREG, qui garde la trace du résultat de la dernière opération. La plupart des instructions s’exécutent en un seul cycle d’horloge.
Les mémoires sont au nombre de trois : 32 Ko de Flash pour le programme, 2 Ko de SRAM pour les variables et la pile, 1 Ko d’EEPROM pour les données à conserver hors tension. Elles sont détaillées dans la section 2.3.
L’horloge peut provenir d’un oscillateur RC interne à 8 MHz, d’un oscillateur à 128 kHz ou d’un résonateur externe ; la Uno utilise un résonateur de 16 MHz. Chaque cycle d’horloge fait avancer le processeur et les périphériques.
Le contrôleur d’interruptions gère 26 sources : broches externes, timers, liaisons série, convertisseur analogique-numérique… Il permet au programme de réagir à un événement sans le surveiller en permanence (chapitre 6).
Les périphériques travaillent en parallèle du processeur : trois ports d’entrées-sorties (23 broches au total), trois timers (Timer0 et Timer2 sur 8 bits, Timer1 sur 16 bits), un convertisseur analogique-numérique 10 bits à 6 voies, une liaison série asynchrone USART, une liaison SPI, une interface I²C (appelée TWI chez Microchip), un chien de garde et des modes de veille. Chacun fait l’objet d’un chapitre de ce livre.
À retenir
Chaque périphérique se pilote par des registres spéciaux, accessibles comme des cases mémoire. Les fonctions Arduino (pinMode, analogRead, Serial.begin…) ne font qu’écrire et lire ces registres à votre place.
2.1.6La famille AVR
L’ATmega328P appartient à la famille AVR, conçue par Atmel au milieu des années 1990 et reprise par Microchip en 2016. On la retrouve sur de nombreuses cartes Arduino, de la minuscule Digispark à la Mega 2560 (figure 2.3).
Figure 2.3interactif – Quatre microcontrôleurs AVR utilisés sur des cartes Arduino : cliquez sur un nom pour afficher ce qui le distingue.
ATtiny85
ATmega328P
ATmega32U4
ATmega2560
Cartes
Digispark
Uno, Nano, Pro Mini
Leonardo, Micro
Mega 2560
Flash
8 Ko
32 Ko
32 Ko
256 Ko
SRAM
512 o
2 Ko
2,5 Ko
8 Ko
EEPROM
512 o
1 Ko
1 Ko
4 Ko
E/S du microcontrôleur
6
23
26
86
Broches sur la carte
6 (P0 à P5)
20 (D0–D13, A0–A5)
20 (D0–D13, A0–A5)
70 (D0–D53, A0–A15)
Liaisons série
USI (pas d’UART)
1 USART
1 USART + USB
4 USART
La ligne « E/S du microcontrôleur » donne le nombre de lignes d’entrées-sorties de la puce, d’après sa fiche technique. La carte n’en rend accessibles qu’une partie : sur la Mega, 16 des 86 lignes de l’ATmega2560 ne sont reliées à aucun connecteur ; sur la Uno, trois des 23 lignes de l’ATmega328P servent à l’horloge (PB6, PB7) et au reset (PC6).
Tous partagent le même cœur 8 bits, les mêmes 32 registres et le même jeu d’instructions. Un croquis passe donc d’une puce à l’autre par une simple recompilation, tant qu’il n’utilise pas un périphérique absent. Les différences portent sur la taille des mémoires et le nombre de périphériques. L’ATtiny85, avec ses 8 broches, n’a ni UART ni bootloader d’origine : on le programme souvent par ISP à l’aide d’une carte Uno. L’ATmega32U4 intègre un contrôleur USB : la Leonardo peut se faire passer pour un clavier ou une souris, son port série est un port USB virtuel et la liaison série des broches D0/D1 devient Serial1.
Exercices
1. Combien de cycles d’horloge l’ATmega328P de la Uno exécute-t-il pendant un delay(1) ? Quelle est la durée d’un cycle ?
À 16 MHz, un cycle dure 1 / 16·106 = 62,5 ns. Une milliseconde correspond donc à 16 000 cycles, pendant lesquels le processeur ne fait qu’attendre.
2. Pourquoi l’ouverture du moniteur série relance-t-elle le croquis depuis le début ?
L’ouverture du port série par le PC fait basculer un signal de l’ATmega16U2 qui met brièvement RESET au niveau bas : c’est le reset automatique prévu pour le téléversement. Le microcontrôleur redémarre, le bootloader attend un instant, puis le croquis repart au début de setup().
3. Un croquis pour Uno utilise Serial pour dialoguer avec un module GPS relié à D0/D1. On le porte sur une Leonardo : que faut-il changer ?
Sur la Leonardo, Serial désigne le port USB virtuel ; la liaison série matérielle des broches D0/D1 s’appelle Serial1. Il faut donc remplacer Serial par Serial1 pour le dialogue avec le GPS, et l’on peut garder Serial pour afficher des messages sur le PC.
Le programme et les données ne sont pas rangés au même endroit, et ce choix d’architecture conditionne la vitesse du processeur comme la façon d’écrire certains programmes. Cette partie détaille les trois mémoires, leur organisation et la séquence qui conduit du reset à l’appel de setup().
Chapitre 2 · Section 2.2
L’architecture Harvard
Un processeur passe son temps à lire des instructions et à manipuler des données. La façon dont il accède à ces deux types d’informations – par un chemin commun ou par deux chemins séparés – détermine combien d’opérations il peut faire en un cycle.
2.2.1Deux architectures
Dans l’architecture de von Neumann, utilisée par la plupart des ordinateurs, une seule mémoire contient à la fois le programme et les données, et un seul bus les relie au processeur. Lire une instruction et lire une variable sont deux accès successifs sur le même chemin : ils ne peuvent pas avoir lieu en même temps.
Dans l’architecture Harvard, adoptée par les AVR, le programme est rangé dans la mémoire Flash et les données dans la SRAM, et chacune possède son propre bus. Le processeur peut ainsi lire l’instruction suivante pendant qu’il lit ou écrit une variable.
Définition – Architecture Harvard
Architecture dans laquelle les instructions et les données sont stockées dans des mémoires distinctes, accessibles par des bus séparés. Elle permet de lire une instruction et une donnée simultanément.
Figure 2.4interactif – Exécution de c = a + b; sur une architecture de von Neumann et sur une architecture Harvard : lancez l’animation ou avancez cycle par cycle.
2.2.2Un exemple cycle par cycle
La figure 2.4 compare l’exécution de l’instruction C c = a + b;, où a, b et c sont des variables globales de type byte. Le compilateur la traduit en quatre instructions : lire a, lire b, additionner, écrire c. Avec un modèle simplifié où chaque bus ne transporte qu’une information par cycle :
la machine de von Neumann doit, pour chaque instruction, lire l’instruction puis accéder à la variable sur le même bus : il lui faut 7 cycles ;
la machine Harvard lit la variable a sur le bus de données pendant qu’elle lit l’instruction suivante sur le bus programme. L’addition se fait entre registres, dans l’UAL, sans occuper de bus. L’opération est terminée en 5 cycles.
2.2.3Le pipeline à deux étages
Cette lecture anticipée porte un nom : le pipeline. Pendant que l’instruction n s’exécute, l’instruction n + 1 est déjà lue en Flash. La plupart des instructions de l’AVR s’exécutent ainsi en un seul cycle, ce qui donne près de 16 millions d’instructions par seconde à 16 MHz. Les sauts font exception : quand le programme change de direction, l’instruction lue par anticipation est inutile et doit être remplacée, ce qui coûte un cycle supplémentaire.
Attention
L’architecture Harvard a une contrepartie : une constante rangée en Flash ne se lit pas comme une variable en SRAM. Il faut une instruction spéciale (lpm) et, en C, des fonctions dédiées comme pgm_read_byte(). C’est la raison d’être de la macro F() et du mot-clé PROGMEM, présentés à la section suivante.
Exercices
1. Avec le modèle simplifié de la figure 2.4, combien de cycles faut-il à chaque machine pour exécuter d = a + b + c;, traduite en six instructions (trois lectures, deux additions, une écriture) ?
Le programme compte six instructions dont quatre accèdent à une variable. Von Neumann : 6 lectures d’instruction + 4 accès aux données sur le même bus = 10 cycles. Harvard : les accès aux données se superposent aux lectures d’instructions suivantes ; il faut 6 cycles pour lire les instructions plus 1 cycle pour terminer la dernière écriture, soit 7 cycles environ.
2. Une boucle exécute 1 000 instructions : 900 instructions d’un cycle et 100 sauts conditionnels pris, de deux cycles chacun. Combien de temps dure-t-elle à 16 MHz ? Combien d’instructions par seconde le processeur exécute-t-il réellement ?
Durée : 900 × 1 + 100 × 2 = 1 100 cycles, soit 1 100 × 62,5 ns = 68,75 µs. Le processeur exécute 1 000 instructions en 68,75 µs, soit environ 14,5 millions d’instructions par seconde, au lieu de 16 millions si toutes duraient un cycle. Chaque saut pris coûte un cycle de plus parce que l’instruction lue d’avance par le pipeline est abandonnée.
L’ATmega328P contient trois mémoires de natures très différentes. Savoir ce que chacune contient, ce qu’elle coûte et comment on y accède évite les plus fréquentes des pannes « mystérieuses » d’un croquis : celles qui viennent d’un manque de mémoire vive.
Figure 2.5interactif – Les trois mémoires de l’ATmega328P et le devenir des chaînes de caractères : comparez les versions sans et avec la macro F().
2.3.1Flash, SRAM et EEPROM
Flash
SRAM
EEPROM
Taille
32 Ko
2 Ko
1 Ko
Hors tension
conservée
perdue
conservée
Contenu
programme, constantes
variables, pile
réglages, compteurs
Organisation
mots de 16 bits
octets
octets
Endurance
≈ 10 000 effacements
illimitée
≈ 100 000 écritures par octet
Écriture
bootloader ou programmateur
1 à 2 cycles
≈ 3,3 ms par octet
La Flash contient le programme. Elle est organisée en mots de 16 bits – la taille d’une instruction simple – et peut donc contenir 16 384 instructions. Elle n’est écrite que lors du téléversement, par le bootloader ou par un programmateur ; le croquis ne peut que la lire.
La SRAM (mémoire vive statique) contient les variables et la pile. Elle est rapide et réinscriptible à volonté, mais son contenu disparaît à chaque coupure d’alimentation. Au démarrage, les valeurs initiales des variables globales sont recopiées depuis la Flash.
L’EEPROM conserve de petites données hors tension : un réglage, un étalonnage, un compteur d’utilisations. Elle n’est pas reliée directement au bus du processeur : on y accède par trois registres (EEAR pour l’adresse, EEDR pour la donnée, EECR pour la commande), ou plus simplement avec la bibliothèque EEPROM.h. L’écriture est lente et le nombre d’écritures limité : on n’écrit en EEPROM que lorsqu’une valeur a réellement changé.
#include <EEPROM.h>
const int ADR_SEUIL = 0; // adresse de l’octet en EEPROM
byte seuil;
void setup() {
seuil = EEPROM.read(ADR_SEUIL); // relu à chaque démarrage
}
void sauverSeuil(byte s) {
EEPROM.update(ADR_SEUIL, s); // n’écrit que si la valeur change
}
2.3.2Où vont les chaînes de caractères ?
Une chaîne écrite entre guillemets dans un croquis, par exemple Serial.println("Démarrage de la station");, est une constante : elle est stockée en Flash avec le programme. Mais les fonctions C attendent une adresse en SRAM. Le compilateur réserve donc de la place en SRAM et le code de démarrage y recopie toutes les chaînes. Chacune occupe ainsi deux fois de la place, dont une dans la mémoire la plus rare. Dans l’exemple de la figure 2.5, trois messages coûtent 90 octets de SRAM.
La macro F() évite cette copie : Serial.println(F("Démarrage de la station")); laisse la chaîne en Flash et indique à println() qu’elle doit la lire avec l’instruction lpm. Le message de compilation de l’IDE permet de vérifier le gain : la ligne « Les variables globales utilisent … octets de mémoire dynamique » diminue.
À retenir
Entourez de F() tous les textes constants passés à Serial.print(), lcd.print() et aux fonctions semblables. Pour un grand tableau de constantes, utilisez PROGMEM et pgm_read_byte().
2.3.3La mémoire programme en détail
Figure 2.6interactif – Carte de la mémoire Flash de l’ATmega328P : cliquez sur une zone, ou suivez pas à pas le démarrage de la carte Uno.
Les 32 Ko de Flash forment 16 384 mots de 16 bits, d’adresse 0x0000 à 0x3FFF (0x0000 à 0x7FFF si l’on compte en octets). Le compilateur et l’éditeur de liens y rangent les éléments dans un ordre précis (figure 2.6) :
le vecteur RESET, en 0x0000 : la toute première instruction lue après un reset, un saut vers le code d’initialisation ;
les vecteurs d’interruption, de 0x0002 à 0x0033 : une instruction jmp par source d’interruption, dans un ordre fixé par le matériel. Une instruction jmp occupe deux mots, d’où les adresses paires : INT0 en 0x0002, INT1 en 0x0004, TIMER0_OVF (utilisé par millis()) en 0x0020. Un vecteur non utilisé saute vers une routine par défaut qui redémarre le programme ;
les constantes déclarées PROGMEM et les chaînes F("…"), lues par lpm et jamais copiées en SRAM ;
le code d’initialisation du C, ajouté par le compilateur, puis le programme lui-même : votre croquis, le cœur Arduino (digitalWrite, millis…) et les bibliothèques utilisées ;
les valeurs initiales des variables globales (section .data), recopiées en SRAM au démarrage ;
un espace libre, puis, tout en haut, le bootloader Optiboot : 512 octets de 0x3F00 à 0x3FFF (0x7E00 à 0x7FFF en octets).
Le bootloader explique le maximum annoncé par l’IDE : « Le maximum est de 32256 octets », soit 32 768 − 512. Il est écrit une fois pour toutes par un programmateur ISP, et un fusible de configuration (BOOTRST) fait démarrer le processeur à son adresse plutôt qu’en 0x0000.
2.3.4L’espace des données
Figure 2.7interactif – L’espace des données de l’ATmega328P : cliquez sur une zone, puis simulez des appels de fonction et une allocation dynamique.
Côté données, une seule plage d’adresses, de 0x0000 à 0x08FF, regroupe des éléments de nature différente (figure 2.7) :
Les registres d’E/S « classiques » ont deux adresses : une adresse d’E/S, de 0x00 à 0x3F, utilisée par les instructions rapides, et une adresse mémoire décalée de 0x20. Ainsi PORTB vaut 0x05 dans l’espace d’E/S et 0x25 dans l’espace des données. Cette double adresse explique pourquoi certaines opérations sur les registres sont plus rapides que d’autres (section 2.5).
La SRAM elle-même est partagée entre quatre zones :
.data : les variables globales qui ont une valeur initiale (int seuil = 500;), recopiées depuis la Flash au démarrage ;
.bss : les variables globales sans valeur initiale, mises à zéro au démarrage ;
le tas (heap), qui croît vers les adresses hautes : la mémoire allouée pendant l’exécution par malloc(), new ou les objets String ;
la pile (stack), qui part de la dernière adresse, RAMEND = 0x08FF, et croît vers les adresses basses : adresses de retour des fonctions, variables locales, registres sauvegardés. Le registre SP (stack pointer) indique son sommet.
Définition – Pile
Zone de mémoire gérée en « dernier entré, premier sorti ». À chaque appel de fonction, l’adresse de retour et les variables locales y sont empilées ; elles sont dépilées au retour. Le pointeur de pile SP indique le sommet.
Définition – Tas
Zone de la SRAM où sont rangées les données créées pendant l’exécution du programme, et non à la compilation : mémoire réservée par malloc() ou new, contenu des objets String. Elle est rendue avec free() ou delete, ou quand l’objet disparaît. En anglais : heap.
Attention – Collision entre le tas et la pile
Le tas grandit vers les adresses hautes à chaque nouvelle allocation, tandis que la pile grandit vers les adresses basses à chaque appel de fonction. Les deux zones avancent donc l’une vers l’autre dans la même SRAM, et rien ne les arrête si la mémoire vient à manquer. Quand elles se chevauchent, l’une écrase les données de l’autre : le croquis se comporte de façon incohérente ou redémarre, sans aucun message d’erreur.
Sur les 2 Ko de la Uno, on évite donc l’allocation dynamique (String, malloc) : en plus de consommer de la mémoire, chaque libération laisse un trou dans le tas, trop petit pour être réutilisé, et la mémoire libre se morcelle au fil de l’exécution. On parle de fragmentation.
Il est possible d’estimer la mémoire libre en mesurant l’écart entre le sommet de la pile et la fin du tas :
int memoireLibre() {
extern int __heap_start, *__brkval;
int v; // variable locale : sur la pile
return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}
Exercices
1. Un croquis affiche vingt messages de 30 caractères avec Serial.println("…"). Combien d’octets de SRAM ces messages occupent-ils ? Que gagne-t-on avec F() ?
Chaque chaîne occupe ses 30 caractères plus le zéro final, soit 31 octets ; vingt chaînes occupent 620 octets, près d’un tiers des 2 Ko de SRAM. Avec F(), elles restent en Flash : les 620 octets de SRAM sont libérés.
2. Un compteur d’utilisations est incrémenté et sauvegardé en EEPROM à chaque mise sous tension. Combien d’années tiendra la case si l’appareil est allumé dix fois par jour ?
100 000 écritures / 10 par jour = 10 000 jours, soit plus de 27 ans. En revanche, une sauvegarde dans loop() toutes les 10 ms épuiserait la case en 1 000 s, moins de 17 minutes.
3. À quelle adresse de l’espace des données se trouve le registre DDRB, dont l’adresse d’E/S est 0x04 ?
On ajoute le décalage de 0x20 : DDRB est en 0x24 dans l’espace des données.
Entre la mise sous tension et l’exécution de la première ligne de setup(), le microcontrôleur exécute plusieurs milliers d’instructions que l’on n’a pas écrites. Les connaître explique l’état dans lequel on trouve les registres et la mémoire au début du croquis.
Figure 2.8interactif – Les étapes qui mènent du reset à loop() : avancez étape par étape.
2.4.1Les sources de reset
Un reset peut avoir quatre origines : la mise sous tension, l’appui sur le bouton Reset (ou le reset automatique de l’USB), le chien de garde (chapitre 10) et la détection d’une baisse de tension (brown-out). Dans tous les cas, les registres d’E/S reprennent leur valeur initiale, presque toujours 0 : toutes les broches sont des entrées, les périphériques sont arrêtés et les interruptions interdites.
2.4.2La séquence de démarrage
Bootloader. Sur la Uno, le fusible BOOTRST fait démarrer le processeur dans le bootloader. Après un reset par le bouton ou par l’ouverture du port série, celui-ci attend brièvement un nouveau croquis ; si rien n’arrive, il saute en 0x0000.
Vecteur RESET. L’instruction en 0x0000 est un saut vers le code d’initialisation du C.
Initialisation du C. Le registre r1 est mis à 0 (le compilateur suppose qu’il vaut toujours zéro), SREG est effacé et le pointeur de pile reçoit RAMEND = 0x08FF : la pile est prête.
Variables globales. Les valeurs initiales (.data) sont copiées de la Flash vers la SRAM, la section .bss est mise à 0, puis les objets C++ globaux sont construits – c’est à ce moment qu’est créé l’objet Serial.
init(). Le cœur Arduino configure le Timer0 pour millis(), les autres timers pour la PWM et le convertisseur analogique-numérique, puis autorise les interruptions avec sei(). L’annexe 4 détaille tous les registres modifiés.
setup(), puis une boucle infinie qui appelle loop() et, si vous l’avez écrite, serialEvent().
La fonction main() du cœur Arduino, simplifiée, montre bien les deux dernières étapes :
int main(void) {
init(); // timers, PWM, ADC, sei()
setup();
for (;;) {
loop();
if (serialEventRun) serialEventRun();
}
return 0; // jamais atteint
}
À retenir
Reset → bootloader → vecteur RESET (0x0000) → initialisation du C (pile, .data, .bss) → init() → setup() → loop() sans fin. Quand setup() commence, les timers et les interruptions sont déjà actifs : c’est pourquoi millis() fonctionne dès la première ligne.
Exercices
1. Une variable globale déclarée int n; vaut-elle une valeur aléatoire au début de setup() ?
Non : elle est placée dans la section .bss, mise à zéro par le code de démarrage. Elle vaut 0. Une variable locale non initialisée, elle, prend la valeur qui se trouvait sur la pile : celle-là est imprévisible.
2. Pourquoi ne faut-il pas reconfigurer le Timer0 dans un croquis qui utilise delay() ?
init() configure le Timer0 et son interruption de débordement pour compter le temps ; millis(), micros() et delay() en dépendent. Modifier ses registres fausse toutes les temporisations (chapitre 7).
Le processeur n’exécute pas du C mais des instructions machine, que l’on écrit lisiblement en assembleur. Sans devenir un programmeur assembleur, savoir lire ce code permet de mesurer le coût réel d’une ligne de C et de comprendre pourquoi les accès directs aux registres sont si rapides.
Chapitre 2 · Section 2.5
Le jeu d’instructions et le compilateur
L’AVR est un processeur RISC : environ 130 instructions simples, presque toutes codées sur 16 bits et exécutées en un ou deux cycles. Toute ligne de C est traduite par le compilateur en une suite de ces instructions.
Figure 2.9 – Les principales instructions de l’AVR, regroupées par catégorie, avec leur durée en cycles sur ATmega328P.
2.5.1Lire une instruction
Une instruction assembleur se compose d’un mnémonique – un mot court qui désigne l’opération – suivi de ses opérandes. Par convention, Rd désigne le registre de destination, Rr le registre source, K une constante sur 8 bits, A une adresse d’E/S, k une étiquette ou une adresse et b un numéro de bit. Ainsi add r24, r18 range dans r24 la somme de r24 et r18, et sbi 0x05, 5 met à 1 le bit 5 du registre d’E/S d’adresse 0x05.
2.5.2Cinq familles d’instructions
La figure 2.9 regroupe les instructions en cinq familles :
Transfert : charger une constante (ldi, seulement dans r16 à r31), copier un registre (mov), lire ou écrire la SRAM (lds, sts, ld, st), un registre d’E/S (in, out) ou une constante en Flash (lpm), empiler et dépiler (push, pop) ;
Calcul : addition, soustraction, incrémentation, opérations logiques ET, OU, OU exclusif, comparaison (cp, cpi), multiplication 8 × 8 bits dont le résultat est rangé dans r1:r0 ;
Bits : mettre à 1 ou à 0 un bit d’E/S (sbi, cbi), sauter l’instruction suivante selon l’état d’un bit (sbis, sbic, sbrs, sbrc), décalages et rotations ;
Sauts : sauts relatifs et absolus (rjmp, jmp), appels et retours de fonction (rcall, call, ret), retour d’interruption (reti) et sauts conditionnels qui testent les indicateurs de SREG (breq, brne, brcs…) ;
Contrôle : nop (ne rien faire pendant un cycle), sei et cli (autoriser ou interdire les interruptions), sleep (veille) et wdr (réarmer le chien de garde).
Définition – Registre d’état SREG
Registre de 8 bits qui conserve des indicateurs sur le dernier résultat calculé : Z (résultat nul), C (retenue), N (résultat négatif), V (dépassement)… Le bit I autorise globalement les interruptions. Les sauts conditionnels décident d’après ces indicateurs.
2.5.3Du C à l’assembleur
Figure 2.10interactif – Quelques lignes de C et les instructions produites par le compilateur : cliquez sur une ligne pour voir sa traduction et sa durée.
La figure 2.10 montre la traduction de lignes de C typiques. Les écarts de coût sont considérables :
Ligne de C
Instructions
Cycles
Durée à 16 MHz
PORTB |= (1 << PB5);
1 (sbi)
2
125 ns
PINB = (1 << PB5);
2 (ldi, out)
2
125 ns
compteur++; (byte)
3
5
312,5 ns
int s = a + b;
8
14
875 ns
ADCSRA |= (1 << ADSC);
3
5
312,5 ns
digitalWrite(13, HIGH);
3 + la fonction
≈ 50 et plus
quelques µs
Plusieurs règles s’en dégagent :
les calculs ne se font qu’entre registres : pour incrémenter une variable, il faut la charger (lds), calculer, puis la ranger (sts) ;
un int coûte deux fois plus qu’un byte : un processeur 8 bits traite les 16 bits en deux morceaux, avec add pour les octets de poids faible puis adc, qui ajoute la retenue, pour les octets de poids fort. On préfère byte (ou uint8_t) quand la valeur tient sur 8 bits ;
les registres d’E/S des adresses 0x00 à 0x1F se modifient bit à bit en une seule instruction sbi ou cbi. Au-delà (ADCSRA, registres des timers…), il faut lire, modifier et réécrire ;
les fonctions Arduino ont un coût : digitalWrite() cherche le port et le bit dans des tables en Flash, désactive la PWM éventuelle et protège l’écriture des interruptions. C’est sûr et portable, mais une vingtaine de fois plus lent que l’accès direct au registre.
Exercices
1. Combien de temps dure l’instruction sbi à 16 MHz ? Quelle fréquence maximale obtiendrait-on en alternant sbi et cbi dans une boucle sans fin, sachant que le saut rjmp dure 2 cycles ?
sbi dure 2 cycles, soit 125 ns. Une période complète comprend sbi (2) + cbi (2) + rjmp (2) = 6 cycles, soit 375 ns : la fréquence est d’environ 2,67 MHz, avec un état haut de 2 cycles et un état bas de 4 cycles.
2. Pourquoi ADCSRA |= (1 << ADSC); n’est-il pas traduit par une instruction sbi ?
ADCSRA est en 0x7A, parmi les registres d’E/S étendus : il n’a pas d’adresse d’E/S et n’est accessible que par lds et sts. De plus, sbi ne fonctionne que sur les adresses d’E/S 0 à 31. Il faut donc lire le registre, faire un OU avec 0x40, puis le réécrire.
3. Quelle instruction utilise le compilateur pour additionner les octets de poids fort de deux int, et pourquoi pas add ?
adc (add with carry) : elle ajoute en plus la retenue C produite par l’addition des octets de poids faible. Avec add, la retenue serait perdue et le résultat faux dès que la somme des octets faibles dépasse 255.
Écrire un petit programme complet en assembleur est le meilleur moyen de comprendre comment le processeur enchaîne les instructions, utilise la pile et prend ses décisions. On reprend ici l’exemple le plus simple : faire clignoter la LED de la carte.
Figure 2.11interactif – Structure d’un programme en assembleur : directives, initialisation, boucle principale et sous-programme d’attente.
2.6.1Structure d’un programme
Une ligne d’assembleur comprend, dans l’ordre, une étiquette facultative suivie de deux-points, qui donne un nom à une adresse, un mnémonique, des opérandes et un commentaire introduit par un point-virgule. Les directives, qui commencent par un point, ne produisent pas d’instruction : elles s’adressent à l’assembleur.
; Clignotement de la LED D13 (PB5), ATmega328P à 16 MHz
.equ DDRB, 0x04 ; adresses dans l’espace d’E/S
.equ PINB, 0x03
.global main
main:
sbi DDRB, 5 ; PB5 en sortie
boucle:
sbi PINB, 5 ; écrire 1 dans PINB inverse PB5
rcall attente ; environ 0,5 s
rjmp boucle ; et on recommence
attente:
ldi r18, 40 ; 40 × 256 × 256 tours
a1: ldi r19, 0 ; 0 donne 256 tours
a2: ldi r20, 0
a3: dec r20 ; 1 cycle
brne a3 ; 2 cycles si le saut a lieu
dec r19
brne a2
dec r18
brne a1
ret
Le programme se lit en quatre blocs (figure 2.11). Les directives.equ donnent un nom aux adresses d’E/S de DDRB et PINB, et .global main rend l’étiquette main visible pour l’éditeur de liens. L’initialisation se réduit à une instruction : sbi met à 1 le bit 5 de DDRB, ce qui fait de PB5 une sortie – c’est le pinMode(13, OUTPUT) d’Arduino. La boucle principale inverse la sortie (écrire 1 dans un bit de PINB inverse le bit correspondant de PORTB), appelle le sous-programme d’attente avec rcall, qui empile l’adresse de retour, puis revient au début avec rjmp : c’est la fonction loop().
2.6.2Exécuter pas à pas
Figure 2.12interactif – Simulateur : exécutez un programme instruction par instruction et observez les registres, l’indicateur Z et la LED.
Le simulateur de la figure 2.12 exécute un second programme qui inverse six fois la LED, puis s’arrête :
ldi r16, 0x20 ; masque de PB5 (0b00100000)
out DDRB, r16 ; PB5 en sortie
ldi r17, 6 ; 6 inversions
boucle: out PINB, r16 ; inverse PB5
dec r17 ; r17 − 1, met Z à jour
brne boucle ; si Z = 0 : reboucle
fin: rjmp fin ; boucle sans fin
On y observe le rôle de l’indicateur Z du registre SREG : dec le met à 1 lorsque r17 atteint zéro, et brne (branch if not equal) ne saute que si Z vaut 0. La dernière instruction saute sur elle-même : un microcontrôleur ne s’arrête jamais, on le laisse tourner sur place – le croquis Arduino fait de même avec loop().
2.6.3De l’assembleur dans un croquis
Figure 2.13 – Trois façons d’utiliser l’assembleur dans un croquis Arduino, et les règles d’utilisation des registres par avr-gcc.
Il est rare d’écrire un programme entier en assembleur, mais l’IDE Arduino permet d’en insérer là où le contrôle du temps est critique (figure 2.13).
Une instruction dans le C, avec asm volatile. Le mot volatile empêche le compilateur de supprimer ou de déplacer l’instruction. L’exemple suivant produit une impulsion d’exactement trois cycles sur D13 :
Avec des opérandes, le compilateur remplace %0, %1… par les valeurs fournies : asm volatile ("sbi %0, %1" :: "I" (_SFR_IO_ADDR(PORTB)), "I" (PB5));
Une fonction dans un fichier .S placé dans le dossier du croquis. Le fichier est assemblé avec le reste ; côté C, on déclare la fonction avec extern "C" :
Lire l’assembleur produit. Le menu Croquis › Exporter les binaires compilés crée un dossier build contenant le fichier .elf. La commande avr-objdump -d -S croquis.ino.elf affiche alors le C et l’assembleur mêlés : c’est la meilleure façon de vérifier ce que coûte une ligne de code.
Attention – Règles d’avr-gcc
Une fonction en assembleur appelée depuis le C doit respecter les conventions du compilateur : les arguments arrivent dans r24, r22, r20…, la valeur de retour est rendue dans r24 (r25:r24 pour 16 bits). Les registres r18 à r27, r30 et r31 sont utilisables librement ; r2 à r17, r28 et r29 doivent être sauvegardés (push/pop) si on les modifie ; r1 doit valoir 0 au retour.
Exercices
1. Modifiez le sous-programme d’attente pour obtenir environ 1 s.
Il faut d’abord la durée d’un tour de la boucle extérieure a1. En partant de 0, dec donne 255 : une boucle initialisée à 0 fait donc 256 tours. dec dure 1 cycle, brne 2 cycles quand le saut a lieu et 1 cycle à la sortie. On compte de l’intérieur vers l’extérieur : boucle a3 : 256 × 3 − 1 = 767 cycles ; boucle a2 : 256 × (767 + 4) − 1 = 197 375 cycles ; un tour de a1 dure donc environ 197 379 cycles (avec la version d’origine, 40 tours donnent ≈ 7,9 millions de cycles, soit 0,49 s).
Une durée d’environ 1 s correspond à 16 millions de cycles : il faut 16·106 / 197 379 ≈ 81 tours. On remplace donc ldi r18, 40 par ldi r18, 81, ce qui donne 81 × 197 379 − 1 ≈ 15,99 millions de cycles, soit 0,999 s.
2. Dans le programme de la figure 2.12, combien de cycles s’écoulent entre la première instruction et l’arrivée sur fin ?
Trois instructions d’initialisation à 1 cycle (3 cycles), puis six tours de boucle : cinq tours où brne saute (1 + 1 + 2 = 4 cycles) et un dernier tour où il ne saute pas (1 + 1 + 1 = 3 cycles). Total : 3 + 5 × 4 + 3 = 26 cycles, soit 1,625 µs à 16 MHz.
3. Une fonction en assembleur utilise r16 et r20. Lesquels faut-il sauvegarder ?
r20 fait partie des registres librement utilisables (r18 à r27). r16 appartient à r2–r17, que le compilateur suppose préservés : il faut l’empiler en début de fonction (push r16) et le restaurer avant ret (pop r16).
Une synthèse des notions essentielles, un questionnaire pour vérifier ses connaissances et les sources qui permettent d’aller plus loin.
Chapitre 2 · Section 2.7
À retenir et QCM
Le tableau suivant résume les notions du chapitre. Le questionnaire de la figure 2.14 permet ensuite de vérifier qu’elles sont acquises.
Élément
À retenir
Microcontrôleur
Cœur + Flash + SRAM + EEPROM + périphériques dans un boîtier. Uno = ATmega328P + résonateur 16 MHz + ATmega16U2 (USB) + bootloader.
Harvard
Bus programme (Flash, mots de 16 bits) et bus données (SRAM, octets) séparés : l’instruction suivante est lue pendant l’accès aux données, presque une instruction par cycle.
Espace des données
r0–r31 en 0x00–0x1F, E/S en 0x20–0x5F (in, out, sbi, cbi), E/S étendues en 0x60–0xFF (lds, sts), SRAM en 0x0100–0x08FF.
Démarrage
Reset → bootloader → vecteur RESET (0x0000) → initialisation du C (pile, .data, .bss) → init() → setup() → loop() sans fin.
Assembleur
Les calculs se font entre registres : charger (lds), calculer (add), ranger (sts). Les sauts conditionnels testent les indicateurs de SREG (Z, C…).
F() pour les textes : Sans F(), chaque chaîne est recopiée de la Flash vers la SRAM au démarrage.
byte plutôt que int : Un int demande deux registres et deux fois plus d’instructions.
Registres directs : PORTB |= … devient une seule instruction sbi.
Surveiller la SRAM : Pile et tas partagent 2 Ko : une collision ne prévient pas.
2.7.1Se tester
Le QCM comporte dix-neuf questions. Choisissez une réponse à la souris ou avec les touches 1 à 4, puis validez avec Entrée ; une explication s’affiche après chaque réponse. En fin de questionnaire, la liste des questions manquées indique les notions à revoir.
Figure 2.14interactif – QCM d’évaluation du chapitre 2.
La fiche technique du microcontrôleur et le manuel du jeu d’instructions font foi pour tout ce qui concerne le matériel ; le code source du cœur Arduino et la documentation d’avr-gcc montrent ce que fait réellement un croquis.
Fiches techniques
Microchip, ATmega328P Datasheet : chapitres « AVR CPU Core », « AVR Memories », « Interrupts » et « Instruction Set Summary ».microchip.com/en-us/product/ATmega328P
Microchip, AVR Instruction Set Manual (DS40002198) : description, codage et durée de chaque instruction.disponible depuis la page du produit, onglet Documentation