Chapitre 4Livre « Arduino sous le capot »

La programmation des délais

Mesurer le temps, attendre sans bloquer le programme et mener plusieurs tâches à la fois

Presque tous les programmes embarqués manipulent le temps : faire clignoter un voyant, cadencer des mesures, laisser un relais coller, abandonner une attente quand un capteur ne répond pas. La façon d’attendre change tout : un programme qui attend sans rien faire ne peut plus réagir à un bouton, alors qu’un programme qui consulte l’heure reste disponible en permanence.

Ce chapitre commence par les délais bloquants, delay() et delayMicroseconds(), et montre leurs limites. Il présente ensuite la technique fondamentale de la programmation embarquée sans système d’exploitation : la temporisation non bloquante avec millis(), déclinée pour plusieurs tâches, l’anti-rebond, la machine à états et le délai de garde. Il se termine par les attentes précises et un exemple complet.

Objectifs du chapitre

  • Connaître le fonctionnement et les limites de delay() et delayMicroseconds().
  • Mesurer une durée avec millis() ou micros() et écrire un test qui résiste au retour à zéro.
  • Programmer plusieurs tâches périodiques sans bloquer loop().
  • Écrire une machine à états temporisée et un délai de garde.
  • Choisir la méthode d’attente adaptée à la précision recherchée.

Prérequis

Les entrées-sorties numériques du chapitre 3, en particulier la lecture d’un bouton et l’anti-rebond.

Plan du chapitre

  1. Partie I – Délais bloquants
  2. 4.1Pourquoi gérer le temps ?
  3. 4.2delay() et ses limites
  4. Partie II – Temporisation non bloquante
  5. 4.3Lire l’heure avec millis() et micros()
  6. 4.4Plusieurs tâches, machine à états et délai de garde
  7. Partie III – Délais précis
  8. 4.5Cadence exacte et attentes courtes
  9. Partie IV – Exemple et évaluation
  10. 4.6Exemple : minuterie d’escalier
  11. 4.7À retenir et QCM
  12. 4.8Sources et références

Chapitre 4 · Partie I

Délais bloquants

La façon la plus simple d’attendre est de s’arrêter. C’est aussi la plus coûteuse : pendant l’attente, le programme principal ne fait plus rien.

Chapitre 4 · Section 4.1

Pourquoi gérer le temps ?

Le temps intervient dans un programme embarqué sous des formes très variées : la partie gauche de la figure 4.1 en donne les principaux usages. Avant de choisir une technique, il faut savoir ce que l’on attend et ce que le programme doit continuer à faire pendant ce temps.

Figure 4.1 interactif – Les usages du temps dans un programme, et trois façons d’attendre comparées à une cuisson.

4.1.1Trois façons d’attendre

La figure 4.1 compare trois techniques à la surveillance d’une cuisson :

  1. le délai bloquant (delay(), delayMicroseconds()) : le programme s’arrête et attend. C’est rester planté devant le four jusqu’à la fin de la cuisson ;
  2. la temporisation non bloquante (millis(), micros()) : le programme continue et consulte l’heure à chaque tour de loop(). C’est cuisiner autre chose en jetant un œil à l’horloge de temps en temps ;
  3. le timer matériel avec interruption : un périphérique compte seul et prévient le programme au bon moment. C’est le minuteur qui sonne, qu’il est inutile de surveiller (chapitre 7).

✎ Signaler une erreur dans cette section

Chapitre 4 · Section 4.2

delay() et ses limites

Les fonctions delay() et delayMicroseconds() suspendent l’exécution de loop() pendant la durée demandée. Elles sont parfaites pour un premier programme, mais deviennent vite un obstacle.

Figure 4.2 interactif – Le clignotement d’une LED avec delay() : réglez les durées allumée et éteinte, et observez la fréquence et le rapport cyclique.

4.2.1Deux fonctions d’attente

const int LED = 13;
void setup() { pinMode(LED, OUTPUT); }
void loop() {
  digitalWrite(LED, HIGH);
  delay(200);                // 200 ms allumée
  digitalWrite(LED, LOW);
  delay(800);                // 800 ms éteinte
}

Ce programme produit un signal de période 200 + 800 = 1 000 ms, soit 1 Hz, avec un rapport cyclique de 20 % (figure 4.2).

FonctionUnitéParamètreDomaine précis
delay(ms)millisecondeunsigned longde 1 ms à ≈ 49 jours
delayMicroseconds(us)microsecondeunsigned intde 3 à 16 383 µs

Attention

Au-delà de 16 383 µs, il faut utiliser delay() : avec une valeur plus grande, delayMicroseconds() peut donner un délai beaucoup trop court.

Pendant delay(), les interruptions restent actives : millis() continue d’avancer, la réception série remplit son tampon et les sorties PWM fonctionnent. En revanche, loop() est figée : aucune lecture de bouton ni de capteur n’est faite.

4.2.2Le problème du délai bloquant

Figure 4.3 interactif – Une LED qui clignote et un bouton qui commande une seconde LED : comparez les versions avec delay() et avec millis() en appuyant brièvement, puis longuement.

Ajoutons au clignotement la lecture d’un bouton qui allume une seconde LED :

void loop() {
  digitalWrite(LED, HIGH);
  delay(500);
  digitalWrite(LED, LOW);
  delay(500);
  // bouton lu une fois par seconde
  digitalWrite(LED2, digitalRead(BP) == LOW);
}

Pendant les deux delay(500), le programme ne lit pas le bouton : la réaction arrive jusqu’à une seconde plus tard, et un appui court peut être complètement perdu (figure 4.3). La version non bloquante, détaillée à la section 4.3, vérifie l’heure puis lit le bouton à chaque tour, soit plusieurs milliers de fois par seconde : la réaction est immédiate et la LED clignote toujours.

4.2.3Dans les coulisses : Timer0, millis() et delay()

Figure 4.4 interactif – Simulation du Timer0 : le compteur 8 bits, ses débordements et la mise à jour de millis().

Au démarrage, la fonction init() du cœur Arduino règle le Timer0 (chapitre 2) : l’horloge de 16 MHz est divisée par 64, ce qui donne un pas de 4 µs. Ce compteur de 8 bits déborde tous les 256 × 4 µs = 1,024 ms. À chaque débordement, l’interruption TIMER0_OVF_vect met à jour le compteur de millis(). Les 24 µs en trop à chaque débordement sont cumulés ; quand ils dépassent 1 ms, millis() avance de 2. C’est pourquoi millis() saute une valeur toutes les 41 ou 42 interruptions (figure 4.4).

delay() s’appuie sur micros(), donc sur le même timer. Sa version simplifiée, tirée du fichier wiring.c, compte les millisecondes écoulées :

void delay(unsigned long ms) {
  uint32_t debut = micros();
  while (ms > 0) {
    yield();
    while (ms > 0 && micros() - debut >= 1000) {
      ms--;
      debut += 1000;
    }
  }
}

Attention – Deux conséquences

  • Ne pas modifier les registres du Timer0 : millis(), micros() et delay() en dépendent.
  • Ne pas appeler delay() dans une routine d’interruption : les interruptions y sont masquées, le Timer0 ne met plus millis() à jour et l’attente ne se termine jamais (chapitre 6).

Exercices

1. Écrivez une boucle qui produit un signal de 50 Hz et de rapport cyclique 25 % sur D8 avec des délais bloquants.

T = 20 ms : 5 ms à l’état haut, 15 ms à l’état bas. digitalWrite(8, HIGH); delay(5); digitalWrite(8, LOW); delay(15); La durée de digitalWrite() (quelques µs) est négligeable.

2. On veut une impulsion de 20 ms. Pourquoi delayMicroseconds(20000) est-il un mauvais choix ?

20 000 dépasse 16 383 µs, limite de précision de delayMicroseconds() : le délai obtenu peut être très court. On écrit delay(20).

3. Combien d’interruptions TIMER0_OVF se produisent-elles par seconde ? Combien de fois millis() saute-t-il une valeur par seconde ?

1 / 1,024 ms ≈ 976,6 interruptions par seconde. Comme millis() doit avancer de 1 000 en une seconde, il fait 1 000 − 976,6 ≈ 23 sauts de 2 par seconde.

✎ Signaler une erreur dans cette section

Chapitre 4 · Partie II

Temporisation non bloquante

Au lieu d’attendre, on consulte l’heure. Cette idée simple, appliquée systématiquement, permet de faire « plusieurs choses à la fois » sur un microcontrôleur qui n’exécute qu’une instruction à la fois.

Chapitre 4 · Section 4.3

Lire l’heure avec millis() et micros()

millis() et micros() renvoient le temps écoulé depuis la mise sous tension. Elles ne bloquent rien : on lit l’heure, on compare, et l’on passe à la suite.

Figure 4.5 interactif – Les caractéristiques de millis() et micros(), et un test de réflexes qui mesure une durée.

4.3.1Deux horloges

millis()micros()
Typeunsigned long (32 bits)unsigned long (32 bits)
Résolution1 ms (certaines valeurs sautées)4 µs à 16 MHz, 8 µs à 8 MHz
Retour à 0232 ms ≈ 49,7 jours232 µs ≈ 71,6 minutes

Pour mesurer une durée, on lit l’heure avant et après, puis on soustrait :

unsigned long t0 = micros();
int n = analogRead(A0);
unsigned long duree = micros() - t0;   // environ 110 µs
Serial.println(duree);

Le test de réflexes de la figure 4.5 applique le même principe : on allume une LED après un temps aléatoire, on note millis(), on attend l’appui sur le bouton, et la différence donne le temps de réaction.

Attention

Stockez toujours les instants dans un unsigned long. Un int (16 bits signés) déborde au bout de 32,8 s et donne des durées fausses, voire négatives.

4.3.2Clignoter sans delay()

Figure 4.6 interactif – Le programme « clignoter sans delay() » au ralenti : chaque trait est un tour de loop().
const int LED = 13;
const unsigned long INTERVALLE = 500;   // ms
unsigned long precedent = 0;
bool etat = LOW;

void setup() { pinMode(LED, OUTPUT); }

void loop() {
  unsigned long maintenant = millis();
  if (maintenant - precedent >= INTERVALLE) {
    precedent = maintenant;              // nouveau départ
    etat = !etat;
    digitalWrite(LED, etat);
  }
  // ... le reste du programme continue ici
}

Le test est évalué à chaque tour de loop(), mais il n’est vrai qu’une fois toutes les 500 ms (figure 4.6). Entre deux changements, le processeur reste libre d’exécuter le reste du programme. C’est la structure de l’exemple BlinkWithoutDelay de l’IDE, et le modèle de toutes les temporisations de ce chapitre.

4.3.3Le retour à zéro de millis()

Figure 4.7 interactif – Le retour à zéro simulé avec un compteur 8 bits : placez « debut » près de 255 et comparez le test juste et le test faux.

Après 232 ms, soit environ 49,7 jours, millis() repasse par 0. Une soustraction entre entiers non signés se calcule modulo 232 : elle donne toujours le bon écart, même de part et d’autre du retour à zéro. Une addition, en revanche, peut déborder :

// JUSTE : fonctionne même après le retour à 0
if (millis() - debut >= DUREE) { ... }
// FAUX : se déclenche trop tôt près du débordement
if (millis() >= debut + DUREE) { ... }

Prenons DUREE = 1 000 et debut = 4 294 967 000, peu avant le débordement. La somme debut + DUREE dépasse 232 et devient 704 : dès le tour suivant, millis(), qui vaut environ 4 294 967 001, est supérieur à 704 et la temporisation se termine immédiatement. Avec la soustraction, 200 ms après le retour à zéro, millis() - debut = 200 − 4 294 967 000 + 232 = 496 : c’est bien le temps écoulé (figure 4.7).

À retenir

Toujours comparer une durée (une différence), jamais deux instants : millis() - debut >= DUREE.

✎ Signaler une erreur dans cette section

Chapitre 4 · Section 4.4

Plusieurs tâches, machine à états et délai de garde

La temporisation non bloquante se généralise : une variable d’instant par tâche, un état mémorisé pour les séquences, une durée maximale pour chaque attente. Ces trois techniques suffisent à structurer la plupart des programmes embarqués.

4.4.1Plusieurs tâches en même temps

Figure 4.8 interactif – Trois tâches indépendantes, chacune avec sa période : réglez les périodes des deux LED.
unsigned long tRouge = 0, tVerte = 0, tMesure = 0;
bool rouge = LOW, verte = LOW;

void loop() {
  unsigned long maintenant = millis();
  if (maintenant - tRouge >= 300) {        // tâche 1
    tRouge = maintenant;
    rouge = !rouge;
    digitalWrite(LED_R, rouge);
  }
  if (maintenant - tVerte >= 700) {        // tâche 2
    tVerte = maintenant;
    verte = !verte;
    digitalWrite(LED_V, verte);
  }
  if (maintenant - tMesure >= 1000) {      // tâche 3
    tMesure = maintenant;
    Serial.println(analogRead(A0));
  }
}

Chaque tâche possède sa variable d’instant et sa période. Aucune n’attend : elles semblent s’exécuter en parallèle (figure 4.8). Cette technique, appelée parfois ordonnancement coopératif, fonctionne tant que chaque tâche s’exécute rapidement et rend la main.

4.4.2Anti-rebond avec millis()

Figure 4.9 interactif – Un appui vu à l’oscilloscope : réglez la durée d’anti-rebond et comparez les appuis comptés.

L’anti-rebond présenté au chapitre 3 est une temporisation non bloquante : un nouvel état n’est accepté que s’il est resté identique pendant ANTIREBOND millisecondes. Chaque changement de lecture relance le chronomètre (figure 4.9).

const int BP = 2;
const unsigned long ANTIREBOND = 20;     // ms
int dernierLu = HIGH, etatStable = HIGH;
unsigned long tChangement = 0;
int compteur = 0;

void loop() {
  int lu = digitalRead(BP);
  if (lu != dernierLu) {                 // ça bouge encore
    tChangement = millis();
    dernierLu = lu;
  }
  if (millis() - tChangement >= ANTIREBOND && lu != etatStable) {
    etatStable = lu;                     // stable assez longtemps
    if (etatStable == LOW) compteur++;   // un appui validé
  }
}

4.4.3Machine à états temporisée : le feu tricolore

Figure 4.10 interactif – Le feu tricolore avec bouton piéton : simulation de la machine à états.

Un feu tricolore passe par des états (vert, orange, rouge) et change d’état selon le temps écoulé et les événements extérieurs. On le programme en mémorisant l’état courant et l’instant où l’on y est entré ; un switch teste, pour chaque état, la condition de sortie :

enum Etat { VERT, ORANGE, ROUGE };
Etat etat = VERT;
unsigned long debut = 0;        // entrée dans l’état
bool appel = false;             // bouton piéton

void changer(Etat e) {
  etat = e;
  debut = millis();
}
void loop() {
  if (digitalRead(BP) == LOW) appel = true;
  unsigned long t = millis() - debut;
  switch (etat) {
    case VERT:
      if (t >= 5000 || (appel && t >= 2000)) changer(ORANGE);
      break;
    case ORANGE:
      if (t >= 2000) changer(ROUGE);
      break;
    case ROUGE:
      if (t >= 5000) { appel = false; changer(VERT); }
      break;
  }
  afficher(etat);               // allume les 3 LED
}

Le programme ne s’arrête jamais : le bouton piéton est lu en permanence, même pendant le vert, et l’appel raccourcit la phase verte à 2 s minimum (figure 4.10).

Définition – Machine à états

Modèle d’un système qui se trouve à chaque instant dans un état parmi un nombre fini, et qui passe d’un état à un autre lorsque certaines conditions (durée écoulée, événement) sont remplies. On la représente par un diagramme d’états et on la programme avec une variable d’état et un switch.

4.4.4Délai de garde (timeout)

Figure 4.11 interactif – Un capteur rapide, lent ou débranché : choisissez le délai de garde et envoyez la requête.

Attendre une réponse sans limite de temps est une erreur classique : si le capteur est débranché, le programme reste bloqué pour toujours. Toute attente d’un événement extérieur doit avoir une durée maximale :

// Attend le caractère c, au plus delaiMax ms
bool attendre(char c, unsigned long delaiMax) {
  unsigned long debut = millis();
  while (millis() - debut < delaiMax) {
    if (Serial.available() && Serial.read() == c)
      return true;              // réponse reçue
  }
  return false;                 // délai dépassé
}
void loop() {
  Serial.print("PING\n");
  if (!attendre('K', 200)) {
    Serial.println("Pas de réponse");   // on continue quand même
  }
  delay(1000);
}

Plusieurs fonctions Arduino prévoient déjà un délai de garde : Serial.setTimeout(ms) fixe celui de readBytes(), parseInt()… (1 000 ms par défaut) ; pulseIn(broche, HIGH, us) renvoie 0 si aucune impulsion n’arrive avant la limite (1 s par défaut).

Exercices

1. Ajoutez au programme des trois tâches une quatrième tâche qui lit un bouton toutes les 10 ms.
unsigned long tBouton = 0;
// dans loop() :
if (maintenant - tBouton >= 10) {
  tBouton = maintenant;
  bool appui = (digitalRead(BP) == LOW);
  // ... traitement
}
2. Dans le feu tricolore, un piéton appuie quand le vert est allumé depuis 3,5 s. Quand le feu passe-t-il à l’orange ? Et s’il appuie après 1 s ?

Après 3,5 s, la condition appel && t >= 2000 est déjà vraie : le feu passe à l’orange immédiatement. Après 1 s, l’appel est mémorisé et le feu passe à l’orange à t = 2 s.

3. Pourquoi la variable appel est-elle remise à false à la fin du rouge et non au passage à l’orange ?

Un piéton qui appuie pendant l’orange ou le rouge serait sinon pris en compte au cycle suivant, raccourcissant inutilement le vert. En effaçant l’appel à la fin du rouge – quand les piétons ont pu traverser – seuls les appuis faits pendant le vert suivant comptent.

✎ Signaler une erreur dans cette section

Chapitre 4 · Partie III

Délais précis

Une temporisation non bloquante peut accumuler de petits retards, et certaines attentes très courtes exigent une précision de l’ordre de la microseconde. Quelques règles permettent de choisir la bonne méthode.

Chapitre 4 · Section 4.5

Cadence exacte et attentes courtes

Cadencer une mesure toutes les 100 ms n’est pas aussi simple qu’il y paraît : selon la façon d’écrire la temporisation, l’erreur reste bornée ou grandit sans cesse. Pour les attentes de quelques microsecondes, d’autres outils s’imposent.

Figure 4.12 interactif – Trois écritures d’une mesure toutes les 100 ms : réglez la durée de la mesure et d’un tour de boucle, et comparez l’erreur accumulée.

4.5.1Éviter la dérive

Trois écritures sont possibles (figure 4.12) :

// A. Avec delay() : période = 100 ms + durée de mesurer()
mesurer();
delay(100);

// B. precedent = millis() : le retard du test est perdu
if (millis() - precedent >= 100) {
  precedent = millis();
  mesurer();
}

// C. precedent += 100 : échéances fixes 100, 200, 300…
if (millis() - precedent >= 100) {
  precedent += 100;
  mesurer();
}

En A, chaque période dure 100 ms plus la durée de la mesure. En B, le test n’est vrai qu’au premier tour de loop() qui suit l’échéance, avec un léger retard ; comme on repart de l’heure actuelle, ce retard est perdu à chaque fois. Dans les deux cas, l’erreur s’accumule et grandit sans cesse. En C, chaque échéance est calculée à partir de la précédente : chaque mesure peut être un peu en retard, mais l’erreur reste bornée par la durée d’un tour de loop().

À retenir

Pour une cadence régulière, écrivez precedent += INTERVALLE. Pour une période strictement exacte, indépendante du programme, utilisez un timer en mode CTC (chapitre 7).

4.5.2Attentes courtes

Attentes courtes avec delayMicroseconds() et util/delay.h, et tableau de choix de la méthode.
Figure 4.13 – Attentes courtes avec delayMicroseconds() et util/delay.h, et tableau de choix de la méthode.

Un capteur à ultrasons demande une impulsion de déclenchement de 10 µs : delayMicroseconds() convient parfaitement.

digitalWrite(TRIG, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG, LOW);

La bibliothèque AVR util/delay.h offre _delay_us() et _delay_ms(). Leur durée est calculée à la compilation à partir de F_CPU : elles comptent des cycles d’horloge (62,5 ns à 16 MHz), n’utilisent pas le Timer0 et fonctionnent même interruptions masquées. Leur argument doit être une constante connue à la compilation.

#include <util/delay.h>
PORTB |= (1 << PB0);     // D8 à 1
_delay_us(10);
PORTB &= ~(1 << PB0);    // D8 à 0
_delay_ms(250);

Attention

Une interruption qui survient pendant delayMicroseconds() allonge le délai de la durée de sa routine. Pour un timing critique, on masque brièvement les interruptions avec noInterrupts() … interrupts().

4.5.3Quelle méthode choisir ?

MéthodeRésolutionBloquanteTimer0Usage
delay()1 msouiouitests, programmes très simples, setup()
delayMicroseconds()≈ 1 µsouinonimpulsions courtes, protocoles
_delay_us(), _delay_ms()1 cycleouinoncode AVR, durées constantes
millis()1 msnonouiclignotements, temporisations, tâches
micros()4 µsnonouimesure de durées courtes
Timer + interruption62,5 nsnonTimer1, 2…cadence stricte, signaux précis (chapitre 7)

Les attentes bloquantes restent acceptables quand elles sont courtes (quelques microsecondes) ou que le programme n’a rien d’autre à faire, par exemple dans setup().

Exercices

1. Une mesure dure 3 ms et l’on utilise l’écriture A. Quelle est l’erreur accumulée au bout d’une minute ?

Chaque période dure 103 ms au lieu de 100 : en 60 s, on fait environ 582 mesures au lieu de 600, et la dernière a près de 1,75 s de retard (582 × 3 ms).

2. Pourquoi _delay_us(n) avec une variable n lue au clavier n’est-il pas correct ?

La durée de _delay_us() est calculée par le compilateur, ce qui suppose un argument constant. Avec une variable, le calcul se fait à l’exécution en virgule flottante : le délai devient très imprécis et le code beaucoup plus gros. On utilise alors delayMicroseconds(n).

✎ Signaler une erreur dans cette section

Chapitre 4 · Partie IV

Exemple et évaluation

Un exemple complet réunit les techniques du chapitre ; une synthèse, un questionnaire et des sources terminent le chapitre.

Chapitre 4 · Section 4.6

Exemple : minuterie d’escalier

Une minuterie d’escalier allume la lumière pendant une durée fixe après un appui, et prévient avant l’extinction. Elle met en œuvre une temporisation non bloquante, redéclenchable, et un clignotement calculé à partir du temps écoulé.

Figure 4.14 interactif – Simulation en temps réel de la minuterie d’escalier : appuyez sur le bouton, y compris pendant le préavis.
const int BP = 2, LAMPE = 8;
const unsigned long DUREE   = 20000;   // 20 s
const unsigned long PREAVIS = 5000;    // clignote les 5 dernières s
unsigned long debut = 0;
bool allumee = false;

void setup() {
  pinMode(BP, INPUT_PULLUP);
  pinMode(LAMPE, OUTPUT);
}
void loop() {
  if (digitalRead(BP) == LOW) {        // appui : (re)démarrage
    debut = millis();
    allumee = true;
  }
  unsigned long t = millis() - debut;
  if (allumee && t >= DUREE) allumee = false;
  bool eteinte = allumee && t >= DUREE - PREAVIS
                 && (t / 250) % 2;     // clignote à 2 Hz
  digitalWrite(LAMPE, allumee && !eteinte);
}

Le bouton est lu à chaque tour : un appui pendant le fonctionnement relance les 20 s, même pendant le clignotement. C’est une temporisation redéclenchable. Le clignotement n’utilise aucune variable supplémentaire : t / 250 compte les quarts de seconde, et son reste modulo 2 alterne entre 0 et 1, ce qui donne 250 ms allumée, 250 ms éteinte. Un anti-rebond est inutile ici : redémarrer plusieurs fois la minuterie en quelques millisecondes ne change rien.

Exercices

1. Modifiez le programme pour que le préavis clignote à 1 Hz.

À 1 Hz, chaque demi-période dure 500 ms : on remplace (t / 250) % 2 par (t / 500) % 2.

2. Que faut-il changer pour que la minuterie ne soit pas redéclenchable (un appui pendant le fonctionnement est ignoré) ?

On ne relance la temporisation que si la lampe est éteinte : if (!allumee && digitalRead(BP) == LOW) { … }.

✎ Signaler une erreur dans cette section

Chapitre 4 · Section 4.7

À retenir et QCM

Le tableau suivant résume les fonctions et les techniques du chapitre. Le questionnaire de la figure 4.15 permet de vérifier qu’elles sont acquises.

ÉlémentÀ retenir
delay(ms), delayMicroseconds(us)Bloquent loop() ; les interruptions continuent. delayMicroseconds() précis de 3 à 16 383 µs.
millis(), micros()unsigned long ; Timer0 ; retour à 0 après ≈ 49,7 jours / ≈ 71,6 min ; résolution 1 ms / 4 µs
Temporisation non bloquanteif (millis() - precedent >= INTERVALLE) : un instant mémorisé et une période par tâche
Cadence exacteprecedent += INTERVALLE évite la dérive ; Timer en mode CTC pour une période stricte (chapitre 7)
Machine à étatsMémoriser l’instant d’entrée dans l’état ; tester la durée écoulée dans un switch

Bonnes habitudes

  • Différence : Comparer une durée, jamais deux instants : millis() - debut.
  • unsigned long : Jamais d’int pour stocker un instant.
  • Pas de delay() en ISR : Le temps ne progresse pas quand les interruptions sont masquées.
  • Timeout : Toute attente d’un événement extérieur a une durée maximale.

4.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 4.15 interactif – QCM d’évaluation du chapitre 4.

✎ Signaler une erreur dans cette section

Chapitre 4 · Section 4.8

Sources et références

La référence Arduino décrit les fonctions de temps et leurs limites ; le code source du cœur AVR (wiring.c) montre leur fonctionnement exact ; les articles de Nick Gammon développent le retour à zéro et la programmation multitâche avec millis().

Référence Arduino

Fiches techniques et code source

Pour aller plus loin

✎ Signaler une erreur dans cette section