Compteur d'appui sur un bouton.

Ce n’est pas un poll !

Bonjour, moi et un ami essayons de faire un compteur qui compte les appuis sur un bouton avec un afficheur 7 segments.

Avec plusieurs essais sans succès, nous n’y arrivons toujours pas.

premier essai (AC) :

//compteur avec un afficheur à LED 7 segment AC


int valeur = 0;
int boutton = 2;

int rien = 53 ;
int zero[] = {12, 11, 10, 6, 7, 8}; // chiffre 0
int un[] = {10, 8}; // chiffre 1
int deux[] = {6, 7, 13, 11, 10}; // chiffre 2
int trois[] = {13, 11, 10, 8, 7}; // chiffre 3
int quatre[] = {13, 12, 10, 8}; // chifre 4
int cinq[] = {13, 12, 11, 8, 7}; // chiffre 5
int six[] = {13, 12, 11, 6, 7, 8}; // chiffre 6
int sept[] = {8, 10, 11}; // chiffre 7
int huit[] = {12, 11, 10, 13, 6, 7, 8}; // chiffre 8
int neuf[] = {12, 11, 10, 13, 8, 7}; // chiffre 9

void setup() {
pinMode(rien,OUTPUT);
pinMode(zero,OUTPUT);
pinMode(un,OUTPUT);
pinMode(deux,OUTPUT);
pinMode(trois,OUTPUT);
pinMode(cinq,OUTPUT);
pinMode(six,OUTPUT);
pinMode(sept,OUTPUT);
pinMode(huit,OUTPUT);
pinMode(neuf,OUTPUT);
pinMode(boutton,INPUT);
pinMode(rien,OUTPUT);
pinMode(zero,OUTPUT);
pinMode(un,OUTPUT);
}
void loop() {
valeur = digitalRead(boutton);

// rien

 digitalWrite(rien,LOW);
 
delay(100);
//zéro

while(valeur == HIGH){
 
delay(100);
  if(valeur == LOW){
 digitalWrite(un,HIGH);
 digitalWrite(deux,HIGH);
 digitalWrite(trois,HIGH);
 digitalWrite(cinq,HIGH);
 digitalWrite(six,HIGH);
 digitalWrite(sept,HIGH);
 digitalWrite(huit,HIGH);

   
}}


delay(100);

// un

while(valeur == HIGH){
 digitalWrite(un,HIGH);
 digitalWrite(deux,HIGH);
 digitalWrite(trois,LOW);
 digitalWrite(cinq,LOW);
 digitalWrite(six,HIGH);
 digitalWrite(sept,HIGH);
 digitalWrite(huit,HIGH);
delay(100);
  if(valeur == LOW){
 digitalWrite(un,HIGH);
 digitalWrite(deux,HIGH);
 digitalWrite(trois,LOW);
 digitalWrite(cinq,LOW);
 digitalWrite(six,HIGH);
 digitalWrite(sept,HIGH);
 digitalWrite(huit,HIGH);   
}}


// deux

while(valeur == HIGH){
 digitalWrite(un,LOW);
 digitalWrite(deux,LOW);
 digitalWrite(trois,HIGH);
 digitalWrite(cinq,LOW);
 digitalWrite(six,LOW);
 digitalWrite(sept,HIGH);
 digitalWrite(huit,LOW);
delay(100);
  if(valeur == LOW){
 digitalWrite(un,LOW);
 digitalWrite(deux,LOW);
 digitalWrite(trois,HIGH);
 digitalWrite(cinq,LOW);
 digitalWrite(six,LOW);
 digitalWrite(sept,HIGH);
 digitalWrite(huit,LOW);
   
}}

// trois

while(valeur == HIGH){
 digitalWrite(un,HIGH);
 digitalWrite(deux,LOW);
 digitalWrite(trois,LOW);
 digitalWrite(cinq,LOW);
 digitalWrite(six,LOW);
 digitalWrite(sept,HIGH);
 digitalWrite(huit,LOW);
delay(100);
  if(valeur == LOW){
 digitalWrite(un,HIGH);
 digitalWrite(deux,LOW);
 digitalWrite(trois,LOW);
 digitalWrite(cinq,LOW);
 digitalWrite(six,LOW);
 digitalWrite(sept,HIGH);
 digitalWrite(huit,LOW);
   
}}}

deuxième essai (CC) :

int zero[] = {12, 11, 10, 6, 7, 8}; // chiffre 0
int un[] = {10, 8}; // chiffre 1
int deux[] = {6, 7, 13, 11, 10}; // chiffre 2
int trois[] = {13, 11, 10, 8, 7}; // chiffre 3
int quatre[] = {13, 12, 10, 8}; // chifre 4
int cinq[] = {13, 12, 11, 8, 7}; // chiffre 5
int six[] = {13, 12, 11, 6, 7, 8}; // chiffre 6
int sept[] = {8, 10, 11}; // chiffre 7
int huit[] = {12, 11, 10, 13, 6, 7, 8}; // chiffre 8
int  neuf[] = {12, 11, 10, 13, 8, 7}; // chiffre 9


int a = 0;
int b = 0;
int c = 0;
int d = 0;
int e = 0;
int f = 0;
int g = 0;
int h = 0;
int i = 0;
int boutton = 2;
int bouttonstate = a;

void setup() {
  
  for (a; a<6; a++) {
    pinMode(zero[i], OUTPUT);  
  }
  for (b; b<2; b++) {
    pinMode(un[i], OUTPUT);  
  }
  for (c; c<5; c++) {
    pinMode(deux[i], OUTPUT);  
  }
  for (d; d<5; d++) {
    pinMode(trois[i], OUTPUT);  
  }
  for (e; e<4; e++) {
    pinMode(quatre[i], OUTPUT);  
  }
  for (f; f<4; f++) {
    pinMode(cinq[i], OUTPUT);  
  }
  for (g; g<6; g++) {
    pinMode(six[i], OUTPUT);  
  }
  for (h; h<3; h++) {
    pinMode(sept[i], OUTPUT);  
  }
  for (i=0; i<7; i++) {
    pinMode(huit[i], OUTPUT);  
  }
  for (i; i<5; i++) {
    pinMode(neuf[i], OUTPUT);  
  }
 
pinMode (boutton, INPUT);

}


void loop() {
  bouttonstate = digitalRead(boutton);

  
  for (a; a<6; a++) {
    digitalWrite(zero[i], HIGH);  
  }
  
  //
 
  if (bouttonstate == HIGH) {
    
    for (a; a<6; a++) {
    digitalWrite(zero[i], LOW);  
  }
    
    for (b; b<2; b++) {
    digitalWrite(un[i], HIGH);  
  }
  
  //
  
  }
  
  
  if (bouttonstate == HIGH) {
    
    for (b; b<2; b++) {
    digitalWrite(un[i], LOW);  
  }
  for (c; c<5; c++) {
    digitalWrite(deux[i], HIGH);  
  }
  
  //
  
  }
  if (bouttonstate == HIGH) {
    
    for (d; d<5; d++) {
    digitalWrite(deux[i], LOW);  
  }
  for (e; e<5; e++) {
    digitalWrite(trois[i], HIGH);  
  }
  
  //
  
  }}

troisième essai (CC) :

int zero[] = {12, 11, 10, 6, 7, 8}; // chiffre 0
int un[] = {10, 8}; // chiffre 1
int deux[] = {6, 7, 13, 11, 10}; // chiffre 2
int trois[] = {13, 11, 10, 8, 7}; // chiffre 3
int quatre[] = {13, 12, 10, 8}; // chifre 4
int cinq[] = {13, 12, 11, 8, 7}; // chiffre 5
int six[] = {13, 12, 11, 6, 7, 8}; // chiffre 6
int sept[] = {8, 10, 11}; // chiffre 7
int huit[] = {12, 11, 10, 13, 6, 7, 8}; // chiffre 8
int  neuf[] = {12, 11, 10, 13, 8, 7}; // chiffre 9

// bon je crois que c'est fini pour les chiffres :)

int i = 0;
int boutton = 2;
int bouttonstate = 0;

void setup() {
  
  for (i=0; i<6; i++) {
    pinMode(zero[i], OUTPUT);  
  }
  for (i=0; i<2; i++) {
    pinMode(un[i], OUTPUT);  
  }
  for (i=0; i<5; i++) {
    pinMode(deux[i], OUTPUT);  
  }
  for (i=0; i<5; i++) {
    pinMode(trois[i], OUTPUT);  
  }
  for (i=0; i<4; i++) {
    pinMode(quatre[i], OUTPUT);  
  }
  for (i=0; i<4; i++) {
    pinMode(cinq[i], OUTPUT);  
  }
  for (i=0; i<6; i++) {
    pinMode(six[i], OUTPUT);  
  }
  for (i=0; i<3; i++) {
    pinMode(sept[i], OUTPUT);  
  }
  for (i=0; i<7; i++) {
    pinMode(huit[i], OUTPUT);  
  }
  for (i=0; i<5; i++) {
    pinMode(neuf[i], OUTPUT);  
  }
 
pinMode (boutton, INPUT);

}


void loop() {
  bouttonstate = digitalRead(boutton);

  
 for (i=0; i<6; i++) {
    digitalWrite(zero[i], HIGH);  
  }
 for (i=0; i<2; i++) {
    pinMode(un[i], HIGH);  
  }
  for (i=0; i<5; i++) {
    pinMode(deux[i], HIGH);  
  }
  for (i=0; i<5; i++) {
    pinMode(trois[i], HIGH);  
  }
  for (i=0; i<4; i++) {
    pinMode(quatre[i], HIGH);  
  }
  for (i=0; i<4; i++) {
    pinMode(cinq[i], HIGH);  
  }
  for (i=0; i<6; i++) {
    pinMode(six[i], HIGH);  
  }
  for (i=0; i<3; i++) {
    pinMode(sept[i], HIGH);  
  }
  for (i=0; i<7; i++) {
    pinMode(huit[i], HIGH);  
  }
  for (i=0; i<5; i++) {
    pinMode(neuf[i], HIGH);  
  }
}

voilà.
Pouvez-vous nous indiquer une erreur à corriger ?
Merci; Numeross.

Merci de mettre ton code en forme en utilisant les balises "code", c'est plus lisible

Déjà là :

int zero[] = {12, 11, 10, 6, 7, 8}; // chiffre 0
...
pinMode(zero,OUTPUT);

Ca n'a aucun sens ! pinMode( pin_number, pin_mode ) ne permet de régler le fonctionnement (entrée ou sortie) que d'une seule broche.

Quand à ta méthode de gestion du bouton, je ne comprend pas non plus. Comment est relié le poussoir ?

Je crois que tu n'as pas compris.

Déjà commence par publier un schéma. Pour cela, pas besoin d'aller chercher un logiciel compliqué. Prend un papier, un crayon, ton appareil photo numérique, reste simple et publie l'image du schéma.

Combien as tu d'afficheur 7-segments ? Est-ce des afficheurs simples (9 broches : une pour chaque segment et le point + point commun) ? ou bien des afficheurs avec décodage BCD intégré ? Anode commune ou cathode commune ?

Marque/référence, data-sheet ?

Mais pour

Prend un papier, un crayon

Oh il ne faut pas oublier la gomme :grin: :grin: :grin:

Je plussoi pour le schéma électrique.

Mais ne pas oublier aussi que près de 200 lignes de codes sans commentaires pour indiquer ce que tu veux faire c'est pas du plus facile à lire.

N'oublies pas les commentaires dans le code, pour nous et aussi pour toi.

Avec plusieurs essais sans succès, nous n'y arrivons toujours pas.

C'est à dire. Quel est le problème?

Bonjour, je suis l’ami de numeross, quand nous transférons le code dans l’arduino et que nous faisons tout les branchements nécessaires, il y a le chiffre 0 qui s’affichent mais quand nous appuyons sur le microrupteur (oui c’est un microrupteur), rien ne se passe.
Le schéma est a venir :slight_smile: .

Voici le code (AC) :

/* les broches 13, 12, 11, 10, 9, 8, 7 et 6 sont utilisées
la broche '' de l'arduino est egal a la broche '' de l'afficheur
           13              =                    10
           12              =                     9
           GND             =                   8 ou 3
           11              =                     7
           10              =                     6 
           8               =                     4
           7               =                     2
           6               =                     1
           
ps : http://sciences.siteduzero.com/tutoriel-3-605437-afficheurs-7-segments.html

il y a des tableaux ou on va mettre en action certaine broche qui sont relié a
certaine broches de l'afficheur donc chaque tableau va faire un chiffre

*/



int zero[] = {12, 11, 10, 6, 7, 8}; // chiffre 0
int un[] = {10, 8}; // chiffre 1
int deux[] = {6, 7, 13, 11, 10}; // chiffre 2
int trois[] = {13, 11, 10, 8, 7}; // chiffre 3
int quatre[] = {13, 12, 10, 8}; // chifre 4
int cinq[] = {13, 12, 11, 8, 7}; // chiffre 5
int six[] = {13, 12, 11, 6, 7, 8}; // chiffre 6
int sept[] = {8, 10, 11}; // chiffre 7
int huit[] = {12, 11, 10, 13, 6, 7, 8}; // chiffre 8
int  neuf[] = {12, 11, 10, 13, 8, 7}; // chiffre 9

// bon je crois que c'est fini pour les chiffres :)

int a = 0;
int b = 0;
int c = 0;
int d = 0;
int e = 0;
int f = 0;
int g = 0;
int h = 0;
int i = 0;
int boutton = 2;
int bouttonstate = a;

void setup() {
  
  pinMode(13,OUTPUT);
  pinMode(12,OUTPUT);
  pinMode(11,OUTPUT);
  pinMode(10,OUTPUT);
  pinMode(9,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(2,INPUT); // boutton
}


void loop() {
  bouttonstate = digitalRead(boutton);

  
  for (a; a<6; a++) {
    digitalWrite(zero[a], HIGH);  
  }
  
  //
 
  if (bouttonstate == HIGH) {
    
// Au debut le chiffre 0 est allumé : 

    for (a; a<6; a++) {
    digitalWrite(zero[a], LOW);  
  }
   
   // On appuie sur le boutton, le chiffre 0 s'éteint
   // Le chiffre 1 s'allume
   
   if (bouttonstate == HIGH) {
    
    for (a; a<2; a++) {
    digitalWrite(zero[a], LOW);  
  }
  for (b; b<2; b++) {
    digitalWrite(un[b], HIGH);  
  }
   
  
  // On appuie sur le boutton, le chiffre 1 s'éteint
   // Le chiffre 2 s'allume
  
  }
  
  
  if (bouttonstate == HIGH) {
    
    for (b; b<2; b++) {
    digitalWrite(un[b], LOW);  
  }
  for (c; c<5; c++) {
    digitalWrite(deux[c], HIGH);  
  }
  
  // On appuie sur le boutton, le chiffre 2 s'éteint
   // Le chiffre 3 s'allume
  
  }
  if (bouttonstate == HIGH) {
    
    for (c; c<5; c++) {
    digitalWrite(deux[c], LOW);  
  }
  for (d; d<5; d++) {
    digitalWrite(trois[d], HIGH);  
  }
  
  // à suivre...
  
  
  }

}

Ton code de gestion des 7-segments est un peu compliqué et ne permet pas facilement de gérer de segments à éteindre.
Je te propose de passer à un octet dont chaque bit va correspondre à l’un des 7-segments

// Correspondance n° de segment  -> pin Arduino
// segment 0 -> pin 13
// segment 1 -> pin 12
// segment 2 -> pin 11
// segment 3 -> pin 10
// segment 4 -> pin 9
// segment 5 -> pin 8
// segment 6 -> pin 7
// segment 7 -> pin 6
int segment2pin[7] = { 13, 12, 11, 10, 9, 8, 7, 6 };

// correspondance chiffre -> segments (basé sur ton code, j'ai par vérifié
// la macro _BV(n) positionne a 1 le bit n (n = 0..7)   #define _BV(n)   ((1)<<(n))
int chiffre2segment[10] = 
{
  /* 0 */ _BV(1) + _BV(2) + _BV(3) + _BV(4) + _BV(5) + _BV(6)
  /* 1 */ _BV(3) + _BV(4),
//... etc jusqu'a 9
};

void affiche(int valeur)
{
  for ( int segment = 0 ; segment <= 7 ; ++segment )
    digitalWrite( segment2pin[segment], chiffre2segment[valeur] & _BV(segment) );
}

Plus simple non ?

à vérifier avec

void loop( void )
{
  for ( int i = 0 ; i < 10 ; i++ )
  {
    affiche( i );
    delay( 1000 );
  }
}

EDIT : PS : Codé de tête sans même vérifier que çà compile donc peut demander quelques petits ajustements. L’idée est là…

Je te propose de passer à un octet dont chaque bit va correspondre à l'un des 7-segments

Je ne comprend pas, tu veut dire qu'on peut associer une variable a un bit ? Et je ne comprend pas le code aussi :roll_eyes: . Desolé mais je suis un debutant :~ .

Un octet est fait de 8 bits numérotés de droite à gauche de 0 à 7
b7 b6 b5 b4 b3 b2 b1 b0

Chaque bit a un “poids” c’est à dire qu’il représente une puissance de 2.
Le poids du bit n est 2^n (2 puissance n)
Ainsi le bit 0 vaut 1, le bit 1 vaut 2, … le bit 7 vaut 128.
Un octet représente donc par défaut un entier non signé entre 0 et 255 écrit sous la forme de somme de puissance de 2
01001010 vaut 64 + 8 + 2 = 74 = 0x4A

Je propose d’utiliser chaque bit pour représenter un des segments de ton afficheur y compris le point.
Cela va permettre une écriture plus compacte.
Ainsi si l’afficheur est représenté de la façon suivante :

    ----b1----
   |          |
   b          b
   0          2
   |          |
    ----b6----
   |          |
   b          b
   5          3
   |          |
    ----b4----
                (b7)

Alors le chifre 0 est représenté par un octet dont les bits b0, b1, b2, b3, b4 et b5 sont à 1, les autres à 0;
D’ou mon code

byte chiffre2segment[10] = 
{
  /* 0 */ _BV(1) + _BV(2) + _BV(3) + _BV(4) + _BV(5) + _BV(6)
  /* 1 */ _BV(3) + _BV(4),
//... etc jusqu'a 9
};

Le tableau chiffre2segment contient 1 octet (j’avais mis int mais on peut mettre byte) pour chaque nombre
chiffre2segment[0] indique quels sont les segments à allumer pour afficher 0
chiffre2segment[1] indique quels sont les segments à allumer pour afficher 1
etc …
La macro _BC(n) est identique à (1<<(n)) c’est à dire qu’elle positionne le bit correspondant
_BV(1) + _BV(2) + _BV(3) + _BV(4) + _BV(5) + _BV(6)
est un octet égal à b01111110 soit 0x7E
_BV(3) + _BV(4),
est un octet égal à b00010001 soit 0x11

Le tableau segment2pin lui indique pour chaque élement le numero de pin auquel est relié le segment en question
segment2pin[0] est le numéro de pin du 1er segment correspondant au bit b0 ci-dessus
segment2pin[1] est le numéro de pin du 1er segment correspondant au bit b1 ci-dessus
etc…

Ok pour la représentation ?

Maintenant pour l’affichage du chiffre N, il suffit de lire dans chiffre2segment l’octet qui contient la représentation des segments à allumer ou éteindre pour afficher le chiffre N.
On va parcourir tous les bits de cet octet et on va positionner en HIGH ou en LOW la pin correspondante suivant que le bit soit à 1 ou à 0. Ca tombe bien, HIGH c’est 1 et LOW c’est 0

En réécrivant la fonction affiche sur plus de ligne pour la rendre plus claire :

void affiche(int valeur)
{
  byte segments_a_afficher = chiffre2segment[valeur];
  // on boucle pour tester chaque bit
  for ( int segment = 0 ; segment <= 7 ; ++segment )
  {
    byte bit_a_tester = _BV(segment); // equivalent à 1<<segment;
    int pin_du_segment = segment2pin[segment];
    if ( (segments_a_afficher & bit_a_tester) != 0 )
      digitalWrite( pin_du_segment, HIGH );
    else
      digitalWrite( pin_du_segment, LOW );
  }
}

Est-ce que c’est plus clair ?