Incrémentation progressive hasardeuse

Bonjour,

Voici l’incrémentation progressive que j’utilise :

void loop() {
  
             // Incrémentation des options du Menu à l'aide de Btn_Up <--------------------------------------------------
    Incr_Up_Etat = digitalRead(Btn_Up);                                                                       // Lecture de Btn_Up et stockage de sa valeur
    if (Incr_Up_Etat == LOW)                                                                                  // Si Btn_Up est appuyé alors...
    {                                      
       Incr_Up_Current_millis = millis();                                                                     // Incr_Up_Current_millis = Le nombre de millisecondes depuis que l'Arduino a démarré
       if (Incr_Up_Mem_Etat == HIGH)                                                                          // Si Btn_Up est relaché alors...
       {
          Incr_Up_Mem_First_millis = Incr_Up_Current_millis;                                                  // Equivalent à une remise à zéro des compteurs
          Incr_Up_Mem_Next_millis  = Incr_Up_Current_millis;                                                  // Equivalent à une remise à zéro des compteurs
       }
      
       if (Incr_Up_Current_millis >= Incr_Up_Mem_Next_millis)                                                 // Si le chrono de l'arduino est supérieur ou égale au temps de la prochain incrémentation alors..
       {       
              Incr_Up_Elasped_millis = (Incr_Up_Current_millis - Incr_Up_Mem_First_millis);                   // Durée depuis que Btn_Up a était enfoncé = ( chronomètre - heure de l'appui )

         
              if (Incr_Up_Elasped_millis < 1000)                                                              // Si Btn_Up est appuyé 1 seconde alors...
              {
                  Incr_Up_Mem_Next_millis = (Incr_Up_Current_millis + 500);                                   // Prochaine incrémentation dans 500ms
              } 

  
              if ((Incr_Up_Elasped_millis > 1000) && (Incr_Up_Elasped_millis < 2000))                         // Si Btn_Up est appuyé entre 1 et 2 secondes alors...
              {
                  Incr_Up_Mem_Next_millis = (Incr_Up_Current_millis + 200);                                   // Prochaine incrémentation dans 200ms
              }


              if (Incr_Up_Elasped_millis > 2000)                                                              // Si Btn_Up est appuyé plus de 2 secondes alors...
              {
                  Incr_Up_Mem_Next_millis = (Incr_Up_Current_millis + 50);                                    // Prochaine incrémentation dans 50ms
              }
         
              switch (Niveau_Menu)                                                                            // Selon Niveau_Menu, on incrémente la variable qui clignote au LCD
              {
                case 0:               
                    if (Niveau_Pause < 1000)                                                                   // Si Niveau_Pause < Limite Maxi
                    {
                    Niveau_Pause++;                                                                           // On incrémente de 1 Niveau_Pause
                    }
                    break;
                case 1:
                    if (Niveau_Interval < 1000)                                                                // Si Niveau_Interval < Limite Maxi
                    {
                    Niveau_Interval++;                                                                        // On incrémente de 1 Niveau_Pause
                    }
                    break;
                case 2: 
                    if (Niveau_Speed < 1000)                                                                    // Si Niveau_Speed < Limite Maxi
                    {
                    Niveau_Speed++;                                                                            // On incrémente de 1 Niveau_Speed
                    }
                    break;                      
                case 3:
                    if (Niveau_Tspd < 1000)                                                                     // Si Niveau_Tspd < Limite Maxi
                    {
                    Niveau_Tspd++;                                                                             // On incrémente de 1 Niveau_Tspd
                    }
                    break;
                    
         }
       }
    }    
Incr_Up_Mem_Etat = Incr_Up_Etat;                                                                              // Détermine Incr_Up_Mem_Etat à l'état haut quand Btn_Up est relaché, pour le prochain appui de Btn_Up afin de remettre les compteurs à zéro
}

Quand je reste appuyé sur le bouton Up, l’incrémentation monte de 1 toutes les 500ms, puis toutes les 200ms, puis toutes les 50ms.
Suite au 2eme message

en gros j'incrémente de 1000 en 55secondes si je mets ça dessous :

// Affichage LCD
    lcd.setCursor(6,1);
    lcd.print(Niveau_Pause);

J'incrémente de 1000 en 1min05sec si je mets un peu plus d'affichage dessous :

// Affichage LCD
    lcd.setCursor(5,0);
    lcd.print(Niveau_Menu);
    lcd.setCursor(0,1);
    lcd.print("Pause");
    lcd.setCursor(6,1);
    lcd.print(Niveau_Pause);
    lcd.print("s");
    lcd.setCursor(0,2);
    lcd.print("Interval");
    lcd.setCursor(9,2);
    lcd.print(Niveau_Interval);
    lcd.print("s");
    lcd.setCursor(0,3);
    lcd.print("Speed");
    lcd.setCursor(6,3);
    lcd.print(Niveau_Speed);
    lcd.print("%");
    lcd.setCursor(11,3);
    lcd.print("Tspd");
    lcd.setCursor(16,3);
    lcd.print(Niveau_Tspd);
    lcd.print("%");

Pourquoi le temps d'incrémentation de 1000 est différent selon l'affichage que je mets ? Bizarre Bizarre..

c'est normal, chaque appel à la fonction print() prend quelque cycle d'horloge et par conséquent ralenti ta loop()

ah mince c’est embêtant, enfin pas pour mon incrémentation du menu mais plutôt pour le cycle qui sera après ( aussi basé sur millis(); ).
c’est un genre d’intervallometre pour rail motorisé, il va exécuter une Pause (pour que l’appareil photo prenne la photo, puis va faire tourner le moteur (0à100% du temps de l’intervalle), puis va terminer par l’intervalle restant (si la durée du moteur n’est pas égale à 100% de l’intervalle)

    for (long i=1;i<=Nombre_Cycles;)
    {
      ValBtn_Back = digitalRead(Btn_Back);                       // Retour au menu principal par Btn_Back
      if (ValBtn_Back==0){                                       // Si Btn_Back appuyé alors..
      i=Nombre_Cycles+1;                                         // Termine la boucle For pour revnir au menu principal
      }
        

      switch (Position_Cycle){                                            // Position du cycle, 0 = Temps de Pause, 1 = Temps alimentation du moteur, 2 = Temps de Tcrenau_Intervalle
    
        case 0:                                                           // Cycle Pause
                if (Tempo_Cycle==0){                                      // Boucle un seul tour
                Tempo_Depart=millis();                                    // Déclare l'heure à laquelle démarre le cycle
                Tempo_Cycle=1;                                            // Définit Tempo_Cycle à 1 pour ne plus executer cette boucle
                }
                if ((millis()-Tempo_Depart)< Pause){                      // Si le temps passé dans le cycle Pause est "plus petit ou égal" au temps de Pause programmé
                  //activation Pin Shutter                                // Déclenchement du shutter
                }
                if ((millis()-Tempo_Depart)> Pause){                      // Si le temps passé dans le cycle est "égal ou plus grand" au temps de Pause programmé 
                  Position_Cycle=1;                                       // On incrémente Position_Cycle à 1 pour passer au cycle "Temps alimentation du moteur" (case 1 de la fonction Switch)
                  Tempo_Cycle=0;                                          // Remise à zero de la variable pour effectuer une seule boucle au 1er "if" du prochain cycle
                }
                break;                                                    // On termine la fonction Switch
          
        case 1:                                                           // Cycle Temps de Tcreneau_Moteur
                if (Tempo_Cycle==0){                                      // Boucle un seul tour
                Tempo_Depart=millis();                                    // Déclare l'heure à laquelle démarre le cycle
                Tempo_Cycle=1;                                            // Définit Tempo_Cycle à 1 pour ne plus executer cette boucle 
                }
                if ((millis()-Tempo_Depart)<Tcreneau_Moteur){             // Si le temps passé dans le cycle est "plus petit ou égal" au temps de Tcreneau_Moteur calculé
                  //activation Pin MoteurPWM                              // Moteur sous tension
                  }
                if ((millis()-Tempo_Depart)>Tcreneau_Moteur){             // Si le temps passé dans le cycle est "égal ou plus grand" au temps de Tcreneau_Moteur calculé
                  Position_Cycle=2;                                       // On incrémente Position_Cycle à 2 pour passer au cycle "Temps de Tcrenau_Intervalle" (case 2 de la fonction Switch)
                  Tempo_Cycle=0;                                          // Remise à zero de la variable pour effectuer une seule boucle au 1er "if" du prochain cycle
                }
                break;                                                    // On termine la fonction Switch
          
        case 2:                                                           // Cycle Temps de Tcrenau_Intervalle
                if (Tempo_Cycle==0){                                      // Boucle un seul tour
                Tempo_Depart=millis();                                    // Déclare l'heure à laquelle démarre le cycle
                Tempo_Cycle=1;                                            // Définit Tempo_Cycle à 1 pour ne plus executer cette boucle
                }
                if ((millis()-Tempo_Depart)< Tcreneau_Intervalle){        // Si le temps passé dans le cycle est "plus petit ou égal" au temps de Tcreneau_Intervalle calculé
                  //activation? pendant Interval                          // Moteur sous tension
                }
                if ((millis()-Tempo_Depart)> Tcreneau_Intervalle){        // Si le temps passé dans le cycle est "égal" au temps de Tcrenau_Intervalle calculé
                  Position_Cycle=0;                                       // On incrémente Position_Cycle à 0 pour recommencer le cycle à "Temps de Pause" (case 0 de la fonction Switch)
                  Tempo_Cycle=0;                                          // Remise à zero de la variable pour effectuer une seule boucle au 1er "if" du prochain cycle
                  i=i+1;
                }
                break;                                                    // On termine la fonction Switch
      }
    }

Ce code ne sera pas précis ? Embêtant pour un intervallometre surtout si le shutter speed est de 1/1000.

cela viendrait de la vitesse du processeur (16Mhz) ou de la lenteur du codage en I2C ? (Ca irait peut être plus vite en Serie?).