Ajout bouton poussoir et fonction

Bonjour à tous !
J’ai besoin d’aide dans la modification d’un code .
C’est le code sm tik tak eurorack de synthmafia .
J’explique le fonctionnement du code actuel :
C’est un module eurorack clock divider, il y a deux potentiomètre , un bouton , 4 sortie jack et led.
Le potentiomètre 1 choisie le bpm
Le potentiomètre 2 choisie la longueur du gate ( durée de la tension envoyer )
Le bouton sert de tap tempo .
Les jack envoie des tension en fonction de la vitesse du bpm, le jack 1 à une tension tous les temps , le jack 2 tous les 2 temps , pareil pour 3 et 4 .

J’aimerais rajouter un deuxième bouton , et dire à l’arduino que quand j’appuie sur ce bouton 1 fois il fait appel à une fonction ( que je créerez par la suite ) et rentre dans un mode complètement différent et y reste tant que je ne re appuie pas sur le bouton .
Quand j’appuie une deuxième fois sur le bouton, l’arduino sort de cette fonction et rentre encore dans une fonction différente .

Mais je rame sur comment faire l’appel de mes fonctions et à quel endroit dans le code …
Quelqu’un peux m’aider ? Me faire un pseudo code pour me montrer comment m’y prendre ?

Merci d’avance à la communauté pour votre aide :slight_smile:

Voici le code :

/*********************Programmed by SyntheMafia(06_06_2018)**********************/


#include <SimpleTimer.h>


SimpleTimer timer;
int count = 0;


void setup() {
 Serial.begin(9600);
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
 pinMode(4, OUTPUT);
 pinMode(5, OUTPUT);
 pinMode(10, INPUT);
   
}

bool started = false;
int priority = 0;
int tapX = 0;
int tapactual;
int tap_time;
int time_actual;
int input1X = 0;
float BPM; 
int max_BPM = 500; /******************************************** write hier the max BPM that you want */
int min_BPM = 60;  /******************************************** write hier the min BPM that you want */
int max_time = ((1/(min_BPM/60)) * 1000);
int min_time = ((1/(max_BPM/60)) * 1000);


void loop() {
 
 if (!started) {
   cycle_on();
   started = true;
 }
 
 timer.run();

 
 if (digitalRead(10) == HIGH && tapX ==0){
   tapX = millis ();
   while (digitalRead (10) == HIGH){
     delay(10);
   }
  }
  
 if (digitalRead (10) == HIGH && tapX !=0  ){
   tapactual = millis ();
   tap_time = (tapactual - tapX);
   if (tap_time > max_time){
     tap_time = max_time;  
   }
    if (tap_time < min_time){
     tap_time = min_time;  
   }
   tapX = tapactual;
   priority = 1; 
   while (digitalRead (10) == HIGH){
     delay(10);
   }
  }
  time_actual = millis ();
   if ((time_actual - tapX) > 4000){
     tapX = 0; 
   }
  
 Serial.print(" BPM: ");
 Serial.println(BPM);
 

}


/*********************************************************************/



void cycle_off() {
 digitalWrite(2, LOW);
 digitalWrite(3, LOW);
 digitalWrite(4, LOW);
 digitalWrite(5, LOW);

 count++;

 if (count == 8) {
   count = 0;
 }
}



/*********************************************************************/


void cycle_on() {

 switch (count) {
   case 0:
     digitalWrite(2, HIGH);
     digitalWrite(3, HIGH);
     digitalWrite(4, HIGH);
     digitalWrite(5, HIGH);
     break;

   case 1:
     digitalWrite(2, HIGH);
     break;

   case 2:
     digitalWrite(2, HIGH);
     digitalWrite(3, HIGH);
     break;

   case 3:
     digitalWrite(2, HIGH);
     break;
 
   case 4:
     digitalWrite(2, HIGH);
     digitalWrite(3, HIGH);
     digitalWrite(4, HIGH);
     break;

   case 5:
     digitalWrite(2, HIGH);
     break;

   case 6:
     digitalWrite(2, HIGH);
     digitalWrite(3, HIGH);
     break;

   case 7:
     digitalWrite(2, HIGH);
     break;
 }

 int input1 = analogRead(A0);
 int input2 = analogRead(A1);

 if (priority == 0){
    BPM = map(input1, 0, 1023, min_BPM, max_BPM);
    
 }
 
 if (priority == 1){
    BPM = (60000 / tap_time);
   
    
 }


 if (input1X - input1 > 5){
   priority = 0;
 }
 if (input1X - input1 < -5){
   priority = 0;
 }

 input1X = input1;
 
 
 


 
 float duration_percentage =  map(input2, 0, 1023, 1, 90);

 int cycletime = (60000/BPM);

 float cycle_start = cycletime;
 float cycle_stop = (cycletime * (duration_percentage/100));


 timer.setTimeout(cycle_start, cycle_on);
 timer.setTimeout(cycle_stop, cycle_off);

}

/*********************************************************************/

y'a un smiley à lunettes dans le code... méfiez vous il mord peut-être...

:grin: :smiling_imp:

J'aimerais rajouter un deuxième bouton , et dire à l'arduino que quand j'appuie sur ce bouton 1 fois il fait appel à une fonction ( que je créerez par la suite ) et rentre dans un mode complètement différent et y reste tant que je ne re appuie pas sur le bouton .
Quand j'appuie une deuxième fois sur le bouton, l'arduino sort de cette fonction et rentre encore dans une fonction différente .

Tu peux créer une variable qui va compter les appuis. Si tu boucles sur 3 appuis, tu calcules 'modulo 3'.
A chaque appui de bouton, tu incrémentes la variable (modulo 3) et selon sa valeur (switch / case) tu exécutes la fonction :

if (!digitalRead(bouton)) { // Si bouton en INPUT_PULLUP, LOW pour un appui
  delay(30); // debounce du bouton
  compteur = (compteur+1)%3; // incrément, modulo 3
  switch (compteur) {
     case 0:
        fonction0();
        break;
     case 1:
        fonction1();
        break;
     case 2:
        fonction2();
        break;
     default:
        Serial.prinln("Probleme bouton");
        while (1);
    }
}

Merci beaucoup pour ton explication c’est pile ce que j’avais besoin :slight_smile:
Par contre avec ce code l’arduino comprend ,
" Quand le bouton est enfoncer
,passe très vite de fonction en fonction ".
Alors que moi j’aimerais qu’une fois entré dans la fonction1() il y reste tant que je n’ai pas rappuyer sur le bouton .
Tu vois ce que je veux dire ?

Il faut placer ça ou dans le code ? Dans la loop ou le setup ?

Il faut placer ça dans la loop.
Si l'arduino comprend ainsi, c'est que ton bouton est en pull-down. Dans ce cas, change LOW en HIGH dans le test.

Mon code ressemble a ça et ne fonctionne pas pour le passage dans differente fonction. ( c’est un debut de la loop).
Pour rapelle , le but est que si je clique sur le bouton, je passe dans le mode 1 et j’y reste , si je clique encore sur le bouton, je passe dans le mode 2 et j’y reste , etc etc .

si quelqu’un peux m’expliquer pourquoi et ou j’ai fait n’importe quoi x) ! merci :slight_smile:

#include <SimpleTimer.h>
#include <LiquidCrystal.h>

/*********************Programmed by SyntheMafia(06_06_2018)**********************/

const int rs = 12, en = 11, d4 = 9, d5 = 8, d6 = 7, d7 = 6;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);


SimpleTimer timer;
int count = 0;
int compteur = 0;

void setup() {
  
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(10, INPUT_PULLUP);
  pinMode(13,INPUT_PULLUP);

}

bool started = false;
int priority = 0;
int tapX = 0;
int tapactual;
int tap_time;
int time_actual;
int input1X = 0;
float BPM; 
int max_BPM = 250; /******************************************** write hier the max BPM that you want */
int min_BPM = 60;  /******************************************** write hier the min BPM that you want */
int max_time = ((1/(min_BPM/60)) * 1000);
int min_time = ((1/(max_BPM/60)) * 1000);





void loop() {

 if (!started && !digitalRead(13)){
    delay(30);
 compteur = (compteur+1)%3;
     
    switch (compteur){
     
      case 0:
      cycle_on();
      break;

      case 1:
      cycle_on1();
      break;

      case 2:
      cycle_on2();
      break;

    }
     started = true;
    
  }
 
  
  timer.run();

  
  if (digitalRead(10) == HIGH && tapX ==0){
    tapX = millis ();
    while (digitalRead (10) == HIGH){
      delay(10);
    }
   }
   
  if (digitalRead (10) == HIGH && tapX !=0  ){
    tapactual = millis ();
    tap_time = (tapactual - tapX);
    if (tap_time > max_time){
      tap_time = max_time;  
    }
     if (tap_time < min_time){
      tap_time = min_time;  
    }
    tapX = tapactual;
    priority = 1; 
    while (digitalRead (10) == HIGH){
      delay(10);
    }
   }
   time_actual = millis ();
    if ((time_actual - tapX) > 4000){
      tapX = 0; 
      }
   
  
 
  }


/*********************************************************************/



void cycle_off() {
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);

  count++;

  if (count == 8) {
    count = 0;
  }
}



/*********************************************************************/
  

void cycle_on() {
   
  lcd.begin(16,2);
  lcd.print(" BPM: ");
  lcd.println(BPM);
  delay(10);

 
    
   
  switch (count) {
    case 0:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
      break;

    case 1:
      digitalWrite(2, HIGH);
      break;

    case 2:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 3:
      digitalWrite(2, HIGH);
      break;
  
    case 4:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      break;

    case 5:
      digitalWrite(2, HIGH);
      break;

    case 6:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 7:
      digitalWrite(2, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0){
     BPM = map(input1, 0, 1023, min_BPM, max_BPM);
     
  }
  
  if (priority == 1){
     BPM = (60000 / tap_time);
    
     
  }


  if (input1X - input1 > 5){
    priority = 0;
  }
  if (input1X - input1 < -5){
    priority = 0;
  }

  input1X = input1;
  
  
  


  
  float duration_percentage =  map(input2, 0, 1023, 1, 90);
 
  int cycletime = (60000/BPM);

  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage/100));


  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);

}
/**************************************************************************************/

void cycle_on1() {
   
  lcd.begin(16,2);
  lcd.print(" mode 1 ");
 
  delay(10);

 
    
   
  switch (count) {
    case 0:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      
      break;

    case 1:
      digitalWrite(2, HIGH);
      digitalWrite(3,HIGH);
      break;

    case 2:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 3:
      digitalWrite(2, HIGH);
      digitalWrite(3,HIGH);
      break;
  
    case 4:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 5:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 6:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 7:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0){
     BPM = map(input1, 0, 1023, min_BPM, max_BPM);
     
  }
  
  if (priority == 1){
     BPM = (60000 / tap_time);
    
     
  }


  if (input1X - input1 > 5){
    priority = 0;
  }
  if (input1X - input1 < -5){
    priority = 0;
  }

  input1X = input1;
  
  
  


  
  float duration_percentage =  map(input2, 0, 1023, 1, 90);
 
  int cycletime = (60000/BPM);

  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage/100));


  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);

}
/********************************************************************************/

void cycle_on2() {
   
  lcd.begin(16,2);
  lcd.print(" mode 2 ");
 
  delay(10);

 
    
   
  switch (count) {
    case 0:
      digitalWrite(5, HIGH);
      break;

    case 1:
      digitalWrite(5, HIGH);
      break;

    case 2:
      digitalWrite(5, HIGH);
      break;

    case 3:
      digitalWrite(5, HIGH);
      break;
  
    case 4:
      digitalWrite(5, HIGH);
      break;

    case 5:
      digitalWrite(5, HIGH);
      break;

    case 6:
      digitalWrite(5, HIGH);
      break;

    case 7:
      digitalWrite(5, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0){
     BPM = map(input1, 0, 1023, min_BPM, max_BPM);
     
  }
  
  if (priority == 1){
     BPM = (60000 / tap_time);
    
     
  }


  if (input1X - input1 > 5){
    priority = 0;
  }
  if (input1X - input1 < -5){
    priority = 0;
  }

  input1X = input1;
  
  
  


  
  float duration_percentage =  map(input2, 0, 1023, 1, 90);
 
  int cycletime = (60000/BPM);

  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage/100));


  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);

}

Je n’ai pas eu beaucoup de temps pour t’aider, mais là j’ai plus de temps.
J’ai un peu nettoyé ton code, simplifié quelques lignes par ci par là, mais surtout j’ai mis des affichages sur la console de l’IDE Arduino.

Voici le code : teste-le et dis moi ce qui apparaît dans la console (tu peux copier coller le contenu dans ta réponse). Règle la à 115200 bauds.

#include <SimpleTimer.h>
#include <LiquidCrystal.h>

/*********************Programmed by SyntheMafia(06_06_2018)**********************/

const int rs = 12, en = 11, d4 = 9, d5 = 8, d6 = 7, d7 = 6;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
SimpleTimer timer;
int count = 0;
int compteur = 0;

void setup() {
  Serial.begin(115200);
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(10, INPUT_PULLUP);
  pinMode(13, INPUT_PULLUP);
}

bool started = false;
int priority = 0;
int tapX = 0;
int tapactual;
int tap_time;
int time_actual;
int input1X = 0;
float BPM;
int max_BPM = 250; /******************************************** write hier the max BPM that you want */
int min_BPM = 60;  /******************************************** write hier the min BPM that you want */
int max_time = ((1 / (min_BPM / 60)) * 1000);
int min_time = ((1 / (max_BPM / 60)) * 1000);

void loop() {
  if (!started && !digitalRead(13)) {
    delay(30);
    compteur = (compteur + 1) % 3;
    Serial.print ("Compteur = "); Serial.println(compteur);

    switch (compteur) {
      case 0:
        cycle_on();
        break;
      case 1:
        cycle_on1();
        break;
      case 2:
        cycle_on2();
        break;
    }
    started = true;
  }

  timer.run();
  if (digitalRead(10) == HIGH && tapX == 0) {
    tapX = millis ();
    while (digitalRead (10) == HIGH);
  }

  if (digitalRead (10) == HIGH && tapX != 0) {
    tapactual = millis ();
    tap_time = (tapactual - tapX);
    if (tap_time > max_time) tap_time = max_time;
    if (tap_time < min_time) tap_time = min_time;
    tapX = tapactual;
    priority = 1;
    while (digitalRead (10) == HIGH);
  }

  time_actual = millis ();
  if ((time_actual - tapX) > 4000) tapX = 0;
}

/*********************************************************************/

void cycle_off() {
  Serial.println("Cycle_off");
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  count = (count + 1) % 8;
}

/*********************************************************************/

void cycle_on() {
  Serial.println("Cycle_on");
  lcd.begin(16, 2);
  lcd.print(" BPM: ");
  lcd.println(BPM);
  delay(10);

  switch (count) {
    case 0:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
      break;
    case 1:
      digitalWrite(2, HIGH);
      break;
    case 2:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
    case 3:
      digitalWrite(2, HIGH);
      break;
    case 4:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      break;
    case 5:
      digitalWrite(2, HIGH);
      break;
    case 6:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
    case 7:
      digitalWrite(2, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0) BPM = map(input1, 0, 1023, min_BPM, max_BPM);
  if (priority == 1) BPM = (60000 / tap_time);

  if (input1X - input1 > 5 || input1X - input1 < -5) priority = 0;
  input1X = input1;

  float duration_percentage =  map(input2, 0, 1023, 1, 90);
  int cycletime = (60000 / BPM);
  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage / 100));

  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);
}
/**************************************************************************************/

void cycle_on1() {
  Serial.println("Cycle_on1");
  lcd.begin(16, 2);
  lcd.print(" mode 1 ");
  delay(10);

  switch (count) {
    case 0:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
    case 1:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
    case 2:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
    case 3:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
    case 4:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
    case 5:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
    case 6:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
    case 7:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0) BPM = map(input1, 0, 1023, min_BPM, max_BPM);
  if (priority == 1) BPM = (60000 / tap_time);

  if (input1X - input1 > 5) || input1X - input1 < -5) priority = 0;
    input1X = input1;

    float duration_percentage =  map(input2, 0, 1023, 1, 90);
    int cycletime = (60000 / BPM);
    float cycle_start = cycletime;
    float cycle_stop = (cycletime * (duration_percentage / 100));

    timer.setTimeout(cycle_start, cycle_on);
    timer.setTimeout(cycle_stop, cycle_off);
  }
/********************************************************************************/

void cycle_on2() {
  Serial.println("Cycle_on2");
  lcd.begin(16, 2);
  lcd.print(" mode 2 ");
  delay(10);

  switch (count) {
    case 0:
      digitalWrite(5, HIGH);
      break;
    case 1:
      digitalWrite(5, HIGH);
      break;
    case 2:
      digitalWrite(5, HIGH);
      break;
    case 3:
      digitalWrite(5, HIGH);
      break;
    case 4:
      digitalWrite(5, HIGH);
      break;
    case 5:
      digitalWrite(5, HIGH);
      break;
    case 6:
      digitalWrite(5, HIGH);
      break;
    case 7:
      digitalWrite(5, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0) BPM = map(input1, 0, 1023, min_BPM, max_BPM);
  if (priority == 1) BPM = (60000 / tap_time);

  if (input1X - input1 > 5 || input1X - input1 < -5) priority = 0;
  input1X = input1;

  float duration_percentage =  map(input2, 0, 1023, 1, 90);
  int cycletime = (60000 / BPM);
  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage / 100));

  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);
}

N’hésite pas à commenter le contenu de la console, pour indiquer si tu appuies sur un bouton ou non, ou si ce qui se passe n’est pas correct et à préciser ce qui devrait se passer dans ce cas.

Merci pour ton aide ! Mais ça ne fonctionne toujours pas ..
dans le moniteur serie s'affiche :

Cycle_on1
Cycle_on
Cycle_off
Cycle_on
Cycle_off
Cycle_on
Cycle_off
Cycle_on
Cycle_off
Cycle_on
Cycle_off
Cycle_on
Cycle_off

il y a écrit ça a l'infini tant que je n'appuie sur rien .
Quand j'appuie sur le bouton pour le changement de fonction l'affichage au moniteur série ce stop sur cycle on ou cycle off , ca depend sur lequel je suis quand je clique .. Puis ça redemarre quand je relache.

Si le module fonctionnerais comme je le souhaite il afficherais sur le moniteur serie :

cycle_on
cycle_off
cycle_on
cycle_off ( a l'infinie tant que je n'appuie pas sur le bouton de changement de fonction )

cycle_on1 ( a l'infini si j'ai appuyer une fois sur le bouton de changement de fonction )
cycle_off
cycle_on1
cycle_off

cycle_on2
cycle_off
cycle_on2
cycle_off ( a l'infini si j'ai appuyer une seconde fois sur le bouton de changement de fonction )

cycle_on
cycle_off
cycle_on
cycle_off ( a l'infini si je rappuie une troisième fois sur le bouton de changement de fonction )

J’ai modifiez le code d’une autre manière hier soir, j’ai ajouter une fonction pour le comptage, je ne sais pas si le code était mieux avant ou maintenant …? en tous cas ça ne fonctionne pas non plus haha

#include <SimpleTimer.h>
#include <LiquidCrystal.h>

/*********************Programmed by SyntheMafia(06_06_2018)**********************/

const int rs = 12, en = 11, d4 = 9, d5 = 8, d6 = 7, d7 = 6;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);


SimpleTimer timer;
int count = 0;
int compteur = 0;

void setup() {
  
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(10, INPUT_PULLUP);
  pinMode(13,INPUT_PULLUP);

}

bool started = false;
int priority = 0;
int tapX = 0;
int tapactual;
int tap_time;
int time_actual;
int input1X = 0;
float BPM;
int max_BPM = 250; /******************************************** write hier the max BPM that you want */
int min_BPM = 60;  /******************************************** write hier the min BPM that you want */
int max_time = ((1/(min_BPM/60)) * 1000);
int min_time = ((1/(max_BPM/60)) * 1000);





void loop() {

 if (!started && !digitalRead(13)){
    fonction_compteur();
    started = true;
    
  }
 
  
  timer.run();

  
  if (digitalRead(10) == HIGH && tapX ==0){
    tapX = millis ();
    while (digitalRead (10) == HIGH){
      delay(10);
    }
   }
  
  if (digitalRead (10) == HIGH && tapX !=0  ){
    tapactual = millis ();
    tap_time = (tapactual - tapX);
    if (tap_time > max_time){
      tap_time = max_time;  
    }
     if (tap_time < min_time){
      tap_time = min_time;  
    }
    tapX = tapactual;
    priority = 1;
    while (digitalRead (10) == HIGH){
      delay(10);
    }
   }
   time_actual = millis ();
    if ((time_actual - tapX) > 4000){
      tapX = 0;
      }
  
  
 
  }


/*********************************************************************/



void cycle_off() {
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);

  count++;

  if (count == 8) {
    count = 0;
  }
}



/*********************************************************************/
  

void cycle_on() {
  
  lcd.begin(16,2);
  lcd.print(" BPM: ");
  lcd.println(BPM);
  delay(10);

 
    
  
  switch (count) {
    case 0:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
      break;

    case 1:
      digitalWrite(2, HIGH);
      break;

    case 2:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 3:
      digitalWrite(2, HIGH);
      break;
  
    case 4:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      break;

    case 5:
      digitalWrite(2, HIGH);
      break;

    case 6:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 7:
      digitalWrite(2, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0){
     BPM = map(input1, 0, 1023, min_BPM, max_BPM);
    
  }
  
  if (priority == 1){
     BPM = (60000 / tap_time);
    
    
  }


  if (input1X - input1 > 5){
    priority = 0;
  }
  if (input1X - input1 < -5){
    priority = 0;
  }

  input1X = input1;
  
  
  


  
  float duration_percentage =  map(input2, 0, 1023, 1, 90);
 
  int cycletime = (60000/BPM);

  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage/100));


  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);

}
/**************************************************************************************/

void cycle_on1() {
  
  lcd.begin(16,2);
  lcd.print(" mode 1 ");
 
  delay(10);

 
    
  
  switch (count) {
    case 0:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      
      break;

    case 1:
      digitalWrite(2, HIGH);
      digitalWrite(3,HIGH);
      break;

    case 2:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 3:
      digitalWrite(2, HIGH);
      digitalWrite(3,HIGH);
      break;
  
    case 4:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 5:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 6:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 7:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0){
     BPM = map(input1, 0, 1023, min_BPM, max_BPM);
    
  }
  
  if (priority == 1){
     BPM = (60000 / tap_time);
    
    
  }


  if (input1X - input1 > 5){
    priority = 0;
  }
  if (input1X - input1 < -5){
    priority = 0;
  }

  input1X = input1;
  
  
  


  
  float duration_percentage =  map(input2, 0, 1023, 1, 90);
 
  int cycletime = (60000/BPM);

  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage/100));


  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);

}
/********************************************************************************/

void cycle_on2() {
  
  lcd.begin(16,2);
  lcd.print(" mode 2 ");
 
  delay(10);

 
    
  
  switch (count) {
    case 0:
      digitalWrite(5, HIGH);
      break;

    case 1:
      digitalWrite(5, HIGH);
      break;

    case 2:
      digitalWrite(5, HIGH);
      break;

    case 3:
      digitalWrite(5, HIGH);
      break;
  
    case 4:
      digitalWrite(5, HIGH);
      break;

    case 5:
      digitalWrite(5, HIGH);
      break;

    case 6:
      digitalWrite(5, HIGH);
      break;

    case 7:
      digitalWrite(5, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0){
     BPM = map(input1, 0, 1023, min_BPM, max_BPM);
    
  }
  
  if (priority == 1){
     BPM = (60000 / tap_time);
    
    
  }


  if (input1X - input1 > 5){
    priority = 0;
  }
  if (input1X - input1 < -5){
    priority = 0;
  }

  input1X = input1;
  
  
  


  
  float duration_percentage =  map(input2, 0, 1023, 1, 90);
 
  int cycletime = (60000/BPM);

  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage/100));


  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);

}
/*********************************************************************************/

void fonction_compteur()
{
 
   compteur = (compteur+1)%3;
  if (compteur==3)
  {
    compteur = 0;
  }
     
    switch (compteur){
     case 0 :
     cycle_on();
     break;
    
      case 1:
      cycle_on1();
      break;

      case 2:
      cycle_on2();
      break;

    }
}

Le problème peut venir de la manière dont tu as connecté tes boutons. Lorsqu'ils sont déclarés en INPUT_PULLUP, il faut les connecter comme ceci
GND - - bouton - - pin arduino

Exemple


Est-ce bien ce que tu as fait ?

Alors effectivement c'etait ce que j'était entrain de regarder ! Non je n'ai pas fait ce branchement la , maintenant quand je fais ce branchement , le moniteur serie affiche

cycle_on ou cycle_off a chaque nouvelle appuie sur le bouton du tap tempo et sinon il n'avance pas il reste bloqué :confused:

Désoler , c'est bon j'ai repasser toute les valeur a LOW , maintenant la partit tap tempo refonctionne normalement .
Mais la partit bouton qui change de fonction , ne fonctionne pas encore.

Copie ce qui s'affiche dans la console, j'ai du mal à le voir d'ici...

dans le moniteur serie il s'affiche rien, et quand je clique sur le bouton changement de fonction tous demarre , et le moniteur affiche :

compteur=1
cycle_on1
cycle_off
cycle_on
cycle_off
cycle_on
cycle_off
cycle_on

Je suppose que tu utilises le code que tu as posté au message 9 ...?

Alors déjà, ceci

compteur = (compteur + 1) % 3;

fait que compteur ne peut prendre que les valeurs 0, 1 et 2. Ensuite il revient à 0 : c'est le modulo (%) qui fait ça. Donc les lignes suivantes ne servent à rien :

 if (compteur == 3)
  {
    compteur = 0;
  }

Dans ta loop il y a

 if (!started && !digitalRead(13)) {
    fonction_compteur();
    started = true;
  }

Si ton bouton 13 est bien connecté en INPUT_PULLUP, comme vu plus haut, la fonction fonction_compteur() est appelée lors du premier appui de ce bouton. compteur va passer à 1 et la fonction cycle_on1 sera exécutée.

Mais les boutons poussoirs ont tendance à rebondir (les ressorts font plusieurs contacts sur les quelques premières millisecondes), c'est ce qu'on voit ici :

Il est nécessaire de les annuler. Il y a plusieurs solutions pour ça, la plus simple est de mettre un delay de 20 à 30 ms juste après que l'appui sur le bouton a été détecté. Dans ton cas, tu ajoutes
delay(30);
au début de la fonction fonction_compteur.

Après, la variable started passe à true :

 if (!started && !digitalRead(13)) {
    fonction_compteur();
    started = true;
  }

Donc, fonction_compteur ne devrait plus être appelée par la suite.

Mais cycle_on1 utilise des timers qui lancent cycle_on et cycle_off alternativement : c'est ce que tu vois dans la console.

Ensuite, je ne sais pas si ton code revient dans la loop : pour le vérifier ajoute

Serial.println("loop");

au début de la loop.

Si le code revient bien dans la loop, il te suffira d'enlever la ligne

started = true;

pour que ton bouton re-devienne actif et te permette de changer les fonctions appelées.

Merci beaucoup pour ton explication !
j'était passer a coter de plein de choses , et j'arrive bien a visualiser maintenant :slight_smile:

ça commence a ce rapprocher plus de quelque choses qui marche haha .

La ou je bloque du coup , c'est quand le code appelle les set.timeout (cycle_on ) et (cycle_off) en bas de chacune des fonctions .
j'ai essayer de les renommer par apport a leur fonction : set.timeout (cycle_on1 ) et (cycle_on2) mais ça ne fonctionne pas.
Quand je lance le programme , le moniteur serie ne fait rien , et si je clique sur le bouton de changement de fonction il m'affiche :

fonction_compteur // premier appuie sur le bouton
compteur=1
cycle_on1
fonction_compteur
compteur=2
cycle_on2
fonction_compteur
compteur=0
cycle_on
cycle_off
cycle_off
cycle_off
cycle_on
cycle_on
cycle_on
cycle_off
cycle_off
cycle_off
cycle_on
cycle_on
cycle_on //
fonction_compteur // deuxieme appuie sur le bouton
compteur=1
cycle_on1
cycle_off
cycle_off
fonction_compteur
compteur=2
cycle_on2
cycle_off
fonction_compteur
compteur=0
cycle_on
cycle_off
cycle_off
cycle_off
cycle_on
cycle_on
cycle_on
cycle_off
cycle_off
cycle_off
cycle_on
cycle_on
cycle_on

le moniteur serie m’affiche ce que j’ai dit au dessus avec ce code .
Vous comprenez peut etre mieux avec le code

#include <SimpleTimer.h>
#include <LiquidCrystal.h>

/*********************Programmed by SyntheMafia(06_06_2018)**********************/

const int rs = 12, en = 11, d4 = 9, d5 = 8, d6 = 7, d7 = 6;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);


SimpleTimer timer;
int count = 0;
int compteur ;
 

void setup() {
  Serial.begin(115200);
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(10, INPUT_PULLUP);
  pinMode(13,INPUT);

}

bool started = false;
int priority = 0;
int tapX = 0;
int tapactual;
int tap_time;
int time_actual;
int input1X = 0;
float BPM; 
int max_BPM = 250; /******************************************** write hier the max BPM that you want */
int min_BPM = 60;  /******************************************** write hier the min BPM that you want */
int max_time = ((1/(min_BPM/60)) * 1000);
int min_time = ((1/(max_BPM/60)) * 1000);







void loop() {

 if (!started && !digitalRead(13) ){ 
  delay(30); 
   fonction_compteur();
  
 }
  timer.run();


  
  
  
  
  
  
  
  
  
  if (digitalRead(10) == LOW && tapX ==0){
    tapX = millis ();
    while (digitalRead (10) == LOW){
      delay(10);
    }
   }
   
  if (digitalRead (10) == LOW && tapX !=0  ){
    tapactual = millis ();
    tap_time = (tapactual - tapX);
    if (tap_time > max_time){
      tap_time = max_time;  
    }
     if (tap_time < min_time){
      tap_time = min_time;  
    }
    tapX = tapactual;
    priority = 1; 
    while (digitalRead (10) == LOW){
      delay(10);
    }
   }
   time_actual = millis ();
    if ((time_actual - tapX) > 4000){
      tapX = 0; 
      }
   
  
 
  }


/*********************************************************************/



void cycle_off() {
  Serial.println("Cycle_off");
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);

  count++;

  if (count == 8) {
    count = 0;
  }
  
}



/*********************************************************************/
  

void cycle_on() {
  Serial.println("Cycle_on");
  lcd.begin(16,2);
  lcd.print(" BPM: ");
  lcd.println(BPM);
  delay(10);

 
    
   
  switch (count) {
    case 0:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
      break;

    case 1:
      digitalWrite(2, HIGH);
      break;

    case 2:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 3:
      digitalWrite(2, HIGH);
      break;
  
    case 4:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      break;

    case 5:
      digitalWrite(2, HIGH);
      break;

    case 6:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 7:
      digitalWrite(2, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0){
     BPM = map(input1, 0, 1023, min_BPM, max_BPM);
     
  }
  
  if (priority == 1){
     BPM = (60000 / tap_time);
    
     
  }


  if (input1X - input1 > 5){
    priority = 0;
  }
  if (input1X - input1 < -5){
    priority = 0;
  }

  input1X = input1;
  
  
  


  
  float duration_percentage =  map(input2, 0, 1023, 1, 90);
 
  int cycletime = (60000/BPM);

  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage/100));


  
  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);
}
/**************************************************************************************/

void cycle_on1() {
   Serial.println("Cycle_on1");
  lcd.begin(16,2);
  lcd.print(" mode 1 ");
 
  delay(10);

 
    
   
  switch (count) {
    case 0:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      
      break;

    case 1:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 2:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 3:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
  
    case 4:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 5:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 6:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;

    case 7:
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0){
     BPM = map(input1, 0, 1023, min_BPM, max_BPM);
     
  }
  
  if (priority == 1){
     BPM = (60000 / tap_time);
    
     
  }


  if (input1X - input1 > 5){
    priority = 0;
  }
  if (input1X - input1 < -5){
    priority = 0;
  }

  input1X = input1;
  
  
  


  
  float duration_percentage =  map(input2, 0, 1023, 1, 90);
 
  int cycletime = (60000/BPM);

  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage/100));


 
  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);

}
/********************************************************************************/

void cycle_on2() {
  Serial.println("Cycle_on2");
  lcd.begin(16,2);
  lcd.print(" mode 2 ");
 
  delay(10);

 
    
   
  switch (count) {
    case 0:
      digitalWrite(5, HIGH);
      break;

    case 1:
      digitalWrite(5, HIGH);
      break;

    case 2:
      digitalWrite(5, HIGH);
      break;

    case 3:
      digitalWrite(5, HIGH);
      break;
  
    case 4:
      digitalWrite(5, HIGH);
      break;

    case 5:
      digitalWrite(5, HIGH);
      break;

    case 6:
      digitalWrite(5, HIGH);
      break;

    case 7:
      digitalWrite(5, HIGH);
      break;
  }

  int input1 = analogRead(A0);
  int input2 = analogRead(A1);

  if (priority == 0){
     BPM = map(input1, 0, 1023, min_BPM, max_BPM);
     
  }
  
  if (priority == 1){
     BPM = (60000 / tap_time);
    
     
  }


  if (input1X - input1 > 5){
    priority = 0;
  }
  if (input1X - input1 < -5){
    priority = 0;
  }

  input1X = input1;
  
  
  


  
  float duration_percentage =  map(input2, 0, 1023, 1, 90);
 
  int cycletime = (60000/BPM);

  float cycle_start = cycletime;
  float cycle_stop = (cycletime * (duration_percentage/100));


  timer.setTimeout(cycle_start, cycle_on);
  timer.setTimeout(cycle_stop, cycle_off);

}

/*********************************************************************************/

void fonction_compteur()
{
   Serial.println("fonction_compteur");
   compteur = (compteur+1)%3;
  Serial.print ("Compteur = "); Serial.println(compteur);
    switch (compteur){
     case 0 :
     cycle_on();
     break;
    
      case 1:
      cycle_on1();
      break;

      case 2:
      cycle_on2();
      break;

    }
}

setTimeout prend en argument un long et une fonction :

// call function f once after d milliseconds
   int setTimeout(long d, timer_callback f);

mais tu utilises souvent des temps de timeout qui sont codés dans des float : peut-être que ça ft le bl..?

Assure-toi de bien employer les bons types, par exemple en faisant ceci :

 timer.setTimeout((long)cycle_start, cycle_on);
  timer.setTimeout((long)cycle_stop, cycle_off);

Si tu veux visualiser plus précisément ce que fait ton code, y compris avec les timers, tu peux déjà utiliser l'horodatage dans la console :


Ensuite, tu affiches les valeurs des durées des timeout lorsqu'elles sont calculées dans tes fonctions :

 timer.setTimeout((long)cycle_start, cycle_on);
  timer.setTimeout((long)cycle_stop, cycle_off);
  Serial.print("Time out cycle_on  : "); Serial.println(cycle_start);
  Serial.print("Time out cycle_off : "); Serial.println(cycle_stop);

Tu pourras ainsi suivre mieux le déroulement et voir si tes durées sont correctement calculées.
Note que les durées doivent être en millisecondes.

Que veux-tu dire ici :

La ou je bloque du coup , c'est quand le code appelle les set.timeout (cycle_on ) et (cycle_off) en bas de chacune des fonctions .
j'ai essayer de les renommer par apport a leur fonction : set.timeout (cycle_on1 ) et (cycle_on2) mais ça ne fonctionne pas.

Il faut que tu expliques ce que veut dire "ça ne fonctionne pas", car toi seul sait ce que doit faire ce code... Moi, je n'en ai aucune idée.

EDIT : qu'est-ce qui est connecté sur la pin 10 ? Un bouton poussoir ?
Si oui, il faut aussi traiter les rebonds, ce que tu ne fais pas ici :

  if (digitalRead(10) == LOW && tapX ==0){
    tapX = millis ();
    while (digitalRead (10) == LOW){
      delay(10);
    }
   }

Le test détecte un appui sur le bouton. Ensuite, tant qu'il est appuyé, il attend. Mais comme tu as vu, les rebonds font que le contact n'est pas maintenu, et donc il est probable que le while ne dure pas aussi longtemps que prévu : il peut s'arrêter au premier rebond. Ajoute un delay(30) juste après le if.
Fais ça à chaque test sur la pin 10.

bonsoir , il serait peut etre bon de s ' inspirer de cet excellent tutoriel , qui ressemble fortement a ce que vous chercher a faire sur une partie : https://forum.arduino.cc/index.php?topic=470879.0

Tres bon tutoriel ecrit par @J-M-L qui a l ' air de correspondre a ce que vous chercher a faire sur la partie detection des boutons appuis simple .

Bonne lecture :slight_smile: