Compteur de 0 à 9999

a marqué ce sujet comme résolu.

Bonjour, Je suis nouveau sur le forum et je débute en programmation. j'aimerais faire un compteur allant de 0 à 9999 en additionnant un nombre avec une virgule (ex.1,674) mais je veux afficher que les entier. J'ai une carte Arduino Mega 2560, l'affichage est fait de 4 afficheur 7 segments et de un décodeur 4543B. Au début tout les zéros s'affiche le comptage se fait jusq'a la dzaine mais dès que le nombre passe la centaine le chiffre des dizaine s'éteint.Quelle est la solution pour garder les dizaines Merci et bonne journée Eric

+0 -0

Bonjour,Voilà la partie calcul. (Je pense pas avoir fait des erreurs sur les autre parties,parce-que j'ai commencer avec 0 à 100 et ça fonctionne parfaitement.

 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
void loop() //fonction principale
{
    for(float i = 0; i<10000; i+= 20.759) //boucle qui permet de compter de 0 à 99 (= 100 valeurs)
    {
        afficher_nombre(i); //appel de la fonction affichage avec envoi du nombre à afficher
    }
}

//fonction permettant d'afficher un nombre sur deux afficheurs
void afficher_nombre(float nombre)
{
    long temps; //variable utilisée pour savoir le temps écoulé...
    char unite = 0, dizaine = 0, centaine = 0, mille = 0; //variable pour chaque afficheur



    if(nombre > 9) //si le nombre reçu dépasse 9
    {
        dizaine = nombre / 10; //on récupère les dizaines
    }
        unite = nombre - (dizaine*10);  //on récupère les unités

    if(nombre > 99) //si le nombre dépasse 99
    {
        centaine = nombre /  100; //on récupère les centaines
    }
        dizaine = nombre - (centaine*100);

    if(nombre > 999)
    {
        mille = nombre / 1000;
    }
        centaine = mille - (mille*1000);


    temps = millis(); //on récupère le temps courant

    // tant qu'on a pas affiché ce chiffre pendant au moins 1000 millisecondes
    // permet donc de pouvoir lire le nombre affiché
    while((millis()-temps) < 1000)
    {
        //on affiche le nombre

Merci pour l'aide

edit by Natalya: ajout de balises code bien placées

+0 -0

Salut,

Ton copier-coller a du mal passer, il nous manque la fin, la partie //affiche nombre.

De plus, on peut faire plus simple:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
void afficher_nombre(float nombre)
{
    long temps; //variable utilisée pour savoir le temps écoulé...
    char unite, dizaine, centaine, millier; //variable pour chaque afficheur

    millier = nombre / 1000;
    nombre -= millier * 1000.0;
    centaine = nombre / 100;
    nombre -= centaine * 1000.0;
    dizaine = nombre / 10; //on récupère les dizaines
    nombre -= dizaine * 10.0;
    unité = nombre

Et on peut encore l'améliorer en utilisant un tableau et une boucle.

Par contre, en écrivant mon code, j'ai trouvé le problème du tiens:
dizaine = nombre / 10;
Si tu as un nombre supérieur ou égal à 1280, le nombre des dizaines dépasse 127, et repasse en dessous de 100, donc millier repasse à 0, et tout l'affichage est faux.

Enfin, en faisant ta fonction d'affichage avec des int, tu te simplifierais beaucoup la vie, et le compilateur gèrerais le passage de flottants à entiers à l'appel de la fonction, tout en évitant des erreurs d'arrondis provoquées par les codes ci-dessus.

+0 -0

Salut Natalya, Merci pour ton aide. Suite à une erreur de manip j'ai perdu mon programme, je ne peut malheureusement pas le recopier-coller. C'est peut-être mieux comme ça. Si on veut afficher les unités,(par exemple) le nombre 1234 on est obligé de faire une opération. Nombre - millier -centaine - dizaine = 4. (nombre - (millier * 1000) - (centaine * 100) - (dizaine * 10) Je vais essayer de refaire mon code sur cette base La fonction afficher est OK puisque j'arrive à écrire manuellement les chiffre séparément et que le compteur fonctionne avec 2 chiffre (0 à 100) J' ai pris le modèle sur le tuto parking à Eskimon. Bonne journée

+0 -0

En fait, on peut simplifier beaucoup. Ci-suit un code qui fonctionne jusque 65535, en passant de int à long, on peut gérer jusque 4 milliards et quelques. Il suffit de s'appuyer sur les mathématiques. Si le code t'intéresse mais que tu ne le comprens pas, n'hésites pas à demander à ce que je te l'explique (toi ou quiconque retrouvant ce sujet à l'avenir).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void afficher_nombre(unsigned int nombre); //j'indique à l'avance que mon argument est un entier

void loop() //fonction principale
{
    for(float i = 0; i<10000; i+= 20.759) //Je ne comprends pas cette boucle, mais admettons que tu veuilles faire ça
    {
        afficher_nombre(i); //appel de la fonction affichage avec envoi du nombre à afficher
    }
}

void afficher_nombre(unsigned int nombre)
{
    char digits[5]= {0}; //max 65535
    int i = 0;
    while(nombre != 0)
    {
        digits[i] = nombre % 10;
        nombre /= 10;
        i++;
    }

    //ici digits contient tes les chiffres composant ton nombre, il ne reste plus qu'à mettre chaque chiffre sur son afficheur
}
+0 -0

En faite oui, je comprend pas grand chose. Le but de mon compteur et de faire un compteur journalier indiquant les dizaine de mètres pour un raid en voiture pour suivre le road-book. 9999 dizaine de mètres = 99,990 Km. c'est pourquoi je met cette ligne : for(float i = 0; i<10000; i+= 20.759) //Je ne comprends pas cette boucle, mais admettons que tu veuilles faire ça. 20.759 ce nombre passera à environ 1.6.. ce qui est mon tour de roue il manque encore le capteur qui donnera l'info pour le tour de roue et le bouton de remise à zéro. Je pense que ces modifs devrais pas être trop compliquée (enfin j’espère). A la suite de discutions avec un informaticien on est arrivé à ce code qui fonctionne (reste les modifs)

  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
//définition des broches du décodeur 7 segments 
 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 = 10;
 const int alim_unite = 11;
 const int alim_centaine = 12;
 const int alim_mille = 13;

 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);
  pinMode(alim_centaine, OUTPUT);
  pinMode(alim_mille, 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);
  digitalWrite(alim_centaine, LOW);
  digitalWrite(alim_mille, LOW);
}

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

//fonction permettant d'afficher un nombre sur deux afficheurs
void afficher_nombre(float nombre)
{
  long temps; //variable utilisée pour savoir le temps écoulé...
  char unite = 0, dizaine = 0, centaine = 0, mille = 0; //variable pour chaque afficheur

  mille = nombre / 1000;   // ex. 2345 / 1000 = 2,345 = 2 millier ( les chiffre après la virgule ne s'affiche pas Parce que La variable et un char)
  centaine = (nombre - (mille * 1000)) / 100; // ex 2345 - millier * 1000 (donc 2000) = 345 / 100 = 3,45
  dizaine = (nombre - (mille * 1000) - (centaine * 100)) / 10; // ex. 2345 - millier * 1000 - centaine * 100 (2345 - 2000 - 300 = 45 / 10 = 3,45)donc "3" sans les chiffres après la virgule
  unite = (nombre - (mille * 1000) - (centaine * 100) - (dizaine * 10)) / 1;   // ex. 2345 - 2 * 1000 - 3 * 100 - 4 * 10 / 1 = 5

  temps = millis(); //on récupère le temps courant

  // tant qu'on a pas affiché ce chiffre pendant au moins 1000 millisecondes
  // permet donc de pouvoir lire le nombre affiché
  while ((millis() - temps) < 1000)
  {
    //on affiche le nombre

    // les dizaines pendant 5 ms
    digitalWrite(alim_mille, LOW); //on allume le transistor des dizaines
    afficher(dizaine); //on appel la fonction qui permet d'afficher le chiffre dizaine
    digitalWrite(alim_dizaine, HIGH); // l'autre transistor est bloqué et l'afficheur éteint
    delay(5);

    // les unités pendant 5 ms
    digitalWrite(alim_dizaine, LOW); //on éteint le transistor allumé
    afficher(unite); //on appel la fonction qui permet d'afficher le chiffre unité
    digitalWrite(alim_unite, HIGH); //et on allume les dizaines
    delay(5);

    //les centaines pendant 5 ms
    digitalWrite(alim_unite, LOW);
    afficher(centaine);
    digitalWrite(alim_centaine, HIGH);
    delay(5);

    //les milles pendant 5ms
    digitalWrite(alim_centaine, LOW);
    afficher(mille);
    digitalWrite(alim_mille, HIGH);
    delay(5);
  }
}

//fonction écrivant sur un seul afficheur
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;
  }
}

//FIN
+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