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.
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.1interactif – 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).
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.
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.2interactif – 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
Mode
Ce qui reste en marche
Usage
Idle
tout sauf le processeur : timers, liaison série, ADC
attendre une interruption sans arrêter les périphériques ; millis() avance
ADC Noise Reduction
l’ADC, le Timer2 asynchrone, les interruptions externes
conversion analogique sans le bruit du processeur
Power-down
rien : même l’oscillateur est arrêté
consommation minimale
Power-save
le Timer2 en mode asynchrone (quartz 32 kHz)
horloge temps réel pendant la veille
Standby
comme Power-down, avec l’oscillateur principal
réveil en 6 cycles au lieu de plusieurs ms
Extended Standby
comme Power-save, avec l’oscillateur principal
ré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.3interactif – 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.
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.4interactif – 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-down
Courant 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 flottantes
variable, 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.5interactif – 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.
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.6interactif – 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.7interactif – 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 :
WDE
WDIE
Mode
0
0
arrêté
0
1
interruption WDT_vect (réveil)
1
0
redémarrage (reset)
1
1
interruption, 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
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.
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.9interactif – 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.
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.10interactif – 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.
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.
Oscillateur 128 kHz, délai de 16 ms à 8 s, mode reset et/ou interruption (WDTCSR)
avr/wdt.h
wdt_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.11interactif – QCM d’évaluation du chapitre 10.
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
Microchip, ATmega328P Datasheet : chapitres « Power Management and Sleep Modes » et « System Control and Reset » (Watchdog Timer).microchip.com/en-us/product/ATmega328P