Avant de commencer : la carte et l'IDE

Jusqu'ici, un programme lisait des données et affichait des résultats : tout se passait à l'écran. Une carte Arduino change la nature de l'exercice. Le programme allume une LED, lit un bouton, mesure une tension : il agit sur le monde physique, et le monde physique lui répond. Ce chapitre pose le décor, explique ce que fait un programme qui ne s'arrête jamais, et fait clignoter une première LED, en simulation, sans aucun matériel.

Un ordinateur réduit à l'essentiel

Définition

Un microcontrôleur réunit sur une seule puce un processeur, de la mémoire et des broches d'entrée et de sortie. Il n'a ni écran, ni clavier, ni système d'exploitation : il exécute un seul programme, qui démarre à la mise sous tension.

La carte Arduino Uno est construite autour du microcontrôleur ATmega328P. Ses chiffres sont modestes, et il faut les avoir en tête dès maintenant : 32 Ko de mémoire pour le programme, dont 0,5 Ko pris par le chargeur d'amorçage, 2 Ko de mémoire vive pour les variables, un processeur cadencé à 16 MHz. Un tableau de mille int occupe à lui seul 2 000 des 2 048 octets de cette mémoire vive : il ne laisse presque rien au reste du programme.

Broches	Nombre	Rôle
Numériques `0` à `13`	14	lire ou écrire un état, haut ou bas
Dont PWM, marquées `~`	6	`3`, `5`, `6`, `9`, `10`, `11` : simuler une tension intermédiaire
Analogiques `A0` à `A5`	6	mesurer une tension entre 0 et 5 V
Alimentation		`5V`, `3.3V`, `GND` (la masse, le 0 V de référence)

Les broches 0 et 1 sont déjà prises

Elles portent la liaison série avec l'ordinateur, celle qui sert à téléverser le programme et à afficher des messages. Y brancher un composant perturbe l'une et l'autre. Les montages de ce parcours commencent donc à la broche 2.

Trois mémoires, trois usages

Les 32 Ko et les 2 Ko ne sont pas la même sorte de mémoire, et la différence explique un comportement qui surprend les débutants : un programme téléversé reste sur la carte après qu'on l'a débranchée, mais les valeurs des variables, elles, sont perdues.

Mémoire	Taille sur l'Uno	Ce qu'elle contient	Après une coupure de courant
Flash	32 Ko	le programme compilé	conservée
SRAM (mémoire vive)	2 Ko	les variables, pendant l'exécution	perdue
EEPROM	1 Ko	quelques réglages que le programme choisit d'y écrire	conservée

La mémoire vive est la plus petite des trois, et c'est pourtant celle qu'on remplit en premier : chaque variable, chaque tableau, chaque texte affiché y prend sa place. Les chapitres suivants comptent donc les octets, ce qu'un programme pour ordinateur ne fait presque jamais.

Du programme à la carte

Le programme ne s'exécute pas sur l'ordinateur. Il y est seulement écrit, puis voyage jusqu'à la carte en quatre étapes.

Écrire le programme dans l'environnement de développement (l'IDE Arduino, ou le mode texte de Tinkercad). Le fichier porte l'extension .ino.
Compiler : le compilateur traduit le texte en instructions machine de l'ATmega328P. C'est là que les fautes de syntaxe sont signalées, avant que rien ne parte vers la carte.
Téléverser : le programme compilé passe par le câble USB. Un petit programme résident de la carte, le chargeur d'amorçage (bootloader), le reçoit et l'écrit dans la mémoire flash.
Exécuter : la carte redémarre, exécute setup() une fois, puis loop() sans fin. L'ordinateur n'a plus aucun rôle, sauf s'il écoute la liaison série.

Compiler n'est pas vérifier. Un programme qui compile est un programme écrit correctement, pas un programme juste. Le compilateur refuse un point-virgule manquant ; il accepte sans broncher un delay de 49 jours ou une LED pilotée sur la mauvaise broche. Ce qui reste à vérifier se vérifie en simulation, puis sur la carte.

`setup()` et `loop()`

Un programme Arduino ne contient pas de point de départ unique qui s'exécuterait puis rendrait la main. Il contient obligatoirement deux fonctions.

Définition

setup() s'exécute une seule fois, au démarrage : c'est là qu'on configure les broches et qu'on ouvre la liaison série.

loop() s'exécute ensuite indéfiniment : dès qu'elle se termine, la carte la relance depuis sa première ligne.

Organigramme

Le cycle de vie d'un programme Arduino. Il n'y a pas de sortie : un microcontrôleur n'a personne à qui rendre la main. Couper l'alimentation est la seule façon d'arrêter le programme.

Cette boucle perpétuelle n'est pas une curiosité. Un thermostat, une alarme, un feu de circulation ne s'arrêtent jamais : ils observent, décident, agissent, et recommencent. loop() est la forme exacte de ce travail.

Le clignotement placé dans setup()

Un programme qui allume puis éteint la LED dans setup(), en laissant loop() vide, ne produit qu'un seul éclair au démarrage. Le code n'est pas faux, il est au mauvais endroit : ce qui doit se répéter va dans loop().

Vérification rapideon peut se reprendre

1.Que fait la carte quand la fonction loop() se termine ?

2.La carte est débranchée puis rebranchée. Qu'est-ce qui a survécu ?

Le parcours d'électricité, en appui

Une carte Arduino est un circuit électrique avant d'être un programme. Chaque fois que ce parcours emploie une loi, tension, courant, résistance, pont diviseur, il renvoie au chapitre du parcours d'électricité qui l'établit. Rien n'oblige à les avoir lus : les calculs utiles sont refaits ici. Mais c'est là que se trouve le pourquoi, et il sert dès qu'un montage se comporte autrement que prévu.

Premier montage : une LED

Une LED ne se branche pas n'importe comment. Elle a un sens : le courant entre par l'anode, la patte la plus longue, et ressort par la cathode, la plus courte, du côté du méplat du boîtier. Branchée à l'envers, elle reste éteinte, sans dommage.

Elle a surtout besoin d'une résistance en série. Une LED rouge fait chuter la tension d'environ 2 V ; sur une broche à 5 V, les 3 V restants tombent dans la résistance. Ce partage, 5 V = 2 V + 3 V, est la loi des mailles : le long d'une boucle, les tensions s'additionnent jusqu'à celle de la source. Et c'est la résistance qui fixe le courant, par la loi d'Ohm :

I = \frac{U_{\text{broche}} - U_{\text{LED}}}{R} = \frac{5 - 2}{R}

Le calcul de la résistance

Avec 220 Ω : $I = \dfrac{3}{220} \approx 0{,}0136$ A, soit $13{,}6$ mA. Avec 330 Ω : $I \approx 9{,}1$ mA.

Une broche de l'Uno supporte 20 mA en fonctionnement normal, et 40 mA au maximum absolu. Sans résistance, rien ne limite le courant sauf la broche elle-même, qui finit détruite avec la LED.

Vérification rapideon peut se reprendre

1.Pourquoi une LED se branche-t-elle toujours avec une résistance ?

2.Une LED est branchée à l'envers, cathode vers la broche. Que se passe-t-il ?

La figure montre le même circuit sous ses deux formes : le schéma, qui dit ce qui est relié à quoi, et la plaque d'essai, qui dit où enfoncer les pattes. Le passage de l'un à l'autre est la première difficulté pratique du parcours.

résistance220 Ω

LED

fonctionnement normal. Courant : 13,6 mA, pour 20 mA recommandés et 40 mA au maximum absolu.

Le premier montage. En haut le schéma : broche 3, résistance, LED, masse. En bas le même circuit sur la plaque d'essai, où chaque colonne de cinq trous forme une seule connexion.

À manipuler

Descendre la résistance jusqu'à 100 Ω, puis jusqu'à « aucune », et lire à chaque fois le courant et le verdict. Remonter ensuite jusqu'à 10 kΩ : la LED ne brille presque plus. Revenir à 220 Ω et retourner la LED : elle s'éteint, sans que rien ne soit abîmé. Essayer enfin une LED bleue, dont la chute de tension est plus forte : à résistance égale, le courant baisse.

Lire la plaque d'essai

Une plaque d'essai (breadboard) permet de câbler sans souder. Sous chaque colonne de cinq trous, notés a à e, une lamelle métallique relie les cinq trous entre eux. Deux pattes enfoncées dans la même colonne sont donc reliées, et deux pattes dans deux colonnes différentes ne le sont pas. De l'autre côté de la tranchée qui coupe la plaque en son milieu, les trous f à j forment un second groupe de cinq, relié de la même façon mais séparé du premier : a à e et f à j d'une même colonne ne sont pas reliés.

Sur la figure, la résistance a une patte dans la colonne du fil qui vient de la broche 3, et l'autre dans la colonne de l'anode de la LED. La cathode, dans une troisième colonne, rejoint le rail de masse, la ligne horizontale qui court le long de la plaque et que l'on relie une fois pour toutes à GND.

Les deux pattes dans la même colonne

Une résistance ou une LED enfoncée avec ses deux pattes dans la même colonne est court-circuitée : la lamelle relie ses deux bornes, et le courant passe à côté du composant. Le montage « ne fait rien », alors qu'aucun fil n'est débranché. Un composant enjambe toujours deux colonnes.

Vérification rapideon peut se reprendre

Sur une plaque d'essai, une résistance a ses deux pattes dans la même colonne. Que se passe-t-il ?

Lire la valeur d'une résistance

Une résistance n'est pas imprimée en chiffres : sa valeur est codée par des anneaux de couleur. Les deux premiers donnent deux chiffres, le troisième le nombre de zéros à ajouter.

Couleur	noir	marron	rouge	orange	jaune	vert	bleu	violet	gris	blanc
Chiffre	0	1	2	3	4	5	6	7	8	9

220 Ω s'écrit donc 2, 2, puis un zéro : rouge, rouge, marron. 10 kΩ, soit 10 000 Ω, s'écrit 1, 0, puis trois zéros : marron, noir, orange. La figure affiche les anneaux de la valeur choisie, et un quatrième anneau, doré ou argenté, indique la tolérance : il se place à droite, ce qui donne le sens de lecture.

Le programme

Le montage, dans l'ordre de la figure : broche 3, résistance de 220 Ω, anode de la LED ; cathode vers GND. Dans un circuit en série, le courant est le même partout : la résistance peut donc se placer d'un côté ou de l'autre de la LED. Puis le programme.

Arduino

void setup() {

pinMode(3, OUTPUT); // la broche 3 pilote la LED

}

void loop() {

digitalWrite(3, HIGH); // 5 V sur la broche : la LED s'allume

delay(1000); // attendre une seconde

digitalWrite(3, LOW); // 0 V : elle s'éteint

delay(1000);

}

pinMode déclare la broche en sortie. digitalWrite y impose 5 V (HIGH) ou 0 V (LOW). delay suspend le programme pendant le nombre de millisecondes indiqué. Ce que produit ce programme n'est pas une suite d'instructions, c'est un signal sur un fil.

1 s par bit1 bauds8 bits, 8 s en tout

Le signal produit par le programme, sur huit secondes. Chaque palier dure une seconde : c'est la valeur passée à delay. Une période complète, allumée puis éteinte, dure donc deux secondes.

L'ordre des lignes est l'ordre du signal

Chaque digitalWrite change le niveau du fil, et chaque delay fixe combien de temps ce niveau dure. Lire un programme de clignotement, c'est donc dessiner son chronogramme ligne par ligne : un changement de niveau, une durée, un changement, une durée. L'inverse est tout aussi mécanique, et c'est l'objet de la section suivante.

La broche 13 a un statut à part : elle est reliée à une LED soudée sur la carte, nommée LED_BUILTIN dans le langage, si bien qu'un programme qui pilote la broche 13 se teste sans aucun montage.

Simuler avant de câbler

Tinkercad est un simulateur en ligne, gratuit, qui propose une carte Uno virtuelle, une plaque d'essai et des composants. On y câble le montage à la souris, on écrit le programme en mode texte, et l'on démarre la simulation.

Ce que la simulation ne remplace pas

Elle valide la logique du programme et la cohérence du câblage. Elle ne reproduit pas tout ce qui existe sur une vraie carte : contacts qui rebondissent, tolérances des composants, parasites. Un montage qui fonctionne en simulation reste à essayer sur le matériel.

Plus simple encore, la plaque d'essai de la salle machine se passe de compte. On y pose des résistances, des LED, des boutons, un potentiomètre ou une photorésistance, on choisit le mode de chaque broche, et la plaque calcule les courants et les tensions : une LED sans résistance y grille, une entrée sans tirage y flotte. Les exercices « Monter sur la plaque » en sont la version guidée, avec un montage attendu.

Du chronogramme au programme

Un cardiofréquencemètre signale chaque battement par deux éclairs rapprochés, puis une pause. Le cahier des charges est donné sous forme de chronogramme, avec un pas de 100 ms :

100 ms par bit10 bauds20 bits, 2 s en tout

Le battement de cœur, sur deux secondes. Deux éclairs de 100 ms séparés de 100 ms, puis 700 ms d'extinction : une période dure une seconde, soit 60 battements par minute.

Traduire ce signal en programme, c'est le lire de gauche à droite en regroupant les paliers de même niveau : haut pendant 1 case, bas pendant 1 case, haut pendant 1 case, bas pendant 7 cases. Chaque palier devient un digitalWrite suivi d'un delay de sa durée.

Arduino

const int LED = 3;

void setup() {

pinMode(LED, OUTPUT);

}

void loop() {

digitalWrite(LED, HIGH);

delay(100); // premier éclair

digitalWrite(LED, LOW);

delay(100); // courte pause

digitalWrite(LED, HIGH);

delay(100); // second éclair

digitalWrite(LED, LOW);

delay(700); // longue pause : la période fait 100 + 100 + 100 + 700 = 1000 ms

}

Le contrôle se fait par la somme : les quatre delay totalisent 1 000 ms, exactement la période du chronogramme. Une somme différente signale un palier oublié ou mal mesuré, avant même toute simulation.

Le moniteur série

La carte n'a pas d'écran, mais elle peut envoyer du texte à l'ordinateur par la liaison série. Le moniteur série de l'environnement de développement, ou celui de Tinkercad, l'affiche.

Arduino

int compteur = 0;

void setup() {

Serial.begin(9600); // ouvrir la liaison à 9600 bauds

}

void loop() {

Serial.print("Secondes : "); // sans retour à la ligne

Serial.println(compteur); // avec retour à la ligne

compteur++;

delay(1000);

}

Le moniteur affiche Secondes : 0, puis Secondes : 1, une ligne par seconde. Le nombre passé à Serial.begin est le débit : 9600 bauds, soit environ 960 caractères par seconde, un caractère occupant dix bits sur la ligne. Le moniteur doit être réglé sur le même débit, sans quoi il affiche des caractères incohérents.

Le moniteur série, premier outil de mise au point

Afficher la valeur d'une variable à un moment choisi est la façon la plus directe de savoir ce que fait réellement le programme. Le chapitre sur le moniteur série en fait une méthode.

Vérification rapideon peut se reprendre

1.Le moniteur série affiche des caractères incohérents. Quelle est la cause la plus probable ?

2.Sur l'Uno, pourquoi éviter de brancher un composant sur les broches 0 et 1 ?

Quand le premier téléversement échoue

La première séance bute presque toujours sur l'une de ces causes, et aucune ne vient du programme.

Symptôme	Cause la plus fréquente	Que faire
L'IDE ne trouve pas la carte	aucun port sélectionné, ou câble USB de charge seule	choisir le port dans le menu Outils ; essayer un autre câble
« Programmer is not responding »	mauvaise carte choisie dans l'IDE	sélectionner « Arduino Uno » dans le menu Outils
Le téléversement échoue une fois sur deux	un composant branché sur les broches 0 ou 1	débrancher ce composant pendant le téléversement
Le programme est téléversé mais la LED ne s'allume pas	LED à l'envers, ou pattes dans la même colonne	vérifier le sens et les colonnes sur la plaque
Le moniteur affiche des signes illisibles	débit différent de `Serial.begin`	régler le moniteur sur 9600

Mettre en pratique

Courants, durées et débits

1.
Une LED verte fait chuter 2,2 V. Quelle résistance, en ohms, donne 14 mA sur une broche à 5 V ?
2.
Avec la valeur normalisée immédiatement supérieure, 220 Ω, quel courant traverse cette LED verte, en milliampères ?
3.
Un programme de clignotement contient delay(150) après l'allumage et delay(350) après l'extinction. Combien d'éclairs produit-il en une minute ?
4.
À 9600 bauds, un caractère occupe dix bits sur la ligne. Combien de millisecondes faut-il pour envoyer la ligne « Secondes : 0 » suivie de son retour à la ligne, soit 14 caractères ?

Le dernier nombre a une conséquence pratique : une ligne de moniteur série prend près de 15 ms sur le fil. Tant que le tampon d'émission de 64 octets n'est pas plein, Serial.print y range le texte et rend la main aussitôt ; au-delà, le programme attend que la ligne se vide. Un programme qui affiche dix lignes à chaque passage dans loop() passe plus de temps à écrire qu'à travailler.

Une LED reste allumée 200 ms puis éteinte 800 ms, en boucle. Combien d'éclairs produit-elle en une minute ?

Une période dure $200 + 800 = 1000$ ms, soit une seconde. En soixante secondes : 60 éclairs.

Arduino

void setup() {

pinMode(13, OUTPUT);

}

void loop() {

digitalWrite(13, HIGH);

delay(200);

digitalWrite(13, LOW);

delay(800);

}

Le rapport entre durée allumée et durée totale vaut ici 20 %. C'est une notion qui reviendra au chapitre sur les sorties PWM, sous le nom de rapport cyclique.

Le programme de clignotement a été écrit entièrement dans setup(), et loop() est vide. Qu'observe-t-on ?

Un seul éclair, au démarrage, puis plus rien. setup() ne s'exécute qu'une fois ; loop() tourne bien indéfiniment, mais ne contient rien.

Pour que le clignotement se répète, les instructions d'allumage, d'extinction et d'attente doivent être déplacées dans loop(). Seul pinMode, qui n'a besoin d'être fait qu'une fois, reste dans setup().

Une LED rouge, qui fait chuter 2 V, doit être parcourue par environ 10 mA sur une broche à 5 V. Quelle résistance choisir ?

La résistance doit absorber $5 - 2 = 3$ V sous 10 mA : $R = \dfrac{3}{0{,}010} = 300$ Ω.

Les résistances ne se vendent qu'en valeurs normalisées. On prend la valeur immédiatement supérieure, 330 Ω (orange, orange, marron), qui donne $\dfrac{3}{330} \approx 9{,}1$ mA : un peu moins de courant, et donc un peu moins de lumière, mais jamais trop. Prendre la valeur inférieure ferait dépasser le courant visé.

Écrire le programme du chronogramme suivant, au pas de 250 ms : 1 1 0 1 0 0 0 0.

On regroupe les paliers de même niveau : haut 2 cases (500 ms), bas 1 case (250 ms), haut 1 case (250 ms), bas 4 cases (1 000 ms).

Arduino

void setup() {

pinMode(3, OUTPUT);

}

void loop() {

digitalWrite(3, HIGH);

delay(500);

digitalWrite(3, LOW);

delay(250);

digitalWrite(3, HIGH);

delay(250);

digitalWrite(3, LOW);

delay(1000);

}

Contrôle : $500 + 250 + 250 + 1000 = 2000$ ms, soit les huit cases de 250 ms du chronogramme.

Une résistance porte les anneaux jaune, violet, marron. Convient-elle pour une LED rouge sur une broche à 5 V ?

Jaune = 4, violet = 7, marron = un zéro : 470 Ω. Le courant vaut $\dfrac{5 - 2}{470} \approx 6{,}4$ mA.

Elle convient : le courant reste bien sous les 20 mA, et la LED est encore nettement visible. Elle brillera un peu moins qu'avec 220 Ω, ce qui est souvent préférable pour un voyant qu'on regarde de près.

Un ordinateur réduit à l'essentiel

Trois mémoires, trois usages

Du programme à la carte

setup() et loop()

Premier montage : une LED

Lire la plaque d'essai

Lire la valeur d'une résistance

Le programme

Simuler avant de câbler

Du chronogramme au programme

Le moniteur série

Quand le premier téléversement échoue

Mettre en pratique

Dans la bibliothèque d'exercices

`setup()` et `loop()`

Premier montage : une LED