besoin aide clavier affichage 4 digits

Bonjour, je fais un compteur de points mais j’ai un problème avec l’affichage, mes unités s’affichent bien mais le dizaine, centaine et milliers s’effacent.
Merci pour m’aider
Palou72

#include <Keypad.h>
const int COLONNES = 4; 
const int LIGNES = 4; 
const int C4=8; 
const int C3=9; 
const int C2=10; 
const int C1=11; 
const int L4=4; 
const int L3=5; 
const int L2=6; 
const int L1=7; 

char touches[LIGNES][COLONNES] = { 
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte BrochesLignes[LIGNES] = {7, 6, 5, 4}; 
byte BrochesColonnes[COLONNES] = {11, 10, 9, 8}; 
char touche; 
unsigned int valeur; 
int son= 0;
int soa= 0;
int compte = 0;
String chaine ="";
String chaine2 ="";
Keypad clavier = Keypad( makeKeymap(touches), BrochesLignes, BrochesColonnes, LIGNES, COLONNES );

int a = 46;
int b = 44;
int c = 42;
int d = 40;
int e = 38;
int f = 36;
int g = 34;
int p = 32;
int d4 = 30;
int d3 = 28;
int d2 = 26;
int d1 = 24;

int count = 0;
long n = 0;// n représente la valeur affichée sur l'affichage LED. Par exemple, lorsque n = 0, 0000 est affiché. La valeur maximale est 9999.
int x = 100;
int del = 5;// Définit del comme 5; la valeur est le degré de réglage fin pour l'horloge
void setup()
{
  Serial.begin(115200);

  //régler toutes les broches de l'affichage LED en sortie
  pinMode(d1, OUTPUT);
  pinMode(d2, OUTPUT);
  pinMode(d3, OUTPUT);
  pinMode(d4, OUTPUT);
  pinMode(a, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
  pinMode(p, OUTPUT);
  }
void loop()
{
while (true){
char touche = clavier.getKey();
if (touche != NO_KEY){ 
if (touche == 'A'){
  chaine ="A";
  compte = 1;
}  
 int valeur = touche - 48;
 Serial.println(valeur);
 if ((valeur>=1) && (valeur<=7)){
    compte=compte+1 ;
if (chaine =="A"){     
  soa = soa + valeur;
  n=soa;
   Serial.println(soa);
}
   chaine2= chaine+touche;  
  
if (compte==2){
  Serial.println(chaine2);
    break;//fin while
    }
   }
  }// no key
}//fin while

  Serial.println(chaine2);
   Serial.println(n);

  clearLEDs();//efface l'écran d'affichage à 7 segments
  pickDigit(0);//Allumez 7 segments d'affichage d1
   pickNumber((n/1000));// get the value of thousand
  delay(del);
  clearLEDs();
  pickDigit(1);
  pickNumber((n%1000)/100);
  delay(del);
 clearLEDs();
  pickDigit(2);
  pickNumber((n%100)/10);
  delay(del);

 clearLEDs();
  pickDigit(3);
  pickNumber((n%10));//Get the value of single digit
  delay(del);
 
}// fin de loop
/**************************************/ 
void pickDigit(int x) //allumer un affichage à 7 segments
{

  // L'affichage LED à 7 segments est un écran à cathode commune. Donc, utilisez aussi digitalWrite pour régler d1 aussi haut et la LED s'éteindra

 digitalWrite(d1, HIGH);
  digitalWrite(d2, HIGH);
  digitalWrite(d3, HIGH);
  digitalWrite(d4, HIGH);
   switch(x)
 {
    case 0: 
    digitalWrite(d1, LOW);//Light d1 up 
       break;
    case 1: 
    digitalWrite(d2, LOW); //Light d2 up 
        break;
    case 2: 
    digitalWrite(d3, LOW); //Light d3 up 
        break;
    default: 
    digitalWrite(d4, LOW); //Light d4 up 
 
  }
}
//La fonction est de contrôler l'affichage LED à 7 segments pour afficher les numéros. Ici x est le nombre à afficher. C'est un nombre entier de 0 à 9
void pickNumber(int x)
{
  switch(x)
  {
    default: 
    zero(); 
    break;
    case 1: 
    one(); 
    break;
    case 2: 
    two(); 
    break;
    case 3: 
    three(); 
    break;
    case 4: 
    four(); 
    break;
    case 5: 
    five(); 
    break;
    case 6: 
    six(); 
    break;
    case 7: 
    seven(); 
    break;
    case 8: 
    eight(); 
    break;
    case 9: 
    nine(); 
    break;
  }
} 
void clearLEDs() //clear the 7-segment display screen
{
  if (chaine == "A") {
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(p, LOW);
 
  }

void zero() //l'affichage à led à 7 segments 0
{
  if (chaine == "A") {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, LOW);
  }
  }

void one() // 1
{
  if (chaine == "A") {
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
 }
}

void two() // 2
{
  if (chaine == "A") {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, LOW);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
  }
  }
void three() // 3
{
  if (chaine == "A") {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
  }
  }

void four() // 4
{
  if (chaine == "A") {
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  }
   }

void five() // 5
{
  if (chaine == "A") {
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  }
 }

void six() // 6
{
  if (chaine == "A") {
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  }
}

void seven() // 7
{
  if (chaine == "A") {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  }
 }

void eight() // 8
{
  if (chaine == "A") {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  }
 }

void nine() // 9
{
  if (chaine == "A") {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  }

}

y'a pas un problème d'accolades {} qui ne se correspondent à la fin de la fonction clearLEDs() pas dans votre code?

combien avez vous d'afficheurs pour vos 4 digits? on dirait que le code n'en connait qu'un seul (j'ai lu en diagonal - ça semble compliqué, je ne sais pas vraiment ce que vous cherchez à faire)

(vous devriez utiliser des tableaux et les pins sont mieux en const byte)

Merci pour ta réponse, en réalité je veux avoir deux afficheurs 4 digits 7segments pour compter et afficher les points de deux joueurs mais comme le code était trop long j'ai enlevé le deuxième affichage, la prise sur le clavier se fait bien et les additions se font bien et sont bien retransmises à chaque afficheur mais seules les unités restent affichées alors

Je suis débutant en programme arduino, le code que j'ai fait est en fait une addition d'un code clavier et d'un code afficheur que j'ai trouvé sur le net.

le code afficheur fonctionne très bien seul, c'est un programme que j'ai trouvé sur le site:www.sunfounder.com : RFID Kit V2.0 for Arduino : Lesson 17 Stopwatch – 4-Digit 7-Segment Display que j'ai adapté.

Je ne vois pas où mettre les {} , il est vrai que d'utiliser des tableaux seraient mieux mais je ne gère pas trop.

Je vais changer les pins en const byte.

Merci

OK… Le code de sunfounder leçon 17 est mauvais… la gestion du temps c’est n’importe quoi et leur code

clearLEDs();//clear the 7-segment display screen
  pickDigit(0);//Light up 7-segment display d1
  pickNumber((n/1000));// get the value of thousand
  delay(del);//delay 5ms

n’efface pas l’afficheur en cours mais le précédent - il faudrait inverser les 2 premières lignes pour d’abord sélectionner un des digits puis ensuite envoyer le chiffre à afficher

Pour eux ça fonctionne parce que la boucle fonce et donc avec la persistence rétinienne on voit sans doute le chiffre un peu moins brillant que normalement mais suffisamment allumé (5ms)

J'ai inversé les lignes la 1ère et la 2éme, puis la 3ème et la 2ème, mêmes résultats, j'ai supprimé la ligne clearLEDs() pour voir cela ne change rien

j'ai même essayé d'ôter les lignes digitalWrite(d1, HIGH) et là les quatre digits sont allumés mais est inscrits l'unités sur les 4.

D1 à D4 disent quel digit choisir et ensuite il faut appeler la bonne fonction dépendant du chifffre à afficher

Votre truc avec le,clavier et le « A » ça sert à quoi? Pourquoi mettre des strings? Vous avez besoin juste d’un nombre entre 0 et 9999 non? Donc un int fait l’affaire

Le A c’est pour le joueur A, et le B pour le 2ème joueur, le calcul se fait bien, quand on lance le programme et que l’on arrive dans les dizaine, le chiffre des dizaines s’affiche correctement mais disparaît instantanément seul le chiffre des unités reste allumé, c’est le problème

le code en réalité sur cette partie c’est:

void loop()
{
while (true){
char touche = clavier.getKey();
if (touche != NO_KEY){
 if (touche == 'A'){
  chaine ="A";
  compte = 1;
  }
  if (touche == 'B'){
  chaine ="B";
  compte = 1;
  }
 int valeur = touche - 48;
 Serial.println(valeur);
 if ((valeur>=1) && (valeur<=7)){
    compte=compte+1 ;
if (chaine =="A"){     
  soa = soa + valeur;
  n=soa;
   Serial.println(soa);
}
if (chaine =="B"){
   sob = sob + valeur;
   n=sob;
    Serial.println(sob);
}
   chaine2= chaine+touche;
   
    Serial.println(chaine2);
if (compte==2){
  Serial.println(chaine2);
    break;//fin while
    }
   }
  }// no key
}//fin while

  clearLEDs();//efface l'écran d'affichage à 7 segments
  pickDigit(0);//Allumez 7 segments d'affichage d1
   pickNumber((n/1000));// get the value of thousand
  delay(del);//delay 5ms

Essayez de mettre à la fin du set up

clearLEDs();
pickDigit(0);
pickNumber(3);
delay(1000);

clearLEDs();
pickDigit(1);
pickNumber(4);
delay(1000);

clearLEDs();
pickDigit(2);
pickNumber(8);
delay(1000);

clearLEDs();
pickDigit(3);
pickNumber(9);
delay(1000);

Et laissez la loop() vide

ça fait quoi? (Normalement vous voyez les chiffres 3 4 8 9 qui vont s’afficher sur chacun des afficheurs et s’éteindre au bout d’une seconde

Maintenant mettez ce même code dans la loop au lieu du setup et changez les delay(1000) par delay(2) à la place - l’affichage devrait être stable avec les 4 chiffres lisibles

C’est parce que l’afficheur que vous avez ne sait afficher qu’un digit à un moment donné. Il,n’a pas de mémoire. C’est pour cela qui faut boucler en permanence pour rafraîchir l’affichage rapidement si on ne veut pas que les chiffes s’eteignent, c’est la persistence rétinienne qui fait que vous verrez les 4

Je n’ai pas lu votre code mais je suppose que vous ne rafraîchissez pas les 4 à chaque tour de loop() s’ils disparaissent

Cela ne fait rien, rien ne s'allume.

Faut garder les fonctions et tout le reste du setup hein.... je e suis pas sûr mon ordi donc je ne peu pas tester; postez le code que vous avez esssayé

J’ai modifié le code ci dessus peut être quand vous testiez - relisez

Voici la partie de code, j’abdique pour ce soir , ma chère et tendre m’appelle pour la soupe.
Merci, je refais des essais demain.

void setup()
{
  Serial.begin(115200);

  //régler toutes les broches de l'affichage LED en sortie
  pinMode(d1, OUTPUT);
  pinMode(d2, OUTPUT);
  pinMode(d3, OUTPUT);
  pinMode(d4, OUTPUT);
  pinMode(a, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
  pinMode(p, OUTPUT);
  
  pinMode(bd1, OUTPUT);
  pinMode(bd2, OUTPUT);
  pinMode(bd3, OUTPUT);
  pinMode(bd4, OUTPUT);
  pinMode(ba, OUTPUT);
  pinMode(bb, OUTPUT);
  pinMode(bc, OUTPUT);
  pinMode(bd, OUTPUT);
  pinMode(be, OUTPUT);
  pinMode(bf, OUTPUT);
  pinMode(bg, OUTPUT);
  pinMode(bp, OUTPUT);
 
  pickDigit(0);
clearLEDs();
pickNumber(3);

pickDigit(1);
clearLEDs();
pickNumber(4);

pickDigit(2);
clearLEDs();
pickNumber(8);

pickDigit(3);
clearLEDs();
pickNumber(9);
}
/***************************************/ 
void loop()
{
/*while (true){
char touche = clavier.getKey();
if (touche != NO_KEY){
 if (touche == 'A'){
  chaine ="A";
  compte = 1;
  }
  if (touche == 'B'){
  chaine ="B";
  compte = 1;
  }
 int valeur = touche - 48;
 Serial.println(valeur);
 if ((valeur>=1) && (valeur<=7)){
    compte=compte+1 ;
if (chaine =="A"){     
  soa = soa + valeur;
  n=soa;
   Serial.println(soa);
}
if (chaine =="B"){
   sob = sob + valeur;
   n=sob;
    Serial.println(sob);
}
   chaine2= chaine+touche;
   
    Serial.println(chaine2);
if (compte==2){
  Serial.println(chaine2);
    break;//fin while
    }
   }
  }// no key
}//fin while
*/
  clearLEDs();//efface l'écran d'affichage à 7 segments
  pickDigit(0);//Allumez 7 segments d'affichage d1
   pickNumber((n/1000));// get the value of thousand
  delay(del);//delay 5ms

  clearLEDs();//efface l'écran d'affichage à 7 segments
  pickDigit(1);//Allumez 7 segments d'affichage d2
  pickNumber((n%1000)/100);// get the value of hundred
  delay(del);//delay 5ms

 clearLEDs();//efface l'écran d'affichage à 7 segments
  pickDigit(2);//Light up 7-segment display d3
  pickNumber((n%100)/10);//get the value of ten
  delay(del);//delay 5ms

 clearLEDs();//efface l'écran d'affichage à 7 segments
  pickDigit(3);//Allumez 7 segments d'affichage d4
  pickNumber((n%10));//Get the value of single digit
  delay(del);//delay 5ms
 
 
}// fin de loop
/**************************************/

Vous avez laissé des trucs dans la loop() et y’a plus les fonctions etc…

Faites un bout de code séparé tout propre

Bonne soupe :slight_smile:

Bon j'ai essayé avec le code refait, rien à faire, j'ai bidouillé rien,

const byte a = 46;
const byte b = 44;
const byte c = 42;
const byte d = 40;
const byte e = 38;
const byte f = 36;
const byte g = 34;
const byte p = 32;
const byte d4 = 30;
const byte d3 = 28;
const byte d2 = 26;
const byte d1 = 24;
/*
void clearLEDs(){}
void pickDigit()
void pickNumber()
*/

void setup()
{
  
  //régler toutes les broches de l'affichage LED en sortie
  pinMode(d1, OUTPUT);
  pinMode(d2, OUTPUT);
  pinMode(d3, OUTPUT);
  pinMode(d4, OUTPUT);
  pinMode(a, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
  pinMode(p, OUTPUT);
  
  
clearLEDs();
pickDigit(0);
pickNumber(3);
delay(1000);

clearLEDs();
pickDigit(1);
pickNumber(4);
delay(1000);

clearLEDs();
pickDigit(2);
pickNumber(8);
delay(1000);

clearLEDs();
pickDigit(3);
pickNumber(9);
delay(1000);
}

/***************************************/ 
void loop()
{

}// fin de loop

Bonjour

Avez vous un affichage LED à 7 segments à cathode ou Anode commune? ça va changer ce que vous faites sur D1…D4 pour choisir le bon afficheur.

Si ça ne marche pas dans ce sens, changez les HIGH en LOW et inversement sur les commandes portant sur D1…D4

testez ce code:

  • une première fois avec le code tel quel → vous devriez voir des chiffres pendant 1 seconde sur chaque afficheur, le dernier “9” restant allumé.

  • une seconde fois en commentant ce qu’il y a dans le setup (là ou c’est indiqué) ET en dé-commentant ce qu’il y a dans la loop. → dans ce cas la persistence rétinienne devrait faire que vous voyez les 4 chiffres comme s’ils étaient tout le temps allumés, même si en pratique il ne restent allumés chacun que 5ms et éteints 15ms → sur 1 seconde ils vont être allumés 50 fois, soit une fréquence de 50Hz et pour l’oeil c’est comme si c’était tout le temps allumé.

const byte a = 46;
const byte b = 44;
const byte c = 42;
const byte d = 40;
const byte e = 38;
const byte f = 36;
const byte g = 34;
const byte p = 32;
const byte d4 = 30;
const byte d3 = 28;
const byte d2 = 26;
const byte d1 = 24;

// ----------------------------

void zero() //l'affichage à led à 7 segments 0
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, LOW);
}

void one() // 1
{
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
}

void two() // 2
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, LOW);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
}

void three() // 3
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
}

void four() // 4
{
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

void five() // 5
{
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

void six() // 6
{
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

void seven() // 7
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
}

void eight() // 8
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

void nine() // 9
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

// ----------------------------

void clearLEDs() //clear the currently selected 7-segment display
{
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(p, LOW);
}

// ----------------------------
void pickDigit(int x) //selectionne le bon 7 segments
{
  // on coupe l'alim de tous les segments
  digitalWrite(d1, HIGH);
  digitalWrite(d2, HIGH);
  digitalWrite(d3, HIGH);
  digitalWrite(d4, HIGH);

  // on n'alimente que le bon
  switch (x)
  {
    case 0:
      digitalWrite(d1, LOW);//Light d1 up
      break;
    case 1:
      digitalWrite(d2, LOW); //Light d2 up
      break;
    case 2:
      digitalWrite(d3, LOW); //Light d3 up
      break;
    case 3:
      digitalWrite(d3, LOW); //Light d3 up
      break;
  }
}


// allume les bons segments sur l'afficheur en cours
void pickNumber(int x)
{
  switch (x)
  {
    case 0:
      zero();
      break;
    case 1:
      one();
      break;
    case 2:
      two();
      break;
    case 3:
      three();
      break;
    case 4:
      four();
      break;
    case 5:
      five();
      break;
    case 6:
      six();
      break;
    case 7:
      seven();
      break;
    case 8:
      eight();
      break;
    case 9:
      nine();
      break;
  }
}

void setup()
{
  //régler toutes les broches de l'affichage LED en sortie
  pinMode(d1, OUTPUT);
  pinMode(d2, OUTPUT);
  pinMode(d3, OUTPUT);
  pinMode(d4, OUTPUT);
  pinMode(a, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
  pinMode(p, OUTPUT);


  // Même si on faisait boucler ce code, comme on met 4 secondes pour revenir au début de la boucle c'est beaucoup
  // trop pour que la persistence rétinienne fonction. il faudrait des délais moins longs
  // le code ci-dessous sert juste à tester si vous avez bien câblé correctement
  // et 

  
  // dans le second test mettre ce qui suit dans la fonction setup en commentaire
  
  // --------------------- COMMENCER ICI ---------------------
  clearLEDs();
  pickDigit(0);
  pickNumber(3);
  delay(1000); // celui là on va le voir une seconde

  clearLEDs(); // en faisant cela on a éteint le digit précédent. 
  pickDigit(1);
  pickNumber(4);
  delay(1000); // on affiche le 4 pendant une seconde

  clearLEDs();
  pickDigit(2);
  pickNumber(8);
  delay(1000);

  clearLEDs();
  pickDigit(3);
  pickNumber(9);
  delay(1000);
  // --------------------- FINIR ICI ---------------------
}

/***************************************/
void loop() {

  // enlevez le commentaire de cette partie pour faire le second test et comprendre ce qu'il se passe avec la persistance rétinienne

  /*
    clearLEDs();    // enlève la valeur des PINS pour que lorsqu'on change d'afficheur il ne prenne pas la valeur de celui en cours
    pickDigit(0);   // choisit le 1er afficheur
    pickNumber(3);  // on affiche le chiffre 3
    delay(5);       // on attend un peu pour que la persistence rétinienne fonctionne

    clearLEDs();
    pickDigit(1);
    pickNumber(4);
    delay(5);

    clearLEDs();
    pickDigit(2);
    pickNumber(8);
    delay(5);

    clearLEDs();
    pickDigit(3);
    pickNumber(9);
    delay(5);
  */

}

Je vais essayer ce soir quand je vais rentrer .
Par contre sur mon programme avec 1 seul joueur en changeant la position de }//fin while cela marche. :slight_smile:

Je pense que je vais mettre deux claviers 12 touches indépendants avec chacun un afficheur afin d’éviter des erreurs lors de la rentrer des scores mais je vais quand même essayer de trouver avec un seul clavier pour le fun. :confused:
Je vais aussi essayer d’inscrire la lettre A ou B sur la 1 ere digits à voir?

Merci encore

// clavier 16 touches + afficheur 4 digits 7segments
#include <Keypad.h>
//--- Constantes utilisées avec le clavier matriciel 4x4
const int LIGNES = 4; // 4 lignes
const int COLONNES = 4; // 4 colonnes
// --- Déclaration des constantes des broches E/S numériques ---

const int C4=8; // Constante pour la broche 2
const int C3=9; // Constante pour la broche 3
const int C2=10; // Constante pour la broche 4
const int C1=11; // Constante pour la broche 5

const int L4=4; // Constante pour la broche 16
const int L3=5; // Constante pour la broche 17
const int L2=6; // Constante pour la broche 18
const int L1=7; // Constante pour la broche 19

// --- Déclaration des variables globales ---

//--- Définition des touches 
char touches[LIGNES][COLONNES] = { // tableau de char à 2 dimensions
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

// tableaux de lignes et colonnes
byte BrochesLignes[LIGNES] = {7, 6, 5, 4}; //connexions  broches de lignes du clavier
byte BrochesColonnes[COLONNES] = {11, 10, 9, 8}; //connexions broches de colonnes du clavier

char touche; // variable de stockage valeur touche appuyée
unsigned int valeur; // variable pour valeur saisie
int son= 0;
int soa= 0;
int compte = 0;
String chaine ="";
String chaine2 ="";
// création d'un objet keypad = initialisation clavier
Keypad clavier = Keypad( makeKeymap(touches), BrochesLignes, BrochesColonnes, LIGNES, COLONNES );
const byte a = 46;
const byte b = 44;
const byte c = 42;
const byte d = 40;
const byte e = 38;
const byte f = 36;
const byte g = 34;
const byte p = 32;
const byte d4 = 30;
const byte d3 = 28;
const byte d2 = 26;
const byte d1 = 24;
long n = 0;
int x = 100;
int del = 5;
int count = 0;
void setup()
{

  pinMode(d1, OUTPUT);
  pinMode(d2, OUTPUT);
  pinMode(d3, OUTPUT);
  pinMode(d4, OUTPUT);
  pinMode(a, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
  pinMode(p, OUTPUT);
 Serial.begin(115200);
 }
void loop()
{
while (true){
char touche = clavier.getKey();
if (touche != NO_KEY){
  
if (touche == 'A'){
  chaine ="A";
  compte = 1;
}
 int valeur = touche - 48;
 Serial.println(valeur);
 if ((valeur>=1) && (valeur<=7)){
    compte=compte+1 ;
if (chaine =="A"){     
  soa = soa + valeur;
  n=soa;
   Serial.println(soa);
}
   chaine2= chaine+touche;
 if (compte==2){
     break;//fin while
    }
   }
  }// no key

  clearLEDs();//efface l'écran d'affichage
  pickDigit(0);//Allumez s d1
  pickNumber((n/1000));// get the value of thousand
  delay(del);//delay 5ms

  clearLEDs();//efface l'écran d'affichage 
  pickDigit(1);//Allumez  d2
  pickNumber((n%1000)/100);//  obtenir la valeur de cent
  delay(del);//delay 5ms

  clearLEDs();//efface l'écran d'affichage à 
  pickDigit(2);//Allumez  d3
  pickNumber(n%100/10);// obtenir la valeur de dix
  delay(del);//delay 5ms

  clearLEDs();// efface l'écran d'affichage 
  pickDigit(3);//Allumez d4                  
  pickNumber(n%10);//  Obtenir la valeur d'un chiffre
  delay(del);//delay 5ms
  }//fin while
}
/**************************************/ 
void pickDigit(int x) //allumer un affichage à 7 segments
{
  // L'affichage LED à 7 segments est un écran à cathode commune. Donc, utilisez aussi digitalWrite pour régler d1 aussi haut et s'éteindra
  digitalWrite(d1, HIGH);
  digitalWrite(d2, HIGH);
  digitalWrite(d3, HIGH);
  digitalWrite(d4, HIGH);

  switch(x)
  {
    case 0: 
    digitalWrite(d1, LOW);// d1 up 
    break;
    case 1: 
    digitalWrite(d2, LOW); // d2 up 
    break;
    case 2: 
    digitalWrite(d3, LOW); //Light d3 up 
    break;
    default: 
    digitalWrite(d4, LOW); //Light d4 up 
    break;
  }
}
//La fonction contrôle l'affichage pour afficher les numéros
void pickNumber(int x)
{
  switch(x)
  {
    default: 
    zero(); 
    break;
    case 1: 
    one(); 
    break;
    case 2: 
    two(); 
    break;
    case 3: 
    three(); 
    break;
    case 4: 
    four(); 
    break;
    case 5: 
    five(); 
    break;
    case 6: 
    six(); 
    break;
    case 7: 
    seven(); 
    break;
    case 8: 
    eight(); 
    break;
    case 9: 
    nine(); 
    break;
  }
} 
void clearLEDs() //efface l'écran d'affichage 
{
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(p, LOW);
}

void zero() //affichage à  0
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, LOW);
}

void one() //affichage à  1
{
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
}

void two() //affichage  2
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, LOW);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
}
void three() //affichage à  3
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
}

void four() //affichage à  4
{
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

void five() //affichage à  5
{
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

void six() //affichage à  6
{
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

void seven() //affichage à  7
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
}

void eight() //affichage à  8
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

void nine() //affichage à 9
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
}

bonjour, Avez vous un affichage LED à 7 segments à cathode ou Anode commune? je ne peux pas te dire, je n'y connais rien, je suis dans la mécanique, pour moi l'électronique et la programmation d'aujourd'hui c'est? Dans le temps je programmais bien en basic sous dos mais depuis Windows j'ai du mal à comprendre la philosophie donc je bricole un peu. Je suis un vieux :(

j'ai essayé les deux codes , le premier les chiffres s'allume et s'éteigne un à un, dans le second cas cela marche bien, les trois chiffres restent allumés.

Je t'ai mis un code qui fonctionne bien en changeant simplement le position de fin de while, maintenant avec deux joueurs, cela marche presque sauf que lorsque je change de a vers b b s'affiche mais a s'efface mais si je tape sur a la valeur s'applique correctement mais efface b et vice versa.

Sur internet j'ai trouvé un code avec la librairie SECVEG qui parait très simple mais après test je ne suis pas arrivé à le faire fonctionner car je ne sais pas comment mettre les pins mais je vais revoir cela.

Merci .

j'ai essayé les deux codes , le premier les chiffres s'allume et s'éteigne un à un, dans le second cas cela marche bien, les trois chiffres restent allumés.

Vous voulez dire dans le second cas les 4 restent allumés, pas les 3? (En fait ils ne restent pas allumés, ils clignotent mais suffisamment vite pour tromper l’oeil)

Dans votre premier post vous dites

mes unités s'affichent bien mais le dizaine, centaine et milliers s'effacent.

et bien c’est exactement ce que ce bout de code vous montre. Il faut penser à rafraîchir souvent chaque digit pour que l’œil ait l’impression de tout voir allumé. Il impose une charge assez importante sur la loop() et donc il vaut mieux traiter cela soit en hardware avec des circuits afficheurs plus intelligents, soit en Software avec des interruptions + usage des PORTS pour accélérer l’affichage)

Sinon vous avez deux afficheurs à 4 digits ou vous voulez utiliser 2 digits pour un joueur et deux digits pour l’autre? (Avec deux de ces afficheurs vous doublez la pression sur les mises à jour)

Hardware, software, pour moi c'est du chinois , je n'ai pas ces connaissances.

J'ai deux afficheurs 4 digits.

Je continue à chercher mais je vais faire deux circuits différents avec deux claviers 12 touches, un pour chaque afficheurs ,cela évitera les erreurs d'imputation des points sur les joueurs soit avec une carte mega 2560 soit avec 2 cartes uno.

Moins de 4 euros pour les uno et 0,8 euros pour les claviers chez banggood et sans frais de port depuis la Chine !!

certes - c'est une façon de faire :)

comment les points sont ils rentrés? s'agit-il d'un tour de rôle (genre lancé de flechette à chacun son tour on rajoutera des points d'un montant variable) ou de +1 pour un joueur aléatoire (genre escrime ou celui qui touche gagne 1 point) ou de +x pour un joueur aléatoire (genre Tennis ou on va compter 15/30/40 avantage etc)

De manière générale c'est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement) si vous voulez apprendre à programmer ce genre de chose

Au snooker, il y a 15 billes rouges et 6 de couleur plus la bille de choc blanche. On doit empocher (faire tomber dans un des trous) une boule rouge puis une de couleur ainsi de suite jusqu'au moment où l'on raté son coup, l'autre joueur peut jouer. Une boule rouge marque 1 point, la jaune 2 points, la verte 3, la marron 4, la bleue 5, la rose 6 et la noire 7. Si la blanche est empoché on donne 4 pts à l'adversaire, il peut jouer et poser la bille blanche où cela l'arrange. Les billes de couleur sont remise en jeu tant qu'il y a des rouges sur le tapis. Quand il n'y a plus de rouges on doit empocher les billes dans l'ordre de leur valeur c'est à dire ', la jaune, la verte ainsi de suite.

Je vais regarder votre tutoriel. Merci