Arduino binaire réveil (4 / 16 étapes)

Etape 4: Temps de maintien de la

Pour garder une trace de temps que j’ai utilisé seulement l’arduino et la millis() de fonction arduino standard. Cette méthode ne sera pas totalement exacte, car l’oscillateur à quartz 16Mhz, qui décide de la fréquence d’horloge de l’arduinos CPU, ne sera probablement pas exactement 16 000 000 Hz. La bonne nouvelle est que vous pouvez mesurer comment inexacte votre horloge est et les compenser dans votre code, car le décalage doit être constant pour une période de temps donnée.

Mesurer comment inexacte votre arduino est :
Comme dit précédemment, l’arduino aura une petite erreur, cette erreur dépend de l’oscillateur à quartz et sera différente pour chaque arduino, pour mesurer combien mon horloge arduino diffère de l’heure, j’ai programmé à imprimer sur le temps (l’heure, minutes et seconde variables) par l’intermédiaire de série. J’ai ensuite laissez-le fonctionner pendant une longue période (plus de nuit et plus) et par rapport au temps de l’arduino avec une horloge que je savais était exacte, au début et à la fin de ma période de mesure. Diviser la différence de temps avec le temps, que le test a eu pour calculer l’erreur chaque heure. J’ai trouvé que mon arduino est d’environ 0,4 secondes de jeûner chaque heure. J’ai utilisé exacttimenow.com pour obtenir l’heure exacte, mais si vous avez une montre que vous savez est très exacte, n’hésitez pas à utiliser à la place.
Le code que j’avais l’habitude de garder le temps est une adaptation d’un code que j’ai trouvé sur les forums de l’arduino. J’ai il réécrit avec instructions if plutôt que de division et modulo, pour voir si il n’y aurait aucune différence de vitesse et a trouvé que la version if est plus de 15 fois plus rapide (bien que les deux sont encore assez rapide, plus d’infos sur le test ici).

Puisque je veux que les autres trucs dans ma boucle principale (comme le contrôle du capteur de toucher, recherchant les touches, etc.) se produise aussi souvent que possible, j’ai utilisé la version plus rapide.

Le code :
Chaque fois que l’horloge est appelée, elle ajoute le temps en millisecondes depuis dernière il a été appelé pour une variable m, lorsqu’une seconde a passé (m > 999) la deuxième variable est augmentée d’une unité et m est réinitialisé. Lorsque la variable secondes atteint 60, la variable minute sera augmentée par l’un, et secondes seront définis sur zéro. La même chose arrive avec la variable minutes ; lorsqu’il atteint 60, ajouter 1 à heures et minutes de réinitialiser. La variable de l’heure est réinitialisée lorsqu’il atteint 24.

Pour compenser que mon arduino est 0,4 secondes heure plus vite evey, je diminue les secondes avec deux secondes chaque cinquième heure.

____________________________________________________________________

The clock() function:

// CLOCK VARIABLES:
#define MAX_MILLIS_VALUE 34359738
unsigned long current_millis_value = 0;
unsigned long previous_millis_value = 0;
unsigned long m = 0;
int seconds = 0;
int minutes = 0;
int hours = 0;

void clock()
{
  current_millis_value = millis();
  if (current_millis_value < previous_millis_value) // if millis overflows
  {
    m += MAX_MILLIS_VALUE - previous_millis_value + current_millis_value;
  }
  else // if millis has not overflown
  {
    m += current_millis_value - previous_millis_value;
  }
  if (m>999)
  {
    seconds++;
    m = m-1000;
  }
  if (seconds>59) // if seconds == 60
  {
    minutes++;
    seconds = 0;
  }
  if (minutes>59) // if minutes == 60
  {
    hours++;
    minutes = 0;
    if(hours%5==0) // adjust the time with -2 seconds every 5th hour.
      seconds = seconds - 2;  // this will cause seconds to be -2,
                             // therefore seconds can't be unsigned.
  }
  if (hours>23) // if hours == 24
  {
    hours = 0;
  }

 The clock() function:

 

// CLOCK VARIABLES:
 #define MAX_MILLIS_VALUE 34359738
 unsigned long current_millis_value = 0;
 unsigned long previous_millis_value = 0;
 unsigned long m = 0;
 int seconds = 0;
 int minutes = 0;
 int hours = 0;

 

void clock()
 {
   current_millis_value = millis();
   if (current_millis_value < previous_millis_value) // if millis overflows
   {
     m += MAX_MILLIS_VALUE - previous_millis_value + current_millis_value;
   }
   else // if millis has not overflown
   {
     m += current_millis_value - previous_millis_value;
   }
   if (m>999)
   {
     seconds++;
     m = m-1000;
   }
   if (seconds>59) // if seconds == 60
   {
     minutes++;
     seconds = 0;
   }
   if (minutes>59) // if minutes == 60
   {
     hours++;
     minutes = 0;
     if(hours%5==0) // adjust the time with -2 seconds every 5th hour.
       seconds = seconds - 2;  // this will cause seconds to be -2,
                              // therefore seconds can't be unsigned.
   }
   if (hours>23) // if hours == 24
   {
     hours = 0;
   }
  
   previous_millis_value = current_millis_value;
 }
  previous_millis_value = current_millis_value;
}

______________________________________________________________________