Bon allez - comme j'ai rien de spécial pour m'occuper... tenez voici un petit bout de code (tapé ici donc je ne sais pas si ça compile et si ça marche), pour le principe et qui correspondrait à une petite machine à 4 états.
const byte pinLED[] = {2, 3, 4, 5};
const byte nbLEDs = sizeof(pinLED) / sizeof(pinLED[0]);
const byte pinBP = 6;
const unsigned long antiRebond = 15; // attente de stabilisation du bouton
byte LEDenCours; // le LED qui est allumé lorsque le chenillard tourne
unsigned long chronoDernierAllumage;
const unsigned long duree = 50; // vitesse du chenillard
enum : byte {ATTENTE_1ER_APPUI, ATTENTE_1ERE_RELACHE, ATTENTE_2ND_APPUI, ATTENTE_2NDE_RELACHE} etat;
// ----------------------------------------------------------------------------------------
// Teste si c'est le moment d'allumer la prochaine LED, si oui on le fait
// ----------------------------------------------------------------------------------------
void testePassageLEDSuivante()
{
if (millis() - chronoDernierAllumage >= duree) {
digitalWrite(pinLED[LEDenCours], LOW); // on éteint celle en cours
LEDenCours = (LEDenCours + 1) % nbLEDs; // on passe à la suivante, le modulo fait qu'on va compter 0, 1, 2, 3, puis 0, 1, 2, 3 etc
digitalWrite(pinLED[LEDenCours], HIGH); // on l'allume
chronoDernierAllumage = millis(); // on se souvient de quand c'était
}
}
// ----------------------------------------------------------------------------------------
// configuration initiale
// ----------------------------------------------------------------------------------------
void setup() {
for (int i = 0; i < nbLEDs; i++) {
pinMode(pinLED[i], OUTPUT); // en sortie
digitalWrite(pinLED[i], LOW); // éteinte
}
pinMode(pinBP, INPUT_PULLUP);
etat = ATTENTE_1ER_APPUI;
}
// ----------------------------------------------------------------------------------------
// GESTION DE LA MACHINE A ETAT
// -----------------------------------------------------------------------------------------
void loop() {
switch (etat) {
case ATTENTE_1ER_APPUI:
// ----------------------------------------------------------------------------------------
// on est au repos, on ne fait rien tant que le bouton n'est pas appuyé
// ----------------------------------------------------------------------------------------
if (digitalRead(pinBP) == LOW) { // on a appuyé
delay(antiRebond); // anti-rebond du pauvre
etat = ATTENTE_1ERE_RELACHE;
LEDenCours = 0;
digitalWrite(pinLED[LEDenCours], HIGH);
chronoDernierAllumage = millis();
}
break;
case ATTENTE_1ERE_RELACHE:
// ----------------------------------------------------------------------------------------
// le bouton est appuyé, le chenillard tourne; on attend la relâche
// ----------------------------------------------------------------------------------------
testePassageLEDSuivante();
if (digitalRead(pinBP) == HIGH) { // on a relâché
delay(antiRebond); // anti-rebond du pauvre
etat = ATTENTE_2ND_APPUI;
}
break;
case ATTENTE_2ND_APPUI:
// ---------------------------------------------------------------------------------------------
// le bouton est relâché, le chenillard tourne; on attend le nouvel appui pour éteindre tout
// ---------------------------------------------------------------------------------------------
testePassageLEDSuivante();
if (digitalRead(pinBP) == LOW) { // on a appuyé à nouveau
delay(antiRebond); // anti-rebond du pauvre
etat = ATTENTE_2NDE_RELACHE;
for (int i = 0; i < nbLEDs; i++) digitalWrite(pinLED[i], LOW);
}
break;
case ATTENTE_2NDE_RELACHE:
// ----------------------------------------------------------------------------------------
// le bouton est appuyé, le chenillard est arrêté; on attend la relâche pour recommencer
// ----------------------------------------------------------------------------------------
if (digitalRead(pinBP) == HIGH) { // on a relâché
delay(antiRebond); // anti-rebond du pauvre
etat = ATTENTE_1ER_APPUI;
}
break;
}
}
dans ce code la boucle teste en permanence dans quel état on est et réagit en fonction de cela. On peut être au repos, c'est à dire en attente du premier click sur le bouton (état = ATTENTE_1ER_APPUI). tant qu'on n'a pas appuyé, on ne fait rien.
Au moment où on appui, on allume la première LED, on mémorise le moment d'allumage et on change d'état - on passe à ATTENTE_1ERE_RELACHE. Dans cet état le chevillard doit tourner, donc on appelle la fonction qui vérifie si la durée d'attente entre 2 LEDs et atteinte et si oui on éteint la LED en cours et on allume la suivante, puis on vérifie si le bouton est relâché. tant qu'il n'est pas relâché on reste dans cet état et donc le chenillard tourne.
une fois le bouton relâché, on passe à l'état ATTENTE_2ND_APPUI. Dans cet état on continue le chenillard (donc appelle la fonction testePassageLEDSuivante()) et on vérifie le bouton. Tant qu'il n'est pas appuyé de nouveau le chenillard continue à tourner.
une fois le bouton appuyé à nouveau, on éteint tout et on passe à l'état ATTENTE_2NDE_RELACHE.
une fois le bouton relâché, on repasse à l'état de début ATTENTE_1ER_APPUI et on est prêt à recommencer.
(On pourrait ne faire qu’avec deux états en testant juste appui et relâche et avoir une variable supplémentaire qui dirait si on est en état « chenillard actif » ou pas pour décider de l’action. J’ai préféré 4 états car c’est plus simple à lire comme cela)
c'est le principe de la programmation par machine à états que j'explique dans mon petit tuto si vous voulez mieux comprendre
Voilà - en espérant que ce code fonctionne (à vérifier, je suis dans un train juste sur mon tel) et qu'il vous donnera des pistes pour vos programmes de ce genre.
:))