Probleme afficheur 4 x 7 segments

International Français
1

bonjour à tous ,

Voici mon souci , qui m'échappe , je souhaite afficher une variable ''Compteur '' sur un afficheur
4 digits 7 segments ( Cathode commune ) et j'utilise 7 résitances de 470 ohms sur chaque Segments .
l'afficheur seul fonctionne , avec un code simple pour afficher un entier à 4 chiffre
Cependant quand j'utilise un code avec un module RFID , pour re créditer la variable compteur
sur le principe tt fonctionne
mais le chiffre des millièmes ( 1er digit ) éclair beaucoup plus que les 3 autres !

avez vous une piste ?

merci d'avance
bonne journée à Tous

#include <SPI.h>
#include <RFID.h>



RFID monModuleRFID(53,48); // broche pin 

int UID[5]={};
int MASTERKEY[5]={233,205,0,185,157}; // code  badge bleu porte clef 



int tpsNote = 30 ;
int pause = 10 ;

int Bouton = A0;
int Led = 3;

int etatbouton;
long temps = 0;
const int ANTIREBOND = 60;    // pour l'anti rebond
int memoire_entree = HIGH;
int Compteur = 1000; // credit

////////////////////////////////////////////////afficheur 
int digit1 = 36;   // digit 
int digit2 = 37;
int digit3 = 38;
int digit4 = 39;
int A = 40;    // segments
int B = 41;
int C = 42;
int D = 43;
int E = 44;
int F = 45;
int G = 46;



void setup()
{

  SPI.begin();
  monModuleRFID.init();   
  
  pinMode(Bouton,INPUT_PULLUP);
  pinMode(Led, OUTPUT);
  
  //////////////////afficheur
  
 pinMode(digit1, OUTPUT) ;
 pinMode(digit2, OUTPUT) ;
 pinMode(digit3, OUTPUT) ;
 pinMode(digit4, OUTPUT) ;
 pinMode(A, OUTPUT) ;
 pinMode(B, OUTPUT) ;
 pinMode(C, OUTPUT) ;
 pinMode(D, OUTPUT) ;
 pinMode(E, OUTPUT) ;
 pinMode(F, OUTPUT) ;
 pinMode(G, OUTPUT) ;

 //Désactivation de tous les digits
 digitalWrite(digit1, HIGH);
 digitalWrite(digit2, HIGH);
 digitalWrite(digit3, HIGH);
 digitalWrite(digit4, HIGH);
  
  

}

void loop()
{
  

   setAfficheur(Compteur); // fonction pour afficher la variable ''compteur " sur l'afficheur 4 digits 7 segments cathode commune
   
   etatbouton = digitalRead(Bouton);
   
     if((etatbouton != memoire_entree) && (etatbouton == LOW) && (millis() - temps >= ANTIREBOND) && (Compteur > 0 ) )
    {   
      
      
        temps = millis();   
        Compteur = Compteur - 1 ;
       digitalWrite ( Led,HIGH); 
       delay ( 50 );    
    }
    
     else {digitalWrite ( Led,LOW); } 

    memoire_entree=etatbouton;
  
  
  /////////////////////////////////////////////////////////////////////////////////////
    if (monModuleRFID.isCard()) {  
          if (monModuleRFID.readCardSerial()) {        
           
            for(int i=0;i<=4;i++)
            {
              UID[i]=monModuleRFID.serNum[i];
             
            }
            
          }
          
          if (UID[0] == MASTERKEY[0]
           && UID[1] == MASTERKEY[1]
           && UID[2] == MASTERKEY[2]
           && UID[3] == MASTERKEY[3]
           && UID[4] == MASTERKEY[4])
          {
             
        Compteur = 1000;    // on remet le compteur à ZERO  
        
       for ( int n=0 ; n<3; n++ )    // si c'est ok on bip 3 fois
 
 {
   tone(2, 2093);
   delay ( tpsNote ) ;
   noTone ( 2 );
   delay ( pause);
  
    tone(2, 2349);
   delay ( tpsNote ) ;
   noTone ( 2 );
   delay ( pause);
   
    tone(2, 2637);
   delay ( tpsNote ) ;
   noTone ( 2 );
   delay ( pause);
   
    tone(2, 2794);
   delay ( tpsNote ) ;
   noTone ( 2 );
   delay ( pause);
   
    tone(2, 3136);
   delay ( tpsNote ) ;
   noTone ( 2 );
   delay ( pause);
   
    tone(2, 3520);
   delay ( tpsNote ) ;
   noTone ( 2 );
   delay ( pause);
   
    tone(2, 3951);
   delay ( tpsNote ) ;
   noTone ( 2 );
   delay ( pause);
  
 
   tone(2, 4186);
   delay ( tpsNote ) ;
   noTone ( 2 );
   delay ( pause);
   
   
   delay ( 100 );
   
 }  
 /////////////////////////////////////////////////
          }
          else             ///////////// sinon pas bonne carte bip grave
          {
            
             tone(2, 600);
             delay ( 300 ) ;
             noTone ( 2 );  
             delay ( 200 ) ;
            
          }          
          monModuleRFID.halt();
    }
    delay(1);
    
}



/////////////////////////////////////////////////////////////////////////

// Définition des FONCTIONS
//-------------------------------
void setNumber(int nombre) {
 switch (nombre) {
 case 1 :
 digitalWrite(A, 0) ;
 digitalWrite(B, 1) ;
 digitalWrite(C, 1) ;
 digitalWrite(D, 0) ;
 digitalWrite(E, 0) ;
 digitalWrite(F, 0) ;
 digitalWrite(G, 0) ;
 break;
 case 2 :
 digitalWrite(A, 1) ;
 digitalWrite(B, 1) ;
 digitalWrite(C, 0) ;
 digitalWrite(D, 1) ;
 digitalWrite(E, 1) ;
 digitalWrite(F, 0) ;
 digitalWrite(G, 1) ;
 break;
 case 3 :
 digitalWrite(A, 1) ;
 digitalWrite(B, 1) ;
 digitalWrite(C, 1) ;
 digitalWrite(D, 1) ;
 digitalWrite(E, 0) ;
 digitalWrite(F, 0) ;
 digitalWrite(G, 1) ;
 break;
 case 4 :
 digitalWrite(A, 0) ;
 digitalWrite(B, 1) ;
 digitalWrite(C, 1) ;
 digitalWrite(D, 0) ;
 digitalWrite(E, 0) ;
 digitalWrite(F, 1) ;
 digitalWrite(G, 1) ;
 break;
 case 5 :
 digitalWrite(A, 1) ;
 digitalWrite(B, 0) ;
 digitalWrite(C, 1) ;
 digitalWrite(D, 1) ;
 digitalWrite(E, 0) ;
 digitalWrite(F, 1) ;
 digitalWrite(G, 1) ;
 break;
 case 6 :
 digitalWrite(A, 1) ;
 digitalWrite(B, 0) ;
 digitalWrite(C, 1) ;
 digitalWrite(D, 1) ;
 digitalWrite(E, 1) ;
 digitalWrite(F, 1) ;
 digitalWrite(G, 1) ;
 break;
 case 7 :
 digitalWrite(A, 1) ;
 digitalWrite(B, 1) ;
 digitalWrite(C, 1) ;
 digitalWrite(D, 0) ;
 digitalWrite(E, 0) ;
 digitalWrite(F, 0) ;
 digitalWrite(G, 0) ;
 break;
 case 8 :
 digitalWrite(A, 1) ;
 digitalWrite(B, 1) ;
 digitalWrite(C, 1) ;
 digitalWrite(D, 1) ;
 digitalWrite(E, 1) ;
 digitalWrite(F, 1) ;
 digitalWrite(G, 1) ;
 break;
 case 9 :
 digitalWrite(A, 1) ;
 digitalWrite(B, 1) ;
 digitalWrite(C, 1) ;
 digitalWrite(D, 1) ;
 digitalWrite(E, 0) ;
 digitalWrite(F, 1) ;
 digitalWrite(G, 1) ;
 break;
 case 0 :
 digitalWrite(A, 1) ;
 digitalWrite(B, 1) ;
 digitalWrite(C, 1) ;
 digitalWrite(D, 1) ;
 digitalWrite(E, 1) ;
 digitalWrite(F, 1) ;
 digitalWrite(G, 0) ;
 break;
 default:
 digitalWrite(A, 0) ;
 digitalWrite(B, 0) ;
 digitalWrite(C, 0) ;
 digitalWrite(D, 0) ;
 digitalWrite(E, 0) ;
 digitalWrite(F, 0) ;
 digitalWrite(G, 1) ;
 break;
 break;
 }
}
void setDigit(int digit, int nombre) {
 switch(digit) {
 case 1 :
 digitalWrite(digit1, LOW) ;
 digitalWrite(digit2, HIGH) ;
 digitalWrite(digit3, HIGH) ;
 digitalWrite(digit4, HIGH) ;
 setNumber(nombre) ;
 break;
 case 2 :
 digitalWrite(digit1, HIGH) ;
 digitalWrite(digit2, LOW) ;
 digitalWrite(digit3, HIGH) ;
 digitalWrite(digit4, HIGH) ;
 setNumber(nombre) ;
 break;
 case 3 :
 digitalWrite(digit1, HIGH) ;
 digitalWrite(digit2, HIGH) ;
 digitalWrite(digit3, LOW) ;
 digitalWrite(digit4, HIGH) ;
 setNumber(nombre) ;
 break;
 case 4 :
 digitalWrite(digit1, HIGH) ;
 digitalWrite(digit2, HIGH) ;
 digitalWrite(digit3, HIGH) ;
 digitalWrite(digit4, LOW) ;
 setNumber(nombre) ;
 break;

 }
}
void setAfficheur(int nombre) {
 int M = nombre/1000, C = (nombre-M*1000)/100, D = (nombre-M*1000-C*100)/10,
U=(nombre-M*1000-C*100-D*10) ;


 setDigit(4, U) ;
 delay(2);
 setDigit(3, D) ;
 delay(2);
 setDigit(2, C) ;
 delay(2);
 setDigit(1, M) ;
 delay(2);
 

}
2

Dans setAfficheur, le premier Digit s'affiche en dernier. Ensuite, il reste allumé tant que loop n'a pas fini son tour. Les digits 2, 3, et 4 ont donc allumés 2ms, mais le premier l'est plus longtemps. c'est pour ça qu'il est plus brillant.

Au passage, si les autres parties de loop prennent trop de temps, ça peut gener fortement la lecture. Typiquement, un seul digit est allumé pendant que tous les autres apparaissent éteints. Pour éviter ça, on peut éteindre les quatre digits après avoir affiché un nombre, ou afficher un message d'attente ("- - - -", par exemple)

3

Merci Fantoche pour ta réponse ,
je viens de débrancher le digit 1 , pour n'afficher qu'une variable ''999''
qui ce décrémente de 1 à chaque appuie sur le Bouton poussoir
l'affichage des 3 chiffres est OK ,

Par rapport à ta réponse , il n'y a donc pas de ''combine'' pour afficher mes 4 chiffres tt le temps ?
Bien à toi

4

As-tu essayé la librairie sevenseg ?

Voir l'exemple sur cette page : GitHub - sigvaldm/SevenSeg: Arduino 7-segment display library

Elle est installable depuis le gestionnaire de bibliothèques.

5

nicopyro:
Par rapport à ta réponse , il n'y a donc pas de ''combine'' pour afficher mes 4 chiffres tt le temps ?

Bonjour,

Il faut rafraîchir l'affichage sur interruption timer. Tu peux utiliser la librairie TimerOne pour gérer l'interruption timer.

6

merci à tous pour votre aide

effectivement je vais tester la lib sevenseg , par contre je viens de voir l'exemple , apprement c'est pour des afficheurs à Anode commune , alors que j'ai un afficheur à Cathode commune !
on peut le paramétrer dans la Lib ?

7

Oui, ça se configure dans la fonction begin()
Mais à mon avis ça ne changera rien à ton problème car le rafraîchissement de l'affichage se fait en tache de fond.

8

setCommonCathode();

La librairie sevenseg peut rafraîchir l'afficheur sous interruption.
Il faut bien étudier le pdf dans le répertoire extras.
Chapitre 4.4 Using Interrupt Timers

Par contre comme l'auteur utilise digitalWrite() cela doit prendre pas mal de temps CPU.
A essayer donc.

9

Autant pour moi, je ne parlais pas de la même librairie J'avais utilisé celle ci: GitHub - DeanIsMe/SevSeg: Seven segment display controller library for Arduino

10

Celle-ci a l'air mieux bâtie au niveau de le gestion des digits. Celle de Sigvald Marholm utilise de gros switch/case pas très élégants.
Celle de Dean Reading ne propose pas de gestion sous interruption.

Les deux utilisent digitalWrite().
Pour une gestion efficace j'aurais préféré un accès direct aux registres.

11

messieurs je viens de faire le test avec la lib "SevenSeg" conseillé par hbachetti , et le probleme est résolu !!!
juste les segments éclairs un peu moins fort
j'ai mi 4 resistances sur les 4 digits de 470 ohms
que me conseillez vous : plutot mettre 7 résistances sur les 7 digits ou diminuer la valeur des résistances ?

bien à vous

12

Il vaut beaucoup mieux mettre les résistances sur les segments et non sur les digits.
Tu peux sans problème descendre à 330 ohms voire 220.

13

nicopyro:
j'ai mi 4 resistances sur les 4 digits de 470 ohms
que me conseillez vous : plutot mettre 7 résistances sur les 7 digits

Si tu mets les résistances sur le commun des digits la luminosité des segments va changer en fonction du nombre de segments allumés.
il vaut donc mieux mettre une résistance par segment. Cela en utilise plus mais le résultat est bien meilleurs.

14

Oui. 7 résistances au lieu de 4 ce n'est pas grand chose.