Optimiser un code

Bonjour, je débute dans l'arduino et la programmation en général, et je travaille avec la libraire adafruit neopixels, je souhaiterais savoir si il est possible de simplifier ce code que j'ai fais mais que je pense n'est pas du tout optimisé. Il pilote deux afficheurs (sur 2 pins) 7 segments en ws2812b.

Merci d'avance !

void Unite(char chiffre) {
    switch(chiffre)
    {
    case 0 :
  AffUnite.setPixelColor(0, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(1, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(2, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(3, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(4, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(5, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(6, AffUnite.Color(0,0,0));
        break;
    case 1 :
  AffUnite.setPixelColor(0, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(1, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(2, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(3, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(4, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(5, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(6, AffUnite.Color(0,0,0));
        break;
    case 2 :
  AffUnite.setPixelColor(0, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(1, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(2, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(3, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(4, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(5, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(6, AffUnite.Color(r,g,b));
        break;
    case 3 :
  AffUnite.setPixelColor(0, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(1, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(2, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(3, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(4, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(5, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(6, AffUnite.Color(r,g,b));
        break;
    case 4 :
  AffUnite.setPixelColor(0, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(1, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(2, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(3, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(4, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(5, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(6, AffUnite.Color(r,g,b));
        break;
    case 5 :
  AffUnite.setPixelColor(0, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(1, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(2, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(3, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(4, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(5, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(6, AffUnite.Color(r,g,b));
        break;
    case 6 :
  AffUnite.setPixelColor(0, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(1, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(2, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(3, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(4, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(5, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(6, AffUnite.Color(r,g,b));
        break;
    case 7 :
  AffUnite.setPixelColor(0, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(1, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(2, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(3, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(4, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(5, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(6, AffUnite.Color(0,0,0));
        break;
    case 8 :
  AffUnite.setPixelColor(0, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(1, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(2, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(3, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(4, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(5, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(6, AffUnite.Color(r,g,b));
        break;
    case 9 :
  AffUnite.setPixelColor(0, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(1, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(2, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(3, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(4, AffUnite.Color(0,0,0));
  AffUnite.setPixelColor(5, AffUnite.Color(r,g,b));
  AffUnite.setPixelColor(6, AffUnite.Color(r,g,b));
        break;
    }
}
void Dizaine(char chiffre)
{
    switch(chiffre)
    {
    case 0 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(1, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(2, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(3, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(4, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(5, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(6, AffDizaine.Color(0,0,0));
        break;
    case 1 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(1, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(2, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(3, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(4, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(5, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(6, AffDizaine.Color(0,0,0));
        break;
    case 2 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(1, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(2, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(3, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(4, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(5, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(6, AffDizaine.Color(r,g,b));
        break;
    case 3 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(1, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(2, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(3, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(4, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(5, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(6, AffDizaine.Color(r,g,b));
        break;
    case 4 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(1, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(2, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(3, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(4, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(5, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(6, AffDizaine.Color(r,g,b));
        break;
    case 5 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(1, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(2, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(3, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(4, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(5, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(6, AffDizaine.Color(r,g,b));
        break;
    case 6 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(1, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(2, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(3, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(4, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(5, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(6, AffDizaine.Color(r,g,b));
        break;
    case 7 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(1, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(2, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(3, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(4, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(5, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(6, AffDizaine.Color(0,0,0));
        break;
    case 8 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(1, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(2, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(3, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(4, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(5, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(6, AffDizaine.Color(r,g,b));
        break;
    case 9 :
  AffDizaine.setPixelColor(0, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(1, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(2, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(3, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(4, AffDizaine.Color(0,0,0));
  AffDizaine.setPixelColor(5, AffDizaine.Color(r,g,b));
  AffDizaine.setPixelColor(6, AffDizaine.Color(r,g,b));
        break;
    }
}

Vous pourriez avoir une fonction qui prendrait en param l’afficheur souhaité (et passer AffUnite Ou AffDizaine). ça ne ferait qu’une seule fonction au lieu de deux.

Bonjour,

Tu peux utiliser une table pour définir les pixels à allumer et tu peux faire une boucle pour les allumer ou les éteindre.
Tu peux faire une seule fonction pour afficher sur l’afficheur de dizaines ou des unités

Tout dépend de l ‘encombrement SRAM et si vous préférez avoir plus de mémoire libre

Si y’a un peu d’octets dispos, Oui une table de byte à 2 dimensions pourrait simplifier.

La première dimension correspond à chiffre et la seconde serait 0 ou 1 pour dire si c’est allumé (on utilise alors r,g,b) ou éteint (on utilise alors 0,0,0)

byte description[10][] = {
   {1,1,1,1,1,1,0}, // chiffre 0, pixels de 0 à 6
   {0,1,1,0,0,0,0}, // chiffre 1, pixels de 0 à 6
... // je vous laisse remplir
   {1,1,1,1,0,1,1} // chiffre 9, pixels de 0 à 6
};

// et dans la fonction qui prend chiffre et afficheur comme params
for (pixel=0; pixel < 7; pixel++) {
   if (description[chiffre][pixel] == 1)  afficheur.setPixelColor(pixel, afficheur.Color(r,g,b));
   else afficheur.setPixelColor(pixel, afficheur.Color(0,0,0));
}

J’ai plus la librairie en tête mais il me semble qu’on peut écrire juste afficheur.setPixelColor(pixel, r, g, b);, pas besoin d’appeler la methode Color

Notez que ça utilise 70 octets si vous voulez faire simple, sinon vous pourriez faire qu’avec 10 octets en utilisant une notation binaire et en lisant les bits à 1 ou 0 (7 bits tiennent dans un octet)

byte description[]= { // attention pixel de poids faible à droite
   B0111111, // chiffre 0, pixels de 6 à 0
   B0000110, // chiffre 1, pixels de 6 à 0
... // je vous laisse remplir
   B1101111  // chiffre 9, pixels de 6 à 0
};

Et utiliser dans la boucle for la fonction bitRead() pour lire if (bitRead(description[chiffre],pixel) == 1) {...

Tout d'abord, merci pour vos réponses !

alors j'ai optimisé mon code d'origine pour y voir plus clair, comme me l'a indiqué J-M-L il n'y avait pas besoin de rappeler la methode color.

void Unite(char chiffre) {
    switch(chiffre)
    {
    case 0 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,r,g,b);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,0,0,0);
        break;
    case 1 :
  AffUnite.setPixelColor(0,0,0,0);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,0,0,0);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,0,0,0);
  AffUnite.setPixelColor(6,0,0,0);
        break;
    case 2 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,0,0,0);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,r,g,b);
  AffUnite.setPixelColor(5,0,0,0);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 3 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,0,0,0);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 4 :
  AffUnite.setPixelColor(0,0,0,0);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,0,0,0);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 5 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,0,0,0);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 6 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,0,0,0);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,r,g,b);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 7 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,0,0,0);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,0,0,0);
  AffUnite.setPixelColor(6,0,0,0);
        break;
    case 8 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,r,g,b);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 9 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    }
}
void Dizaine(char chiffre)
{  
  switch(chiffre)
    {
        case 0 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,r,g,b);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,0,0,0);
        break;
    case 1 :
  AffDizaine.setPixelColor(0,0,0,0);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,0,0,0);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,0,0,0);
  AffDizaine.setPixelColor(6,0,0,0);
        break;
    case 2 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,0,0,0);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,r,g,b);
  AffDizaine.setPixelColor(5,0,0,0);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 3 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,0,0,0);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 4 :
  AffDizaine.setPixelColor(0,0,0,0);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,0,0,0);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 5 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,0,0,0);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 6 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,0,0,0);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,r,g,b);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 7 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,0,0,0);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,0,0,0);
  AffDizaine.setPixelColor(6,0,0,0);
        break;
    case 8 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,r,g,b);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 9 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    }
}

Puis j'ai créé le byteDescription.

byte description[10][] = {
   {1,1,1,1,1,1,0}, // chiffre 0, pixels de 0 à 6
   {0,1,1,0,0,0,0}, // chiffre 1, pixels de 0 à 6
   {1,1,0,1,1,0,1}, // chiffre 2, pixels de 0 à 6
   {1,1,1,1,0,0,1}, // chiffre 3, pixels de 0 à 6
   {0,1,1,0,0,1,1}, // chiffre 4, pixels de 0 à 6
   {1,0,1,1,0,1,1}, // chiffre 5, pixels de 0 à 6
   {1,0,1,1,1,1,1}, // chiffre 6, pixels de 0 à 6
   {1,1,1,0,0,0,0}, // chiffre 7, pixels de 0 à 6
   {1,1,1,1,1,1,1}, // chiffre 8, pixels de 0 à 6
   {1,1,1,1,0,1,1}  // chiffre 9, pixels de 0 à 6
};

Jusqu'à là c'est bon, par contre j'ai du mal avec la syntaxe pour intégrer le système de table dans mes deux fonctions que sont "Dizaine" et "unite"

P.S. Je comprends que mon code d'origine ne servira plus.

Merci pour votre aide en tout cas.

c’est quoi le type de AffUnite ou AffDizaine ? je suppose que c’est une instance de Adafruit_NeoPixel

votre fonction pourrait être

byte description[10][] = {
   {1,1,1,1,1,1,0}, // chiffre 0, pixels de 0 à 6
   {0,1,1,0,0,0,0}, // chiffre 1, pixels de 0 à 6
   {1,1,0,1,1,0,1}, // chiffre 2, pixels de 0 à 6
   {1,1,1,1,0,0,1}, // chiffre 3, pixels de 0 à 6
   {0,1,1,0,0,1,1}, // chiffre 4, pixels de 0 à 6
   {1,0,1,1,0,1,1}, // chiffre 5, pixels de 0 à 6
   {1,0,1,1,1,1,1}, // chiffre 6, pixels de 0 à 6
   {1,1,1,0,0,0,0}, // chiffre 7, pixels de 0 à 6
   {1,1,1,1,1,1,1}, // chiffre 8, pixels de 0 à 6
   {1,1,1,1,0,1,1}  // chiffre 9, pixels de 0 à 6
};


void afficheChiffre(byte chiffre, Adafruit_NeoPixel& afficheur)
{
   // et dans la fonction qui prend chiffre et afficheur comme params
   for (byte pixel=0; pixel < 7; pixel++) {
      if (description[chiffre][pixel] == 1)  afficheur.setPixelColor(pixel,r,g,b);
      else afficheur.setPixelColor(pixel,0,0,0);
}
}

code tapé ici, je n’ai pas vérifié, il peut y avoir des bugs

et quand vous voulez appeler afficheChiffre() pour les unités vous faites afficheChiffre(n, AffUnite); idem avec AffDizaine

NB - comme c’est quand même assez simple avec les bits, je vous conseille de prendre un tableau plus petit comme expliqué plus haut

Oui AffUnite et AffDizaine permettent de choisir quel est l’afficheur en focus

// Paramètres de la librairie NeoPixels et déclaration du nom des afficheurs
Adafruit_NeoPixel AffDizaine = Adafruit_NeoPixel(7, PIN1, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel AffUnite = Adafruit_NeoPixel(7, PIN2, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel AffRod = Adafruit_NeoPixel(60, PIN3, NEO_GRB + NEO_KHZ800);

Je vais travailler sur ton code… je te fais un retour rapide. Merci

Au fait, c’est un décompteur que je suis en train de faire. AffRod c’est un anneau de 60 neopixels.
pour les personnes intéressées, et une fois le système fonctionnel, je donnerais le code complet + découpe CNC

MESSAGE 1/2 (Limite de 9000 caractères)

Je suis désolé, je galère un peu avec les tables, je n’y arrive pas.
j’ai refais mon code et je l’ai commenté

Il fonctionne parfaitement sur mon afficheur.

#include <Adafruit_NeoPixel.h> // Activation de la librairie Néopixels
#include <SoftwareSerial.h>  // Activation du port série
#include <Arduino.h>

#ifdef __AVR__  // Si c'est pour µC AVR
  #include <avr/power.h> // alors Librairie power
#endif  // Fin de condition

// Définition des pins de l'arduino pour les afficheurs
#define PIN1  2 // Afficheur de gauche
#define PIN2  4 // Afficheur de droite
#define PIN3  3 // Point central


// Paramètres de la librairie NeoPixels et déclaration du nom des afficheurs
Adafruit_NeoPixel AffDizaine = Adafruit_NeoPixel(7, PIN1, NEO_GRB + NEO_KHZ800);  //Afficheur de gauche des dizaines
Adafruit_NeoPixel AffUnite = Adafruit_NeoPixel(7, PIN2, NEO_GRB + NEO_KHZ800);    //Afficheur de droite des unités
Adafruit_NeoPixel AffPoint = Adafruit_NeoPixel(1, PIN3, NEO_GRB + NEO_KHZ800);    //Affichage du point central qui deviendra le ROD plus tard
//Adafruit_NeoPixel AffRod = Adafruit_NeoPixel(60, PIN3, NEO_GRB + NEO_KHZ800);   //Implémentation du ROD de 60 pixels qui remplacera AffPoint

int delayval = 500; // Délai d'une demi-seconde pour charger les condensateurs
int resultat = 185; // Ici je choisis manuellement un temps en secondes en attendant d'ajouter un système de sélection
                    // Le temps ici est de 185 secondes auquel il faut retrancher réellement 60 secondes
                    // Pour éviter de passer de 2min à 1min mais aller directement a 60sec...
                     
int nombre = 0;     // Il permet de calculer sa division ou son modulo pour dissocier unités des dizaines
int couleur(int r,int g,int b); //Gestion de la couleur
int r=0;  //Mise à zero des couleurs rouges par défaut
int g=0;  //Mise à zero des couleurs vertes par défaut
int b=0;  //Mise à zero des couleurs bleues par défaut
int lepoint = 0;  //Sert pour la bascule du point central

void setup() {

  Serial.begin(9600);  // Initialisation de la communication série en 9600 Bauds

// Initialisation et test des afficheurs
  AffUnite.begin(); 
  AffDizaine.begin(); 
  AffPoint.begin(); 

}

void loop() 
{
  
/////////////////////////////////
//Clignotement du point central//
/////////////////////////////////////////  
switch(lepoint)
    {
    case 0 :  
      AffPoint.setPixelColor(0,0,0,0);
      lepoint = 1;
      break;
    case 1 :
      AffPoint.setPixelColor(0,r,g,b);
      lepoint = 0;
      break;
    }
////////////////////////////////////////

      
Serial.println(resultat);
Nombre_affiche(resultat);
AffUnite.show(); // Affiche le chiffre de droite
AffDizaine.show(); // Affiche le chiffre de gauche
AffPoint.show();  // Affiche le point central
delay(996);
resultat--; //décompte "resultat" de 1


}   

void Nombre_affiche(int valeur_secondes) //prépare l'affichage du nombre selon le temps
{
if(valeur_secondes >= 180)                                  //Si le temps est supérieur à 180 alors l'afficheur est vert
  {                                                         //et indique le temps en minutes 0.3 par exemple
  Couleur_vert();
  nombre = (valeur_secondes/60);
  int dizaines = (nombre/10);
  int unites = (nombre%10);
  Dizaine(dizaines);
  Unite(unites);
  Serial.println(nombre);
  Serial.println("Minutes restantes");
  }
  
else if((valeur_secondes > 119) && (valeur_secondes < 180)) //Si le temps est entre 119 et 180 secondes alors l'afficheur est orange
  {                                                         //et indique deux minute 0.2
  Couleur_orange();
  nombre = (valeur_secondes/60);
  int variable = nombre;
  int dizaines = (variable/10);
  int unites = (variable%10);
  Dizaine(dizaines);
  Unite(unites);
  Serial.println(nombre);
  Serial.println("Minutes restantes");
  }
    
else if((valeur_secondes > 59) && (valeur_secondes < 120))  //Si le temps est inférieur à 120 secondes, le temps passe à 60 secondes
  {                                                         //et l'afficheur change de système pour passer des minutes aux secondes.
  resultat = 60;                                            
  }
  
else if(valeur_secondes < 60)                               //le temps devient rouge et décompte en secondes 59-58-57... 
  {
  Couleur_rouge();
  nombre = valeur_secondes;
  int variable = nombre;
  int dizaines = variable/10;
  int unites = variable%10;
  Dizaine(dizaines);
  Unite(unites);
  Serial.println(nombre);
  Serial.println("Secondes restantes");
  }
   
else if(valeur_secondes <= 0)                               //Dès que c'est a zero, le temps reste a zero indéfiniment. 
  {
  Couleur_rouge();
  nombre = valeur_secondes/60;
  int variable = nombre;
  int dizaines = (0);
  int unites = (0);
  Dizaine(dizaines);
  Unite(unites);
  resultat = 0;
  Serial.println("Termine");
  }
}
/////////////////////////////////
//    Fonction couleurs RGB    //
///////////////////////////////////////////////
void Couleur_noir() {     //Noir
    r=0;
    g=0;
    b=0; 
    }
void Couleur_rouge() {    //rouge
    r=150;
    g=0;
    b=0; 
    }
void Couleur_vert() {     //vert
    r=0;
    g=150;
    b=0; 
    }
void Couleur_bleu() {     //bleu
    r=0;
    g=0;
    b=150; 
    }
void Couleur_jaune() {    //jaune
    r=150;
    g=150;
    b=0; 
    }
void Couleur_cyan() {     //cyan
    r=0;
    g=150;
    b=150; 
    }
void Couleur_magenta() {  //magenta
    r=150;
    g=0;
    b=150; 
    }
void Couleur_orange() {   //orange
    r=150;
    g=64;
    b=1; 
    }
///////////////////////////////////////////////
        
/*
byte caractere[10][] = {
   B0111111, // chiffre 0, pixels de 0 à 6
   B0000110, // chiffre 1, pixels de 0 à 6
   B1011011, // chiffre 2, pixels de 0 à 6
   B1001111, // chiffre 3, pixels de 0 à 6
   B1100110, // chiffre 4, pixels de 0 à 6
   B1101101, // chiffre 5, pixels de 0 à 6
   B1111101, // chiffre 6, pixels de 0 à 6
   B0000111, // chiffre 7, pixels de 0 à 6
   B1111111, // chiffre 8, pixels de 0 à 6
   B1101111  // chiffre 9, pixels de 0 à 6
};
*/
/*
byte description[10][] = {
   {1,1,1,1,1,1,0}, // chiffre 0, pixels de 0 à 6
   {0,1,1,0,0,0,0}, // chiffre 1, pixels de 0 à 6
   {1,1,0,1,1,0,1}, // chiffre 2, pixels de 0 à 6
   {1,1,1,1,0,0,1}, // chiffre 3, pixels de 0 à 6
   {0,1,1,0,0,1,1}, // chiffre 4, pixels de 0 à 6
   {1,0,1,1,0,1,1}, // chiffre 5, pixels de 0 à 6
   {1,0,1,1,1,1,1}, // chiffre 6, pixels de 0 à 6
   {1,1,1,0,0,0,0}, // chiffre 7, pixels de 0 à 6
   {1,1,1,1,1,1,1}, // chiffre 8, pixels de 0 à 6
   {1,1,1,1,0,1,1}  // chiffre 9, pixels de 0 à 6
};


void afficheChiffre(byte chiffre, Adafruit_NeoPixel & afficheur)
{
   // et dans la fonction qui prend chiffre et afficheur comme params
   for (byte pixel=0; pixel < 7; pixel++) {
      if (description[chiffre][pixel] == 1)  afficheur.setPixelColor(pixel,r,g,b);
      else afficheur.setPixelColor(pixel,0,0,0);
}
}

*/

MESSAGE 2/2

////////////////////////////////////////////
// Création des caractères des 7 segments //
//                                        //
//                   0                    //
//              ___________               //
//                                        //
//            |             |             //
//          5 |             | 1           //
//            |             |             //
//                   6                    //
//              ___________               //
//                                        //
//            |             |             //
//          4 |             | 2           //
//            |             |             //
//                   3                    //
//              ___________               //
//                                        //
////////////////////////////////////////////
  
void Unite(char chiffre) {        //Chiffre des unités
    switch(chiffre)
    {
    case 0 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,r,g,b);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,0,0,0);
        break;
    case 1 :
  AffUnite.setPixelColor(0,0,0,0);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,0,0,0);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,0,0,0);
  AffUnite.setPixelColor(6,0,0,0);
        break;
    case 2 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,0,0,0);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,r,g,b);
  AffUnite.setPixelColor(5,0,0,0);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 3 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,0,0,0);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 4 :
  AffUnite.setPixelColor(0,0,0,0);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,0,0,0);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 5 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,0,0,0);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 6 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,0,0,0);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,r,g,b);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 7 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,0,0,0);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,0,0,0);
  AffUnite.setPixelColor(6,0,0,0);
        break;
    case 8 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,r,g,b);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    case 9 :
  AffUnite.setPixelColor(0,r,g,b);
  AffUnite.setPixelColor(1,r,g,b);
  AffUnite.setPixelColor(2,r,g,b);
  AffUnite.setPixelColor(3,r,g,b);
  AffUnite.setPixelColor(4,0,0,0);
  AffUnite.setPixelColor(5,r,g,b);
  AffUnite.setPixelColor(6,r,g,b);
        break;
    }
}
void Dizaine(char chiffre)        //Chiffre des unités
{  
  switch(chiffre)
    {
        case 0 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,r,g,b);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,0,0,0);
        break;
    case 1 :
  AffDizaine.setPixelColor(0,0,0,0);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,0,0,0);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,0,0,0);
  AffDizaine.setPixelColor(6,0,0,0);
        break;
    case 2 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,0,0,0);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,r,g,b);
  AffDizaine.setPixelColor(5,0,0,0);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 3 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,0,0,0);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 4 :
  AffDizaine.setPixelColor(0,0,0,0);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,0,0,0);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 5 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,0,0,0);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 6 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,0,0,0);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,r,g,b);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 7 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,0,0,0);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,0,0,0);
  AffDizaine.setPixelColor(6,0,0,0);
        break;
    case 8 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,r,g,b);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    case 9 :
  AffDizaine.setPixelColor(0,r,g,b);
  AffDizaine.setPixelColor(1,r,g,b);
  AffDizaine.setPixelColor(2,r,g,b);
  AffDizaine.setPixelColor(3,r,g,b);
  AffDizaine.setPixelColor(4,0,0,0);
  AffDizaine.setPixelColor(5,r,g,b);
  AffDizaine.setPixelColor(6,r,g,b);
        break;
    }
}

Merci de m'aider à comprendre, je suis un peu perdu.

Voici ton programme modifié pour affichage avec une table.

#include <Adafruit_NeoPixel.h> // Activation de la librairie Néopixels
#include <SoftwareSerial.h>  // Activation du port série
#include <Arduino.h>

#ifdef __AVR__  // Si c'est pour µC AVR
#include <avr/power.h> // alors Librairie power
#endif  // Fin de condition

// Définition des pins de l'arduino pour les afficheurs
#define PIN1  2 // Afficheur de gauche
#define PIN2  4 // Afficheur de droite
#define PIN3  3 // Point central


// Paramètres de la librairie NeoPixels et déclaration du nom des afficheurs
Adafruit_NeoPixel AffDizaine = Adafruit_NeoPixel(7, PIN1, NEO_GRB + NEO_KHZ800);  //Afficheur de gauche des dizaines
Adafruit_NeoPixel AffUnite = Adafruit_NeoPixel(7, PIN2, NEO_GRB + NEO_KHZ800);    //Afficheur de droite des unités
Adafruit_NeoPixel AffPoint = Adafruit_NeoPixel(1, PIN3, NEO_GRB + NEO_KHZ800);    //Affichage du point central qui deviendra le ROD plus tard
//Adafruit_NeoPixel AffRod = Adafruit_NeoPixel(60, PIN3, NEO_GRB + NEO_KHZ800);   //Implémentation du ROD de 60 pixels qui remplacera AffPoint

int delayval = 500; // Délai d'une demi-seconde pour charger les condensateurs
int resultat = 185; // Ici je choisis manuellement un temps en secondes en attendant d'ajouter un système de sélection
// Le temps ici est de 185 secondes auquel il faut retrancher réellement 60 secondes
// Pour éviter de passer de 2min à 1min mais aller directement a 60sec...

int nombre = 0;     // Il permet de calculer sa division ou son modulo pour dissocier unités des dizaines
int couleur(int r, int g, int b); //Gestion de la couleur
int r = 0; //Mise à zero des couleurs rouges par défaut
int g = 0; //Mise à zero des couleurs vertes par défaut
int b = 0; //Mise à zero des couleurs bleues par défaut
int lepoint = 0;  //Sert pour la bascule du point central

void setup() {

  Serial.begin(9600);  // Initialisation de la communication série en 9600 Bauds

  // Initialisation et test des afficheurs
  AffUnite.begin();
  AffDizaine.begin();
  AffPoint.begin();

}

void loop()
{

  /////////////////////////////////
  //Clignotement du point central//
  /////////////////////////////////////////
  switch (lepoint)
  {
    case 0 :
      AffPoint.setPixelColor(0, 0, 0, 0);
      lepoint = 1;
      break;
    case 1 :
      AffPoint.setPixelColor(0, r, g, b);
      lepoint = 0;
      break;
  }
  ////////////////////////////////////////


  Serial.println(resultat);
  Nombre_affiche(resultat);
  AffPoint.show();  // Affiche le point central
  delay(996);
  resultat--; //décompte "resultat" de 1


}

void Nombre_affiche(int valeur_secondes) //prépare l'affichage du nombre selon le temps
{
  if (valeur_secondes >= 180)                                 //Si le temps est supérieur à 180 alors l'afficheur est vert
  { //et indique le temps en minutes 0.3 par exemple
    Couleur_vert();
    nombre = (valeur_secondes / 60);
    int dizaines = (nombre / 10);
    int unites = (nombre % 10);
    affiche(true,dizaines);
    affiche(false,unites);
    Serial.println(nombre);
    Serial.println("Minutes restantes");
  }

  else if ((valeur_secondes > 119) && (valeur_secondes < 180)) //Si le temps est entre 119 et 180 secondes alors l'afficheur est orange
  { //et indique deux minute 0.2
    Couleur_orange();
    nombre = (valeur_secondes / 60);
    int variable = nombre;
    int dizaines = (variable / 10);
    int unites = (variable % 10);
    affiche(true,dizaines);
    affiche(false,unites);
    Serial.println(nombre);
    Serial.println("Minutes restantes");
  }

  else if ((valeur_secondes > 59) && (valeur_secondes < 120)) //Si le temps est inférieur à 120 secondes, le temps passe à 60 secondes
  { //et l'afficheur change de système pour passer des minutes aux secondes.
    resultat = 60;
  }

  else if (valeur_secondes < 60)                              //le temps devient rouge et décompte en secondes 59-58-57...
  {
    Couleur_rouge();
    nombre = valeur_secondes;
    int variable = nombre;
    int dizaines = variable / 10;
    int unites = variable % 10;
    affiche(true,dizaines);
    affiche(false,unites);
    Serial.println(nombre);
    Serial.println("Secondes restantes");
  }

  else if (valeur_secondes <= 0)                              //Dès que c'est a zero, le temps reste a zero indéfiniment.
  {
    Couleur_rouge();
    nombre = valeur_secondes / 60;
    int variable = nombre;
    int dizaines = (0);
    int unites = (0);
    affiche(true,dizaines);
    affiche(false,unites);
    resultat = 0;
    Serial.println("Termine");
  }
}
/////////////////////////////////
//    Fonction couleurs RGB    //
///////////////////////////////////////////////
void Couleur_noir() {     //Noir
  r = 0;
  g = 0;
  b = 0;
}
void Couleur_rouge() {    //rouge
  r = 150;
  g = 0;
  b = 0;
}
void Couleur_vert() {     //vert
  r = 0;
  g = 150;
  b = 0;
}
void Couleur_bleu() {     //bleu
  r = 0;
  g = 0;
  b = 150;
}
void Couleur_jaune() {    //jaune
  r = 150;
  g = 150;
  b = 0;
}
void Couleur_cyan() {     //cyan
  r = 0;
  g = 150;
  b = 150;
}
void Couleur_magenta() {  //magenta
  r = 150;
  g = 0;
  b = 150;
}
void Couleur_orange() {   //orange
  r = 150;
  g = 64;
  b = 1;
}

// définition des segments à allumer
const byte SegCh[] =
{
  //gfedcba
  B0111111,  // 0
  B0000110,  // 1
  B1011011,  // 2
  B1001111,  // 3
  B1100110,  // 4
  B1101101,  // 5
  B1111101,  // 6
  B0000111,  // 7
  B1111111,  // 8
  B1101111,  // 9
};

// affichage d'un chiffre
// si fDizaine=false -> unité
// si fDizaine=true -> dizaine
//
void affiche(bool fDizaine, byte val)
{
  Adafruit_NeoPixel *pAff = fDizaine ? &AffDizaine : &AffUnite; // sélection de l'afficheur
  byte b = SegCh[val];
  for (int i = 0; i < 7; i++)
  {
    if (bitRead(b, i))
      pAff->setPixelColor(0, AffUnite.Color(r, g, b));
    else
      pAff->setPixelColor(6, AffUnite.Color(0, 0, 0));
  }
  pAff->show();
}

Tu peux voir que ça simplifie grandement la partie affichage.
Ta fonction Nombre_affiche peut aussi être grandement simplifiée.

Je viens de tester le code, ça créé un bug d’affichage, il me fais des couleurs que je ne savais pas qu’elles existaient ^^ le point clignote toujours, mais seuls les segments du haut s’allument de plusieurs couleurs.

j’essaye de regarder si je peux modifier le code pour que ça tourne…

Merci kamill en tout cas, car si y a un segment qui fonctionne c’est que ça doit pas être grand chose qui fait bugger…

afficheur.png

Oula! j'ai fait une faute :confused:
ce n'est pas

   if (bitRead(b, i))
     pAff->setPixelColor(0, AffUnite.Color(r, g, b));
   else
     pAff->setPixelColor(6, AffUnite.Color(0, 0, 0));

mais

   if (bitRead(b, i))
     pAff->setPixelColor(i, AffUnite.Color(r, g, b));
   else
     pAff->setPixelColor(i, AffUnite.Color(0, 0, 0));

tice66:
j'ai remplacé "byte b" par "byte ba" car "b" correspondait a la couleur bleue

Oui, bien vu. C'est une erreur assez courante de donner à une variable locale le même nom qu'une variable globale.

ça y est j'ai trouvé les bugs !!! (trop fier^^)

  • j'ai remplacé "byte b" par "byte ba" car "b" correspondait a la couleur bleue
  • j'ai remplacé "0" et "6" par "i"
if (bitRead(ba, i))
      pAff->setPixelColor(0, AffUnite.Color(r, g, b));
    else
      pAff->setPixelColor(6, AffUnite.Color(0, 0, 0));

par

if (bitRead(ba, i))
      pAff->setPixelColor(i, AffUnite.Color(r, g, b));
    else
      pAff->setPixelColor(i, AffUnite.Color(0, 0, 0));

Encore merci

Bravo! :slight_smile:

Pour le void Nombre_affiche(int valeur_secondes) pour l'optimiser

je voulais utiliser des switch...case mais on ne peux pas utiliser une plage de donnée dans un case comme if, c'est sur que mon programme a été codé avec mes pieds^^ et qu'il est perfectible...

faut être indulgent, c'est mon premier gros projet (je m'étais arrêté à faire clignoter une led avec un bouton)

et ça fait bien 20 ans que je n'ai pas codé (QBASIC quand tu nous tiens)

Tu ne peux pas utiliser switch case qui ne teste que l’égalité avec des constantes
Tu vois que de nombreuses lignes de code sont répétées plusieurs fois. Tu peux simplifier en les écrivant une seule fois.
Tes tests sont redondants
quand tu ecris

else if((valeur_secondes > 119) && (valeur_secondes < 180)) //Si le temps est entre 119 et 180 secondes alors l'afficheur est orange

le 2eme test ne sert à rien car il est déjà fait dans le if du dessus. Donc tu peux écrire:

else if(valeur_secondes > 119) //Si le temps est entre 119 et 180 secondes alors l'afficheur est orange

Idem pour le test suivant