Bonjour,

Pour une meilleure lisibilité du code, je souhaiterais utiliser un tableau de structure contenant notamment des variables, pointeurs de fonctions et si possible des champs de bits. Je précise que ce programme est utilisé sur microcontrôleur.

Ci-dessous un exemple de l'utilisation d'un tableau de structure qui permet l'appel d'une fonction correspondant à l'octet reçu.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
const struct {
	unsigned char cmd_inactive;
	unsigned char (*ptr_fct_inactive)(void);
	unsigned char cmd_disabled;
	unsigned char (*ptr_fct_disabled)(void);
} table_cmd[] = {
{0x10, cmd_reset_inactive,              0x10, cmd_reset_disabled,},
{0x11, cmd_configuration_inactive,      0x11, cmd_configuration_disabled,},
{0x12, cmd_poll_inactive,               0x12, cmd_poll_disabled,},
{0x14, cmd_reader_inactive,             0x14, cmd_reader_disabled,},	
{0x35, cmd_expansion_inactive,          0x35, cmd_expansion_disabled,}
};
 
unsigned char Etat_inactive()
{
int i;	 
  	for (i = 0; table_cmd[i].cmd_inactive; i++)      		   
    	if (Rx_octet == table_cmd[i].cmd_inactive)	
		return table_cmd[i].ptr_fct_inactive(); 
 return 0;	
}

Cet exemple est fonctionnel et j'aimerais utiliser cette architecture avec les bits d'interruptions du microcontrôleur, ceux-ci sont construits sous forme de champs de bits:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
extern volatile near unsigned char       PIR1;
extern volatile near union {
  struct {
    unsigned TMR1IF:1;
    unsigned TMR2IF:1;
    unsigned CCP1IF:1;
    unsigned SSP1IF:1;
    unsigned TX1IF:1;
    unsigned RC1IF:1;
    unsigned ADIF:1;
    unsigned PSPIF:1;
  };
  struct {
    unsigned :3;
    unsigned SSPIF:1;
    unsigned TXIF:1;
    unsigned RCIF:1;
  };
} PIR1bits;
Mon problème est donc d'utiliser un de ces champs dans le tableau de structure et ensuite appeler une fonction si tel bit & tel bit à été mis à 1.

J'ai pu lire que les champs de bits sont difficilement portables alors est il possible d'obtenir une solution ou doit on se contenter d'une architecture basé sur un if, else if...

Merci d'avance pour vos informations.
Bon week end