[Résolu]module led 8*8 N²

bonjour suite a un problème (j’ai écraser ma nouvelle sauvegarde avec une ancienne) j’ai du tous me retaper

mes sa marche plus au niveau du switch

#include <LedControlMS.h>
//afficheur led
byte Nafficheur = 8;

byte VA = 0;
byte VD = 0;
byte VE = 0;
byte VF = 0;
byte VM = 0;
byte VN = 0;
byte VO = 0;
byte VR = 0;
byte VT = 0;
byte VU = 0;
byte VV = 0;
byte select = 1;

LedControl Module=LedControl(2,3,4,Nafficheur);


   byte A[8]={B00110000,B01111000,B11001100,B11001100,B11111100,B11001100,B11001100,B00000000};
   byte D[8]={B11111000,B01101100,B01100110,B01100110,B01100110,B01101100,B11111000,B00000000};
   byte E[8]={B11111110,B01100010,B01101000,B01111000,B01101000,B01100010,B11111110,B00000000};
   byte F[8]={B11111110,B01100010,B01101000,B01111000,B01101000,B01100000,B11110000,B00000000};
   byte M[8]={B11000110,B11101110,B11111110,B11111110,B11010110,B11000110,B11000110,B00000000};
   byte N[8]={B11000110,B11100110,B11110110,B11011110,B11001110,B11000110,B11000110,B00000000};
   byte O[8]={B00111000,B01101100,B11000110,B11000110,B11000110,B01101100,B00111000,B00000000};
   byte R[8]={B11111100,B01100110,B01100110,B01111100,B01101100,B01100110,B11100110,B00000000};
   byte T[8]={B11111100,B10110100,B00110000,B00110000,B00110000,B00110000,B01111000,B00000000};
   byte U[8]={B11001100,B11001100,B11001100,B11001100,B11001100,B11001100,B11111100,B00000000};
   byte V[8]={B11001100,B11001100,B11001100,B11001100,B11001100,B01111000,B00110000,B00000000};
   
   


void setup() {
 
  Serial.begin(9600);   //innitialisation debugmode
}

void loop() {
  LedModule();
    for(byte i=1;i<Nafficheur+1;i++){
      set_unit(i);
    }
   
}


void LedModule(){
   switch (select){
      case 1://fermer
         for(VF=0; VF<7; VF++){
            Module.setRow(7,VF,F[VF]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(6,VE,E[VE]);
         }         
         for(VR=0; VR<7; VR++){
            Module.setRow(5,VR,R[VR]);
         }
         for(VM=0; VM<7; VM++){
            Module.setRow(4,VM,M[VM]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(3,VE,E[VE]);
         }
         for(VR=0; VR<7; VR++){
            Module.setRow(2,VR,R[VR]);
         }
      break;
      case 2: //ouvert
         for(VO=0; VO=7; VO++){
            Module.setRow(7,VO,O[VO]);
         }
         for(VU=0; VU=7; VU++){
            Module.setRow(6,VU,U[VU]);
         }
         for(VV=0; VV=7; VV++){
            Module.setRow(5,VV,V[VV]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(4,VE,E[VE]);
         }
         for(VR=0; VR<7; VR++){
            Module.setRow(3,VR,R[VR]);
         }
         for(VT=0; VT<7; VT++){
            Module.setRow(2,VT,T[VT]);
         }
      break;
      case 3: //attendre
         for(VA=0; VA=7; VA++){
            Module.setRow(7,VA,A[VA]);
         }
         for(VT=0; VT<7; VT++){
            Module.setRow(6,VT,T[VT]);
         }
         for(VT=0; VT<7; VT++){
            Module.setRow(5,VT,T[VT]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(4,VE,E[VE]);
         }
         for(VN=0; VN<7; VN++){
            Module.setRow(3,VN,N[VN]);
         }
         for(VD=0; VD<7; VD++){
            Module.setRow(2,VD,E[VD]);
         }
         for(VR=0; VR<7; VR++){
            Module.setRow(1,VR,R[VR]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(0,VE,E[VE]);
         }
      break;
      case 4://entree
         for(VE=0; VE<7; VE++){
            Module.setRow(7,VE,E[VE]);
         }
         for(VN=0; VN<7; VN++){
            Module.setRow(6,VN,N[VN]);
         }
         for(VT=0; VT<7; VT++){
            Module.setRow(5,VT,T[VT]);
         }
         for(VR=0; VR<7; VR++){
            Module.setRow(4,VR,R[VR]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(3,VE,E[VE]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(2,VE,E[VE]);
         }
      break;
   }
}



void set_unit(byte number_of_unit){//innitialisation matrice
  Module.shutdown(number_of_unit-1,false);
  Module.setIntensity(number_of_unit-1,1);
  Module.clearDisplay(number_of_unit-1);
}

quand je fait select

select = 0 //rien ne marche (normal)
select = 1 //affiche fermer (ok)
select = 2 //affiche rien (pas ok(dois afficher ouvert))
select = 3 //affiche rien (pas ok(dois afficher attendre))
select = 4 //affiche entree (ok)

jai chercher mes je trouve pas pour quoi

j'ai fait sur chaque case

Serial.print("nom de la case");
Serial.println(select);

pour le 1 et 4 sa s'affiche en boucle donc c'est normal
mes le 2 et 3 sa l'affiche 1 fois et c'est tous

Relit bien ton code
Ce qui marche

      case 1://fermer
         for(VF=0; VF<7; VF++){
            Module.setRow(7,VF,F[VF]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(6,VE,E[VE]);
         }         
         for(VR=0; VR<7; VR++){
            Module.setRow(5,VR,R[VR]);
         }
         for(VM=0; VM<7; VM++){
            Module.setRow(4,VM,M[VM]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(3,VE,E[VE]);
         }
         for(VR=0; VR<7; VR++){
            Module.setRow(2,VR,R[VR]);
         }
      break;

ce qui ne marche pas

      case 2: //ouvert
         for(VO=0; VO=7; VO++){
            Module.setRow(7,VO,O[VO]);
         }
         for(VU=0; VU=7; VU++){
            Module.setRow(6,VU,U[VU]);
         }
         for(VV=0; VV=7; VV++){
            Module.setRow(5,VV,V[VV]);
         }
         for(VE=0; VE<7; VE++){
            Module.setRow(4,VE,E[VE]);
         }
         for(VR=0; VR<7; VR++){
            Module.setRow(3,VR,R[VR]);
         }
         for(VT=0; VT<7; VT++){
            Module.setRow(2,VT,T[VT]);
         }
      break;

Bien vu, il faut de bons yeux pour voir les erreurs... 8)

Oui, mais surtout j'aimerais savoir pourquoi ludocraft s'acharne à écrire ce genre de fonction alors que la librairie qu'il utilise possède des fonctions d'affichage de caractères et de chaînes de caractères?
J'aimerais aussi savoir pourquoi aussitôt après avoir rempli sa matrice il appelle cette fonction qui éteint tout?

void set_unit(byte number_of_unit){//innitialisation matrice
  Module.shutdown(number_of_unit-1,false);
  Module.setIntensity(number_of_unit-1,1);
  Module.clearDisplay(number_of_unit-1);
}

pour que ce soit plus visible… parce qu’avec l’age…

      case 1://fermer
         for(VF=0; [b][color=green]VF<7[/color][/b]; VF++){
            Module.setRow(7,VF,F[VF]);
         }
     case 2: //ouvert
         for(VO=0; [b][color=red]VO=7[/color][/b]; VO++){
            Module.setRow(7,VO,O[VO]);
         }
...

et en plus - moi je ne comprends pas pourquoi ces boucles for nécessitent des variables globales des boucles différentes quand un bon vieux

for(byte i=0; i<7; i++){
  Module.setRow(7,VO,O[i]);
  Module.setRow(6,VU,U[i]);
  Module.setRow(5,VV,V[i]);
  Module.setRow(4,VE,E[i]);
  Module.setRow(3,VR,R[i]);
  Module.setRow(2,VT,T[i]);
}

pourrait faire l’affaire

bonne question j'ai effacer le clear mes pour le premier pour quoi sa marche pas je dois etre aveugle je vois pas de difference

ludocraft:
bonne question j'ai effacer le clear mes pour le premier pour quoi sa marche pas je dois etre aveugle je vois pas de difference

vous êtes daltonien aussi ? (si pas aveugle?) cf mon message #5

merci J-M-L :slight_smile: pour (les variable global on peux les utiliser dans n'importe quel fonction ?? si oui je vais les utiliser apres dans autre chose) et pour les caractère de la librairie il sont dégelasse XD sauffe erreur il me suffi juste de le modifier dans le fichier ldcontrolms.h la partie alphabetBitmap ??

J-M-L:
vous êtes daltonien aussi ? (si pas aveugle?) cf mon message #5

oui jai vue apres ^^

ludocraft:
pour (les variable global on peux les utiliser dans n’importe quel fonction ??

mon point c’est que pour l’indice dans une boucle vous n’avez pas besoin de variable globale. Généralement cet indice n’a pas besoin d’exister en dehors de la boucle, donc le plus souvent on le déclare directement dans la boucle

// ici la variable i n'existe pas encore
...

for([b][color=red]byte i[/color][/b]=0; i<7; i++){  // on déclare [color=red]i[/color] que pour cette boucle for
 ... // ici on utilise la variable [color=red]i[/color]
}

// ici la variable i n'existe plus
...

donc a chaque fois que on sort de la boucle elle disparais mes sa permet de prendre moins de mémoire stockage ou de mémoire dynamique ??

Oui il y a juste un octet (si i es de type byte) occupé pendant la boucle mais pas de place occupée en permanence pour rien

case 1:
         for(byte i = 0; i<7; i++){
            Module.setRow(7,i,F[i]);
            Module.setRow(6,i,E[i]);
            Module.setRow(5,i,R[i]);
            Module.setRow(4,i,M[i]);
            Module.setRow(3,i,E[i]);
            Module.setRow(2,i,R[i]);
}
ok c'est ce que J-M-L cf#5 a dit je vien juste de comprendre je retire ma question