bug materiel, ou bug logiciel ?

bonjour à tous,

j'aimerais avoir votre avis s'il vous plait:

j'ai fais un montage, accompagné d'un code, je veux allumer une DEL, soit directement, soit avec une tempo près définie, soit par une tempo dont je choisis le temps grâce à un encodeur rotatif.
le tout avec son état et le compte à rebours inscrit sur un LCD.

tout fonctionne correctement, sauf l'encodeur qui incrémente, mais ne décrémente qu'aléatoirement.

j'aimerais savoir si c'est à cause du montage, ou du code.

je vous montre le montage, le code, et une petite vidéo pour voir tout ça en direct.

pour info, lorsque je teste l'encodeur rotatif seul avec le même type de code, il fonctionne parfaitement.

voici le montage :

voici le code en deux partis : (regardez la fonction GelProg de plus près, c'est la que se situ le programme de l'encodeur rotatif )

première partis :

// - - - dabord pour l'écran LCD, il nous faut ça - - -
#include <LiquidCrystal.h> // Inclusion de la librairie pour afficheur LCD
const int RS=2; //constante broche 2 pour l'ecran LCD
const int E=3; //constante broche 3 pour l'ecran LCD
const int D4=4; //constante broche 4 pour l'ecran LCD
const int D5=5; //constante broche 5 pour l'ecran LCD
const int D6=6; //constante broche 6 pour l'ecran LCD
const int D7=7; //constante broche 7 pour l'ecran LCD

// - - - pour le codeur rotatif - - -
// - - - ATTENTION : l'encodeur est un KY 040 - - -
// le + est branché au 5V
// le GND est branché à la masse

int val = LOW;
int PinCLK = 8; //bouton CLK connécté à la broche 8
int PinDT = 9; //bouton DT connécté à la broche 9
int PinSW = A0; //bouton Switch connécté à la broche A0
static long encoderPos = -1;    // Au 1er démarrage, il passera à 0
int PinCLKLast = LOW;
int nbPas = 200;                 // Résolution de l'encodeur
int n = LOW;



// - - - constantes pour les trois boutons poussoirs - - -
int BPMARCHE = 12; //bouton marche connecté à la broche 12
int BPARRET = 13; //bouton arret connecté à la broche 13
int BPARRETPROG = 10; //bouton arret programmé connecté à la broche 10

// - - - constantes d'état - - -
int etatBPMARCHE; //variable qui enregistre l'état du bouton marche
int etatBPARRET; //variable qui enregistre l'état du bouton arret
int etatBPARRETPROG; //variable qui enregistre l'état du bouton arret programmé


// - - - constante pour les LEDS - - -
int LEDS = 11; //et toutes les leds sont connectés à la broche 11 via quelques bon vieux transistor

// - - - constantes pour la tempo - - -
int heure;
int time;
int minute;
int seconde; // variable de comptage des secondes écoulées
long milliref; // variable de mémorisation de la dernière valeur de milli utilisée

// - - -  création d'un objet afficheur LCD alphanumérique - - -
// les broches de lignes sont automatiquement configurées en ENTREE avec pullup interne activé
// les broches de colonnes sont automatiquement configurées en SORTIE
LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// initialisation LCD en mode 4 bits



void setup(){ 
  
  //**************** FONCTION SETUP = Code d'initialisation *****

     Serial.begin (9600);
    
    // - - - allocation des entrées sorties - - -
    pinMode (BPMARCHE, INPUT_PULLUP); //le bouton marche est une entrée
    pinMode (BPARRET, INPUT_PULLUP);  //le bouton arret est une entrée
    pinMode (BPARRETPROG, INPUT_PULLUP); //le bouton arret programmé est une entrée
    pinMode (LEDS, OUTPUT); //les leds sont des sorties
    
    // - - - entrée pour l'encodeur rotatif - - -

    pinMode (PinCLK, INPUT_PULLUP); //le bouton CLK est une entrée
    pinMode (PinDT, INPUT_PULLUP); //le bouton DT est une entrée
    pinMode (PinSW,INPUT_PULLUP);         //le bouton SW est une entrée

    // essai - - - initialisation de val à 0 pour le switch de l'encodeur rotatif- - -

     //val = 0;

    // - - - Test de l'afficheur LCD - - -
    lcd.begin(16,2); // Initialise le LCD avec 16 colonnes x 2 lignes
    lcd.print("***Innovation***"); // affiche le message de test
    lcd.setCursor(0,1); //positionne le curseur au début de la seconde ligne
    lcd.print(" Olivier CAPOEN "); //affiche le texte
    delay(2000); // pause de 2 secondes
    lcd.clear(); // // efface écran et met le curseur en haut à gauche
    delay(10); // pour laisser le temps d'effacer l'écran

    // - - - initialisation d'une tempo minimum - - -
    // inutil

    // initialisation du carré en position éteint
     lcd.clear(); // efface l'écran
     lcd.setCursor(2, 0);
     lcd.print("Carre eteint"); // Affiche carré éteint
    digitalWrite(LEDS, LOW);
}
void loop()    {
      
    etatBPMARCHE = digitalRead(BPMARCHE); // Lecture du Statut du BP marche
    etatBPARRET = digitalRead(BPARRET); // Lecture du Statut du BP arret
    etatBPARRETPROG = digitalRead(BPARRETPROG); // Lecture du Statut du BP arret programmé
   
    if (digitalRead(BPMARCHE) == LOW) //si on appui sur BP marche
      { lcd.clear(); //tout d'abord, on efface l'écran
        lcd.setCursor(0, 0); //on met le curseur en haut à gauche
        lcd.print("  Carre ALLUME  "); //on affiche que le carré est allumé
        digitalWrite(LEDS, HIGH); //on allume les leds
        
        if(digitalRead(BPARRETPROG) == LOW){ //si on appuis sur BP arret programmé
         ArretProgFix(); //on lance le sous programme d'arret temporisé
        }
      }

    if (etatBPARRET == LOW){ //si on appuis sur BP arret
        digitalWrite(LEDS, LOW); //on éteint les leds
        lcd.clear(); //on efface l'écran
        lcd.setCursor(0, 0); //on met le curseur en haut à gauche
        lcd.print("Carre en attente"); //on affiche carré en attente d'activation
        lcd.setCursor(2, 1);
        lcd.print("d'activatioo");  
      }
 
        
    if(digitalRead(BPARRETPROG) == LOW){ //si on appuis sur BP arret programmé
       ArretProgFix(); //on lance le sous programme d'arret temporisé fixe
        }

    if (!(digitalRead(PinSW))) {
        val = HIGH; //on met val à la valeure 1
        encoderPos = 0; // Reset la position si on appui sur l'encodeur
        GelProg (); //on lance le sous programe de gel du compte à rebours et de sa programmation
        
             }
      
    }

void ArretProgFix(){
     // - - - initialisation d'une tempo minimum - - -
     
            heure = 0;
            minute = 0;
            seconde = 10;
            time = (seconde + (60 * minute) + (3600 * heure));
            ArretProg(); // on lance le sous programme ArretProg
            
}

suite du code :

void ArretProg(){
  
        digitalWrite(LEDS, HIGH); // on allume le carré
        lcd.clear(); // Efface LCD
        delay(10); // pour laisser temps d'effacer l'écran
        milliref = millis(); // mémorisation de la valeur de millis() courante
        
            
        while(time>0) { // tant que la tempo n'est pas fini

            
           
            if (millis() > (milliref + 1000)) { // si une seconde s'est écoulée
                seconde = seconde - 1; // Décrémente le comptage des secondes
                time = time - 1; // Décrémente Temps total d'une seconde
                milliref = milliref + 1000;  // incrémente la valeur de référence milliseconde
            }
            if (minute > 0) {
                if (seconde < 0) {
                    minute--; // Décrémente une minute si le comptage des secondes arrivent à 0 et si les minutes sont sup?rieurs à 0
                    seconde = 59; // reset seconde à 60
                }
            }
            if (heure > 0) {
                if (minute <= 0) {
                    if (time == 3600 * heure - 1) {
                        heure--; // Décrémente une heure si le comptage des minutes arrivent à 0 et si les heures sont supérieurs à 0 et si le temps total est un multiple de 3600 seconde (1 heure)
                        minute = 59; // reset minutes à 60
                        seconde = 59;
                    }
                }    
            }

              
            
              lcd.clear();
              lcd.setCursor(0, 0);
              lcd.print("Extinction dans:");
              lcd.setCursor(4, 1);                                 
              lcd.print("00:00:00");  // Affiche le format du Compte à rebours
    
    // Imprime les heures sur la collone 4 si ils sont supérieur à 10, et sur la colonne 5 si inférieur à 10:
              if (heure >= 10) {
              lcd.setCursor(4, 1);
    }
              else{
              lcd.setCursor(5, 1);
    }
              lcd.print(heure);
    
    // Imprime les minutes sur la collone 7 si ils sont supérieur à 10, et sur la colonne 8 si inférieur à 10:
              if (minute >= 10){
              lcd.setCursor(7, 1);
    }
              else {
              lcd.setCursor(8, 1);
    }
              lcd.print(minute);
    
    // Imprime les seconde sur la collone 10 si ils sont supérieur à 10, et sur la colonne 11 si inférieur à 10:
              if (seconde >= 10){
              lcd.setCursor(10, 1);
    }
              else {
             lcd.setCursor(11, 1);
    }
             lcd.print(seconde); 

             
              
             delay(100); // Délais de rafraichisement LCD
             lcd.clear();
             
      // en cas d'appuis sur le bouton rotatif
      // rien
   
       //  si on appuis sur BP arret pendant le décompte  
          
             if (digitalRead (BPARRET) == LOW){ 
                ARRET(); //on lance le sous programe d'arret
             }

        // lorsque le compte à rebours est fini
        
           if(time <= 0){
            val = LOW; //on initialise val à 0
            lcd.clear(); // efface l'écran
            lcd.setCursor(2, 0);
            lcd.print("Carre eteint"); // Affiche carré éteint
            digitalWrite(LEDS, LOW); // on éteint le carré
            delay(3000);
            lcd.clear();
            lcd.setCursor(0, 0); //on met le curseur en haut à gauche
            lcd.print("Carre en attente"); //on affiche carré en attente sur la première ligne
            lcd.setCursor(2, 1); //on met le curseur sur la seconde ligne de l'afficheur
            lcd.print("d'activation"); //et on affiche d'activation
            


           }
           
               
        }
   
       
        }
        
  
void ARRET(){
       heure = 0;
       minute = 0;
       seconde = 0;
       time = (seconde + (60 * minute) + (3600 * heure));
       //val = LOW; //on initialise val à 0
       ArretProg();
       

}

void GelProg (){
   // - - - initialisation de l'écran en mode programme - - -
   
   lcd.clear();
   lcd.setCursor(1, 0);     // positionne le curseur à la première ligne
   lcd.print("Programmez"); // Affiche programmez
   lcd.setCursor(4, 1);
   lcd.print("00:00:00");  // Affiche le format du Compte à rebours
   Serial.print("valeure de val dans GelProg avant While :  "); 
   Serial.println(val);
 
     if (!(digitalRead(PinSW))) {
        encoderPos = 0; // Reset la position si on appui sur l'encodeur
        val = LOW; //on initialise val à 0
        ArretProg();    // On lance le sous programme ArretProg
       }
     
   
   // - - - lecture de l'encodeur rotatif - - -
while ((digitalRead(PinSW))&& (val == HIGH)) {
      Serial.print(" valeure de val après while dans GelProg :  "); Serial.println(val);
      n = digitalRead(PinCLK);
   
   if ((PinCLKLast == LOW) && (n == HIGH)) {
     
     if (digitalRead(PinDT) == LOW) {
      //Sens antihoraire
       encoderPos--;
       minute = minute - 15;
       if ( encoderPos < 0 ) {
         encoderPos = nbPas;
         minute = 0;
         heure --;
       }
     } else {
       //Sens horaire
       encoderPos++;
       minute = minute + 15;
       if ( encoderPos > ( nbPas - 1 ) ) {
         encoderPos = 0;
                                         }
            }
 
     Imprime (); // on lance le sous programme d'impression sur le LCD
     
       

                                          }

   PinCLKLast = n;
  }   
}

  void Imprime (){

              lcd.clear();
              lcd.setCursor(0, 0);
              lcd.print("Appuyez pour Go");
              lcd.setCursor(4, 1);                                 
              lcd.print("00:00:00");  // Affiche le format du Compte à rebours

     // Limite des minutes et des heures
     if (minute > 59){
      minute = 0;
      heure ++;
     }
     if (minute < 0){
      minute = 0;
      heure --;
     }
     if (heure < 0){
      heure = 0;
     }
     
  
     // Imprime les heures sur la collone 4 si ils sont supérieur à 10, et sur la colonne 5 si inférieur à 10:
              if (heure >= 10) {
              lcd.setCursor(4, 1);
    }
              else{
              lcd.setCursor(5, 1);
    }
              lcd.print(heure);
    
    // Imprime les minutes sur la collone 7 si ils sont supérieur à 10, et sur la colonne 8 si inférieur à 10:
              if (minute >= 10){
              lcd.setCursor(7, 1);
    }
              else {
              lcd.setCursor(8, 1);
    }
              lcd.print(minute);
    
    // Imprime les seconde sur la collone 10 si ils sont supérieur à 10, et sur la colonne 11 si inférieur à 10:
              if (seconde >= 10){
              lcd.setCursor(10, 1);
    }
              else {
             lcd.setCursor(11, 1);
    }
             lcd.print(seconde); 

             time = (seconde + (60 * minute) + (3600 * heure)); // on met à jour le temps programé
             
       //           if (!(digitalRead(PinSW))) {
        //encoderPos = 0; // Reset la position si on appui sur l'encodeur
        //val = LOW; //on initialise val à 0
       // ArretProg();    // On lance le sous programme ArretProg
      // } 
             //delay(10); // Délais de rafraichisement LCD
             
             
}

et la vidéo arrive juste après

et voici la vidéo (disponible dès que youtube aura traité la vidéo)

pour info, l'encodeur est un KY-040, avec le + et la masse connecté respectivement au + 5V et la masse de l'arduino,

et j'ai ajouté un condo de 100nF entre SW et la masse pour l'effet rebond du switch

hello
un tour sur le site de l'auteur te montrera que tu n'as pas cable le KY40 correctement

hello dfgh,
Merci de ton attention,

:o à tout hazard, aurais tu le lien vers l'auteur s'il te plait, car il y a 36 liens différents pour ce composant.
d'avance merci

ICI

bin si, je l'ai branché comme ça pourtant !
exactement comme sur le schéma, et en plus j'ai câblé le switch comme un bouton poussoir classique (car s'en est un )

j'ai juste rajouté un condo entre la patte SW et la masse pour le pullup, afin d'éviter les rebonds.

à ce propos, quelle est la valeure d'un condensateur pour éviter l'effet rebond ?

100nF, est ce corecte ?

bonjour,
la lecture de la rotation est où dans le programme?

digitalRead(PinCLK)
digitalRead(PinDT)

Bonjour infobarquee,

la lecture est ici, sachant que je désir avancer par pas de 15mn :

void GelProg (){
   // - - - initialisation de l'écran en mode programme - - -
   
   lcd.clear();
   lcd.setCursor(1, 0);     // positionne le curseur à la première ligne
   lcd.print("Programmez"); // Affiche programmez
   lcd.setCursor(4, 1);
   lcd.print("00:00:00");  // Affiche le format du Compte à rebours
  
 
     if (!(digitalRead(PinSW))) {
        encoderPos = 0; // Reset la position si on appui sur l'encodeur
        val = LOW; //on initialise val à 0
        ArretProg();    // On lance le sous programme ArretProg
       }
     
   
   // - - - lecture de l'encodeur rotatif - - -
while ((digitalRead(PinSW))&& (val == HIGH)) {
     
      n = digitalRead(PinCLK);
   
   if ((PinCLKLast == LOW) && (n == HIGH)) {
     
     if (digitalRead(PinDT) == LOW) {
      //Sens antihoraire
       encoderPos--;
       minute = minute - 15;
       if ( encoderPos < 0 ) {
         encoderPos = nbPas;
         minute = 0;
         heure --;
       }
     } else {
       //Sens horaire
       encoderPos++;
       minute = minute + 15;
       if ( encoderPos > ( nbPas - 1 ) ) {
         encoderPos = 0;
                                         }
            }
 
     Imprime (); // on lance le sous programme d'impression sur le LCD
     
       

                                          }

   PinCLKLast = n;
  }   
}

sur ton fritzing, tu as cablé:
GND, D8, D9, A0 pourtant, il semble qu'il faille le +5V

+1

et mets tout le code, tu vas pas nous mettre un petit bout à chaque question.

Bonjour,

dfgh:
sur ton fritzing, tu as cablé:
GND, D8, D9, A0 pourtant, il semble qu'il faille le +5V

sur le fritzing je n'ai pas mis le +5V, (car je n'ai pas trouvé de KY-040 pour frizing), mais je l'ai bel et bien branché sur mon montage chez moi, j'ai donc branché GND à la masse, D8 sur DT, D9 sur CLK, A0 sur SW, et +5V sur +.

infobarquee:
+1

et mets tout le code, tu vas pas nous mettre un petit bout à chaque question.

le code est posté dans son intégralité au début du post en deux messages, car le code est trop grand, nous ne pouvons poster que 9000 caractères à la fois.
mais vous m'avez demandé ceci :

infobarquee:
bonjour,
la lecture de la rotation est où dans le programme?

digitalRead(PinCLK)

digitalRead(PinDT)

j'ai donc répondu en re postant la parties du code qui vous intéresse, mais je vous assure que le code est dans son intégralité au début du post, dans le premier et second message

ceci étant dis, je vous remercie tout deux de vous intéresser à mon problème, car je perd un peu les pédales sur ce sujet :slight_smile:
milles mercies

hello
j'ai un peu joué avec ton code, mais n'ayant pas de codeur, pas possible de tester

#include <LiquidCrystal.h> 

int val = LOW;
int PinCLK = 8;//2; 
int PinDT = 9;//3; //voie B
int PinSW = A0;//14; 
static long encoderPos = -1;    // Au 1er démarrage, il passera à 0
int PinCLKLast = LOW;
int nbPas = 200;                 // Résolution de l'encodeur
int lecture_PinCLK = LOW;
int BPARRETPROG = 10; int etatBPARRETPROG;
int LEDS = 11; 
int BPMARCHE = 12;    int etatBPMARCHE; 
int BPARRET = 13;     int etatBPARRET; 
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);
//LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
int time;int heure;int minute;int seconde; 
long milliref; 

void setup() 
{
  Serial.begin (115200);
  pinMode (BPMARCHE, INPUT_PULLUP); 
  pinMode (BPARRET, INPUT_PULLUP);  
  pinMode (BPARRETPROG, INPUT_PULLUP); 
  pinMode (LEDS, OUTPUT); 
  pinMode (PinCLK, INPUT_PULLUP); 
  pinMode (PinDT, INPUT_PULLUP);  
  pinMode (PinSW, INPUT_PULLUP);  

  // essai - - - initialisation de val à 0 pour le switch de l'encodeur rotatif- - -
  //val = 0;
  
  lcd.begin(16, 2);lcd.print("***Innovation***");lcd.setCursor(0, 1);lcd.print(" Olivier CAPOEN ");delay(2000);lcd.clear();delay(10); 
  lcd.setCursor(2, 0);lcd.print("Carre eteint");digitalWrite(LEDS, LOW);
}

void loop()
{
  etatBPMARCHE = digitalRead(BPMARCHE); 
  etatBPARRET = digitalRead(BPARRET); 
  etatBPARRETPROG = digitalRead(BPARRETPROG);

  if (digitalRead(BPMARCHE) == LOW) 
  {
    lcd.clear(); lcd.print("  Carre ALLUME  "); 
    digitalWrite(LEDS, HIGH); 
    if (digitalRead(BPARRETPROG) == LOW){ArretProgFix();}
  }

  if (etatBPARRET == LOW)
  {
    digitalWrite(LEDS, LOW);
    lcd.clear(); lcd.print("Carre en attente");
    lcd.setCursor(2, 1); lcd.print("d'activation");
  }

  if (digitalRead(BPARRETPROG) == LOW){ ArretProgFix();}

  if (!(digitalRead(PinSW)))
  {
    val = HIGH;
    encoderPos = 0;
    GelProg ();
  }
}

void ArretProgFix() // - - - initialisation d'une tempo minimum - - -
{
  heure = 0;minute = 0;seconde = 10;time = (seconde + (60 * minute) + (3600 * heure));
  ArretProg(); // on lance le sous programme ArretProg
}

void ArretProg()
{
  digitalWrite(LEDS, HIGH);
  lcd.clear();delay(10);
  milliref = millis(); // mémorisation de la valeur de millis() courante

  while (time > 0) // tant que la tempo n'est pas finie si une seconde s'est écoulée
  {
    if (millis() > (milliref + 1000)) {seconde = seconde - 1;time = time - 1;milliref = milliref + 1000;}
    if (minute > 0) {if (seconde < 0) {minute--;seconde = 59;}}
    if (heure > 0) {if (minute <= 0) {if (time == 3600 * heure - 1) { heure--; minute = 59;seconde = 59;}}}
 //lcd.clear();
    lcd.setCursor(0, 0);lcd.print("Extinction dans:");lcd.setCursor(4, 1);lcd.print("00:00:00");// Affiche le format du Compte à rebours
    affich_tempo(heure,minute,seconde);
  
    delay(100); // Délai de rafraichisement LCD
 //lcd.clear();

    // en cas d'appui sur le bouton rotatif
    // rien

    //  si appui sur BP arret pendant le décompte on lance le sous programe d'arret
    if (digitalRead (BPARRET) == LOW) {ARRET();}

    if (time <= 0)                       // lorsque le compte à rebours est fini
    {
      val = LOW;                                                        //on initialise val à 0
      lcd.clear();lcd.setCursor(2, 0);lcd.print("Carre eteint");        // Affiche carré éteint
      digitalWrite(LEDS, LOW);                                          // on éteint le carré
      delay(3000);
      lcd.clear();lcd.print("Carre en attente");lcd.setCursor(2, 1);lcd.print("d'activation");//et on affiche d'activation
    }
  }
}


void ARRET()
{
  heure = 0;minute = 0;seconde = 0;
  time = (seconde + (60 * minute) + (3600 * heure));
  //val = LOW; //on initialise val à 0
  ArretProg();
}

void GelProg () // - - - initialisation de l'écran en mode programme - - -
{
  lcd.clear();lcd.setCursor(1, 0);lcd.print("Programmez");lcd.setCursor(4, 1);lcd.print("00:00:00");  // Affiche le format du Compte à rebours
  Serial.print("valeur de val dans GelProg avant While :  ");Serial.println(val);

  if (!(digitalRead(PinSW)))
  {
    encoderPos = 0;
    val = LOW;
    ArretProg();
  }

  // - - - lecture de l'encodeur rotatif - - -
  while ((digitalRead(PinSW)) && (val == HIGH))
  {
    Serial.print(" valeur de val après while dans GelProg :  "); Serial.println(val);
    lecture_PinCLK = digitalRead(PinCLK);//voie A

    if (lecture_PinCLK!=PinCLKLast)//si chgt état sur voie A
    {

      if (digitalRead(PinDT) != lecture_PinCLK)//et voie B actionnée
      {//Sens horaire
       encoderPos++;
        minute = minute + 15;
        if ( encoderPos > ( nbPas - 1 ) ){encoderPos = 0;} 
      } 
      else
      {//Sens antihoraire
        encoderPos--;
        minute = minute - 15;
        if ( encoderPos < 0 ){encoderPos = nbPas;minute = 0;heure --;}
      }
      Imprime (); // on lance le sous programme d'impression sur le LCD
    }
    PinCLKLast = lecture_PinCLK;
  }
}

void Imprime ()
{
  lcd.clear();lcd.print("Appuyez pour Go");lcd.setCursor(4, 1);lcd.print("00:00:00");  // Affiche le format du Compte à rebours
  if (minute > 59) {minute = 0;heure ++;}if (minute < 0) {minute = 0;heure --;}if (heure < 0) { heure = 0;}// Limite des minutes et des heures
  affich_tempo(heure,minute,seconde);
  time = (seconde + (60 * minute) + (3600 * heure)); // on met à jour le temps programé

  //           if (!(digitalRead(PinSW))) {
  //encoderPos = 0; // Reset la position si on appui sur l'encodeur
  //val = LOW; //on initialise val à 0
  // ArretProg();    // On lance le sous programme ArretProg
  // }
  //delay(10); // Délais de rafraichisement LCD
}

void affich_tempo(int heure,int minute,int seconde)// affiche sur LCD les heures, minutes, secondes
{
  if (heure >= 10) {lcd.setCursor(4, 1);} else {lcd.setCursor(5, 1);} lcd.print(heure);
  if (minute >= 10) {lcd.setCursor(7, 1);} else {lcd.setCursor(8, 1);} lcd.print(minute);
  if (seconde >= 10) {lcd.setCursor(10, 1);} else { lcd.setCursor(11, 1);} lcd.print(seconde);
}

Hello dfgh,

whaou, effectivement, ça fonctionne mieux,

seul petit défaut, il incrémente de 30mn en 30mn, au lieu de 15mn en 15mn.

j'ai remarqué que si je tourne l'encodeur d'un demi cran il fonctionne de 15mn en 15mn..., on ne doit pas être loin de la vérité

ceci dit, l'encodeur fonctionne de façon plus fiable, même si il ne fait pas tout à fait ce que je veux.

Bravo! c'est du bon boulot, je dirais même plus, c'est remarquable.

franchement chapeau ! :wink:

cool. :slight_smile:

je te laisse continuer, c'est plus facile de debuger avec une maquette opérationnelle

encore Mille Mercis dfgh.

étant donné que pour avoir la programmation de 15mn en 15 mn, ça devient trop compliqué, car si je met : 15/2, il m’incrémente de 14 mn en 14mn

 if (digitalRead(PinDT) != lecture_PinCLK)//et voie B actionnée
      {//Sens horaire
       encoderPos++;
        minute = minute + (15/2);
        if ( encoderPos > ( nbPas - 1 ) ){encoderPos = 0;} 
      } 
      else
      {//Sens antihoraire
        encoderPos--;
        minute = minute - (15/2);

donc j'ai mis 5, et il m’incrémente le compteur de 10mn en 10 mn c'est pas mal non plus après tout.

par contre j'ai une question:

pourquoi lorsque je programme le compte à rebours au delà de 9H00, (à 9H10 par exemple), l'arduino bug ?

est ce parce que je sature la capacité de la mémoire int ?

je n'ai pas pris le temps de détailler ton code, mais cette ligne ...

time = (seconde + (60 * minute) + (3600 * heure)); // on met à jour le temps programé

tu mets le temps en secondes, et pour 9 h tu as 36009=32400
et si tu rajoute 10mn tu as 32400+60
10=33000

avec time qui est un tu peux y mettre + ou - 32767

time = (seconde + (60 * minute) + (3600 * heure)); // on met à jour le temps programé

passe time en "long" au lieu de int

Merci dfgh pour ton intérêt qui m'aide énormément.

je viens de le faire, et, aucun changement, toujours ce bug après 9H00 :o

ce n'es peut être pas ta solution, mais il faut ceci:

long time, heure, minute, seconde;

unsigned long milliref;