macro : créer des boucles => possible ?

Version imprimable

07/09/2010, 09h22
boboss123

macro : créer des boucles => possible ?
Bonjour,

Je voudrais générer ce genre de code à l'aide de macro :
Code:

1 2 3 4 5 toto1 = 1; toto2 = 1; toto3 = 1; toto4 = 1; ...
Est-il possible de le générer automatiquement à l'aide de macro (éviter de me taper toutes les lignes à la main) ?

Pour l'écriture d'une ligne je pensais partir sur cette méthode. Mais je ne vois pas comment faire pour faire n fois l'itération
Code:

1 2 3 #define MAKE_TOTO(x) totox = 1 #define MAKE_TOTO(x) toto ## x = 1 // => quelle est la différence entre les deux méthodes ? les deux fonctionnent ?
07/09/2010, 09h34
seeme

Bonjour,

Je ne vois pas trop l'intérêt de faire ça...

Pourquoi ne pas utiliser un tableau?

Décrit un peu plus ton problème qu'on puisse t'aiguiller au mieux.

C'est pour gagner de la taille en code car je programme sur un µControlleur 32 bits.
J'essaye de voir ce qu'on peut faire avec les macros pour avoir un code facilement configurable.
=> je voudrais à l'aide de #define définir les voies qui sont à mesurer

J'essaye de faire une programme qui mesure des valeurs sur des voies analogiques.

Je voudrais à l'aide de #define activer les voies analogiques à mesurer. Donc voici un code simplifier ce qu'il faudrait faire pour l'initialisation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
void anaInit(void){
 
	// *******************************************
	// configuration des I/O => input
	TRISBbits.TRISB0 = 1; AD1PCFGbits.PCFG0 = 0;	// active voie 0
	TRISBbits.TRISB1 = 1; AD1PCFGbits.PCFG1 = 0;	// active voie 1
	TRISBbits.TRISB2 = 1; AD1PCFGbits.PCFG2 = 0;	// active voie 2
	// ...
	TRISBbits.TRISB15 = 1; AD1PCFGbits.PCFG15 = 0;	// active voie 15
	// Remarque : on peut aussi ecrire directement dans les registres en utilisant : TRISB et AD1PCFG (registres de 16 bits);
	//		=> cette méthode serait prévérable car on pourrait tout configurer en un seul coup (=> gain de code)
	//		=> exemple : 
	//			TRISB =  MASK_BIT0 | MASK_BIT1 | ... | MASK_BIT15 | TRISB;
	//			AD1PCFG =  0xFFFF & (~MASK_BIT0) & (~MASK_BIT1) & ... & (~MASK_BIT15);
 
 
 
	// *******************************************
	// activation des mesure
	AD1CSSLbits.CSSL0 = 1;	// active voie 0
	AD1CSSLbits.CSSL1 = 1;	// active voie 1
	// ...
	AD1CSSLbits.CSSL15 = 1;	// active voie 15
 
 
 
	// *******************************************
	// configuration du nombre de voies à mesurer
	// => mesure de 16 voies
	AD1CON2bits.SMPI = 15; // => valeur = n - 1 
}
 
 
 
static unsigned long tabVal[16]; // unsigned long : taille 64 bits (8 octets)
 
// récupère les valeurs
void anaGet(void){
 
	// création des pointeurs
	// unsigned int : taille 32 bits (4 octets)	
	unsigned int *ptReg;
	unsigned int i;
 
	static nb_mesures = 0;
 
 
	// ****************************************
	// réinitialisation des valeurs
	if (nb_mesures == 0){
		for(i=0; i<16; i++){
			tabVal[i] = 0; 
		}
	}
 
 
	// ****************************************
	// récupération des valeurs
 
	// les valeurs à lire sont dans les registres ADC1BUF0, ADC1BUF1, ..., ADC1BUFA, ADC1BUFB, .... , ADC1BUFF
	// => ce sont des registres de 32 bits (4 octets)
	// Remarque : les adresses des registres se suivent
	ptReg = &ADC1BUF0;
 
 
	for(i=0; i<16; i++){
		// récupération des valeurs
		// => on cumule les valeurs récupérées pour pouvoir faire un moyennage
		tabVal[i] += *ptReg; 
 
		ptReg++; // incrémentation du pointeur
	}
 
 
	// ****************************************
	// gestion du moyennage
	nb_mesures++;
	if (nb_mesures == 8){
 
		// division par 8 des valeurs
		for(i=0; i<16; i++){
			tabVal[i] >>= 3; 
		}
		nb_mesures = 0;
 
 
		// ****************
		// affectation des valeurs à des variables globales
		// => code spécifique à l'application
		// => il peut y avoir des calculs de conversion
		temperature = tabVal[0];
		alimentation = tabVal[1];
		// ...
		humidite = tabVal[15];
	}
 
 
}

Attention : dans la fonction anaGet(), pour les registres ADC1BUFx, 'x' ne représente pas le numéro de la voie qui à été mesurée mais le numéro de la mesure. Exemple : ADC1BUF0 => mesure n°0, ADC1BUF5 => mesure n°5, ADC1BUFA => mesure n°10, ...

J'ai commencé à faire la fonction d'initialisation

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
// **************************************************
//     Configuration
// **************************************************
 
// Définir les voies à échantilloner
// => mettre en commentaire les voies non utilisées
// Remarque : toutes les voies analogiques sont sur le port B
//#define AN0_ENB
#define AN1_ENB
#define AN2_ENB
//#define AN3_ENB
#define AN4_ENB
#define AN5_ENB
#define AN6_ENB
#define AN7_ENB
#define AN8_ENB
#define AN9_ENB
//#define AN10_ENB
#define AN11_ENB
#define AN12_ENB
#define AN13_ENB
#define AN14_ENB
//#define AN15_ENB
 
 
// **************************************************
// génération automatique des #define
// **************************************************
 
// génération des masques
#ifdef AN0_ENB
	#define AN0_MASK	0x0001
#else
	#define AN0_MASK	0x0000
#endif
 
#ifdef AN1_ENB
	#define AN1_MASK	0x0002
#else
	#define AN1_MASK	0x0000
#endif
 
#ifdef AN2_ENB
	#define AN2_MASK	0x0004
#else
	#define AN2_MASK	0x0000
#endif
 
#ifdef AN3_ENB
	#define AN3_MASK	0x0008
#else
	#define AN3_MASK	0x0000
#endif
 
#ifdef AN4_ENB
	#define AN4_MASK	0x0010
#else
	#define AN4_MASK	0x0000
#endif
 
#ifdef AN5_ENB
	#define AN5_MASK	0x0020
#else
	#define AN5_MASK	0x0000
#endif
 
#ifdef AN6_ENB
	#define AN6_MASK	0x0040
#else
	#define AN6_MASK	0x0000
#endif
 
#ifdef AN7_ENB
	#define AN7_MASK	0x0080
#else
	#define AN7_MASK	0x0000
#endif
 
#ifdef AN8_ENB
	#define AN8_MASK	0x0100
#else
	#define AN8_MASK	0x0000
#endif
 
#ifdef AN9_ENB
	#define AN9_MASK	0x0200
#else
	#define AN9_MASK	0x0000
#endif
 
#ifdef AN10_ENB
	#define AN10_MASK	0x0400
#else
	#define AN10_MASK	0x0000
#endif
 
#ifdef AN11_ENB
	#define AN11_MASK	0x0800
#else
	#define AN11_MASK	0x0000
#endif
 
#ifdef AN12_ENB
	#define AN12_MASK	0x1000
#else
	#define AN12_MASK	0x0000
#endif
 
#ifdef AN13_ENB
	#define AN13_MASK	0x2000
#else
	#define AN13_MASK	0x0000
#endif
 
#ifdef AN14_ENB
	#define AN14_MASK	0x4000
#else
	#define AN14_MASK	0x0000
#endif
 
#ifdef AN15_ENB
	#define AN15_MASK	0x8000
#else
	#define AN15_MASK	0x0000
#endif
 
 
 
 
// configuration des I/O et registres pour pourvoir faire les mesures analogiques
void anaInit(void){
 
	// ****************************************************
	// configuration des I/O analogiques
 
	// config des I/O
	// => les I/O doivent être des input
	TRISB =	AN0_MASK  | AN1_MASK  | AN2_MASK  | AN3_MASK  |
			AN4_MASK  | AN5_MASK  | AN6_MASK  | AN7_MASK  |
			AN8_MASK  | AN9_MASK  | AN10_MASK | AN11_MASK |
			AN12_MASK | AN13_MASK | AN14_MASK | AN15_MASK |
			TRISB;
 
	// activation des voies analogiques
	AD1PCFG =	(~AN0_MASK)  & (~AN1_MASK)  & (~AN2_MASK)  & (~AN3_MASK)  &
				(~AN4_MASK)  & (~AN5_MASK)  & (~AN6_MASK)  & (~AN7_MASK)  &
				(~AN8_MASK)  & (~AN9_MASK)  & (~AN10_MASK) & (~AN11_MASK) &
				(~AN12_MASK) & (~AN13_MASK) & (~AN14_MASK) & (~AN15_MASK) ;
 
 
	// activation des voies à échantilloner
	AD1CSSL =	AN0_MASK  | AN1_MASK  | AN2_MASK  | AN3_MASK  |
				AN4_MASK  | AN5_MASK  | AN6_MASK  | AN7_MASK  |
				AN8_MASK  | AN9_MASK  | AN10_MASK | AN11_MASK |
				AN12_MASK | AN13_MASK | AN14_MASK | AN15_MASK ;
 
 
	AD1CON2bits.SMPI = AN_NB_VOIES - 1; 
 
}

Comment faire pour définir AN_NB_VOIES ?
Pour le calcul de TRISB, le compilateur va bien simplifier tous les mask en une seule valeur ?

Pour :

Code:

1
2
3
4
5
6
 
#ifdef AN0_ENB
	#define AN0_MASK	0x0001
#else
	#define AN0_MASK	0x0000
#endif

=> peut-on réduire ce code sur une seul ligne (via macro ?) afin d'améliorer la lisibilité du code ?

Pourquoi pas :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#define AN0_ENB 1
#define AN1_ENB 0
#define AN2_ENB 0
#define AN3_ENB 1
//.....
#define AN_ENB(x) AN##x##_ENB
#define AN_MASK(x) AN_ENB(x)<<x
#define AN_MASKINV(x) ~(AN_ENB(x)<<x)
 
  AD1CSSL   =  AN_MASK(0) | AN_MASK(1) | AN_MASK(2) | AN_MASK(3) /* etc */ ;
  AD1PCFG   =  AN_MASKINV(0) & AN_MASKINV(1) & AN_MASKINV(2) & AN_MASKINV(3) /* etc */ ;
  AN_NB_VOIES =   AN0_ENB + AN1_ENB + AN2_ENB + AN3_ENB /* etc*/ ;

merci, cette solution est pas mal

j'ai encore un problème au niveau des récupérations des valeurs dans mes variable. Actuellement, je fais comme ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 // définition des variables de stockage #define AN0_VAR temperature #define AN1_VAR alimentation #define AN15_VAR humidite void anaGet(void){ // .... // .... i=0; #if AN0_ENB == 1 AN0_VAR = tabVal[i++]; #endif #if AN1_ENB == 1 AN1_VAR = tabVal[i++]; #endif // ... #ifdef AN15_ENB == 1 AN15_VAR = tabVal[i++]; #endif // .... // .... }
=> Les valeurs sont stockées dans le buffer tampon tabVal[] et je les copie vers mes variables : vous en pensez quoi de cette methode ?

C'est possible de faire une macro pour créer ce code ?
On a le droit de faire un truc du genre ?
Code:

1 2 3 4 5 6 7 #define AN_VAR(x) AN##x##_VAR #define GET_VAR(x) \ #ifdef AN_ENB(x) == 1 \ AN_VAR(x) = tabVal[i++]; \ #endif // => ne compile pas :'(

07/09/2010, 14h42
matafan

L'utilisation de macros peut permettre de réduire la taille du source, mais pas celle de ton binaire.
07/09/2010, 14h56
Invité

Je vais même renforcer ce que dit Matafan, une boucle se répète à l'exécution, mais n'est écrite qu'une seule fois dans le binaire, alors que s'il s'agit d'une simulation de boucle, avec une macro, elle est écrite physiquement autant de fois qu'elle doit être exécutée.
07/09/2010, 15h07
boboss123
il me semble que vous n'avez pas bien compris ce que je voulais faire.
dans ma fonction, j'aimerais remplacer les multiples #if:
Code:

1 2 3 4 5 6 7 8 9 #ifdef AN0_ENB == 1 AN0_VAR = tabVal[i++]; #endif // ... #ifdef AN15_ENB == 1 AN15_VAR = tabVal[i++]; #endif
par :
Code:

1 2 3 4 5 // GET_VAR(x) doit renvoyer "ANx_VAR = tabVal[i++]" si ANx_ENB == 1 sinon il ne doit rien renvoyer (ligne vide) GET_VAR(0); // ... GET_VAR(15);
=> pour que le code soit moins chargé au niveau de la lecture. La seconde méthode (si elle marchait) me permettrait de n'ecrire que 16 lignes dans ma fonction au lieu de 64
07/09/2010, 17h21
diogene

Je ne vois pas d'autres solutions que d'écrire

Citation:

#define AN_VAR(x) AN##x##_VAR
#define GET_VAR(x) if(AN_ENB(x)) AN_VAR(x) = tabVal[i++]

Normalement, le compilateur devrait éliminer les tests puisqu'il sait si ils sont vrai ou faux et remplacer

if(AN0_ENB) AN0_VAR = tabVal[i++]
par l'équivalent de
- si AN0_ENB == 1 : AN0_VAR = tabVal[i++]
- si AN0_ENB == 0 : pas d'opérations; AN0_VAR = tabVal[i++] ne pouvant dans ce cas jamais être exécuté

(mais il peut s'étonner de ces tests bidons et émettre des warnings)

merci ça marche nickel (le code est bien optimisé et je n'ai pas de warning) mais il y a un petit problème c'est qu'il faut que tous les ANx_VAR soient définis pour que ça fonctionne.

Donc pour la partie configuration, je fais comme ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 #define AN_NULVAR *((unsigned long*)NULL) // ne pas modifier cette ligne // definition des voies actives #define AN0_ENB 0 #define AN1_ENB 1 #define AN2_ENB 0 #define AN3_ENB 1 #define AN4_ENB 1 #define AN5_ENB 0 #define AN6_ENB 0 #define AN7_ENB 0 #define AN8_ENB 0 #define AN9_ENB 0 #define AN10_ENB 0 #define AN11_ENB 0 #define AN12_ENB 0 #define AN13_ENB 0 #define AN14_ENB 0 #define AN15_ENB 0 // définition des variables associées #define AN0_VAR AN_NULVAR #define AN1_VAR temperature #define AN2_VAR AN_NULVAR #define AN3_VAR alim1 #define AN4_VAR alim2 #define AN5_VAR AN_NULVAR #define AN6_VAR AN_NULVAR #define AN7_VAR AN_NULVAR #define AN8_VAR AN_NULVAR #define AN9_VAR AN_NULVAR #define AN10_VAR AN_NULVAR #define AN11_VAR AN_NULVAR #define AN12_VAR AN_NULVAR #define AN13_VAR AN_NULVAR #define AN14_VAR AN_NULVAR #define AN15_VAR AN_NULVAR
Est-il possible de créer une macro AN_SET_CHANEL(numVoie, nomVar) qui permette de redéfinir les valeurs de ANx_ENB et ANx_VAR.
Je pensais mettre par défaut tous les ANx_ENB à 0 et tous les ANx_VAR à AN_NULVAR puis d'utiliser la macro AN_SET_CHANEL() pour activer les voies utilisées => ça serait plus simple à utiliser (pas obliger de définir les voies non utilisées vu qu'elles auraient le paramêtre ANx_ENB à 0 par défaut)

En gros je voudrais remplacer tout le code précédent par seulement ça :
Code:

1 2 3 AN_SET_CHANEL(1, temperature) AN_SET_CHANEL(3, alim1) AN_SET_CHANEL(4, alim2)
=> j'espère que vous avez compris ce que je voulais dire...

Je ne comprend pas bien le pourquoi de
Code:

1 2 3 4 5 #define AN0_VAR AN_NULVAR #define AN1_VAR temperature #define AN2_VAR AN_NULVAR #define AN3_VAR alim1 ....
D'après un de tes posts précédent, je penserai plutôt à
Code:

1 2 3 #define temperature AN1_VAR #define alim1 AN3_VAR ....

08/09/2010, 13h13
boboss123

non, c'est bien ça que je veux faire :

Code:

#define AN1_VAR temperature

temperature est une variable globale qui est déclarée dans le main de mon programme. anaGet() est appelé périodiquement depuis le main => il récupère les valeurs et les copies dans les variables globales (ex: temperature).
Ce que veux faire, c'est avoir un module qui soit facilement configurable. Donc pour la configuration, je pensais faire :
1- définir les voies à activer => ANx_ENB
2- définir la variable globale associée à la voie (endroit où est stoqué la valeur) => ANx_VAR
=> Ce qui serait bien c'est de faire ces deux déclarations en une seule commande : AN_SET_CHANEL()

Est-ce qu'il existe un moyen d'avoir une version de mon code source sans les macro (pour voir si j'ai bien le bon résultat) ? (j'utilise gcc)
08/09/2010, 14h40
orfix

Citation:

Envoyé par boboss123

Est-ce qu'il existe un moyen d'avoir une version de mon code source sans les macro (pour voir si j'ai bien le bon résultat) ? (j'utilise gcc)

Utilises l'option -E de gcc.
08/09/2010, 15h24
boboss123

ok merci ;)

aussi, j'ai un autre probleme du même genre :

Je voudrais appeler les fonctions OpenPort1() et ClosePort1(). Pour cela j'ai fait :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #define PORT 1 // définition du numéro de port #define _MACRO1(x) OpenPort##x #define MACRO1 _MACRO1(PORT) #define _MACRO2(x) ClosePort##x #define MACRO2 _MACRO2(PORT) // utilisation des macros : void main(void){ MACRO1(); MACRO2(); }
=> le probleme, c'est que ces macros ne me mettent pas OpenPort1 et ClosePort1 mais OpenPortPORT et ClosePortPORT : y a t-il un moyen de faire cela (c'est pour pouvoir configurer un driver en indiquant le numéro de port utilisé) ?