Utilisez correctement la fonction millis()

Le compteur de millisecondes disponible avec la fonction millis() est très pratique pour réaliser des temporisations. Cependant il faut l’utiliser correctement car sinon vos programmes risquent de ne plus fonctionner correctement au bout d’une cinquantaine de jours. C’est un bug vicieux car comme il n’apparaît qu’après une longue durée de fonctionnement, il risque fort de passer inaperçu en phase de test.

Le compteur de millisecondes est au format unsigned long int donc sur 32bits pour le compilateur avr-gcc. Il est initialisé au reset et revient donc à zéro au bout de 2³² ms soit 4294967296 ms et donc 4294967296/(1000*3600*24) = 49,7 jours.
Si on ne prend pas de précaution les temporisations utilisant ce compteur ne seront pas valables après environ 50 jours. Si on s’y prend correctement le retour à zéro du compteur ne pose aucun problème et les temporisations pourront fonctionner indéfiniment.

L’exemple de base de l’IDE arduino blinkWithoutDelay indique la bonne façon de faire et il vaut mieux ne pas faire différemment.
Voyons pourquoi.

Imaginons qu’on souhaite déclencher une action périodiquement toutes les 30 secondes.

On déclare une variable pour stocker la valeur du compteur au moment au fait l’action.
On déclare une variable contenant l’intervalle convertie en millisecondes [1] .
Ces deux variables sont de type unsigned long pour pouvoir contenir des valeurs sur 32bits.

unsigned long previousMillis=0 ;
unsigned long interval = 30000L;

On peut initialiser previousMillis à zéro ou bien avec millis().
Dans la boucle infinie (fonction loop), on compare la valeur courante du compteur (millis()) à sa valeur lors de la dernière action ( previousMillis ). Lorsque l’écart dépasse l’intervalle [2], on déclenche l’action et on sauve la valeur du compteur dans previousMillis [3].

void loop() {
  .....
  if( millis() - previousMillis >= interval) {
    previousMillis = millis();   
    DoAction() ;
    }
....
}

Tant que previousMillis est inférieur à millis() on comprend aisément le fonctionnement. On va voir qu’en procédant ainsi, avec une soustraction , le retour à zéro ne pose aucun problème .
Imaginons que la dernière action est été faite 25s avant le retour à zéro. Il faut donc que la prochaine action soit déclenchée 5s après le passage à zéro pour respecter l’intervalle de 30s. Donc lorsque le compteur de millisecondes vaudra 5000.
Notre programme fonctionne donc (sans reset) depuis 2³² - 25000 millisecondes. milis() retourne donc la valeur 4294967296 - 25000 = 4294942296.
Donc PreviousMillis =  4294942296 = 0xFFFF9E58
Quand le compteur passe à zéro, la soustraction millis() - previousMillis donne :

Donc millis() - previousMillis reste bien inférieure à 30000. Et ce jusqu’à ce que le compteur vaille 5000. On aura alors :
5000 - 4294942296 = 0x00001388 - 0xFFFF9E58 = 0x00013880 + x000061A8 = 0x00007530 = 30000
Donc millis() - previousMillis >= interval sera vraie. L’action sera bien déclenchée au bon moment et previousMillis vaudra alors 5000. On repart pour 50 jours sans problème.

Ce qu’il ne faut pas faire :
On pourrait avoir l’idée de calculer la valeur que doit avoir le compteur lorsque l’action doit être déclenchée et de déclencher l’action lorsque le compteur atteint cette valeur.

unsigned int actionTime = 30000L ;
unsigned long interval = 30000L;

Dans la boucle infinie, on "attend" que le compteur ait la bonne valeur puis on calcule la date de la prochaine action en ajoutant l’intervalle.

void loop() {
  .....
  if( millis() >=  actionTime ) {
    actionTime = millis() + interval ;  
    DoAction() ;
    }
....
}

Cet algorithme a l’air correct et le drame c’est qu’il fonctionne correctement pendant presque 50 jours.
Imaginons comme précédemment que l’action est été faite 25s avant le retour à zéro. La prochaine action doit être faite lorsque le compteur atteindra 5000.
La valeur de actionTime est alors :

mais comme il s’agit de valeur 32 bits, le poids fort n’est pas conservé et
actionTime = 0x00001388 = 5000
Mais au moment où actionTime prend cette valeur le compteur possède une valeur supérieure (0xFFFF9E58). Donc une nouvelle action est déclenchée juste après.
Puis actionTime vaudra 5001 et une autre action sera déclenchée... et il en sera ainsi jusqu’à ce que le compteur repasse à zéro et on reprendra un fonctionnement à peu près normal. Dans l’intervalle (ici pendant 5 seconde) l’action aura été déclenchée de nombreuses fois. On n’est plus vraiment dans le cas d’une action toute les 30 secondes !!!

Il n’est pas nécessaire d’attendre 50 jours pour tester votre programme. Il suffit d’écrire une fonction qui retourne la valeur de millis() augmentée d’une valeur proche de la valeur maximum et de l’appeler à la place de millis(). Dans l’exemple on part de 0xFFFEB3F8 qui est 85 secondes avant le retour à 0.

/*
 * Exemple showing millis() rollover 
 
15 May 2015
  by Philippe Arlotto
 */
#include <Arduino.h>          
extern HardwareSerial Serial; 
unsigned long previousMillis=0xFFFEB3F8 ; // 85s before rollover 
unsigned long interval = 30000L;
bool x = 0 ;
int n=0;
unsigned long testMillis(); // function to test millis() rollover
 
 
void setup() {
  // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);
   digitalWrite(13,0);
  // initialize serial port
  Serial.begin(9600);
  Serial.print("previousMillis at start=");
  Serial.print(testMillis(),DEC);
  Serial.print(" 0x"); Serial.println(testMillis(),HEX);
 
}
 
// the loop function runs over and over again forever
void loop() {
  if( testMillis() - previousMillis >= interval) {
   previousMillis = testMillis();  
   //Action
   x=1-x ;
   digitalWrite(13,x);
   n++;
   Serial.print("action "); Serial.print(n); Serial.print(" previousMillis=");
   Serial.print(testMillis(),DEC);
   Serial.print(" 0x"); Serial.println(testMillis(),HEX);
   // End of Action
   }
 
}
 
unsigned long testMillis(){
 
    return 0xFFFEB3F8 + millis() ;
}

Et le résultat qui prouve que ça fonctionne correctement :

Maintenant la mauvaise solution :

unsigned long actionTime = testMillis() ;
 
void badLoop() {
  if( testMillis() >= actionTime ) {
   actionTime = testMillis() + interval ;  
   //Action
   x=1-x ;
   digitalWrite(13,x);
   n++;
   Serial.print("action "); Serial.print(n); Serial.print(" done at ");
   Serial.print(testMillis(),DEC);
   Serial.print(" 0x"); Serial.print(testMillis(),HEX);
   Serial.print(" next due at "); Serial.print(actionTime,DEC);
   Serial.print(" 0x"); Serial.println(actionTime,HEX);
 
   // End of Action
   }
   }
 
}

ça marche au début quand la valeur du compteur est assez faible :

Mais après un certain temps :

Dès que le compteur est revenu à zéro les actions sont quasiment faites en permanence (5001,5002,5066,5133,...). Mais le pire c’est qu’ensuite ça reprend le fonctionnement normal :

Entre-temps il y a juste eu 362 actions en trop !!! [4]

En résumé il faut donc :

• utiliser des variables de type unsigned long.
• travailler par soustraction entre la valeur du compteur et la valeur qu’il avait lors de la dernière action.
• Tester votre programme en ajoutant un valeur proche du débordement.