[projet] compte à rebours avant de quitter la france

Bonjour à tous!

je suis un débutant en arduino, voir en électronique tout cours et j’aurai besoin d’un coup de main.
malgré mes nombreuses recherches je n’ai pas trouvé mon bonheur.

Alors voila, je suis en train de faire un compte à rebours qui devra afficher jours et heures avant de prendre mon envol vers de nouvelle destination!
pour le moment je suis sur une platine de test, la finalité étant un grand écran dans le salon.

objectif du minuteur :
afficher les nombres de jours (365) et le nombre d’heure (23). Comme son nom l’indique, il doit décompter.
à la fin du décompte, j’ai prévu un buzzer ou un moteur qui fait tourner une planète etc… je ne suis pas encore super décidé

Par la suite j’intégrerai un module temps réel DS1307, j’ai lu que la précision de la carte uno était assez médiocre selon la base temps choisi.

matériel :

  • clone arduino uno
  • registre à décalage 74HC595
  • afficheur 7 segments 4 digits 3461BS

Pour le test, je restreint à 65 le nombre de jour.

voici le code :

const int chiffre1 = 4;
const int chiffre2 = 5;
const int chiffre3 = 6;
const int chiffre4 = 7;
int latch=9;  //74HC595  pin 9 STCP
int clock=10; //74HC595  pin 10 SHCP
int data=8;   //74HC595  pin 8 DS

/* Variables globales */
int jours_remain = 65;       // Nombre de jours restantes (par défaut 65)
int heures_remain = 23;     // Nombre de heures restantes (par défaut 23) 

byte num[10] = 
{ B00000011, B10011111, B00100101, B00001101, B10011001, B01001001, B01000001, B00011111, B00000001, B00001001};// 0123456789

void setup() 
{
  Serial.begin(9600);
  pinMode(latch,OUTPUT);
  pinMode(clock,OUTPUT);
  pinMode(data,OUTPUT);
  pinMode(chiffre1, OUTPUT);
  pinMode(chiffre2, OUTPUT);
  pinMode(chiffre3, OUTPUT);
  pinMode(chiffre4, OUTPUT);
 }  

void loop() {
   {
    do {
       unsigned long time_now= millis();  // Temps actuel  
      //boucle comptage seconde
    {
     int time_now=0;
          while(time_now!=3600){
      time_now++;
          }
        }
      
           if(time_now = 3600)
           { //si une heure en milliseconde s'est écoulée -1 heure = 3600000, pour le test je ne prend que 3600 soit 3,6 sec
           -- heures_remain ; // Décrémentation des heures
           SevenSegDisplay(heures_remain);
           SevenSegDisplay(jours_remain);
          
             if(heures_remain < 0) 
             { // Décrémentation des jours
             heures_remain = 23; // Si il n'y as plus de heures
             SevenSegDisplay(heures_remain);
              -- jours_remain ;
             SevenSegDisplay(jours_remain);
             }
           }
      
   }while(jours_remain!=0);
}
  if (jours_remain=0) {
  heures_remain=0;
  SevenSegDisplay(heures_remain);
  SevenSegDisplay(jours_remain);
  }

}

  /* Fonction d'affichage du temps restant */

//void affiche_temps(int nombre, byte digit2chiffre)

void SevenSegDisplay(int chiffre) //
{

  int h1,h2,j1,j2; // Valeurs temporaires pour heure et jours



  h1 = (int) (heures_remain / 10);      // dizaine
  h2 = heures_remain - (h1* 10);        // unité
  j1 = (int) (jours_remain / 10);      // dizaine
  j2 = jours_remain - (j1* 10);        // unité


  affiche_temps(chiffre4,byte(num[h2]));  // montre dizaine heure
  affiche_temps(chiffre3,byte(num[h1]));  // montre unité heure
  affiche_temps(chiffre2,byte(num[j1]));  // montre dizaine jour
  affiche_temps(chiffre1,byte(num[j2]));  // montre unité jour

}
void affiche_temps(byte chiffre,byte num[])
{
  // Turn off the shift register pins
  // while you're shifting bits:
  AllDispOff();  // Turn off all cathode drivers.
  digitalWrite(latch, LOW); 
  // shift the bits out:
  shiftOut(data, clock, LSBFIRST, num);
  digitalWrite(latch, HIGH);  // Set latch high to set segments.
  digitalWrite(chiffre, HIGH);  // Drive one cathode low to turn on display.
delay(1); // rafraichissement de l'écran
}


void AllDispOff()
{
  // Turn all cathode drivers off
  digitalWrite(chiffre1, LOW);
  digitalWrite(chiffre2, LOW);
  digitalWrite(chiffre3, LOW);
  digitalWrite(chiffre4, LOW);
}

J’ai deux problèmes :
1 - le compteur va beaucoup trop vite, même en faisant varier la condition de time_now
2 - je n’arrive pas arrêter le compteur en essayant

 if (jours_remain=0) {
  break;
  }

Pourriez-vous m’aider?

Merci

Geof

mauvaise section ce n'est pas un projet fini ni une réalisation utilise le lien "report to moderator" pour le faire déplacer

= ne veut pas dire égal, == oui

qu’est ce qui ne fonctionne pas ?

if (jours_remain=0) {

au lieu de

if (jours_remain==0) {
if(time_now = 3600)

idem

Merci de la réponse, je ne connaissais pas les égalités

maintenant ça m'affiche 5 sur le 2 ème digit ^^' je ne comprend pas pourquoi

Bonjour à tous,

alors voila j’ai résolu mon problème de décompte.
en fait au lieu de lui faire décompter selon un base temps (en milis) puis de lui faire afficher la valeur décompter, il fallait lui faire décompter puis de lui dire d’attendre un certain moment pour afficher.
un peu tordu comme logique, enfin bon ça marche.

Voici le code

const int chiffre1 = 5;
const int chiffre2 = 6;
const int chiffre3 = 7;
const int chiffre4 = 8;
int latch=10;  //74HC595  pin 9 STCP
int clock=11; //74HC595  pin 10 SHCP
int data=9;   //74HC595  pin 8 DS

#define BP_UP 3      // Bouton +
#define BP_DOWN 4    // Bouton -
#define BP_START 2   // Bouton Start/Stop (interruption)

volatile byte running = false; // Etat du minuteur (true = en fonctionnement, false = à l'arrêt)

int jours_remain = 60;       // Nombre de jours restantes (par défaut 65)
int heures_remain = 24;     // Nombre de heures restantes (par défaut 24) 
byte num[10] = 
{ B00000011, B10011111, B00100101, B00001101, B10011001, B01001001, B01000001, B00011111, B00000001, B00001001};// 0123456789

void setup() 
{
  Serial.begin(9600);
  pinMode(latch,OUTPUT);
  pinMode(clock,OUTPUT);
  pinMode(data,OUTPUT);
  pinMode(chiffre1, OUTPUT);
  pinMode(chiffre2, OUTPUT);
  pinMode(chiffre3, OUTPUT);
  pinMode(chiffre4, OUTPUT);
 
  pinMode(BP_UP, INPUT_PULLUP);
  pinMode(BP_DOWN, INPUT_PULLUP);
  pinMode(BP_START, INPUT_PULLUP);
  attachInterrupt(0, bp_start_int, FALLING);


 }  

/* Loop() */
void loop() {
  /* Variables globales */

// Si le minuteur est en marche

  if(running==true)
  {


                    heures_remain-=1;
  
 
                if(heures_remain < 00)
                {
                  heures_remain = 23;
                  jours_remain-=1;
                }
                      if (jours_remain==00)
                      {
                       heures_remain=00;
                       jours_remain=00;

                      }

                    SevenSegDisplay();             
          
     }
 
  else { // Si le minuteur n'est pas en marche
 SevenSegDisplay();
      // Si le bouton + est appuyé
    if(digitalRead(BP_UP) == LOW) 
    {
 
      // Incrémentation des heures
      if(++heures_remain > 23) {
        heures_remain = 0; // Si le nombre de d'heure atteint 24
 
          // Incrémentation des jours
        if(++jours_remain > 23) {
          jours_remain = 65;  // Si le nombre de jours atteint 65
          heures_remain = 23; // Blocage à 65:23
        }
      }
 


       SevenSegDisplay();
  } // Si le bouton - est appuyé
    else if(digitalRead(BP_DOWN) == LOW) {
 
      // Décrémentation des heures
      if(--heures_remain < 0) 
      {
        heures_remain = 23; // Si il n'y as plus d'heures
 
        // Décrémentation des jours
        if(--jours_remain < 0) 
        {
          jours_remain = 0; // Si il n'y as plus de jors
          heures_remain = 0;
        }
      }
 

 
      // Affiche du temps restant
       SevenSegDisplay();
 
    } // Si aucun bouton n'est appuyé
    else {

    } 
  }
SevenSegDisplay();
}       


 
/* Interruption du bouton Start/Stop */
void bp_start_int() 
{
  running = !running;

}
void SevenSegDisplay() //
{
  long temps= millis();
 int h1,h2,j1,j2; // Valeurs temporaires pour heure et jours

if (heures_remain > 23)
     heures_remain = 23;  
if (heures_remain < 0)
     heures_remain = 0;
if (jours_remain > 65)
     heures_remain = 65;  
if (jours_remain < 0)
     jours_remain = 0;

  h1 = (int) (heures_remain / 10);   //dizaine d'heure

  h2 = (int) (heures_remain) - (h1*10);   //unité d'heure  

  j1 = (int) (jours_remain / 10);    //dizaine jours

  j2 = (int) (jours_remain)-(j1 * 10);     // unité jours

   while ((millis() - temps) < 1000)
    {
affiche_temps(chiffre4,byte(num[h2] ));  // montre dizaine heure
affiche_temps(chiffre3,byte(num[h1]));  // montre unité heure
affiche_temps(chiffre2,byte(num[j2]));  // montre dizaine jour
affiche_temps(chiffre1,byte(num[j1]));  // montre unité jour

     }
}

void affiche_temps(int chiffre, byte num )

{

   digitalWrite(latch, LOW); 
   AllDispOff();  // Turn off all cathode drivers.
  // shift the bits out:
  shiftOut(data, clock, LSBFIRST, num);
  digitalWrite(latch, HIGH);  // Set latch high to set segments.
  digitalWrite(chiffre, HIGH);  // Drive one cathode low to turn on display.
  delay(1); // rafraichissement de l'écran 
}




 void AllDispOff()
{
  // Turn all cathode drivers off
  digitalWrite(chiffre1, LOW);
  digitalWrite(chiffre2, LOW);
  digitalWrite(chiffre3, LOW);
  digitalWrite(chiffre4, LOW);
}

j’aimerai faire augmenter varier la vitesse d’incrément/décrément des boutons selon le temps d’appui dessus.
j’ai un peu de mal à voir comment je pourrais faire.
Des pistes pour m’aiguiller?

Votre code est bloqué une seconde ici

while ((millis() - temps) < 1000)
    {
affiche_temps(chiffre4,byte(num[h2] ));  // montre dizaine heure
affiche_temps(chiffre3,byte(num[h1]));  // montre unité heure
affiche_temps(chiffre2,byte(num[j2]));  // montre dizaine jour
affiche_temps(chiffre1,byte(num[j1]));  // montre unité jour

     }

—> Il faut virer toute attente bloquante du code si vous voulez que ça aille plus vite…

Profitez en pour appuyer sur ctrl-T dans l’IDE pour indenter votre code, la présentation c’est du grand n’importe quoi, ça donne pas envie de le lire.