Tableau multidimensionnel

Bonjour,

Je suis en train de développer un système de gestion de course RC, principalement pour buggy en échelle 1/8.

Pour planter un peu le décors, j'utilise :

  • pour ce que j'appelle le décodeur (gestionnaire principal) :
  • Nano
  • nRF24L01
  • écran LCD 2x16 (I2C)
  • 5 BP
  • pour les transpondeurs (module embarqué dans les voitures) :
  • ATtiny84
  • nRF24L01
  • ILS (pour détection des barres aimantées qui matérialise la ligne d'arrivée)

J'ai plusieurs versions du décodeur qui sont aujourd'hui opérationnelles mais j'ai le cerveau qui bouillonne d'idées. Mon 1er problème était donc l'optimisation de ma gestion mémoire.
Grâce à nombreuses heures de fouille sur le forum j'ai réussi à diviser par 2 ma consommation. C'est déjà, à mon niveau, une belle victoire.

Mon application fonctionne sous la forme de menus.

Voici la méthode que j'utilise :

Déclaration :

//Index des menus (l'ordre des num n'est pas important)
#define MN_NONE             999
#define MN_MAIN               0
#define MN_MAINCOURSE         1
#define MN_MAINCONFIG         2
#define MN_MODE               3
#define MN_PCLC               4
.
.
.
#define MN_TEMPSPILOTES      23
#define MN_LISTEPILOTES      24
#define MAX_MENUS            25 //declaration tableau menu (hors MN_NONE)

// Structure et declaration des variables de menus
typedef struct
{
  byte Parent;                  // index du menu Parent
  byte Suivant;                 // index du menu Suivant
  byte Precedent;               // index du menu Precedent
  byte Cible;                   // index du menu Cible
  byte TypeAff;                 // type affichage du menu
  byte Option1;                 // usage suivant type affichage ; Selection : coché/decoché ; Liste : index courant ; Saisie num : valeur enregistree
  byte Option2;                 // utilisé pour l'affichage de menu LST : stockage de l'index du tableau LST
} InfoMenu_t;

InfoMenu_t ListeMenus[MAX_MENUS];

// Gestion mémoire des textes de menus - ATTENTION - prompt_xx : xx = index menu correspondant
const char prompt_00[] PROGMEM = "";                                 //MN_MAIN
const char prompt_01[] PROGMEM = "Course";                           //MN_MAINCOURSE
const char prompt_02[] PROGMEM = "Configuration";                    //MN_MAINCONFIG
const char prompt_03[] PROGMEM = "Mode";                             //MN_MODE
const char prompt_04[] PROGMEM = "PCLC";                             //MN_PCLC
.
.
.
const char prompt_20[] PROGMEM = "minutes";                          //MN_SAISIETEMPSCOURSE
const char prompt_21[] PROGMEM = "General";                          //MN_GENERAL
const char prompt_22[] PROGMEM = "Meilleur temps";                   //MN_MEILLEURTEMPS
const char prompt_23[] PROGMEM = "Pilote";                           //MN_TEMPSPILOTES

// Construction de la table de stockage
const char* const string_table[] PROGMEM = {
prompt_00, prompt_01, prompt_02, prompt_03, prompt_04, prompt_05,prompt_06, prompt_07, prompt_08, prompt_09,
prompt_10, prompt_11, prompt_12, prompt_13, prompt_14, prompt_15,prompt_16, prompt_17, prompt_18, prompt_19,
prompt_20, prompt_21, prompt_22, prompt_23
};

// buffer de lecture des prompts : 16 caracteres maxi
char buffer[16];

La partie initialisation de mes menus se fait dans void setup() :

void setup() {
  //Construction du tableau des menus
  //Affichage principal
  //                                               Parent             Suivant             Precedent           Cible                  Affichage             Option1  Option2   
  ListeMenus[MN_MAIN]=                            {MN_NONE ,          MN_NONE ,           MN_NONE ,           MN_NONE ,              AF_MAIN ,             false ,  false };

  //Liste des menus de configuration : appel suite à appui long sur pinBPSelect
  //                                               Parent             Suivant             Precedent           Cible                  Affichage             Option1  Option2    
  ListeMenus[MN_MAINCONFIG]=                      {MN_MAIN ,          MN_MAINCONFIG ,     MN_MAINCONFIG ,     MN_MODE ,              AF_MAIN ,             false ,  false };
      ListeMenus[MN_MODE]=                        {MN_MAINCONFIG ,    MN_PILOTES ,        MN_WIFI ,           MN_AUTONOME ,          AF_SSMENU ,           false ,  false };
          ListeMenus[MN_AUTONOME]=                {MN_MODE ,          MN_PCLC ,           MN_WFLC ,           MN_NONE ,              AF_SELECTION ,        true ,   false };
          ListeMenus[MN_PCLC]=                    {MN_MODE ,          MN_PCWFLC ,         MN_AUTONOME ,       MN_NONE ,              AF_SELECTION ,        false ,  false };
          ListeMenus[MN_PCWFLC]=                  {MN_MODE ,          MN_WFLC ,           MN_PCLC ,           MN_NONE ,              AF_SELECTION ,        false ,  false };
          ListeMenus[MN_WFLC]=                    {MN_MODE ,          MN_AUTONOME ,       MN_PCWFLC ,         MN_NONE ,              AF_SELECTION ,        false ,  false };
      ListeMenus[MN_PILOTES]=                     {MN_MAINCONFIG ,    MN_WIFI ,           MN_MODE ,           MN_LISTEPILOTES ,      AF_SSMENU ,           false ,  false };
          ListeMenus[MN_LISTEPILOTES]=            {MN_PILOTES ,       MN_LISTEPILOTES ,   MN_LISTEPILOTES ,   MN_NONE ,              AF_LSTSSMENU ,        false ,      0 };
      ListeMenus[MN_WIFI]=                        {MN_MAINCONFIG ,    MN_MODE ,           MN_PILOTES ,        MN_NONE ,              AF_SSMENU ,           false ,  false };
.
.
.
 }

J'ai donc essayé de créer une structure la plus "light" possible permettant un usage le plus générique possible.

Voici maintenant ma question (enfin...) :
J'ai besoin de créer 2 menus qui seront chargés sous forme de 2 tableaux depuis l'eeprom :

Déclaration des 2 tableaux :

char Pilotes[20][10];                                // Nom des pilotes : 20 pilotes max ; 9 caracteres par nom de pilote + \0
byte Transpondeurs[21];                               // index tableau = n° transpondeur (de 1 à 20 - 0 pas utilisé) et valeur tableau = index du tableau Pilotes

Je cherche donc une méthode me permettant de d'associer le plus légèrement possible ces tableaux aux menus correspondants.

J'ai pensé créer un 3e tableau pour y stocker les 2 premiers, l'index de ce 3e tableau me permettant de cibler avec simplement un byte le bon tableau. Mais ils sont dimensionnés différemment et je n'ai pas trouvé la méthode.
Si c'est pas possible.

Je compte donc sur vous pour confirmer si c'est réalisable avec un tableau. Si ce n'est pas possible, quelqu'un aura peut-être "la" solution à me proposer.

Merci de m'avoir lu et j'attends avec impatience de vous lire à mon tour.

PS : J'ai dû tailler mes extrait de code pour entrer dans les 9000 caractères. J'espère que cela reste compréhensible.