Tableau pour allumer Led Adressable

Version imprimable

Bonjour à tous,

Je débute en Arduino, et j'ai un projet pour allumer 7 rubans de Led adressable qui correspondent à 7 segments pour afficher des chiffres, pour cela j'ai fais 2 tableau mais je ne sais pas comment les utiliser

1 tableau pour le N° des Led sur chaque ruban
1 tableau pour le N° des rubans à allumer en fonction du chiffre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Les numéro des Leds pour chaques Digits
const int segments[7][NUM_LED] =  {{0,1,2,3,4,5},   // Numéro Led du segment 1
                   		          {6,7,8,9,10,11},   // Numéro Led du segment 2
                        		  {12,13,14,15,16,17},   // Numéro Led du segment 3
		                          {18,19,20,21,22,23},   // Numéro Led du segment 4
        		                  {24,25,26,27,28,29},   // Numéro Led du segment 5
                		          {30,31,32,33,34,35},  // Numéro Led du segment 6
                        		  {36,37,38,39,40,41}   // Numéro Led du segment 7
                        	    };
 
// Les numéros des Digits à allumer pour les chiffres
const int digits[6][NUM_LED] =   {{0,1,2,3,4,5,0},   // Chiffre 0 on allume les Segments qui correspondents au chiffre
                   		          {2,3,0,0,0,0,0},   // Chiffre 1 on allume les Segments qui correspondents au chiffre
                        		  {1,2,4,5,6,0,0},   // Chiffre 2 on allume les Segments qui correspondents au chiffre
		                          {1,2,3,4,6,0,0},   // Chiffre 3 on allume les Segments qui correspondents au chiffre
        		                  {0,2,3,6,0,0,0},   // Chiffre 4 on allume les Segments qui correspondents au chiffre
                		          {0,1,3,4,6,0,0}  // Chiffre 5 on allume les Segments qui correspondents au chiffre
                        	    };

Le problème est que pour le nombre de segment, ça dépend du chiffre donc ici dans mon code du 2° tableau les 0 ne correspondent à aucun ruban.
Vous me direz que c'est plus simple si je prend des rubans non adressable, oui, c'est certain mais je voudrais pouvoir le faire et ainsi pouvoir faire autre chose que j'ai en tête.

Il y aura aussi 3 BP : 1 pour incrémenter les chiffres, 1 pour diminuer et 1 pour remettre à 0

Merci pour votre aide car ça fais un moment que je planche dessus et je n'y arrive pas

PS N° des segments
2
1 3
7
6 4
5

A+

donc si je comprends bien vous avez 42 Leds adressables, numérotées de 0 à 41. Le Ruban est virtuellement découpé en 7 morceaux de 6 LEDs (7x6=42) qui correspondent à des parties d'un afficheur organisé comme un digit 7 segments

allumer les leds du segment N correspond à allumer les LEDs numérotées de 6N à 6N+5 (par exemple N = 0, on va de 0 à 5. ou encore N=1 on va de 6 à 11, etc ) ==> le premier tableau ne sert donc pas à grand chose puisqu'on peut calculer quelles LEDs atteindre.

Ensuite vous avez besoin de dessiner un chiffre. Vous pouvez créer un tableau de 7 booléen qui dit si un segment doit être allumé ou pas

par exemple vous voulez dire que les segments 1,2,4,5,6 sont allumés pour faire le chiffre 2, votre description serait {false, true, true, false, true, true, true}

le tableau des chiffres dans ce cas est un tableau de 10 lignes (pour 0 à 9) de 7 booléens

Ensuite si on veut faire un peu plus optimisé, au lieu de mettre 7 booléens (qui vont donc prendre 7 octets) pour décrire un chiffre, on peut se rappeler qu'un octet c'est 8 bits et comme on veut représenter que deux états (allumé ou pas) on peut utiliser 0 pour dire éteint et 1 pour dire allumé. On n'a besoin de 7 bits sur les 8 donc on peut juste ne pas utiliser le bit de poids fort par exemple.

Dans ce cas, le chiffre 2 sera représenté en binaire par 0b1110110. Le bit de poids faible représente l'état du segment 0, le bit suivant l'état du segment 1 etc
ça permet de gagner pas mal de mémoire, on n'a besoin d'un tableau de 10 octets simplement au lieu de 70.

voici un bout de code utilisant cette dernière approche qui devrait vous aider à démarrer
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 // Exemple en supposant que les segments sont arrangés ainsi // // -- 1 --- // | | // 0 2 // | | // -- 3 -- // | | // 4 6 // | | // -- 5 --- const byte lesSegments[] = { 0b1110111, 0b1000100, 0b1101110, // ... }; const byte nombreDeSegments = sizeof lesSegments; void afficher(const byte chiffre) { if (chiffre < nombreDeSegments) { Serial.print(F("Affichage du chiffre ")); Serial.println(chiffre); for (byte segment = 0; segment < 7; segment++) { Serial.print(F("\tLes LEDs du Segment ")); Serial.print(segment); Serial.print(F(" (de ")); Serial.print(6 * segment); Serial.print(F(" à ")); Serial.print(6 * segment + 5); Serial.print(F(") sont ")); if (bitRead(lesSegments[chiffre], segment) == 0) { // le segment est éteint Serial.println(F("éteintes.")); } else { // le segment est allumé Serial.println(F("allumées.")); } } } } void setup() { Serial.begin(115200); Serial.println(); afficher(0); afficher(1); afficher(1); } void loop() {}
(à exécuter avec le moniteur série ouvert à 115200 bauds)

12/04/2022, 19h55
electrosat03

Salut Jay M,

Merci pour ta réponse, je vais regarder ça de plus près.

A+

Re,

Bon, j'ai regardé ton code, c'est OK, on commence la lecture du chiffre sur le Bit de droite
Mais comment on peut allumer les leds pour faire les chiffres

Mon code avec des boucles for

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
114
115
116
117
118
119
120
121
122
/ Affiche les chiffre de 1 à 5
// Bibliothèque du ruban Led
#include "Adafruit_NeoPixel.h" 
// Pin des DATA pour le ruban
#define PIN 3 
// Nombre de Led
#define LEDS 42 
// Bouton raccodé Pin 2 = Plus 1
#define PLUS_BUTTON   2
// Bouton raccodé Pin 4 = Moins 1
#define MINUS_BUTTON  4
 
byte LedNo; // Numéro de la Led à allumer
byte Affiche_Numero; // Chiffre à afficher
 
boolean plusUp = true;
boolean minusUp = true;
 
// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDS, PIN, NEO_GRB + NEO_KHZ800);
 
void setup() {
  pinMode(2, INPUT_PULLUP);
  pinMode(4, INPUT_PULLUP);
  strip.begin();
  strip.show();  // Initialize all pixels to 'off'
}
 
void loop() { // Debut Loop
 
  // Chiffre 1 Led 12 à 23
  for(LedNo=12 ; LedNo<24 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 255, 0, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
  } // Fin For
 
  // Chiffre 2 Led 6 à 18 et 24 à 41
  delay(200);
  strip.clear(); // Eteint toutes les Led
 
  for(LedNo=6 ; LedNo<18 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 0, 255, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
  } // Fin For
 
  for(LedNo=24 ; LedNo<42 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 0, 255, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
   } // Fin For
 
  // Chiffre 3 
  delay(200); // Attend 1 sec
  strip.clear(); // Eteint toutes les Led
 
  for(LedNo=6 ; LedNo<30 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 255, 0, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
  } // Fin For
 
  for(LedNo=36 ; LedNo<42 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 255, 0, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
   } // Fin For
 
  // Chiffre 4 
  delay(200); // Attend 1 sec
  strip.clear(); // Eteint toutes les Led
 
  for(LedNo=0 ; LedNo<6 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 0, 255, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
  } // Fin For
 
  for(LedNo=12 ; LedNo<24 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 0, 255, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
   } // Fin For
 
  for(LedNo=36 ; LedNo<42 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 0, 255, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
   } // Fin For
 
  // Chiffre 5 
  delay(200); // Attend 1 sec
  strip.clear(); // Eteint toutes les Led
 
  for(LedNo=0 ; LedNo<12 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 0, 255, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
  } // Fin For
 
  for(LedNo=18 ; LedNo<30 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 0, 255, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
   } // Fin For
 
  for(LedNo=36 ; LedNo<42 ; LedNo++) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
  { // Debut For
  strip.setPixelColor(LedNo, 0, 255, 0); // (N° de la Led,Rouge,Vert,bleu)
  strip.show(); //Show The Color
   } // Fin For
  delay(500); // Attend 1 sec
  strip.clear(); // Eteint toutes les Led
} // Fin Loop

Pour l'instant les BP ne servent pas.

Merci

Voilà, je viens de finir le code et ça fonctionne

Reste à coder les 3 BP

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
#include "Adafruit_NeoPixel.h" 
// Pin des DATA pour le ruban
#define PIN 3 
// Nombre de Led
#define LEDS 42 
const byte lesSegments[] = 
{
  0b0111111, // chiffre 0 la lecture des segments se fait de droite à gauche
  0b0001100, // chiffre 1
  0b1110110, // chiffre 2
  0b1011110, // chiffre 3
  0b1001101, // chiffre 4
  0b1011011, // chiffre 5
  // ...
};
 
const byte nombreDeSegments = sizeof lesSegments;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDS, PIN, NEO_GRB + NEO_KHZ800);
 
void afficher(const byte chiffre)
{
  if (chiffre < nombreDeSegments) 
  {
    Serial.print(F("Affichage du chiffre "));
    Serial.println(chiffre);
    for (byte segment = 0; segment < 7; segment++) 
	{  
	  Serial.println(nombreDeSegments);	
      Serial.print(F("\Les LEDs du Segment "));
      Serial.print(segment);
      Serial.print(F(" (de "));
      Serial.print(6 * segment);
      Serial.print(F(" à "));
      Serial.print(6 * segment + 5);
      Serial.print(F(") sont "));
      if (bitRead(lesSegments[chiffre], segment) == 0) 
	  {
        // le segment est éteint
        Serial.println(F("eteintes."));
      } else 
	  {
        // le segment est allumé
        Serial.println(F("allumees."));
 
    	//Serial.println((6 * segment));
        //Serial.println(segment);
        int Num_Led = (6 * segment);  // Numéro de la Led de démarrage du segment à afficher    	
 
        for(Num_Led ; Num_Led <((6 * segment)+6) ; (Num_Led++)) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
        { // Debut For
         Serial.println((Num_Led));
          //Serial.println((6 * segment));
          //delay(100);
         //Serial.println(Num_Led);
      	strip.setPixelColor(Num_Led, 255, 0, 0); // (N° de la Led,Rouge,Vert,bleu)    	
      	} // Fin For
 
        strip.show(); //Show The Color
      }
    }
    delay(500); // Délai de 500 ms
    strip.clear(); // Eteint toutes les Led
  }
}
 
void setup() 
{
  Serial.begin(115200); Serial.println();
   afficher(0);
   afficher(1);
   afficher(2);
   afficher(3);
  afficher(4);
   afficher(5);
}
 
void loop()
{}

13/04/2022, 08h19
Jay M

Pour les boutons prenez une bibliothèque ça simplifie bien la vie
13/04/2022, 09h25
electrosat03

Salut,

Oui, mais laquelle, je débute je ne connais pas encore tout.

Salut,

Ca y est, j'ai placé les 3 BP et ça fonctionne MAIS

Il faut que je reste appuyé 2 sec pour que l'appuis soit pris en compte

Je ne sais pas pourquoi?

Pourrais-tu y regarder et voir si mon code tient la route.

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#include "Adafruit_NeoPixel.h" 
// Pin des DATA pour le ruban
#define PIN 3 
// Nombre de Led
#define LEDS 42 
 
#define DELAY_MS		(50) // Délai de 50 ms
 
#define NO_BUTTON		(0) // Numéro donné si aucun bouton poussé
#define BUTTON_MINUS	(1) // Numéro donné si BP poussé est Moins
#define BUTTON_PLUS		(2) // Numéro donné si BP poussé est Plus
#define BUTTON_RESET	(3) // Numéro donné si BP poussé est Reset
 
const int MIN_VALUE	= 0; // Chiffre Minimum à afficher
const int MAX_VALUE	= 5; // Chiffre Maximum à afficher
 
const int pinMinus = A0; // Pin BP Moins
const int pinPlus  = A1; // Pin BP Plus
const int pinReset = A2; // Pin BP Reset
 
const byte lesSegments[] = 
{
  0b0111111, // chiffre 0 la lecture des segments se fait de droite à gauche
  0b0001100, // chiffre 1
  0b1110110, // chiffre 2
  0b1011110, // chiffre 3
  0b1001101, // chiffre 4
  0b1011011, // chiffre 5
  // ...
};
 
const byte nombreDeSegments = sizeof lesSegments;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDS, PIN, NEO_GRB + NEO_KHZ800);
 
void setup() 
{
  pinMode(pinMinus, INPUT_PULLUP); // Défini la pin A0 en Input_PullUp
  pinMode(pinPlus,  INPUT_PULLUP); // Défini la pin A1 en Input_PullUp
  pinMode(pinReset, INPUT_PULLUP); // Défini la pin A2 en Input_PullUp
 
  Serial.begin(115200); Serial.println();
}
 
 
int curValue = 0; // Valeur au Démarrage est 0 
 
 
void loop()
{
int keyPressed = scanButtons();
 
  if(keyPressed == BUTTON_MINUS) // BP Moins Pressé
  {strip.clear(); // Eteint toutes les Led
    curValue--; // On descende de 1 la valeur courante de la variable
    if(curValue<MIN_VALUE) // Si la valeur courante de la variable est plus petit que 0
      curValue = MIN_VALUE; // on reste sur 0
  }
  if(keyPressed == BUTTON_PLUS) // BP Plus Pressé
  {strip.clear(); // Eteint toutes les Led
    curValue++; // On monte de 1 la valeur courante de la variable
    if(curValue>MAX_VALUE) // Si la valeur courante de la variable est plus grande que 5
      curValue = MAX_VALUE; // On reste sur 5
  }
  if(keyPressed == BUTTON_RESET) // BP Reset Pressé
  {strip.clear(); // Eteint toutes les Led
    curValue = MIN_VALUE; // On donne à la variable la valeur 0
 
  }
  afficher(curValue); // Va à la procédure afficher pour afficher le chiffre dans la variable curValue
  //delay(DELAY_MS);
}
 
 
void afficher(const byte chiffre)
{
 
  if (chiffre < nombreDeSegments) 
  {
 
    for (byte segment = 0; segment < 7; segment++) 
	{  
      if (bitRead(lesSegments[chiffre], segment) == 0) 
	  {
        // le segment est éteint
 
      } else 
	  {
        // le segment est allumé
        int Num_Led = (6 * segment);  // Numéro de la Led de démarrage du segment à afficher    	
 
        for(Num_Led ; Num_Led <((6 * segment)+6) ; (Num_Led++)) // Boucle pour allumer les Led (N° Led début; N° Led fin;N° Led+1)
        { // Debut For
      	strip.setPixelColor(Num_Led, 255, 0, 0); // (N° de la Led,Rouge,Vert,bleu)    	
      	} // Fin For
 
        strip.show(); //Show The Color
      }
    }
  }
}
 
 
int scanButtons()
{
  int buttonPressed = NO_BUTTON;
 
  if(digitalRead(pinMinus)==LOW) // Si on appuie sur le BP Moins
 
    buttonPressed = BUTTON_MINUS;
 
  else if(digitalRead(pinPlus)==LOW) // Si on appuie sur le BP Plus
 
    buttonPressed = BUTTON_PLUS;
 
  else if(digitalRead(pinReset)==LOW) // Si on appuie sur le BP Reset
    buttonPressed = BUTTON_RESET; 
 
 
  if(buttonPressed!=NO_BUTTON) // Si on appuie sur aucun BP
  {
  	while( (digitalRead(pinMinus)==LOW) ||
           (digitalRead(pinPlus)==LOW)  ||
           (digitalRead(pinReset)==LOW)
         )
    {
      delay(DELAY_MS); // Pour éviter une redondance
    }
  }
  return buttonPressed; // Retourne à la procédure buttonPressed
}

Merci

Bonjour,

Quelques propositions de modifications. Comme je n'avais que quelques chiffres certains segments étaient difficiles à identifier. J'ai donc repris l'ordre en escargot qui est assez facile à câbler.

L'anti rebond n'était pas très efficace.

La fonction affiche() a été modifiée pour effacer les segments éteints. Le clear n'est donc plus nécessaire.

Si aucun bouton n'est appuyé la fonction affiche() n'est pas appelée puisque rien ne change. Il en résulte cependant que l'afficheur est éteint au démarrage. Si cela gène il est facile d'ajouter un appel à affiche() en fin de setup() pour avoir un "0".

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
#include "Adafruit_NeoPixel.h" 
 
#define PIN           3      // Pin des DATA pour le ruban
#define LEDS         42      // Nombre de Leds
#define DELAY_MS     25      // Délai de 25 ms
 
#define NO_BUTTON     0      // Valeur si aucun bouton poussé
#define BUTTON_MINUS  1      // Valeur si bouton pressé est Moins
#define BUTTON_PLUS   2      // Valeur si bouton pressé est Plus
#define BUTTON_RESET  3      // Valeur si bouton pressé est Reset
 
const int MIN_VAL    =  0;   // Chiffre minimal à afficher
const int MAX_VAL    =  9;   // Chiffre maximal à afficher
const int pinMinus   = A0;   // Pin BP Moins              
const int pinPlus    = A1;   // Pin BP Plus               
const int pinReset   = A2;   // Pin BP Reset              
 
const byte SegmOn[] = {
   //        gfedcba              gfedcba        //     ——a——   
   /* 0 */ 0b0111111,   /* 1 */ 0b0000110,       //  f |     | b
   /* 2 */ 0b1011011,   /* 3 */ 0b1001111,       //     ——g——   
   /* 4 */ 0b1100110,   /* 5 */ 0b1101101,       //  e |     | c
   /* 6 */ 0b1111101,   /* 7 */ 0b0000111,       //     ——d——   
   /* 8 */ 0b1111111,   /* 9 */ 0b1101111,       // Ordre classique en escargot (facile à câbler)
   /*   */ 0b0000000};
 
const byte NbChar    = sizeof(SegmOn);
int CurVal           = 0;                        // La valeur au Démarrage est 0 
 
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDS, PIN, NEO_GRB + NEO_KHZ800); // GRB ?
 
// Afficher en rouge les chiffres___________________________________________________________________ 
void afficher(const byte chiffre) {
   if(chiffre >= NbChar) return;
   int Num_Led = 0;
   for(byte segment = 0; segment < 7; segment++) {  
      uint8_t R = bitRead(SegmOn[chiffre], segment) ? 255: 0;
      for(int i = 5 ; i >= 0; --i, ++Num_Led)    // Mettre à jour les 6 Leds du segment
         strip.setPixelColor(Num_Led, R, 0, 0);  // (N° de la Led, Rouge, Vert, bleu)    	
   }
   strip.show(); //Show The Color
}
 
// Lire l'état des boutons_________________________________________________________________________
int scanButtons() {
   int buttonPressed = NO_BUTTON;                // NO_BUTTON == 0
   if(digitalRead(pinMinus) == LOW)              // Si on appuie sur le BP Moins
      buttonPressed = BUTTON_MINUS;
   else if(digitalRead(pinPlus) == LOW)          // Si on appuie sur le BP Plus
      buttonPressed = BUTTON_PLUS;
   else if(digitalRead(pinReset) == LOW)         // Si on appuie sur le BP Reset
      buttonPressed = BUTTON_RESET; 
   do delay(DELAY_MS);                           // Au moins un délai anti rebond à la descente
   while((digitalRead(pinMinus) == LOW) || (digitalRead(pinPlus) == LOW)  
      || (digitalRead(pinReset) == LOW));        // Attendre la remontée de tous les btn
   delay(DELAY_MS);                              // Eviter les rebonds aussi à la remontée
   return buttonPressed;
}
 
// Initialisation___________________________________________________________________________________ 
void setup() {
   pinMode(pinMinus, INPUT_PULLUP);              // Défini la pin A0 en Input_PullUp
   pinMode(pinPlus,  INPUT_PULLUP);              // Défini la pin A1 en Input_PullUp
   pinMode(pinReset, INPUT_PULLUP);              // Défini la pin A2 en Input_PullUp
   // Serial.begin(115200); Serial.println();
}
 
 
// Boucle principale________________________________________________________________________________ 
void loop() {
   int keyPressed = scanButtons();
   if(     (keyPressed == BUTTON_MINUS) && (CurVal > MIN_VAL)) CurVal--;    // BP - pressé
   else if((keyPressed == BUTTON_PLUS ) && (CurVal < MAX_VAL)) CurVal++;    // BP + pressé
   else if( keyPressed == BUTTON_RESET)  CurVal = MIN_VAL;                  // BP Reset pressé
   if(keyPressed) afficher(CurVal);              // Afficher le chiffre correspondant à CurVal
}

Comme je n'ai pas testé ce code, il n'est pas garanti sans scories.

Salutations