Aide sur programme compteur

Tuto Eskimon et Olyte

a marqué ce sujet comme résolu.

Bonjour Je suis débutant en la matière et je découvre ce passionnant tuto d’Eskimon et Olyte. Je bloque sur la modification du programme du compteur de 0 à 100 en se servant de la boucle millis à la place de delay pour gérer un bouton par la suite. (Page 81 du PDF). Le compteur ne fonctionne pas comme je l’attends. L’afficheur des unités s’allume seul et fait 9 fois des boucles de 0 à 9 puis il s’éteint et c’est l’afficheur des dizaines qui s’allume à son tour pour afficher de 0 à 9 puis s’éteint pour laisser l’afficheur des unités reprendre son tour et ainsi de suite. Je ne comprends pas ce qui cloche dans mon code. Merci de bien vouloir m’aider. voici le code:

// définition des broches du décodeur 7 segments // (vous pouvez changer les numéros si vous voulez) const int bit_A = 2; const int bit_B = 3; const int bit_C = 4; const int bit_D = 5;

// définitions des broches des transistors pour chaque afficheur const int alim_dizaine = 6; // les dizaines const int alim_unite = 7; // les unites bool afficheur = false ; // variable pour le choix de l’afficheur long temps;

void setup() { // Les broches sont toutes des sorties pinMode(bit_A, OUTPUT); pinMode(bit_B, OUTPUT); pinMode(bit_C, OUTPUT); pinMode(bit_D, OUTPUT); pinMode(alim_dizaine, OUTPUT); pinMode(alim_unite, OUTPUT);

1
2
3
4
5
6
7
// Les broches sont toutes mises à l'état bas
digitalWrite(bit_A, LOW);
digitalWrite(bit_B, LOW);
digitalWrite(bit_C, LOW);
digitalWrite(bit_D, LOW);
digitalWrite(alim_dizaine, LOW);
digitalWrite(alim_unite, LOW);

}

void loop() // fonction principale { // boucle qui permet de compter de 0 à 99 (= 100 valeurs) for(char i = 0; i<99; i++)
{
// appel de la fonction affichage avec envoi du nombre à afficher afficher_nombre(i, afficheur);

1
}

// gestion du rafraichissement // si ça fait plus de 10 ms qu’on affiche, // on change de 7 segments (alternance unité <-> dizaine)

1
2
3
4
5
6
7
8
9
if((millis() - temps) > 10)
{
    // on inverse la valeur de "afficheur"
    // pour changer d'afficheur (unité ou dizaine)
    afficheur = !afficheur;
    // on affiche la valeur sur l'afficheur
    // afficheur : true->dizaines, false->unités  
    temps = millis(); // on met à jour le temps
}

}

1
// ici, on peut traiter les évènements (bouton...)

// fonction permettant d’afficher un nombre // elle affiche soit les dizaines soit les unités void afficher_nombre(char nombre, bool afficheur){ delay(100); char unite = 0, dizaine = 0;
if(nombre > 9) dizaine = nombre / 10; // on recupere les dizaines unite = nombre - (dizaine*10); // on recupere les unités // si " if(afficheur) { // on affiche les dizaines digitalWrite(alim_unite, LOW);
digitalWrite(alim_dizaine, HIGH); afficher(dizaine); }

1
2
3
4
5
6
7
else // égal à : else if(!afficheur)
{
    // on affiche les unités
    digitalWrite(alim_dizaine, LOW);       
    digitalWrite(alim_unite, HIGH);
    afficher(unite);
}

} // fonction écrivant sur un seul afficheur // on utilise le même principe que vu plus haut void afficher(char chiffre) { digitalWrite(bit_A, LOW); digitalWrite(bit_B, LOW); digitalWrite(bit_C, LOW); digitalWrite(bit_D, LOW);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
if(chiffre >= 8)
{
    digitalWrite(bit_D, HIGH);
    chiffre = chiffre - 8;
}
if(chiffre >= 4)
{
    digitalWrite(bit_C, HIGH);
    chiffre = chiffre - 4;
}
if(chiffre >= 2)
{
    digitalWrite(bit_B, HIGH);
    chiffre = chiffre - 2;
}
if(chiffre >= 1)
{
    digitalWrite(bit_A, HIGH);
    chiffre = chiffre - 1;
}

}

+0 -0

Pense à utiliser les balises code.

voici le code:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
// définition des broches du décodeur 7 segments
// (vous pouvez changer les numéros si vous voulez)
const int bit_A = 2;
const int bit_B = 3;
const int bit_C = 4;
const int bit_D = 5;

// définitions des broches des transistors pour chaque afficheur
const int alim_dizaine = 6; // les dizaines
const int alim_unite = 7;   // les unites
bool afficheur = false ; // variable pour le choix de l'afficheur
long temps;

void setup()
{
    // Les broches sont toutes des sorties
    pinMode(bit_A, OUTPUT);
    pinMode(bit_B, OUTPUT);
    pinMode(bit_C, OUTPUT);
    pinMode(bit_D, OUTPUT);
    pinMode(alim_dizaine, OUTPUT);
    pinMode(alim_unite, OUTPUT);

    // Les broches sont toutes mises à l'état bas
    digitalWrite(bit_A, LOW);
    digitalWrite(bit_B, LOW);
    digitalWrite(bit_C, LOW);
    digitalWrite(bit_D, LOW);
    digitalWrite(alim_dizaine, LOW);
    digitalWrite(alim_unite, LOW);
  }

void loop() // fonction principale
{
    // boucle qui permet de compter de 0 à 99 (= 100 valeurs)
    for(char i = 0; i<99; i++)    
    {       
        // appel de la fonction affichage avec envoi du nombre à afficher
       afficher_nombre(i, afficheur);

    }
// gestion du rafraichissement
    // si ça fait plus de 10 ms qu'on affiche,
    // on change de 7 segments (alternance unité <-> dizaine)

    if((millis() - temps) > 10)
    {
        // on inverse la valeur de "afficheur"
        // pour changer d'afficheur (unité ou dizaine)
        afficheur = !afficheur;
        // on affiche la valeur sur l'afficheur
        // afficheur : true->dizaines, false->unités  
        temps = millis(); // on met à jour le temps
    }
}

    // ici, on peut traiter les évènements (bouton...)   

// fonction permettant d'afficher un nombre
// elle affiche soit les dizaines soit les unités
  void afficher_nombre(char nombre, bool afficheur){
   delay(100);
       char unite = 0, dizaine = 0;    
    if(nombre > 9)
        dizaine = nombre / 10; // on recupere les dizaines
    unite = nombre - (dizaine*10); // on recupere les unités
          // si "
    if(afficheur)
    {
        // on affiche les dizaines
        digitalWrite(alim_unite, LOW);        
        digitalWrite(alim_dizaine, HIGH);
        afficher(dizaine);
    }

    else // égal à : else if(!afficheur)
    {
        // on affiche les unités
        digitalWrite(alim_dizaine, LOW);       
        digitalWrite(alim_unite, HIGH);
        afficher(unite);
    }
}
// fonction écrivant sur un seul afficheur
// on utilise le même principe que vu plus haut
void afficher(char chiffre)
{
    digitalWrite(bit_A, LOW);
    digitalWrite(bit_B, LOW);
    digitalWrite(bit_C, LOW);
    digitalWrite(bit_D, LOW);

    if(chiffre >= 8)
    {
        digitalWrite(bit_D, HIGH);
        chiffre = chiffre - 8;
    }
    if(chiffre >= 4)
    {
        digitalWrite(bit_C, HIGH);
        chiffre = chiffre - 4;
    }
    if(chiffre >= 2)
    {
        digitalWrite(bit_B, HIGH);
        chiffre = chiffre - 2;
    }
    if(chiffre >= 1)
    {
        digitalWrite(bit_A, HIGH);
        chiffre = chiffre - 1;
    }
}
Bruno62
+0 -0

Le problème est que ta fonction afficher_nombre est bloquante (à cause du delay ligne 62). Du coup, le programme fait exactement ce que tu lui demandes, en affichant les chiffres de un à 9 sur chacun des afficheurs tour à tour.

Pour réussir à faire cet exercice, il faut réussir à se passer de delay dans le programme grace justement à l’utilisation maline de la fonction millis().

+0 -0

Bonjour Merci à Eskimon d’avoir pris le temps de me guider un peu… Je suis enfin arrivé au résultat voulu. :) Désolé pour la mise en forme de mon premier message, je découvre le site. Pour apporter ma modeste aide je vous livre le code revu et corrigé.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
// définition des broches du décodeur 7 segments
// (vous pouvez changer les numéros si vous voulez)
const int bit_A = 2;
const int bit_B = 3;
const int bit_C = 4;
const int bit_D = 5;

// définitions des broches des transistors pour chaque afficheur
const int alim_dizaine = 6; // les dizaines
const int alim_unite = 7;   // les unites
bool afficheur = false ; // variable pour le choix de l'afficheur
long temps;
long temps2;
char i = 0;

void setup()
{
  // Les broches sont toutes des sorties
  pinMode(bit_A, OUTPUT);
  pinMode(bit_B, OUTPUT);
  pinMode(bit_C, OUTPUT);
  pinMode(bit_D, OUTPUT);
  pinMode(alim_dizaine, OUTPUT);
  pinMode(alim_unite, OUTPUT);

  // Les broches sont toutes mises à l'état bas
  digitalWrite(bit_A, LOW);
  digitalWrite(bit_B, LOW);
  digitalWrite(bit_C, LOW);
  digitalWrite(bit_D, LOW);
  digitalWrite(alim_dizaine, LOW);
  digitalWrite(alim_unite, LOW);
}

void loop() // fonction principale
{

  // gestion du rafraichissement
  // si ça fait plus de 10 ms qu'on affiche,
  // on change de 7 segments (alternance unité <-> dizaine)

  if ((millis() - temps) > 10)
  {
    // on inverse la valeur de "afficheur"
    // pour changer d'afficheur (unité ou dizaine)
    afficheur = !afficheur;
    // on affiche la valeur sur l'afficheur
    // afficheur : true->dizaines, false->unités
    temps = millis(); // on met à jour le temps
    // appel de la fonction affichage avec envoi du nombre à afficher
    afficher_nombre(i, afficheur);
  }
  if ((millis() - temps2) > 1000)
  {
    // on avance le compteur
    if (i > 19)
      i = 0;
    else
      i = i + 1;

    temps2 = millis(); // on met à jour le temps

  }
}

// ici, on peut traiter les évènements (bouton...)

// fonction permettant d'afficher un nombre
// elle affiche soit les dizaines soit les unités
void afficher_nombre(char nombre, bool afficheur) {

  char unite = 0, dizaine = 0;
  if (nombre > 9)
    dizaine = nombre / 10; // on recupere les dizaines
  unite = nombre - (dizaine * 10); // on recupere les unités
  // si "
  if (afficheur)
  {
    // on affiche les dizaines
    digitalWrite(alim_unite, LOW);
    digitalWrite(alim_dizaine, HIGH);
    afficher(dizaine);
  }

  else // égal à : else if(!afficheur)
  {
    // on affiche les unités
    digitalWrite(alim_dizaine, LOW);
    digitalWrite(alim_unite, HIGH);
    afficher(unite);
  }
}
// fonction écrivant sur un seul afficheur
// on utilise le même principe que vu plus haut
void afficher(char chiffre)
{
  digitalWrite(bit_A, LOW);
  digitalWrite(bit_B, LOW);
  digitalWrite(bit_C, LOW);
  digitalWrite(bit_D, LOW);

  if (chiffre >= 8)
  {
    digitalWrite(bit_D, HIGH);
    chiffre = chiffre - 8;
  }
  if (chiffre >= 4)
  {
    digitalWrite(bit_C, HIGH);
    chiffre = chiffre - 4;
  }
  if (chiffre >= 2)
  {
    digitalWrite(bit_B, HIGH);
    chiffre = chiffre - 2;
  }
  if (chiffre >= 1)
  {
    digitalWrite(bit_A, HIGH);
    chiffre = chiffre - 1;
  }
}
+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte