Chapitre 10Livre « Arduino sous le capot »

Économie d’énergie et chien de garde

Modes de veille, réduction de la consommation, réveil et chien de garde

Un capteur de jardin, une station météo, une balise ou une télécommande fonctionnent sur pile, et passent l’essentiel de leur temps à attendre. Entre deux actions, le microcontrôleur peut dormir : sa consommation passe de quelques milliampères à moins d’un microampère, et l’autonomie de quelques jours à plusieurs années.

Ce chapitre présente les six modes de veille de l’ATmega, la façon sûre d’y entrer avec la bibliothèque avr/sleep.h, et tout ce qu’il faut couper pour atteindre le courant minimal. Il étudie ensuite le chien de garde, ce minuteur indépendant qui redémarre le microcontrôleur quand le programme se bloque, et qui sert aussi de réveil périodique. Un exemple de station de mesure sur pile réunit les deux techniques.

Objectifs du chapitre

  • Évaluer la consommation et l’autonomie d’un montage, et identifier ce qui consomme sur une carte.
  • Choisir un mode de veille selon les horloges à conserver et les sources de réveil.
  • Mettre le microcontrôleur en veille et le réveiller par une interruption, sans risque de blocage.
  • Configurer le chien de garde en mode reset pour surveiller un programme.
  • Utiliser le chien de garde en mode interruption pour un réveil périodique.

Prérequis

Les interruptions externes et PCINT (chapitre 6), les timers (chapitre 7) et l’ADC (chapitre 8).

Plan du chapitre

  1. Partie I – Économie d’énergie
  2. 10.1Pourquoi économiser l’énergie ?
  3. 10.2Les modes de veille
  4. 10.3Réduire encore la consommation
  5. Partie II – Chien de garde
  6. 10.4Le chien de garde
  7. Partie III – Applications
  8. 10.5Se réveiller régulièrement
  9. 10.6Exemple : station de mesure sur pile
  10. Partie IV – Évaluation et ressources
  11. 10.7À retenir et QCM
  12. 10.8Sources et références

Chapitre 10 · Partie I

Économie d’énergie

Pourquoi un montage autonome doit dormir, quels sont les modes de veille de l’ATmega, comment y entrer sans risque et comment descendre sous le microampère.

Chapitre 10 · Section 10.1

Pourquoi économiser l’énergie ?

L’autonomie d’un montage sur pile se calcule simplement : la capacité de la pile divisée par le courant moyen consommé. Réduire ce courant est le seul levier, et la veille est de loin le plus efficace.

Figure 10.1 interactif – Courant consommé et autonomie théorique selon la configuration, pour une capacité de pile réglable.

10.1.1Un montage sur pile doit dormir

Le plus souvent, un montage autonome n’a rien à faire : une mesure toutes les minutes, un appui de temps en temps. Entre deux actions, le microcontrôleur peut dormir. Une pile de 2 000 mAh alimentant un ATmega actif, qui consomme environ 15 mA, dure un peu plus de cinq jours ; le même ATmega en veille profonde, autour de 0,36 µA, tiendrait en théorie plusieurs siècles – en pratique, l’autodécharge de la pile fixe la limite à quelques années (figure 10.1).

autonomie (h) = capacité (mAh) / courant moyen (mA)

10.1.2La carte d’abord

Attention

Sur une carte Uno, le régulateur de tension, l’interface USB (ATmega16U2) et la LED « ON » consomment en permanence, environ 35 mA. Mettre le microcontrôleur en veille ne change presque rien à l’autonomie. Un vrai montage autonome utilise un ATmega seul, ou une carte sans régulateur ni LED, comme une Pro Mini modifiée.

Toutes les mesures de ce chapitre sont celles de Nick Gammon, à 5 V et 16 MHz, sur un ATmega328P seul. À 3,3 V et 8 MHz, les courants actifs sont encore plus faibles.

✎ Signaler une erreur dans cette section

Chapitre 10 · Section 10.2

Les modes de veille

L’ATmega propose six modes de veille. Plus un mode est profond, plus il arrête d’horloges et moins il reste de sources capables de réveiller le microcontrôleur.

Figure 10.2 interactif – Les six modes de veille de l’ATmega : choisissez un mode et observez les horloges arrêtées et les sources de réveil.

10.2.1Six modes

ModeCe qui reste en marcheUsage
Idletout sauf le processeur : timers, liaison série, ADCattendre une interruption sans arrêter les périphériques ; millis() avance
ADC Noise Reductionl’ADC, le Timer2 asynchrone, les interruptions externesconversion analogique sans le bruit du processeur
Power-downrien : même l’oscillateur est arrêtéconsommation minimale
Power-savele Timer2 en mode asynchrone (quartz 32 kHz)horloge temps réel pendant la veille
Standbycomme Power-down, avec l’oscillateur principalréveil en 6 cycles au lieu de plusieurs ms
Extended Standbycomme Power-save, avec l’oscillateur principalréveil rapide avec horloge temps réel

En Power-down, seuls une interruption externe (INT0, INT1, sur niveau bas), une interruption PCINT, la reconnaissance d’une adresse sur le bus I²C ou le chien de garde peuvent réveiller le microcontrôleur. Le Timer0 est arrêté, si bien que millis() reste figé pendant la veille. La Mega 2560 a les mêmes modes et les mêmes registres.

Définition – Mode de veille

État dans lequel le processeur cesse d’exécuter des instructions et où une partie des horloges internes est arrêtée pour réduire la consommation. Le microcontrôleur en sort lorsqu’une source de réveil autorisée se manifeste, et reprend le programme là où il s’était arrêté.

10.2.2Entrer en veille avec avr/sleep.h

Figure 10.3 interactif – La séquence recommandée pour entrer en veille, pas à pas : déclenchez l’interruption de réveil.

Le mode se choisit dans le registre SMCR (bits SM2..SM0) ; le bit SE (Sleep Enable) autorise l’instruction SLEEP. La bibliothèque avr/sleep.h fournit les fonctions correspondantes. La séquence recommandée est la suivante :

#include <avr/sleep.h>
void dormir() {
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);   // SM2..0 = 010
  cli();                  // pas d’interruption pendant la préparation
  sleep_enable();         // SE = 1
  sei();                  // réautoriser les interruptions
  sleep_cpu();            // instruction SLEEP : le processeur dort
  // ... réveil : l’ISR s’exécute, puis on reprend ici
  sleep_disable();        // SE = 0
}

Pourquoi tant de précautions ? Si l’interruption de réveil arrive pendant la préparation, juste avant sleep_cpu(), elle est traitée, puis le processeur s’endort… et plus rien ne le réveillera. La séquence évite ce piège grâce à une propriété de l’AVR : après sei(), l’instruction suivante est toujours exécutée avant toute interruption. sleep_cpu() ne peut donc pas être « sauté » : l’interruption en attente réveille immédiatement le processeur (figure 10.3).

Attention

sleep_mode() fait tout en une fois (enable, sleep, disable), mais ne protège pas contre une interruption arrivée juste avant l’endormissement. Il convient seulement lorsque le réveil est périodique, par le chien de garde par exemple.

Exercices

1. Quel mode choisir pour qu’un montage reste en veille tout en tenant l’heure grâce à un quartz de 32 768 Hz sur le Timer2 ?

Power-save : seul le Timer2 en mode asynchrone continue de fonctionner, cadencé par le quartz externe, et son débordement réveille le microcontrôleur.

2. Après une veille Power-down de 10 s, millis() a-t-il avancé de 10 000 ?

Non : le Timer0, qui fait avancer millis(), est arrêté en Power-down. millis() a gardé sa valeur d’avant la veille. Pour connaître le temps écoulé, il faut compter les réveils du chien de garde ou utiliser une horloge externe.

✎ Signaler une erreur dans cette section

Chapitre 10 · Section 10.3

Réduire encore la consommation

En Power-down, l’ATmega328P seul consomme environ 0,36 µA… à condition d’avoir tout coupé. Le moindre oubli – l’ADC, une LED, une entrée flottante – multiplie ce courant par cent ou par mille.

Figure 10.4 interactif – Ce qui reste allumé en Power-down : cochez les éléments oubliés et observez le courant et l’autonomie.

10.3.1Tout couper avant de dormir

#include <avr/sleep.h>
#include <avr/power.h>
void setup() {
  for (byte b = 2; b < 20; b++)
    pinMode(b, INPUT_PULLUP);        // aucune entrée flottante
}
void dormir() {
  ADCSRA &= ~(1 << ADEN);            // éteindre l’ADC
  power_all_disable();               // PRR : horloges des périphériques
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  cli();
  sleep_enable();
  sleep_bod_disable();               // BOD coupé pendant la veille
  sei();
  sleep_cpu();
  sleep_disable();                   // réveil
  power_all_enable();
  ADCSRA |= (1 << ADEN);
}
Élément resté actif en Power-downCourant supplémentaire
ADC activé (ADEN = 1)+ 335 µA
Détecteur de baisse de tension (BOD)+ 25 µA
Chien de garde (réveil périodique)+ 6,2 µA
LED témoin allumée (1 kΩ)+ 3 mA
Entrées laissées flottantesvariable, de quelques µA à plusieurs centaines

L’ADC est de loin le premier poste : il doit être éteint avant la veille. Le BOD (Brown-Out Detector), qui surveille la tension d’alimentation, peut être coupé pendant la veille seulement ; sleep_bod_disable() doit précéder immédiatement sleep_cpu(), car il s’agit d’une séquence chronométrée de trois cycles. Une entrée flottante oscille autour du seuil de basculement et fait consommer son étage d’entrée de façon imprévisible : on met toutes les broches inutilisées en INPUT_PULLUP. Le registre PRR (Power Reduction Register), piloté par power_all_disable(), coupe l’horloge des périphériques inutilisés ; il agit surtout en fonctionnement normal.

10.3.2Réveil par un bouton

Figure 10.5 interactif – Réveil par un bouton : appuyez et observez le courant consommé, le courant moyen et l’écart entre millis() et le temps réel.

Le programme suivant allume une LED pendant deux secondes – le « travail » – puis s’endort jusqu’au prochain appui sur le bouton de D2 :

#include <avr/sleep.h>
const byte BP = 2, LED = 13;

void reveil() {
  detachInterrupt(digitalPinToInterrupt(BP));   // une seule fois
}
void setup() {
  pinMode(BP, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
}
void loop() {
  digitalWrite(LED, HIGH);                      // le « travail »
  delay(2000);
  digitalWrite(LED, LOW);
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  cli();
  sleep_enable();
  attachInterrupt(digitalPinToInterrupt(BP), reveil, LOW);
  sei();
  sleep_cpu();                                  // dort jusqu’à l’appui
  sleep_disable();
}

Attention

En Power-down, INT0 et INT1 ne réveillent que sur un niveau bas (LOW), pas sur un front : l’horloge nécessaire à la détection des fronts est arrêtée. C’est pourquoi l’interruption est attachée en mode LOW juste avant la veille, puis détachée dans la routine, sans quoi elle se redéclencherait sans cesse tant que le bouton est appuyé (chapitre 6). Les interruptions PCINT, elles, réveillent sur tout changement d’état.

Exercices

1. Un montage dort en Power-down mais une LED témoin reste allumée à travers 1 kΩ. Quelle autonomie a-t-il avec 2 000 mAh ? Et sans la LED ?

Avec la LED : environ 3 mA, soit 2 000 / 3 ≈ 667 h, moins d’un mois. Sans la LED, à 0,36 µA, l’autonomie théorique se compte en centaines d’années : c’est l’autodécharge de la pile qui la limite.

2. Pourquoi la routine reveil() détache-t-elle l’interruption ?

En mode LOW, l’interruption est rappelée en boucle tant que la broche reste à 0. Si on la laissait attachée, loop() serait presque bloquée pendant tout l’appui. On la détache donc au premier appel, et on la rattache juste avant la prochaine veille.

✎ Signaler une erreur dans cette section

Chapitre 10 · Partie II

Chien de garde

Le chien de garde est un minuteur indépendant qui redémarre le microcontrôleur si le programme cesse de le relancer. Il protège les montages autonomes contre les blocages, et sert aussi de réveil périodique.

Chapitre 10 · Section 10.4

Le chien de garde

Un programme embarqué peut se bloquer : boucle infinie inattendue, capteur qui ne répond pas, bus I²C figé. Sans personne pour appuyer sur le bouton Reset, le montage reste bloqué indéfiniment. Le chien de garde est là pour cela.

Figure 10.6 interactif – Simulation du chien de garde avec un délai de 2 s : bloquez le programme et observez le redémarrage.

10.4.1Principe

Le chien de garde (watchdog) est un compteur indépendant, cadencé par son propre oscillateur à 128 kHz. Le programme doit le remettre à zéro régulièrement avec wdt_reset(). S’il ne le fait pas avant la fin du délai choisi, de 16 ms à 8 s, le chien de garde redémarre le microcontrôleur. Un programme bloqué repart donc tout seul (figure 10.6). C’est la veille automatique d’un conducteur de train : s’il n’appuie plus régulièrement sur la pédale, le train freine.

Définition – Chien de garde

Minuteur matériel, indépendant du programme, qui provoque un redémarrage (ou une interruption) s’il n’est pas réarmé avant la fin de son délai. Il permet à un système de se remettre seul d’un blocage logiciel.

10.4.2Le registre WDTCSR

Figure 10.7 interactif – Le registre WDTCSR : choisissez le délai et le mode, et lisez le programme de configuration correspondant.

Le délai se règle avec les bits WDP3..0, de 2 048 cycles (16 ms) à 1 048 576 cycles (8 s) de l’oscillateur à 128 kHz. Le mode dépend des bits WDE et WDIE :

WDEWDIEMode
00arrêté
01interruption WDT_vect (réveil)
10redémarrage (reset)
11interruption, puis reset au délai suivant

Le délai varie avec la tension et la température, d’environ ±10 % : le chien de garde n’est pas une base de temps précise. Pour éviter qu’une écriture accidentelle ne le désactive, la modification de WDE ou du délai est protégée : il faut d’abord écrire WDCE et WDE à 1, puis la nouvelle valeur dans les quatre cycles qui suivent (figure 10.7).

10.4.3Programmer le chien de garde avec avr/wdt.h

Un programme surveillé par le chien de garde, et les bonnes pratiques.
Figure 10.8 – Un programme surveillé par le chien de garde, et les bonnes pratiques.
#include <avr/wdt.h>
void setup() {
  byte cause = MCUSR;              // cause du dernier démarrage
  MCUSR = 0;
  wdt_disable();                   // en premier : évite un reset en boucle
  Serial.begin(9600);
  if (cause & (1 << WDRF))
    Serial.println("Redémarrage par le chien de garde");
  wdt_enable(WDTO_2S);             // mode reset, délai 2 s
}
void loop() {
  lireCapteurs();
  traiter();
  envoyer();
  wdt_reset();                     // tour complet : on relance le chien
}

wdt_enable() effectue la séquence chronométrée WDCE/WDE à votre place ; wdt_disable() arrête le chien de garde. Le registre MCUSR indique la cause du dernier démarrage (bit WDRF pour le chien de garde) ; selon le bootloader, il peut cependant avoir déjà été effacé.

Bonnes pratiques

  • Relancer le chien de garde à un seul endroit, à la fin de loop(), quand tout le travail a été fait correctement. Jamais dans une routine d’interruption : un timer continuerait de le relancer même si loop() était bloquée.
  • Choisir un délai nettement plus long que la durée normale d’un tour de loop(), delay() compris.
  • Pour tester, provoquer volontairement un blocage : while (true) { }.

Attention

Après un reset par le chien de garde, celui-ci reste actif, avec le délai le plus court. Le bootloader de la Uno le gère ; certains anciens bootloaders de Mega 2560 ne le font pas, et la carte redémarre alors en boucle. D’où l’appel à wdt_disable() au tout début de setup().

Exercices

1. Un tour de loop() contient un delay(1500). Le programme utilise wdt_enable(WDTO_1S). Que se passe-t-il ?

Le chien de garde n’est relancé qu’une fois par tour, toutes les 1,5 s au moins : son délai d’une seconde expire avant, et la carte redémarre en permanence. Il faut un délai plus long, WDTO_4S par exemple.

2. Pourquoi relancer le chien de garde dans une ISR de timer est-il une mauvaise idée ?

Le timer continue de déclencher son interruption même si loop() est bloquée dans une boucle infinie ou en attente d’un capteur. Le chien de garde serait relancé indéfiniment et ne détecterait jamais le blocage, ce qui est précisément son rôle.

✎ Signaler une erreur dans cette section

Chapitre 10 · Partie III

Applications

Le chien de garde en mode interruption devient un réveil périodique à très faible consommation. Associé au Power-down, il permet de construire une station de mesure qui fonctionne des années sur piles.

Chapitre 10 · Section 10.5

Se réveiller régulièrement

En mode interruption, le chien de garde ne redémarre pas le microcontrôleur : il le réveille. Comme son oscillateur continue de fonctionner en Power-down et ne consomme que quelques microampères, c’est le réveil périodique idéal.

Figure 10.9 interactif – Courant moyen et autonomie d’un montage réveillé par le chien de garde : réglez la période et la durée des mesures.
#include <avr/sleep.h>
#include <avr/wdt.h>
volatile byte cycles = 0;

ISR(WDT_vect) {
  cycles++;                          // réveil toutes les 8 s
}
void setup() {
  cli();
  MCUSR &= ~(1 << WDRF);
  WDTCSR |= (1 << WDCE) | (1 << WDE);
  WDTCSR  = (1 << WDIE) | (1 << WDP3) | (1 << WDP0);   // interruption, 8 s
  sei();
}
void loop() {
  if (cycles >= 8) {                 // toutes les 64 s
    cycles = 0;
    mesurerEtEnregistrer();
  }
  ADCSRA &= ~(1 << ADEN);            // ADC éteint pendant la veille
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_mode();                      // dort jusqu’au prochain WDT_vect
  ADCSRA |= (1 << ADEN);
}

Huit secondes sont le délai maximal du chien de garde : pour attendre plus longtemps, on compte les réveils. Ici, une mesure est faite tous les huit réveils, soit environ toutes les 64 secondes. Ici, sleep_mode() suffit : un réveil manqué serait simplement rattrapé huit secondes plus tard.

Le courant moyen se calcule en pondérant chaque état par sa durée (figure 10.9). Avec 15 mA pendant 2 ms à chaque réveil et 6,5 µA le reste du temps, un réveil toutes les 8 s donne un courant moyen d’environ 10 µA : plus de vingt ans sur le papier avec 2 000 mAh.

Imoy = (Iactif × tactif + Iveille × tveille) / T

Exercices

1. Quelle valeur donner aux bits WDP pour un réveil toutes les secondes ?

Une seconde correspond à 131 072 cycles de 128 kHz, code WDP3..0 = 0110 : WDTCSR = (1 << WDIE) | (1 << WDP2) | (1 << WDP1);, ou la constante WDTO_1S avec la bibliothèque.

2. Calculez le courant moyen d’un montage qui consomme 15 mA pendant 50 ms une fois par minute et 6,5 µA le reste du temps.

15 mA × 0,05 s / 60 s = 12,5 µA, plus environ 6,5 µA de veille : environ 19 µA. Avec 2 000 mAh, l’autonomie théorique dépasse 100 000 h, soit plus de onze ans.

✎ Signaler une erreur dans cette section

Chapitre 10 · Section 10.6

Exemple : station de mesure sur pile

Une station qui mesure la température environ une fois par minute et la stocke en mémoire réunit toutes les techniques du chapitre. Son autonomie dépend surtout de choix matériels.

Figure 10.10 interactif – Calculateur d’autonomie : comparez une Uno complète et un ATmega seul, pour plusieurs sources et réglages.

10.6.1Les choix de conception

  • Le capteur est alimenté par une broche de sortie : il est éteint entre deux mesures.
  • Le chien de garde réveille le microcontrôleur toutes les 8 s ; on compte les réveils pour une mesure par minute environ.
  • Pendant la veille, l’ADC et le BOD sont coupés, aucune entrée n’est flottante et la LED est éteinte.
  • Les mesures sont stockées en EEPROM (chapitre 2) : une carte SD consommerait beaucoup plus.

Le calculateur de la figure 10.10 montre que le choix de la carte compte plus que tout le reste : une Uno complète ne descend jamais sous 30 mA environ, et une pile de 9 V de 500 mAh n’y tient pas une journée, alors qu’un ATmega seul sur trois piles AA dure des années. Pour aller plus loin, on fait fonctionner le microcontrôleur en 3,3 V à 8 MHz, avec un régulateur à faible courant de repos, ou directement sur piles.

Pour aller plus loin

Les mesures de Nick Gammon (« Power saving techniques for microprocessors ») détaillent l’effet de chaque réglage, y compris l’horloge, la tension et la désactivation de chaque périphérique. Elles constituent la meilleure référence pratique sur le sujet.

✎ Signaler une erreur dans cette section

Chapitre 10 · Partie IV

Évaluation et ressources

Une synthèse des modes de veille et du chien de garde, un questionnaire et les sources pour aller plus loin.

Chapitre 10 · Section 10.7

À retenir et QCM

Le tableau suivant résume les éléments essentiels de la veille et du chien de garde. Le questionnaire de la figure 10.11 permet de vérifier qu’ils sont acquis.

ÉlémentÀ retenir
Modes de veilleIdle, ADC Noise Reduction, Power-down, Power-save, Standby, Extended Standby (registre SMCR)
Power-down≈ 0,36 µA ; réveil par INT0/INT1 (niveau bas), PCINT, I²C ou chien de garde ; millis() figé
avr/sleep.hset_sleep_mode(), cli(), sleep_enable(), sei(), sleep_cpu(), sleep_disable()
Chien de gardeOscillateur 128 kHz, délai de 16 ms à 8 s, mode reset et/ou interruption (WDTCSR)
avr/wdt.hwdt_enable(WDTO_2S), wdt_reset(), wdt_disable()

Bonnes habitudes

  • La carte d’abord : Régulateur, USB et LED d’une Uno consomment ≈ 35 mA en permanence.
  • Tout couper : ADC, BOD, entrées flottantes, LED avant de dormir.
  • Un seul wdt_reset() : Dans loop(), quand tout s’est bien passé.
  • Réveil périodique : Chien de garde en interruption : 8 s au maximum, compter les réveils.

10.7.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 10.11 interactif – QCM d’évaluation du chapitre 10.

✎ Signaler une erreur dans cette section

Chapitre 10 · Section 10.8

Sources et références

Les chapitres « Power Management and Sleep Modes » et « System Control and Reset » de la fiche technique font foi ; la documentation d’avr-libc décrit les fonctions de avr/sleep.h et avr/wdt.h.

Fiches techniques et bibliothèques

Mesures et tutoriels

✎ Signaler une erreur dans cette section