Bonjour,

Je possède une matrice de led 24*8 commandée par un PIC avec des transistors NPN 2N2222 et PNP 2N3906 afin d'avoir un courant suffisant.

Pour l'instant je fais des tests sur une autre matrice (10x8) avec seulement des transistors NPN, le courant étant fourni directement par le µC.

Mon problème est que je n'arrive pas à avoir un rafraichissement suffisamment fluide ainsi qu'une luminosité correcte. Mon problème doit être surement du coté software étant donnée que je programme le PIC en C de manière non optimisée.

Principe : Je rafraichis ma matrice ligne par ligne grâce au registre B. Les colonnes sont réparties entre les registres A,C,D et E.
J'ai donc un tableau à 2 dimensions contenant mon motif à afficher. Je souhaite le balayer dans le style "pulsation cardiaque". J'utilise ensuite des tableaux pour stocker ce que chaque registre doit afficher pour chaque ligne.
Ensuite, j'affiche ligne par ligne le contenu des registres un certain nombre de fois, je règle ainsi la cadence d'avancement de l'affichage.

Voilà mon code, pour vous donner une idée de comment je pensais implémenter cela :
Code:
unsigned char raffraichissement_A ( unsigned char matrice[8][24] , unsigned char ligne)
{
unsigned char k = 1;
unsigned char j;
unsigned char vecteurA = 0;
for ( j = 0 ; j < 8 ; j++) // On balaie les colonnes de 0 à 7 ( de A )
{
    if( matrice[ligne][j] == 1)
    {
        vecteurA =  vecteurA + k;
    }
    k = k*2;
}
return vecteurA;
}



unsigned char raffraichissement_C ( unsigned char matrice[8][24] , unsigned char ligne)
{
unsigned char k = 1;
unsigned char j;
unsigned char vecteurC = 0;
     for( j = 8 ; j < 11 ; j++) // On sélectionne les bits à partir de 0 jusque 2 de C ( 8 ème à 10ème colonne )
     {
          if( matrice[ligne][j] == 1)
          {
              vecteurC =  vecteurC + k;
          }
          k = k*2;
     }
     k = 0b01000000;
     for( j = 11 ; j < 13 ; j++) // On sélectionne les bits à partir de 6 jusque 7 de C ( 11 ème à 12ème colonne )
     {
          if( matrice[ligne][j] == 1)
          {
              vecteurC =  vecteurC + k;
          }
          k = k*2;
     }
return vecteurC;
}



unsigned char raffraichissement_D ( unsigned char matrice[8][24] , unsigned char ligne)
{
unsigned char k = 1;
unsigned char j;
unsigned char vecteurD = 0;
     for( j = 13 ; j < 21 ; j++) // On sélectionne les bits de 0 jusque 7 de D ( 13 ème à 20ème colonne )
     {
          if( matrice[ligne][j] == 1)
          {
              vecteurD =  vecteurD + k;
          }
          k = k*2;
     }
return vecteurD;
}



unsigned char raffraichissement_E ( unsigned char matrice[8][24] , unsigned char ligne)
{
unsigned char k = 1;
unsigned char j;
unsigned char vecteurE = 0;
     for( j = 21 ; j < 25 ; j++) // On sélectionne les bits de 0 jusque 7 de D ( 21 ème à 24 ème colonne )
     {
          if( matrice[ligne][j] == 1)
          {
              vecteurE =  vecteurE + k;
          }
          k = k*2;
     }
return vecteurE;
}



//FONCTION MAIN
void main() 
{
unsigned char i , j, l;
int k, m;
unsigned char avancement;
unsigned char heart_beat[8][24] = {0};
unsigned char LATA_stockage[8], LATC_stockage[8], LATD_stockage[8], LATE_stockage[8];


//A0 -> A7 puis C0 -> C2 puis C6 -> C7 puis D0 -> D7 puis E0 -> E3 (24 sorties en tout)
unsigned char matrice[8][24] = {{0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0},
                                {0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0},
                                {0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0},
                                {0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0},
                                {1,1,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1,1,1,1,1,1,1},
                                {0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0},
                                {0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0},
                                {0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0}};

//Paramètres
OSCCON = 0xFF;
TRISB = 0;
TRISA = 0;
TRISC = 0;
TRISD = 0;
TRISE = 0;
LATA = 0;
LATC = 0;
LATB = 0;
LATD = 0;
LATE = 0;

for ( l = 0 ; l < 8 ; l++ )
{
LATA_stockage [l] = 0;
LATC_stockage [l] = 0;
LATD_stockage [l] = 0;
LATE_stockage [l] = 0;
}

//BOUCLE PRINCIPALE
while (1) 
{
//EFFET HEART BEAT
for (avancement = 1 ; avancement < 49 ; avancement ++ )
{
    if(avancement < 25)
    {
         for ( i = 23 ; i >= 24 - avancement ; i--)
         {
             for ( j = 0 ; j < 8 ; j++ )
             {
                heart_beat[j][i] = matrice[j][i];
             }
         }
    }
    else if(avancement >= 25 && avancement < 49)
    {
      //INCOMPLET
    
    }
    
    //RAFFRAICHISSEMENT  DES REGISTRES
    for ( l = 0 ; l < 8 ; l++)
    {
        LATA_stockage [l] = raffraichissement_A ( heart_beat , l );
        LATC_stockage [l] = raffraichissement_C ( heart_beat , l );
        LATD_stockage [l] = raffraichissement_D ( heart_beat , l );
        LATE_stockage [l] = raffraichissement_E ( heart_beat , l );
    }

//AFFICHAGE
k = 100;
while (k>0)
{
      k--;
      i = 0x01;
      for ( l = 0 ; l < 8 ; l++)
      {
          LATB = i;
          LATA = LATA_stockage [l];
          LATC = LATC_stockage [l];
          LATD = LATD_stockage [l];
          LATE = LATE_stockage [l];
          m = 5;  //15
          while (m>0)
          {
                m--;
          }
          i=i*2 ;
          LATA = 0;
          LATC = 0;
          LATD = 0;
          LATE = 0;
      }
}

}//Fin boucle FOR

}//Fin boucle WHILE principale

}//Fin boucle MAIN
Merci pour votre aide !