Structures ou Array ? / TLC5947 de chez TI pour matrice RVB
Répondre à la discussion
Affichage des résultats 1 à 1 sur 1

Structures ou Array ? / TLC5947 de chez TI pour matrice RVB



  1. #1
    zanzeoo

    Structures ou Array ? / TLC5947 de chez TI pour matrice RVB


    ------

    bonjour a tous

    Je suis en train de bricoler un afficheur a base de matrice RVB , j'utilise un composant de chez Texas instrument le TLC5947

    Sans rentrer dans trop de détails ce qui me pose problème c'est la programmation

    La valeur d l'intensité lumineuse est codée sur 12 bit , soit une valeur comprise entre 0 et 4095

    Le composant requière qu'on lui envoie 36 octets ces octets correspondent a la luminosité et on pourrait dire que pour mon application on a donc 3 paquets de 12 octets qui correspondent respectivement au rouge , vert , bleu

    exemple:

    voici l’état des LED sur la 1ere ligne de ma matrice 10100101 avec 1 pour allumé et 0 pour eteinte
    supposons que je décide de mettre une luminosité a 4072 pour toutes les LED ( rouge , vert ,bleu) , donc FE8h

    j'ai donc 3 couleurs que je dose a ma guise

    int Rouge
    int vert
    int bleu

    les 36 octets a envoyer au TLC seraient les suivants FE 80 00 FE 80 00 00 0F E8 00 0F E8 FE 80 00 FE 80 00 00 0F E8 00 0F E8 FE 80 00 FE 80 00 00 0F E8 00 0F E8

    j'ai pondu un code qui marche presque bien.... mais qui merite d'etre amelioré donc je suis preneur si vous avez des suggestions


    Code:
    void ftc_coloris(void)
        {   
    
        char quartet[3]; //quartets pour decomposer le mot de 12 bit en paquet de 8bit
    
        quartet[0] = 0x000F &  couleur[i] >>8;  //0F
        quartet[1] = 0x000F &  couleur[i] >>4 ; //0E
        quartet[2] = 0x000F &  couleur[i];      //08   
    
        octet[0] = (quartet[0]<<4 | quartet[1]); //FE
        octet[1] = (quartet[2]<<4 | quartet[0]); //8F
        octet[2] = (quartet[1]<<4 | quartet[2]); //E8
        octet[3] = (quartet[2]<<4);              //80
        octet[4] =  0x00;                        //00
        octet[5] = 0x000F &  couleur[i] >>8;        //0F
    
        }
    
    
    
    
        void fct_color(void)
        { 
            
            char *ptr_hexdata0,*ptr_hexdata1,*ptr_hexdata2;
            char *ptr_matrice_bit1,*ptr_matrice_bit2;
    
            for (i=0;i<3;i++)
             {
              ftc_coloris();  
                    
                for (row=0;row<8;row++)
                 {
    
                    ptr_matrice_bit1 =&matrice[row][0];
                    ptr_matrice_bit2 =&matrice[row][1];
                                
                    ptr_hexdata0 =&gs_hexdata[i][row][0];
                    ptr_hexdata1 =&gs_hexdata[i][row][1];
                    ptr_hexdata2 =&gs_hexdata[i][row][2];
    
                  for(col=0;col<4;col++)
                        {   
                                
                        if(*ptr_matrice_bit1)
                           {
                            *ptr_hexdata0 = octet[0];          //FE
                                    
                                if(*ptr_matrice_bit2)
                                 {
                                  *ptr_hexdata1  = octet[1];  //8F
                                  *ptr_hexdata2  = octet[2];  //E8
                                 } 
                                  else
                                  {
                                   *ptr_hexdata1 =  octet[3];  //80
                                   *ptr_hexdata2 =  octet[4];  //00
                                  }  
                            ptr_hexdata0 +=3;
                            ptr_hexdata1 +=3;
                            ptr_hexdata2 +=3;
                                    
                            ptr_matrice_bit1 +=2;
                            ptr_matrice_bit2 +=2;
                                    
                           }
                                    
                            else
                            {
                             *ptr_hexdata0= octet[4];          //00
                                        
                                if(*ptr_matrice_bit2)
                                 {
                                  *ptr_hexdata1= octet[5];     //0F
                                  *ptr_hexdata2= octet[2];     //E8
                                 } 
                                  else
                                  {
                                   *ptr_hexdata1 = octet[4];  //00
                                   *ptr_hexdata2 = octet[4];  //00
                                  } 
    
                            ptr_hexdata0 +=3;
                            ptr_hexdata1 +=3;
                            ptr_hexdata2 +=3;
                                    
                            ptr_matrice_bit1 +=2;
                            ptr_matrice_bit2 +=2;
                            } 
                      }    
                        
                  }
             
              }

    -----
    Dernière modification par JPL ; 31/12/2014 à 18h56. Motif: Ajout de la balise Code (#) pour garder l'indentation

Discussions similaires

  1. Mécanique des structures / structures en nid d'abeille
    Par V_456 dans le forum TPE / TIPE et autres travaux
    Réponses: 3
    Dernier message: 12/10/2015, 07h12
  2. Récupérer une valeur dans un array qui est lui même dans un array
    Par squal31 dans le forum Programmation et langages, Algorithmique
    Réponses: 2
    Dernier message: 28/12/2014, 00h01
  3. Array = Matrice ?
    Par invite264f71b9 dans le forum Physique
    Réponses: 7
    Dernier message: 22/06/2011, 08h38
  4. C : Initialisation de structures/tableaux de structures
    Par invitef1d0ad93 dans le forum Logiciel - Software - Open Source
    Réponses: 1
    Dernier message: 12/08/2008, 10h57