Chapitre 3Livre « Arduino sous le capot »

Entrées / sorties numériques et PWM

Configurer, commander et lire une broche, manipuler les bits d’un registre et produire un signal PWM

Allumer une LED, lire un bouton, commander un relais : la plupart des montages commencent par des entrées et des sorties numériques. Une broche ne connaît que deux états, 0 V et 5 V, mais bien les utiliser demande de comprendre ce qui se passe électriquement à l’intérieur du microcontrôleur.

Ce chapitre présente d’abord les fonctions Arduino pinMode(), digitalWrite() et digitalRead(), avec les précautions électriques indispensables : courant maximal, résistance de la LED, résistance de tirage des entrées, rebonds des boutons. Il descend ensuite au niveau des registres de l’ATmega, où l’on pilote huit broches d’un coup grâce aux masques binaires. Il se termine par les sorties PWM, qui donnent à une broche numérique une tension moyenne réglable.

Objectifs du chapitre

  • Configurer une broche en entrée ou en sortie et respecter ses limites électriques.
  • Calculer la résistance série d’une LED et choisir entre montage source et montage puits.
  • Lire un bouton de façon fiable : résistance de tirage, anti-rebond, détection de front.
  • Programmer les broches par les registres DDRx, PORTx et PINx à l’aide de masques.
  • Produire un signal PWM avec analogWrite() et en connaître les applications et les limites.

Prérequis

Le chapitre 1 (cartes, IDE, programme Blink) et, pour la partie sur les registres, la notion de registre d’E/S vue au chapitre 2.

Plan du chapitre

  1. Partie I – Broches et sorties
  2. 3.1Broches numériques et pinMode()
  3. 3.2Commander une sortie
  4. Partie II – Entrées numériques
  5. 3.3Lire une entrée
  6. 3.4Rebonds et détection d’un appui
  7. Partie III – Registres AVR
  8. 3.5Les ports et leurs registres
  9. 3.6Travailler avec des masques
  10. Partie IV – Sorties PWM
  11. 3.7La modulation de largeur d’impulsion
  12. Partie V – Évaluation et ressources
  13. 3.8À retenir et QCM
  14. 3.9Sources et références

Chapitre 3 · Partie I

Broches et sorties

Une broche numérique se configure, puis se commande. Avant d’écrire la moindre ligne, il faut connaître les niveaux de tension qu’elle produit et accepte, et le courant qu’elle peut fournir sans être détruite.

Chapitre 3 · Section 3.1

Broches numériques et pinMode()

La carte Uno offre quatorze entrées-sorties numériques, numérotées D0 à D13, auxquelles s’ajoutent les six broches analogiques A0 à A5, utilisables elles aussi en numérique. Chacune peut être une entrée ou une sortie, au choix du programme.

Les broches numériques de la Uno, les niveaux logiques en 5 V et les limites de courant.
Figure 3.1 – Les broches numériques de la Uno, les niveaux logiques en 5 V et les limites de courant.

3.1.1Les broches de la Uno

Les broches D0 à D13 sont repérées dans le programme par leur numéro (13), les broches A0 à A5 par leur nom (A0…) ou par les numéros 14 à 19. Certaines ont un rôle supplémentaire (figure 3.1) :

  • D0 et D1 sont reliées à la liaison série avec le PC, utilisée pour le téléversement et le moniteur série. On évite de s’en servir, sous peine de perturber l’une et l’autre ;
  • D13 commande aussi la LED « L » soudée sur la carte ;
  • ~3, ~5, ~6, ~9, ~10 et ~11, repérées par un tilde, peuvent produire un signal PWM (section 3.7).

3.1.2Les niveaux logiques

Une entrée numérique compare la tension qu’elle reçoit à deux seuils proportionnels à la tension d’alimentation Vcc. Sur une carte alimentée en 5 V :

  • au-dessus de 0,6 × Vcc = 3 V, la broche est lue à 1 (HIGH) ;
  • en dessous de 0,3 × Vcc = 1,5 V, elle est lue à 0 (LOW) ;
  • entre les deux s’étend une zone incertaine : la valeur lue est imprévisible. Un montage correct ne doit jamais y laisser une entrée.

Une sortie à HIGH fournit environ 5 V (au moins 4,2 V en débitant 20 mA) ; une sortie à LOW environ 0 V (au plus 0,9 V en absorbant 20 mA). La tension baisse un peu quand le courant augmente, car le transistor de sortie a une petite résistance interne.

Attention – Les limites de courant

  • 20 mA par broche : courant conseillé, celui d’une LED avec sa résistance.
  • 40 mA par broche : maximum absolu. Au-delà, la broche peut être détruite.
  • 200 mA au total pour l’ensemble des broches du microcontrôleur.

Un moteur, un relais, un haut-parleur ou un ruban de LED demandent bien plus : on les commande par l’intermédiaire d’un transistor.

3.1.3Configurer une broche avec pinMode()

Avant d’utiliser une broche, on indique son rôle avec pinMode(broche, mode), en général une seule fois, dans setup(). Trois modes existent :

ModeRôle
OUTPUTSortie : la broche impose 0 V ou 5 V.
INPUTEntrée à haute impédance. C’est le mode de toutes les broches au démarrage.
INPUT_PULLUPEntrée reliée au 5 V par une résistance interne de 20 à 50 kΩ.
void setup() {
  pinMode(13, OUTPUT);         // LED
  pinMode(2, INPUT_PULLUP);    // bouton
}
Figure 3.2 interactif – Une broche vue de l’intérieur : choisissez le mode et, en sortie, l’état imposé par digitalWrite().

La figure 3.2 montre ce que chaque mode change à l’intérieur de la broche. En OUTPUT, deux interrupteurs électroniques relient la broche soit au 5 V, soit à la masse : la broche fournit du courant à l’état haut et en absorbe à l’état bas. En INPUT, les deux interrupteurs sont ouverts et seul le circuit de lecture reste connecté : la broche ne consomme presque aucun courant. En INPUT_PULLUP, une résistance interne la relie en plus au 5 V : elle lit HIGH tant que rien ne la tire vers la masse.

Définition – Haute impédance

État d’une entrée qui présente une résistance très élevée (plusieurs mégohms) : elle mesure une tension sans prélever de courant au circuit qui la fournit. En contrepartie, si rien ne lui impose de tension, elle « flotte ».

✎ Signaler une erreur dans cette section

Chapitre 3 · Section 3.2

Commander une sortie

Une fois la broche configurée en sortie, digitalWrite() lui impose un niveau qu’elle garde jusqu’à l’ordre suivant. Le premier usage est d’allumer une LED, ce qui suppose un petit calcul de résistance.

Figure 3.3 interactif – Calcul de la résistance d’une LED et comparaison des montages « source » et « puits » : changez l’état de la broche.

3.2.1digitalWrite()

digitalWrite(8, HIGH);   // 5 V
digitalWrite(8, LOW);    // 0 V

La broche doit avoir été mise en OUTPUT dans setup(). Le niveau reste en place jusqu’au prochain digitalWrite() : il n’est pas nécessaire de le répéter dans loop().

3.2.2Calculer la résistance d’une LED

Une LED présente à ses bornes une tension presque constante, sa tension directe VLED, d’environ 2 V pour une LED rouge, 3 V pour une LED bleue ou blanche. La résistance série absorbe le reste de la tension et fixe le courant :

R = (Vcc − VLED) / I

Pour une LED rouge et un courant visé de 15 mA : R = (5 − 2) / 0,015 = 200 Ω. On choisit la valeur normalisée immédiatement supérieure, 220 Ω, ce qui donne I = 3 / 220 ≈ 13,6 mA, bien en dessous des 20 mA conseillés.

3.2.3Montage source ou montage puits

Il existe deux façons de brancher la LED (figure 3.3) :

  • en source, la LED et sa résistance vont de la broche à la masse : la broche fournit le courant, la LED s’allume à HIGH ;
  • en puits, elles vont du 5 V à la broche : la broche absorbe le courant, la LED s’allume à LOW.

Les deux montages sont aussi valables l’un que l’autre pour l’ATmega328P, qui fournit et absorbe des courants comparables. Le montage puits se rencontre souvent sur les modules du commerce : il faut alors se souvenir que la logique est inversée.

Attention

Moteur, relais, haut-parleur, ruban de LED : le courant est trop fort pour une broche. On intercale un transistor (bipolaire ou MOSFET), commandé par la broche, et, pour une charge inductive comme un moteur ou un relais, une diode de roue libre qui absorbe la surtension à la coupure.

Exercices

1. Quelle résistance choisir pour une LED blanche (VLED ≈ 3,1 V) parcourue par 10 mA ?

R = (5 − 3,1) / 0,010 = 190 Ω. On prend la valeur normalisée supérieure, 220 Ω, soit I ≈ 8,6 mA.

2. Un module à LED est câblé en puits sur D7. Écrivez les deux lignes qui l’allument puis l’éteignent.

En puits, la LED s’allume quand la broche est à 0 V : digitalWrite(7, LOW); l’allume, digitalWrite(7, HIGH); l’éteint.

3. Huit LED rouges à 15 mA sont allumées en même temps. Les limites du microcontrôleur sont-elles respectées ?

Chaque broche débite 15 mA < 20 mA, et le total vaut 8 × 15 = 120 mA < 200 mA : oui. Avec quatorze LED, on atteindrait 210 mA et la limite globale serait dépassée.

✎ Signaler une erreur dans cette section

Chapitre 3 · Partie II

Entrées numériques

Lire un bouton paraît plus simple que commander une LED. C’est pourtant là que se cachent les pièges les plus fréquents : entrée qui flotte, logique inversée, rebonds qui comptent un appui plusieurs fois.

Chapitre 3 · Section 3.3

Lire une entrée

digitalRead(broche) renvoie HIGH ou LOW selon la tension présente sur la broche. Encore faut-il que cette tension soit définie à chaque instant, bouton appuyé ou relâché.

Figure 3.4 interactif – Trois façons de câbler un bouton : sans résistance, avec une résistance de pull-down, en INPUT_PULLUP. Appuyez et observez la valeur lue.

3.3.1L’entrée flottante

Une broche en INPUT est à haute impédance. Si elle n’est reliée qu’à un bouton ouvert, rien ne fixe sa tension : elle capte les parasites environnants – un doigt qui approche, un fil voisin, le rayonnement du secteur – et digitalRead() renvoie HIGH ou LOW au hasard (figure 3.4, premier montage).

3.3.2Les résistances de tirage

Une résistance de tirage impose le niveau de repos ; le bouton ne fait que le changer :

  • en pull-down, une résistance de 10 kΩ relie la broche à GND et le bouton la relie au 5 V. Au repos on lit LOW, à l’appui HIGH ;
  • en pull-up, la résistance relie la broche au 5 V et le bouton la relie à GND. Au repos on lit HIGH, à l’appui LOW.

La résistance de pull-up existe à l’intérieur du microcontrôleur : le mode INPUT_PULLUP l’active. Il n’y a alors plus aucune résistance à câbler, et le bouton se branche avec un seul fil vers GND.

Définition – Résistance de tirage

Résistance qui relie une entrée au 5 V (pull-up) ou à la masse (pull-down) pour lui imposer un niveau défini quand aucun autre composant ne la commande. Sa valeur, de quelques kilo-ohms à quelques dizaines de kilo-ohms, limite le courant quand le bouton est fermé.

3.3.3Lire un bouton avec INPUT_PULLUP

Un bouton entre D2 et GND, lu en INPUT_PULLUP, allume la LED de la carte tant qu’il est appuyé.
Figure 3.5 – Un bouton entre D2 et GND, lu en INPUT_PULLUP, allume la LED de la carte tant qu’il est appuyé.
const int BP  = 2;    // bouton entre D2 et GND
const int LED = 13;   // LED de la carte

void setup() {
  pinMode(BP, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
}
void loop() {
  int etat = digitalRead(BP);     // HIGH ou LOW
  if (etat == LOW) {              // LOW = appuyé
    digitalWrite(LED, HIGH);
  } else {
    digitalWrite(LED, LOW);
  }
}

La logique est inversée : relâché, le bouton laisse la résistance tirer D2 à 5 V et l’on lit HIGH ; appuyé, il relie D2 à GND et l’on lit LOW. Le même programme s’écrit en une ligne, l’opérateur ! inversant la valeur lue :

digitalWrite(LED, !digitalRead(BP));

À retenir

Une entrée ne doit jamais rester flottante : toute entrée a une résistance de tirage, interne ou externe. Avec INPUT_PULLUP, un appui se lit LOW.

✎ Signaler une erreur dans cette section

Chapitre 3 · Section 3.4

Rebonds et détection d’un appui

Un bouton mécanique ne passe pas proprement d’un état à l’autre. Comme loop() s’exécute des milliers de fois par seconde, il voit chaque hésitation du contact. Compter des appuis demande donc de filtrer ces rebonds et de détecter le changement d’état plutôt que l’état lui-même.

Figure 3.6 interactif – Oscilloscope sur D2 pendant un appui : comparez le nombre d’appuis comptés avec et sans anti-rebond, pour plusieurs durées de filtrage.

3.4.1Les rebonds mécaniques

Quand on appuie, les lames métalliques du bouton s’entrechoquent : le contact s’établit et se coupe plusieurs fois pendant 1 à 10 ms (figure 3.6). Pendant ce temps, loop() s’exécute des milliers de fois, et chaque rebond peut être compté comme un nouvel appui. Deux remèdes existent :

  • l’anti-rebond matériel : un condensateur (100 nF par exemple) en parallèle sur le bouton lisse les transitions ;
  • l’anti-rebond logiciel : on n’accepte un nouvel état que s’il reste stable pendant 20 à 50 ms.

3.4.2Front ou niveau ?

Tester le niveau (« le bouton est-il appuyé ? ») déclenche l’action à chaque passage dans loop() tant que le bouton est maintenu. Pour une seule action par appui, on détecte le front : le passage de HIGH à LOW (front descendant, l’appui) ou de LOW à HIGH (front montant, le relâchement). Il suffit pour cela de comparer la lecture actuelle à la précédente.

Définition – Front

Changement d’état d’un signal logique : front montant de 0 à 1, front descendant de 1 à 0. Détecter un front, c’est réagir au changement et non à l’état.

3.4.3Le programme d’anti-rebond

Le programme étudié ici inverse l’état de la LED à chaque appui. Il réunit les deux idées précédentes : un anti-rebond logiciel et la détection du front descendant. Le logigramme de la figure 3.7 décrit son algorithme et l’exécute pas à pas sur trois cas concrets . Voici son code complet :

Figure 3.7 interactif – Logigramme de l’anti-rebond, exécuté pas à pas sur trois scénarios : appui avec rebonds, relâchement, bouton maintenu.
const int BP = 2, LED = 13;
int etatStable = HIGH;          // état validé du bouton
int dernierLu  = HIGH;          // dernière lecture brute
unsigned long tChange = 0;      // instant du dernier changement
bool led = false;

void setup() {
  pinMode(BP, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
}
void loop() {
  int lu = digitalRead(BP);
  if (lu != dernierLu) {        // ça bouge : on relance le chrono
    dernierLu = lu;
    tChange = millis();
  }
  if (millis() - tChange > 30 && lu != etatStable) {
    etatStable = lu;            // stable depuis 30 ms
    if (etatStable == LOW) {    // front descendant = appui
      led = !led;
      digitalWrite(LED, led);
    }
  }
}

Le code repose sur deux variables : dernierLu, la dernière lecture brute, et etatStable, l’état validé. Chaque fois que la lecture change, on note l’instant dans tChange : un rebond relance donc le chronomètre. Lorsque la lecture n’a pas changé depuis plus de 30 ms et qu’elle diffère de l’état validé, on valide le nouvel état. Si ce nouvel état est LOW, c’est un appui : on inverse la LED. Un appui long ne la fait basculer qu’une fois, puisque l’état validé ne change plus.

Front ou niveau, le rôle de millis() et pourquoi éviter delay(30).
Figure 3.8 – Front ou niveau, le rôle de millis() et pourquoi éviter delay(30).

La fonction millis() renvoie le nombre de millisecondes écoulées depuis le démarrage, à ranger dans un unsigned long. La soustraction millis() - tChange reste juste même lorsque le compteur repasse à zéro, au bout de 49,7 jours (chapitre 4).

Attention – Pourquoi pas delay(30) ?

Attendre avec delay() bloque tout le programme : pendant ce temps, aucune autre broche n’est lue ni commandée. Avec millis(), l’attente ne coûte rien et loop() continue de tourner.

Exercices

1. Un bouton est câblé entre D4 et le 5 V, avec une résistance de 10 kΩ entre D4 et GND. Quel mode donner à D4, et que lit-on à l’appui ?

C’est un montage pull-down : D4 se configure en INPUT (surtout pas INPUT_PULLUP, qui formerait un pont diviseur avec la résistance externe). Au repos on lit LOW, à l’appui HIGH.

2. Modifiez le programme d’anti-rebond pour compter les appuis et afficher le total dans le moniteur série.
int nb = 0;   // variable globale
// dans setup() : Serial.begin(9600);
// à la place de l’inversion de la LED :
if (etatStable == LOW) {
  nb++;
  Serial.println(nb);
}
3. Pourquoi la condition millis() - tChange > 30 ne suffit-elle pas seule, sans lu != etatStable ?

Sans le second test, la condition resterait vraie à chaque passage dans loop() tant que le bouton ne bouge pas : l’état serait « validé » en boucle et la LED basculerait des milliers de fois par seconde pendant l’appui.

✎ Signaler une erreur dans cette section

Chapitre 3 · Partie III

Registres AVR

Les fonctions Arduino sont portables et sûres, mais lentes et limitées à une broche à la fois. En écrivant directement dans les registres des ports de l’ATmega, on commande huit broches en une seule instruction de 125 ns.

Chapitre 3 · Section 3.5

Les ports et leurs registres

Le microcontrôleur ne connaît pas les numéros D0 à D13 : il regroupe ses broches en ports de huit bits. Chaque port est piloté par trois registres, qui correspondent exactement aux trois fonctions pinMode(), digitalWrite() et digitalRead().

Les trois ports de l’ATmega328P, la correspondance avec les broches de la Uno et le rôle des registres DDRx, PORTx et PINx.
Figure 3.9 – Les trois ports de l’ATmega328P, la correspondance avec les broches de la Uno et le rôle des registres DDRx, PORTx et PINx.

3.5.1Les ports de l’ATmega328P

Chaque port regroupe jusqu’à huit broches, une par bit (figure 3.9) :

  • port B : D8 à D13 sur les bits 0 à 5 ; les bits 6 et 7 sont reliés au résonateur et inutilisables ;
  • port C : A0 à A5 sur les bits 0 à 5 ; le bit 6 est la broche RESET ;
  • port D : D0 à D7 sur les bits 0 à 7, D0 et D1 étant RX et TX.

3.5.2Trois registres par port

RegistreRôleÉquivalent Arduino
DDRx
direction
Un bit par broche : 1 = sortie, 0 = entrée.pinMode()
PORTx
écriture
Broche en sortie : 1 = 5 V, 0 = 0 V.
Broche en entrée : 1 active la résistance de pull-up.
digitalWrite()
PINx
lecture
Niveau réel de chaque broche, qu’elle soit en entrée ou en sortie.digitalRead()

Le registre PINx réserve une particularité : écrire 1 dans un de ses bits inverse l’état de la broche correspondante lorsqu’elle est configurée en sortie. C’est la façon la plus rapide de faire clignoter une LED.

Figure 3.10 interactif – Cliquez sur les bits de DDRB et PORTB : la figure affiche l’état des broches D8 à D13 et la valeur lue dans PINB.

La figure 3.10 permet d’expérimenter ces règles sur le port B. On y vérifie qu’une broche dont le bit de DDRB vaut 0 et celui de PORTB vaut 1 est une entrée avec pull-up – exactement ce que fait pinMode(…, INPUT_PULLUP) – et que PINB, en lecture seule, reflète toujours le niveau réel des broches.

3.5.3Modifier un bit sans toucher aux autres

Écrire PORTB = 0b00100000; met D13 à 5 V, mais met aussi à 0 les cinq autres broches du port. Pour ne modifier qu’un bit, on combine la valeur actuelle du registre avec un masque. La figure 3.11 résume les opérations courantes et leur équivalent Arduino.

Les opérations sur les registres et leur équivalent Arduino.
Figure 3.11 – Les opérations sur les registres et leur équivalent Arduino.

L’expression 1 << PB5 décale un 1 de cinq rangs vers la gauche : elle vaut 0b00100000, un masque qui ne contient que le bit 5. Son complément ~(1 << PB5) vaut 0b11011111. L’opérateur |= force à 1 les bits du masque, l’opérateur &= ~ les force à 0 ; les autres bits sont recopiés à l’identique.

Avantages et inconvénients

  • Vitesse : une instruction de 125 ns à 16 MHz, contre plusieurs microsecondes pour digitalWrite() (chapitre 2).
  • Simultanéité : plusieurs broches d’un même port changent exactement au même instant.
  • Portabilité : le code est propre à un microcontrôleur. Il ne fonctionne plus tel quel sur une Mega (ports différents) ni sur une UNO R4.

3.5.4Les ports de la Mega 2560

Les ports complets de l’ATmega2560 et leur correspondance avec les broches de la Mega.
Figure 3.12 – Les ports complets de l’ATmega2560 et leur correspondance avec les broches de la Mega.

L’ATmega2560 possède onze ports, de A à L, et la correspondance avec les numéros de la carte est différente (figure 3.12). Les ports complets, dont les huit broches sont libres, sont les plus intéressants pour piloter plusieurs broches à la fois : PORTA (D22 à D29), PORTC (D30 à D37), PORTL (D42 à D49), PORTF (A0 à A7) et PORTK (A8 à A15). Les autres ports sont incomplets ou partagés avec les liaisons série, I²C et SPI ; la LED de la carte, D13, est sur PB7.

Attention à l’ordre

Sur PORTC et PORTL, le bit 0 correspond à la broche de plus grand numéro : D37 = PC0 et D30 = PC7. Sur PORTA, au contraire, D22 = PA0. Vérifiez toujours la correspondance dans l’annexe 2 avant de câbler.

✎ Signaler une erreur dans cette section

Chapitre 3 · Section 3.6

Travailler avec des masques

Un masque est une valeur binaire qui désigne les bits sur lesquels on veut agir. Combiné aux opérateurs logiques du C, il permet de forcer, d’inverser ou de tester n’importe quel ensemble de bits d’un registre, en une seule opération.

Figure 3.13 interactif – Les trois opérations de masquage appliquées à PORTA : choisissez l’opération, cliquez sur les bits du registre et du masque.

3.6.1Forcer, effacer, inverser

Les opérations bit à bit du C reposent sur quatre règles simples (figure 3.13) :

OpérateurRègleUsageCode
OU |x | 1 = 1, x | 0 = xforcer à 1PORTA |= masque;
ET &x & 0 = 0, x & 1 = xforcer à 0PORTA &= ~masque;
OU exclusif ^x ^ 1 = x, x ^ 0 = xinverserPORTA ^= masque; ou PINA = masque;
NON ~inverse tous les bitspréparer un masque d’effacement~0b00001100 = 0b11110011

Pour effacer des bits, on inverse d’abord le masque : les bits à effacer deviennent des 0, les autres des 1, et le ET efface les premiers en recopiant les seconds. Pour inverser des bits, écrire le masque dans PINx fait sur AVR la même chose que le OU exclusif, mais en une seule instruction.

3.6.2Tester un bit

Figure 3.14 interactif – Tester un ou plusieurs bits de PIND : choisissez le test, cliquez sur les bits de PIND et du masque, et observez la condition.

PINx donne l’état des huit broches du port en une seule lecture. Le ET avec un masque efface tous les bits, sauf ceux du masque. Le résultat vaut donc 0 si le bit testé est à 0, et la valeur du masque – et non 1 – s’il est à 1 :

// bouton sur D2 (PD2) en INPUT_PULLUP
if ((PIND & (1 << PD2)) == 0) {   // bit à 0 : appui
  PORTB |= (1 << PB5);           // allumer D13
} else {
  PORTB &= ~(1 << PB5);          // éteindre D13
}

Avec un masque de plusieurs bits, trois tests sont possibles : (PIND & masque) != 0 est vrai si au moins un bit du masque est à 1 ; (PIND & masque) == masque si tous le sont ; (PIND & masque) == 0 si tous sont à 0.

Attention – Deux pièges classiques

  • Comparer à 1 : (PIND & (1 << PD2)) == 1 est toujours faux, car le résultat vaut 4 quand le bit est à 1.
  • Oublier les parenthèses : en C, == est évalué avant &. PIND & (1 << PD2) == 0 calcule PIND & 0, qui vaut toujours 0.

3.6.3Écrire et lire plusieurs bits à la fois

Figure 3.15 interactif – Un afficheur 7 segments sur PORTA de la Mega, et les techniques pour écrire ou lire un groupe de bits.

L’intérêt des registres apparaît pleinement lorsqu’on commande plusieurs broches ensemble. Un afficheur 7 segments à cathode commune, dont les segments a à g sont reliés à D22–D28 (PA0 à PA6) d’une Mega, s’affiche en une seule écriture (figure 3.15) :

const byte SEG[10] = { 0x3F, 0x06, 0x5B, 0x4F, 0x66,
                       0x6D, 0x7D, 0x07, 0x7F, 0x6F };
void setup() {
  DDRA |= 0x7F;                          // PA0 à PA6 en sortie
}
void loop() {
  for (byte n = 0; n < 10; n++) {
    PORTA = (PORTA & 0x80) | SEG[n];     // D29 (PA7) préservée
    delay(500);
  }
}

La technique générale pour changer quelques bits sans toucher aux autres tient en une ligne. Pour écrire un nombre de 0 à 15 sur les quatre bits bas de PORTC :

PORTC = (PORTC & 0xF0) | (n & 0x0F);

PORTC & 0xF0 efface les quatre bits bas et garde les quatre hauts ; n & 0x0F limite n à quatre bits ; le OU assemble les deux moitiés, puis le registre est écrit une seule fois. En lecture, on combine masque et décalage :

DDRK  &= ~0x0F;                  // PK0 à PK3 (A8 à A11) en entrée
PORTK |=  0x0F;                  // avec pull-up
byte code = ~PINK & 0x0F;        // 1 = interrupteur fermé
byte haut = (PINL >> 4) & 0x0F;  // bits 4 à 7 ramenés en 0 à 3

Exercices

1. Écrivez avec les registres l’équivalent de pinMode(8, OUTPUT); pinMode(9, OUTPUT); en une seule instruction.

D8 et D9 sont PB0 et PB1 : DDRB |= (1 << PB0) | (1 << PB1);, soit DDRB |= 0x03;.

2. Que valent PORTD après PORTD = 0b10110100; PORTD &= ~0b00110000;, puis après PORTD ^= 0b00000011; ?

Le masque inversé vaut 0b11001111 : 0b10110100 & 0b11001111 = 0b10000100. Le OU exclusif inverse ensuite les bits 0 et 1 : 0b10000111.

3. Deux boutons en INPUT_PULLUP sont sur D2 et D3. Écrivez la condition « les deux boutons sont appuyés ».

Appuyé = bit à 0. Les deux bits du masque 0b00001100 doivent être à 0 : if ((PIND & 0b00001100) == 0) { … }.

✎ Signaler une erreur dans cette section

Chapitre 3 · Partie IV

Sorties PWM

Une broche numérique ne produit que 0 V ou 5 V. En la faisant basculer très vite, on obtient pourtant une tension moyenne réglable, suffisante pour faire varier la luminosité d’une LED ou la vitesse d’un moteur.

Chapitre 3 · Section 3.7

La modulation de largeur d’impulsion

La PWM (Pulse Width Modulation, modulation de largeur d’impulsion) est la technique qui permet à un microcontrôleur sans convertisseur numérique-analogique de commander une puissance de façon progressive.

Figure 3.16 interactif – Simulateur de PWM : réglez le rapport cyclique et la fréquence, et lisez la tension moyenne obtenue.

3.7.1Le principe

La broche bascule entre 0 V et 5 V à fréquence fixe – 490 Hz par défaut sur la plupart des broches de la Uno. Le rapport cyclique α est la fraction de la période T pendant laquelle la broche est à 5 V : α = thaut / T. Une LED ou un moteur ne suivent pas 490 basculements par seconde : l’œil perçoit la luminosité moyenne, l’inertie du moteur lisse le couple. Tout se passe comme si l’on appliquait la tension moyenne :

α = valeur / 255     Umoy = α × 5 V

Définition – Rapport cyclique

Rapport entre la durée de l’état haut et la période d’un signal rectangulaire, exprimé entre 0 et 1 ou en pourcentage. Un signal à 25 % est à l’état haut pendant le quart de chaque période.

3.7.2La fonction analogWrite()

La syntaxe d’analogWrite() et les broches PWM de chaque carte.
Figure 3.17 – La syntaxe d’analogWrite() et les broches PWM de chaque carte.

analogWrite(broche, valeur) produit un signal PWM sur une broche marquée ~ ; la figure 3.17 donne la liste de ces broches et leur fréquence pour chaque carte. La valeur va de 0 (toujours 0 V) à 255 (toujours 5 V), soit 256 niveaux. Il n’est pas nécessaire d’appeler pinMode() : la fonction met la broche en sortie. Le signal est produit par un timer (chapitre 7) et continue seul, sans occuper le processeur, jusqu’au prochain analogWrite() ou digitalWrite() sur cette broche.

Attention

Malgré son nom, analogWrite() n’a aucun rapport avec analogRead() ni avec les broches A0 à A5. Elle ne produit pas une tension analogique, mais un signal numérique dont seule la moyenne varie.

Le programme suivant fait varier en douceur la luminosité d’une LED branchée sur D9 : une première boucle augmente la valeur de 0 à 255, une seconde la ramène à 0, avec une pause de 5 ms à chaque pas.

const int LED = 9;          // broche PWM (~)
void setup() { }            // rien à configurer
void loop() {
  for (int v = 0; v <= 255; v++) {
    analogWrite(LED, v);    // de plus en plus fort
    delay(5);
  }
  for (int v = 255; v >= 0; v--) {
    analogWrite(LED, v);    // de moins en moins fort
    delay(5);
  }
}

Pour régler la luminosité avec un potentiomètre branché sur A0, on divise par 4 la valeur lue, comprise entre 0 et 1023 (chapitre 8) : analogWrite(9, analogRead(A0) / 4);

3.7.3Applications et précautions

Applications de la PWM et ce que analogWrite() ne sait pas faire.
Figure 3.18 – Applications de la PWM et ce que analogWrite() ne sait pas faire.

Faire varier la luminosité d’une LED. À 490 Hz, l’œil ne voit pas le clignotement. Mais la luminosité perçue n’est pas proportionnelle à la valeur : 128 paraît bien plus que « la moitié » de 255. Pour un fondu régulier, on fait varier la valeur de façon exponentielle (correction gamma).

Régler la vitesse d’un moteur à courant continu. La vitesse suit la tension moyenne. Le moteur ne se branche jamais directement sur la broche : on passe par un transistor MOSFET avec une diode de roue libre, ou par un module pont en H (L298N, DRV8833…) pour pouvoir changer de sens. Le moteur est alimenté séparément, et les masses sont reliées.

Obtenir une vraie tension continue. Un filtre RC passe-bas, dont la fréquence de coupure fc = 1 / (2πRC) est très inférieure à la fréquence PWM, ne laisse passer que la valeur moyenne. Avec 10 kΩ et 10 µF, fc ≈ 1,6 Hz. L’UNO R4 dispose, elle, d’un vrai convertisseur numérique-analogique sur A0.

Ce que analogWrite() ne fait pas

  • Servomoteur : il attend une impulsion de 1 à 2 ms toutes les 20 ms, que la PWM à 490 Hz ne fournit pas. On utilise la bibliothèque Servo.
  • Son : la fréquence PWM est fixe. Pour jouer une note, on utilise tone().
  • Niveau de tension : les impulsions restent à 5 V. Un composant 3,3 V a toujours besoin d’un adaptateur de niveau.

Exercices

1. Quelle tension moyenne obtient-on avec analogWrite(9, 64) ? Quelle est la durée de l’état haut ?

α = 64 / 255 ≈ 0,25, soit Umoy ≈ 1,25 V. À 490 Hz, T ≈ 2,04 ms et thaut ≈ 0,25 × 2,04 ≈ 0,51 ms.

2. Quelle valeur passer à analogWrite() pour qu’un moteur 12 V, alimenté par un transistor sous 12 V, reçoive en moyenne 9 V ?

Le transistor recopie le rapport cyclique sur l’alimentation de 12 V : α = 9 / 12 = 0,75, soit une valeur de 0,75 × 255 ≈ 191.

3. Un filtre RC avec R = 10 kΩ doit avoir une fréquence de coupure de 10 Hz. Quelle valeur de C choisir ? Le filtre convient-il pour une PWM à 490 Hz ?

C = 1 / (2π × 10 000 × 10) ≈ 1,6 µF. La fréquence PWM est 49 fois plus élevée que la coupure : l’ondulation est fortement atténuée, le filtre convient, avec un temps de réponse de quelques dizaines de millisecondes.

✎ Signaler une erreur dans cette section

Chapitre 3 · Partie V

Évaluation et ressources

Une synthèse des fonctions et des règles du chapitre, un questionnaire pour vérifier ses connaissances et les sources pour aller plus loin.

Chapitre 3 · Section 3.8

À retenir et QCM

Le tableau suivant résume les fonctions et les règles électriques du chapitre. Le questionnaire de la figure 3.19 permet ensuite de vérifier qu’elles sont acquises.

FonctionRôleExemple
pinMode(b, mode)OUTPUT, INPUT ou INPUT_PULLUPpinMode(2, INPUT_PULLUP);
digitalWrite(b, v)Sortie à HIGH (5 V) ou LOW (0 V)digitalWrite(13, HIGH);
digitalRead(b)Renvoie HIGH ou LOWif (digitalRead(2) == LOW) …
millis()Temps écoulé en ms, sans bloquerif (millis() - t > 30) …
DDRx / PORTx / PINxDirection / écriture ou pull-up / lecturePORTB |= (1 << PB5);
analogWrite(b, v)PWM de 0 à 255, broches ~analogWrite(9, 128);

Bonnes habitudes

  • Jamais flottante : Toute entrée a une résistance de tirage, interne ou externe.
  • 20 mA par broche : Au-delà, un transistor commande la charge.
  • Anti-rebond : Un état n’est validé qu’après 20 à 50 ms de stabilité.
  • PWM = moyenne : Le signal reste 0 V / 5 V ; seule sa moyenne varie.

3.8.1Se tester

Le QCM comporte vingt et une questions. Choisissez une réponse à la souris ou avec les touches 1 à 4, puis validez avec Entrée. En fin de questionnaire, chaque question manquée renvoie à la section qui donne les explications.

Figure 3.19 interactif – QCM d’évaluation du chapitre 3.

✎ Signaler une erreur dans cette section

Chapitre 3 · Section 3.9

Sources et références

La référence du langage Arduino décrit chaque fonction ; les tutoriels officiels développent les montages du chapitre ; la fiche technique de l’ATmega328P fait foi pour les ports et les caractéristiques électriques.

Référence du langage Arduino

Bibliographie

  • C. Tavernier, Arduino : maîtrisez sa programmation et ses cartes d’interface (shields), 2e éd., Dunod, 2019.
  • Microchip Technology, ATmega328P Datasheet : chapitre « I/O-Ports », caractéristiques électriques.microchip.com/en-us/product/ATmega328P

Tutoriels Arduino

✎ Signaler une erreur dans cette section