|
Clock est une classe de métronomes. Ce sont des horloges qui vont délivrer un évènement onTime
régulièrement
class Clock
{
Clock(duree_ms=1000);
Constructeur, s'insère dans la liste des horloges gérées. duree_ms: période en ms
actif;
true par défaut . Si true, déclenche une action régulière, si false ne fait plus rien. Lecture seule
duree;
Période exprimée en millisecondes
depart;
Temps en ms de la dernière fin de comptage
*onTimeFunction;
Pointeur sur une fonction sans paramètre et ne retournnant rien qui sera appelée à chaque fin de comptage
*horlogeSuivante;
Pointeur sur l'horloge suivante dans la liste des horloges
start();
Permet de faire repartir le métronome si on l'a arrêté, réinitialise le comptage si il est actif
stop();
Suspend l'activité de ce métronome
onTime();
Appellée en fin de comptage, elle peut être surchargée pour définir des comportements supplémentaires. Par
défaut elle ne fait rien.
};
Quand un métronome est crée, il déclenche son action toutes les périodes déterminées par l'attribut
"milliseconde". La première occurence a lieu une période après sa création.
La plupart du temps, on ne fera que deux choses:
- déclarer l'instance, bien souvent par Clock variable;
- associer une fonction pour la fin du comptage genre variable.onTimeFunction = & action;
Le reste est en supplément, souvent parce que la gestion a besoin de ces méthodes
Si une fonction retarde la scrutation d'un métronome, celui-ci rattrapera son retard en racourcissant
le temps de comptage suivant. Ainsi sur un temps long le nombre d'appel de fin de comptage est correct.
Les déclenchements moyens ne dépendent pas de la charge de travail des différentes fonctions.
C'est scanEvent() qui, en visitant une fois chaque horloge, va s'occuper de savoir si une horloge doit
intervenir ou pas. C'est pour cela que scanEvent() est mis dans loop(). La résolution des horloges est égal
à l'intervalle séparant deux appel s à scanEvent(). Mais sur le long terme, la résolution est de 1ms.
Si la période du métronome est plus petite que l'intervalle d'appel de scanEvent(), le métronome
déclenchera à chaque appel de scanEvent().
La période est donnée par un entier long non signé (duree). Naturellement la période maximale est
d'environ 50 jours. Pour avoir des périodes plus longues, on peut ne déclencher l'action voulue que si le
métronome a fini son comptage X fois.
La fonction onTime() n'est utile qu pour la surcharger en créant une classe fille. Voir les
exemples complets.
Exemples d'utilisation:
Clock:
Clock metronome(); Crée metronome avec une prériode de 1s (par défaut)
Clock metronome(2000); Crée metronome avec une prériode de 2s
Clock metronome = new Clock(); Crée une instance dynamique metronome avec une prériode
de 1s (par défaut)
Clock metronome = new Clock(500); Crée une instance dynamique metronome avec une
prériode de 0,5s
new Clock(); Crée une instance dynamique metronome avec une prériode de 1s (par défaut),
mais sans pointeur dessus
actif:
metronome.actif=false; Interdit, utiliser stop()
metronome.actif=true; Interdit, utiliser start()
if (metronome.actif) ... permet d'interroger son activité
duree:
metronome.duree=2000; Change la période. La première période est mise à la création
du métronome.
metronome.duree = metronome.duree*2; Double la période
depart:
Serial.println("On en est à " + String((100*(millis() - metronome.depart)) / metronome.duree) + "%";
Affiche par exemple "On en est à 10%".
onTimeFunction:
metronome.onTimeFunction = & action; Appel la fonction void action(void) en fin de comptage
start():
metronome.start(); Redémarre le métronome si on l'avait arrêté
stop():
metronome.stop(); Arrête le métronome, il repartira sur metronome.start();
onTime():
metronome.onTime(); Ne fait rien!
Voir aussi:
- scanEvent(); Moteur de la gestion des évènements
- Timer; Temporisateur (une action une seule fois)
| 
Clock
