MTdoubleClock: Exemple 5
On veut réaliser une led clignotante avec des flashs pilotés par un bouton marche/arrêt. Quand elle clignote, le chronogramme ressemble à:
Pour faire les flashs, on va utiliser une première horloge qui va en délivrer 5 flashs puis qui va s'arrêter. Pour faire le clignotement global, une deuxième horloge va déclencher la première toutes les deux secondes. Enfin, pour gérer le marche/arrêt, un bouton va activer ou non la deuxième horloge.
5 flashs
C'est ce métronome qui va allumer et éteindre la led pour la faire clignoter. Voici comment on peut définir une fonction qui allume la led et une fonction qui l'éteint:
void allume(void)
{
digitalWrite(LED_BUILTIN, HIGH);
}
void eteint(void)
{
digitalWrite(LED_BUILTIN, LOW);
}
Notre métronome va donc appeler alternativement chacune des deux fonctions. Si l'on veut un cycle allumé pendant 50ms et éteint pendant 100ms il faut bien prendre un MTdoubleClock qui permet de différentier les deux temps différents:
MTdoubleClock CinqFlash( ...
Cela va créer un objet (en gros une variable) de type MTdoubleClock.
Au début la led est éteinte. Il faut donc une première action (un appel à la fonction allume) au bout de 100ms:
MTdoubleClock CinqFlash(100 milli_secondes, ... , allume, ...
Les temps étant exprimés obligatoirement en millisecondes, on a donc le nombre 100. Le milli_secondes est un mot commentaire ignoré par le compilateur. On reconnaît ces mots à la présence d'un caractère "_" au milieu de plein de lettres minuscules sans avoir ce caractère en début.
Et pour la deuxième action, ce sera au bout de 50ms. On aura donc:
MTdoubleClock CinqFlash(100 milli_secondes, 50 milli_secondes, allume, eteint, ...
A chaque fois que l'on déclenche ce métronome, il faut ne faire que 5 flashs. On va donc programmer ce métronome pour qu'il s'arrête au bout de 10 actions (5 allumage et 5 extinctions):
MTdoubleClock CinqFlash( ..., 10 actions_et_arret, ...
actions_et_arret est aussi un mot commentaire.
La led ne doit pas clignoter par défaut, mais seulement quand le bouton sera appuyé. Le métronome doit donc être inactif à l'initialisation. Il faut donc le préciser avec le dernier paramètre penant la valeur MT_OFF:
MTdoubleClock CinqFlash( ..., MT_OFF);
La définition complète du métronome est donc:
MTdoubleClock CinqFlash(100 milli_secondes, 50 milli_secondes, allume, eteint, 10 actions_et_arret, MT_OFF);
Il faut comme dans tous les programmes qui utilisent MTobjets, inclure la bibliothèque utile. Ici on utilise un double métronome (le nom de l'objet est MTdoubleClock):
#include "MTdoubleClock.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects
Je conseille fortement de laisser le commentaire, si une autre personne voulait essayer le programme, elle aurait directement un lien de téléchargement. C'est valable pour toutes les bibliothèques que vous utilisez.
Déclenchement toutes les 2 secondes
Il faut maintenant déclencher le métronome CinqFlash toutes les deux seconde. Cela va donc se faire avec un deuxième métronome. Ce dernier n'ayant qu'une seule action régulière à faire, sera du type métronome simple, un MTclock. Toutes les deux secondes il va donc appeler la fonction start de CinqFlash. Bien que ce soit une méthode qui n'a pas de paramètre et qui ne retourne rien, on ne peut pas l'appeler directement car ce n'est pas une fonction avec une adresse fixe. Il va donc falloir appeler une autre fonction flash qui va se charger d'appeler CinqFlash.start(). Cela donne:
void flash(void)
{
CinqFlash.start();
}
MTclock Metronome(2000 milli_secondes, flash, ...
Ce métronome doit être à l'arrêt par défaut. Il ne fonctionnera qu'après un appui sur le bouton. Il faudra donc préciser le dernier paramètre en lui donnant la valeur MT_OFF:
MTclock Metronome( ..., MT_OFF);
Si on précise le dernier paramètre, il faut aussi préciser l'avant dernier qui est le nombre d’actions à faire. Par défaut c'est l'infini, mais comme il ne peut être omis, on doit le renseigner. La déclaration complète de Metronome sera donc:
Il faut comme dans tous les programmes qui utilisent MTobjets, inclure la bibliothèque utile. Ici on utilise un métronome simple (le nom de l'objet est MTclock):
#include "MTclock.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects
Si on analysait la bibliothèque, on pourrait voir que l'appel #include "MTdoubleClock" ramènera aussi le code pour les MTclock et l'appel ci-dessus est facultatif. Mais cela nécessite une connaissance de la bibliothèque qui n'est pas nécessaire et cela ne change pas le code final. Par défaut c'est plus simple de mettre en #include tous les objets utilisés.
Le bouton
Pour la fonction j'appuie ça clignote, je rappuie ça s'arrête correspond à l'objet MTcheckButton. C'est donc lui que nous allons utiliser.
On va commencer par donner un nom symbolique à la broche utilisée par le bouton:
const uint8_t PIN_BUTTON = A0; // Bouton câblé entre GND et A0
Définissons notre bouton:
MTcheckButton Bouton(PIN_BUTTON, marche, arrêt);
Cela définit un bouton nommé "Bouton". Il est du type MTcheckButton car c'est un poussoir simple. Il y a trois paramètres à passer:
- le nom de la broche
- le nom de la fonction qui va être appelée si on appuie sur le bouton
- le nom de la fonction qui va être appelée si on rappuie le bouton
Les fonctions appelées ne doivent pas avoir de paramètres et ne doivent rien retourner.
MTcheckButton admet un dernier paramètre qui doit donner l'état de repos. Il est plus simple de brancher le bouton entre A et GND (pas besoin de résistance) et c'est cet état qui est pris par défaut, on n'a donc pas besoin de rajouter ce paramètre. On pourrait aussi ne pas préciser la deuxième fonction si ce n'était pas le bouton qui éteignait la led.
Notez que dans la définition de Bouton on parle de marche et arret qui doivent être définis auparavant. Il va donc falloir les définir avant cette ligne. marche va permettre le clignottement. Cette fonction va donc appeler la fonction start du métronome ce qui fera clignoter la led. La fonction arret appelera le fonction stop du métronome, forçant ainsi l'arrêt du clignotement. Au cas où la led serait allumée quand on relâche le bouton, il faut éteindre la led par défaut. Voici la définition des deux fonctions:
void marche(void)
{
Metronome.start();
}
void arret(void)
{
Metronome.stop();
}
Il reste un dernier petit détail à régler. Avec ce code, la mise en marche commence par une temporisation de deux secondes avant les premiers flashs. Cela répond au problème posé, mais ce serait mieux si les flashs arrivaient dès l'appui sur le bouton. Metronome ne peut pas résoudre ceci car il déclenchera la première action qu'au bout de la temporisation. Il va donc falloir, lors de l'allumage, faire flasher manuellement la led. Pour cela il suffit d'introduire cet ordre dans la fonction marche qui devient:
void marche(void)
{
CinqFlash.start(); / Pour flasher dès la mise en marche
Metronome.start();
}
Ces deux lignes s'éxécutent rapidement pour l'humain qui regarde et elles sont indépendantes. On peut donc les permuter.
Il faut comme dans tous les programmes qui utilisent MTobjets, inclure la bibliothèque utile. Ici on utilise un bouton bistable (le nom de l'objet est MTcheckButton):
#include "MTcheckButton.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects
setup()
Comme on utilise une broche pour commander une led, il faut la déclarer en sortie:
void setup()
{
pinMode(LED_BUILTIN, OUTPUT);
}
loop()
Il n'y a rien à faire de plus, loop() ne nous sert à rien. Il va rester vide. Mais vous pouvez y mettre un autre programme, celui que nous avons fait est indépendant. Donc:
void loop(){}
J'ai tout mis sur la même ligne mais vous pouvez en prendre deux ou trois. Même si la fonction est vide et ne nous sert à rien apparemment, il faut la définir. En fait, elle va servir de boucle d'attente quand notre programme ne va pas s'intéresser au métronome.
Programme complet
Voici donc le programme complet:
// Clignotement d'une led qui flash avec un marche/arrêt
#include "MTclock.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects
#include "MTdoubleClock.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects
#include "MTcheckButton.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects
const uint8_t PIN_BUTTON = A0; // Bouton câblé entre GND et A0
// CinqFlash est la partie qui fait flasher la led
void allume(void)
{
digitalWrite(LED_BUILTIN, HIGH);
}
void eteint(void)
{
digitalWrite(LED_BUILTIN, LOW);
}
MTdoubleClock CinqFlash(100 milli_secondes, 50 milli_secondes, allume, eteint, 10 actions_et_arret, MT_OFF);
// Metronome est responsable du clignotement général
void flash(void)
{
CinqFlash.start();
}
MTclock Metronome(2000 milli_secondes, flash, MT_INFINI, MT_OFF);
//Bouton permet la marche ou l'arrêt général
void marche(void)
{
CinqFlash.start(); // Pour flasher dès la mise en marche
Metronome.start();
}
void arret(void)
{
Metronome.stop();
}
MTcheckButton Bouton(PIN_BUTTON, marche, arret);
void setup()
{
pinMode(LED_BUILTIN, OUTPUT);
}
void loop(){}