Comment faire un tableau PROGMEM de tableaux 2D PROGMEM

Question

J'ai plusieurs tableaux 2D dans PROGMEM. Je veux les stocker dans un autre tableau, et donc avoir une matrice PROGMEM de 2d tableaux PROGMEM.

Ensuite, je veux lire les données.

Voici ce que j'ai

void myFunc() 
{ 
    const static byte DATA1[3][2] PROGMEM = 
    { 
    -1, 6, 
    -3, 6, 
    -5, 5 
    }; 
    const static byte DATA2[3][2] PROGMEM = 
    { 
    1, 0, 
    1, 0, 
    1, 0 
    }; 
    const static byte DATA3[6][2] PROGMEM = 
    { 
    0, 1, 
    1, 3, 
    2, 4, 
    4, 4, 
    6, 3, 
    7, 1 
    }; 
    //PROGMEM array of 2d arrays in PROGMEM 
    const static byte* const MY_DATA[] PROGMEM = {DATA1, DATA2, DATA3}; 

    //read out the data now: 
    byte myData = pgm_read_byte(&((MY_DATA[arrayNum])[x][y])); 

    //use the data here, etc, etc... 
} 

Mon erreur est:

error: cannot convert 'const byte (*)[2] {aka const 
unsigned char (*)[2]}' to 'const byte* const {aka const 
unsigned char* const}' in initialization 

Comment suis-je censé faire? J'ai lu et essayé de comprendre cela pendant une heure. Je ne sais pas ce que je fais mal.

pages de référence utiles:

1. http://www.nongnu.org/avr-libc/user-manual/pgmspace.html
2. http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html#ga963f816fc88a5d8479c285ed4c630229
3. https://www.arduino.cc/en/Reference/PROGMEM

Answer 1

Le type d'éléments de MY_DATA est const byte* const, mais DATA1, etc. sont convertis en const byte (*)[2] comme l'erreur ou un message suggère, donc la différence de type se produit. Notez que les tableaux dans l'expression sont automatiquement convertis en pointeurs pointant leurs premiers éléments à l'exception de quelques exceptions telles que l'opérateur unaire & ou sizeof.

Utilisez le type correct: tableaux de pointeurs vers const byte (*)[2] comme ceci:

const static byte(* const MY_DATA[])[2] PROGMEM = {DATA1, DATA2, DATA3}; 

Ceci est "my_data variable statique comme un tableau de pointeur const tableau 2 de l'octet const".

Selon cdecl, const char(* const MY_DATA[99])[2]; peut être décodé comme "MY_DATA en tant que tableau 99 de pointeur const au tableau 2 de const char". Avec quelques modifications, vous pouvez obtenir l'implémentation du type correct.

Vous pouvez décoder une déclaration de type sans const dans l'ordre inverse de l'évaluation de l'expression normale. (Désolé, actuellement je ne suis pas bon à décoder les qualificatifs) Laissez-moi décoder byte(*MY_DATA[])[2] dans cette méthode.

évaluation de l'expression normale:

1. MY_DATA
2. MY_DATA[]: un élément de MY_DATA
3. *MY_DATA[]: déréférencer l'élément
4. (*MY_DATA[])[2]: un élément de ce qui est déréférencé

Décodage déclaration de type (quelque chose non encore décodé est représenté par @):

1. byte @: quelque chose ayant le type byte
2. byte @[2]: tableau 2 éléments de byte
3. byte (*@)[2]: pointeur vers la matrice 2-élément de byte
4. byte (*@[])[2]: tableau de pointeurs sur un tableau à 2 éléments de byte
5. byte (*MY_DATA[])[2]: MY_DATA, qui est un tableau de pointeurs vers tableau 2 éléments de byte