Bonjour, j'ai un soucie pour la lecture d'un tableau mais je ne trouve pas la solution.

Donc j'utilise deux MAX7219 pour contrôler deux matrices 8x8 accolées pour créer une table basse.

J'ai réussi à créer un tableur Exel qui me permet de générer le code à base de 0 (Led éteinte) et de 1 (Led allumée).

Voici un exemple de code créé (représentant deux croix avec deux barres):

byte anim[16]={
B10000000,
B11000001,
B10100010,
B10010100,
B10001000,
B10010100,
B10100010,
B11000001,
B10000011,
B01000111,
B00101011,
B00010011,
B00101011,
B01000111,
B10000011,
B00000001,
};

Je lis le tableau à travers une boucle for qui renvoi l'information des 8 premiers caractères vers la première matrice en utilisant la librairie "LedControl" mais je n'arrive pas à lire les 8 dernières lignes de mon tableau pour envoyé vers ma seconde matrice.

Le morceau de code la fonctionne très bien pour ma première matrice en lisant les 8 premiers caractères du tableau :

 for (int i = 0; i < 8; i++)
 {
  lc.setRow(0,i,anim[i]); 
 }

J'ai fait pleins d'essais mais impossible d'afficher le reste sur l'autre matrice 

Je débute en Arduino, la réponse est surement très simple mais je ne trouve pas 

Merci de vos réponses et bonne journée 

-
Edité par Donovan-88 4 mars 2015 à 15:31:39

En gros c'est pour optimiser ce petit code :

// envoi des 8 premières valeurs du tableau vers la première matrice ("1")
lc.setRow(1,0,anim[0]);
lc.setRow(1,1,anim[1]);
lc.setRow(1,2,anim[2]);
lc.setRow(1,3,anim[3]);
lc.setRow(1,4,anim[4]);
lc.setRow(1,5,anim[5]);
lc.setRow(1,6,anim[6]);
lc.setRow(1,7,anim[7]);

// envoi des 8 dernières valeurs du tableau vers la seconde matrice ("0")

lc.setRow(0,0,anim[8]);
lc.setRow(0,1,anim[9]);
lc.setRow(0,2,anim[10]);
lc.setRow(0,3,anim[11]);
lc.setRow(0,4,anim[12]);
lc.setRow(0,5,anim[13]);
lc.setRow(0,6,anim[14]);
lc.setRow(0,7,anim[15]); 

-
Edité par Donovan-88 4 mars 2015 à 15:32:02

En effet, la réponse est très simple

Une petite addition :

for (int i = 0; i < 8; i++)
{
 lc.setRow(0,i,anim[i+8]);
}

-
Edité par lorrio 4 mars 2015 à 20:39:48

Ah oui, c'est terriblement simple 

Voici ma version pour afficher un tableau de 16 lignes en deux fois (sur deux matrices alignées) si sa peut aider :

for (int i = 0; i < 15; i++)
 {
   lc.setRow(1,i,anim[i]); //premier
   lc.setRow(0,i,anim[i+8]); //second
 }

Je passe le sujet en résolu 

Tu es sur que i doit allé de 0 à < 15 ???

Je viens de modifier le 15 par 8 et sa marche aussi . Je pensais mettre 15 pour les 16 lignes du tableaux mais il n'y a pas besoin vu qu'il y a le +8.

J'ai une nouvelle question à propos de la lecture de des tableaux.

J'ai beaucoup de tableaux avec diverses images stockées à l'intérieur comme celui-ci (pour une animation daftpunk) :

byte daftpunk0[16]={
B11100000,
B11100000,
B11100000,
B00000000,
B00000000,
B11100000,
B11100000,
B11100000,
B00000111,
B00000111,
B00000111,
B00000000,
B00000000,
B00000111,
B00000111,
B00000111,
};
byte daftpunk1[16]={
B11110000,
B11110000,
B11110000,
B11110000,
B11110000,
B11110000,
B11110000,
B11110000,
B00001111,
B00001111,
B00001111,
B00001111,
B00001111,
B00001111,
B00001111,
B00001111,
};

etc.....

J'utilise ces tableaux grâce à une fonction :

void Affichage(byte anim[])
{
 for (int i = 0; i < 8; i++)
 {
 lc.setRow(1,i,anim[i]);
 lc.setRow(0,i,anim[i+8]);
 }
}

Que j'appel dans mon loop de cette manière :

      Affichage(daftpunk0);
      delay(delaytime);
      Affichage(daftpunk1);
      delay(delaytime);
      Affichage(daftpunk2);
      delay(delaytime);
      Affichage(daftpunk3);
      delay(delaytime);
      Affichage(daftpunk4);
      delay(delaytime);

etc.....

Ce code fonctionne très bien mais je n'arrive pas à l'optimiser pour qu'il me prenne moins de mémoire.

J'ai tenté une boucle :

  for (int x = 0; x < 15; x++) //15 correspond au nombre de tableaux à utiliser
   {
      String nom = "daftpunk";
      String choix = String(nom + x);
      Serial.print(choix);
      Affichage(choix);
      delay(delaytime);
   }

La valeur choix est bien retournée dans le Serial en écrivant "daftpunk0" puis "daftpunk1" etc.... mais en tant que paramètre de ma fonction, sa ne marche pas .

Avez-vous une astuce pour moi?

Bonne journée

-
Edité par Donovan-88 13 mars 2015 à 12:13:15

Ah là, ça ne risque pas de marcher

Ta variable choix est une chaine de caractère et rien d'autre.

Serte, cette chaine contient le nom d'un de tes tableau mais ça reste une chaine de caractères et non le tableau en question.

Pour faire ce que tu veux, il te faut utiliser un tableau à 2 dimensions

byte daftpunkTab[...][16] {
    
    // Index 0:
    {
        B11100000,
        ... (mettre ici tes 15 autres lignes)
    },

    // Index 1:
    {
        B11100000,
        ... (mettre ici tes 15 autres lignes)
    },

    // ...
    {
        ...
    }

};

 Et avec le code qui va avec :

for (int x = 0; x < 15; x++) //15 correspond au nombre de tableaux à utiliser
 {
    Serial.print(choix);
    Affichage(daftpunkTab[choix]);
    delay(delaytime);
 }

Cependant, déclarer tes énormes tableaux comme ça te bouffe de la mémoire programme ET de la mémoire RAM.

Je conseillerais te passer des tableau en mémoire programme et adapter ta fonction affichage avec pgm_read_byte_near

Plus d'info ici : http://arduino.cc/en/Reference/PROGMEM

-
Edité par lorrio 13 mars 2015 à 12:58:50

Merci bien! J'ai modifié mes tableaux en tableaux à deux dimensions et ça fonctionne.

Pour la gestion de la mémoire, je vais regarder le lien que tu m'as donné.

Pour la gestion de la mémoire avec PROGMEM, si je créé mes tableaux de cette manière --> const char daftpunk[][16] PROGMEM={

Comment faire pour les utiliser sachant que ma fonction Affichage créé un paramètre --> byte anim[]

void Affichage(byte anim[])
{
 for (int i = 0; i < 8; i++)
 {
 lc.setRow(1,i,anim[i]);
 lc.setRow(0,i,anim[i+8]);
 }
}

il te faut utiliser pgm_read_byte_near pour lire l'octet qui t'intéresse avant de l'utiliser

J'ai pondu un truc comme ça : 

void Affichage(const char anim[])
{
 for (int i = 0; i < 8; i++)
 {
 anim[i] = { pgm_read_byte_near(anim[i]) };
 lc.setRow(1,i,anim[i]);
 lc.setRow(0,i,anim[i+8]);
 }
}

Mais j'ai que des erreurs 

C'est à cause du paramètre de ma fonction que ça bug non?

Tu dois pouvoir t'en sortir avec un code de ce genre :

#include <avr/pgmspace.h>


#define  ANIMS_COUNT  10
#define  ANIMS_SIZE   16


const byte daftpunkTab[ANIMS_COUNT][ANIMS_SIZE] PROGMEM {
     
    // Index 0:
    {
        B11100000,
        ... (mettre ici tes 15 autres lignes)
    },
 
    // Index 1:
    {
        B11100000,
        ... (mettre ici tes 15 autres lignes)
    },
 
    // ...
    {
        ...
    }
 
};



void Affichage(int animIdx) {
	
	for ( int idx = 0 ; idx < 8 ; idx++ ) {
		
		lc.setRow(1, i, pgm_read_byte_near( ((bye*)daftpunkTab) + ( animIdx * ANIMS_SIZE ) + idx + 0 ));
		lc.setRow(0, i, pgm_read_byte_near( ((bye*)daftpunkTab) + ( animIdx * ANIMS_SIZE ) + idx + 8 ));
		
	}
	
}

Bien sure, ANIMS_COUNT est à changer par ton nombre d'animation.

Quand à Affichage, son premier paramètre est maintenant l'index de l'animation donc tu tu devras utiliser Affichage(0), Affichage(1), Affichage(2) ...

-
Edité par lorrio 13 mars 2015 à 20:30:39

Salut, merci pour ton aide , le code fonctionne. Le (byte*) sert à convertir le tableau ?

Voici mon bloc dans le loop servant à appeler la fonction Affichage :

for (int i = 0; i < 5; i++) // le 5 correspond au nom d'animations
  {
    Affichage(i);
    delay(500);
  }

Et j'ai modifié légèrement ton code :

void Affichage(int animIdx) {
     
    for ( int idx = 0 ; idx < 8 ; idx++ ) {
         
        lc.setRow(1, idx, pgm_read_byte_near( ((byte*)daftpunk) + ( animIdx * 16 ) + idx + 0 ));
        lc.setRow(0, idx, pgm_read_byte_near( ((byte*)daftpunk) + ( animIdx * 16 ) + idx + 8 ));
         
    }
     
}

Mais voila, en résolvant un problème de mémoire, nous avons supprimé la possibilité de changer de tableau en l'appelant dans la fonction Affichage.

Car j'ai un switch(Choix) qui est contrôlé par la variable Choix qui me permet de choisir entre les différents tableaux (et donc les différentes animations) que j'ai en appelant la fonction Affichage(daftpunk) ou Affichage(tetris) etc...

Ya t'il possibilité de commander ça à nouveaux avec un second paramètre avec le code que tu m'as donné?

-
Edité par Donovan-88 14 mars 2015 à 12:10:45

(byte*) sert à convertir la variable daftpunk en un pointeur nue sur byte et non un pointeur sur tableau à 2 dimensions.

Je fais ce genre de chose par habitude quand j'utilise pgm_read_byte_near (je préfère manipuler une adresse brute) mais on doit pouvoir faire autrement.

Ce code là fonctionne probablement tout aussi bien :

void Affichage(int animIdx) {
      
    for ( int idx = 0 ; idx < 8 ; idx++ ) {
          
        lc.setRow(1, idx, pgm_read_byte_near( &(daftpunk[animIdx][idx]) ));
        lc.setRow(1, idx, pgm_read_byte_near( &(daftpunk[animIdx][idx+8]) ));
          
    }
      
}

Quand à ta deuxième question, oui, c'est possible, peux très bien donner des pointeurs de tableau (ou un pointeur sur byte* comme à mon habitude) en argument de tes fonction.

Mais je ne vais pas te faire tout ton code non plus donc à toi de chercher un peu.

Ou au pire, tu te fais une fonction AffichageDraftpunk, une fonction AffichageTetris ...

-
Edité par lorrio 14 mars 2015 à 13:31:28

Merci, je comprend mieux avec ton second code.

Voici le mien (ou le tiens modifié ) qui résous également mon problème :

 void Affichage(int animIdx, const byte nom[][16]) {
     
    for ( int idx = 0 ; idx < 8 ; idx++ ) {
         
        lc.setRow(1, idx, pgm_read_byte_near( &(nom[animIdx][idx]) ));
        lc.setRow(0, idx, pgm_read_byte_near( &(nom[animIdx][idx+8]) ));
        
    }     
}

// avec :

    Affichage(i,daftpunk);
ou
    Affichage(i,tetris);
ou tous mes autres tableaux 

-
Edité par Donovan-88 14 mars 2015 à 21:14:06