Question sur les tableaux et les define

Version imprimable

21/08/2014, 16h37
lcd27

Question sur les tableaux et les define

Bonjour à tous

J'effectue la lecture de 4 composants de température, qui me retournent chacun 9 bytes. J'inscris ces 4 fois 9 bytes dans 4 tableaux (extern) mon_tableau1[9], mon_tableau2[9] etc.. J'utilise le byte1 et 2 pour effectuer des calculs dans d'autres fonctions ou le byte 2 et 3 pour modifier des données etc..
Par facilité j'utilise des define du genre #define s1tab0 mon_tableau1[0]; #define s2tab1 mon_tableau2[1]...
Les résultats de ces opérations sont introduits dans un tableau (extern) que j'utilise pour d'autres fonctions.
Je voulais savoir si cette façon d'opérer était rationnelle ou si il existe une meilleure solution

Merci
Cordialement
Olivier
21/08/2014, 16h47
ternel

Ce qui serait rationnel, c'est que tu nous montres un peu de code.
Par exemple, les déclarations, les macros, une fonction les utilisant, et un main (fictif) qui écrit dans les tableaux puis appelle la fonction.

Je n'avais pas effectué cette démarche car cela me paraissait un peu compliqué
Le main n'apporte rien dans cette fonction, appel d'un menu sur exploration d'un clavier qui fait appel à la fonction du sous-menu A2B1 qui permet le choix d'une sonde sur les quatres
Il s'agit du protocole one wire, il y a donc lecture de la rom du composant( sans intérêt ici) puis lecture de la ram qui contient 9 bytes lecture 9 byte de la ram puis calcul pour display temperature brute
et les define et tableaux concernant cette partie de programme
J'en suis à ce stade,pour continuer je veux faire un menu de calibration pour créer un offset ajouté ou retranché à cette valeur brute afin d'afficher une température étalonnée
J'espère ne pas être trop confus

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
/*************************************************************************
lecture 9 byte de la ram
*************************************************************************/
void read_ram (byte sonde)
 
{
	byte i;
 
	ow_init ();						//init
 
	ow_write_byte(OW_1_SLAVE);		//skip rom
 
	ow_write_byte(DS_CONV);			// commande conversion
 
	_delay_us(60);
 
	ow_init ();						// init
 
	ow_write_byte(OW_1_SLAVE);		// skip rom
 
	ow_write_byte(DS_R_RAM);		// commande read ram
 
	switch (sonde)
	{
		case 1://sonde 1
			for (i=0;i<9; i++)
			{
			ow_read_byte(& ow_temp1_tab[i]);
			}
 
		break;
 
		case 2://sonde 2
			for (i=0;i<9; i++)
			{
			ow_read_byte(& ow_temp2_tab[i]);
			}
 
		break;
 
		case 3://sonde 3
			for (i=0;i<9; i++)
			{
			ow_read_byte(& ow_temp3_tab[i]);
			}
 
		break;
 
		case 4://sonde 4
			for (i=0;i<9; i++)
			{
			ow_read_byte(& ow_temp4_tab[i]);
			}
 
		break;
 
	}
 
}

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
/*************************************************************************
calcul pour display temperature brute
*************************************************************************/
void disp_temp_b (byte lsb,byte msb, byte deg, int cent)
{
 
	int j = 0;
	byte result = 0;
	byte result1 = 0;
	byte temp_c;
	int temp_d;
 
	char temp_lsb, temp_msb;
	char number [12];
 
	for (j=4;j<15;j++)
	vOSDTSVclearline(j);
 
 
	temp_lsb = (lsb >>4) & 0x0f;
	temp_msb = (msb <<4) & 0xf0;
	temp_c = temp_lsb + temp_msb;
	temp_d = ow_temp1_tab [0] & 0x0f;
	temp_d *= 625;
	sprintf (number,"Sonde 1 - %02d,%04d",temp_c, temp_d);
	vOSDTSVwriteline(11, 4 , 350, number, 3,0,0);
 
 
 
 
}

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
/****************************************************************************
fonction du sous-menu A2B1
*****************************************************************************/
void fonct_menus_A2B1 (void)
 
{
 	byte result = 0;
	byte result1 = 0;
	vTEMPOhalfSec(0x02);
 
	do
	{
	result1 = ioex_read(KB_IOEX_WRITE,P0_IOEX_IN);
	result = ~result1;
	}
	while (result==0);
 
		switch (result)
		{
		case 0x01://sonde1
			read_temp_code (S1RAM);	//0 du tableau
			read_ram (S1NUM);
			disp_temp_b (S1TAB0,S1TAB1);
 
		break;
 
		case 0x02://sonde2
			read_temp_code (S2RAM);	//9 du tableau
			read_ram (S2NUM);
			disp_temp_b (S2TAB0,S2TAB1);
 
		break;
 
		case 0x04://sonde3
			read_temp_code (S3RAM);	//18 du tableau
			read_ram (S3NUM);
			disp_temp_b (S3TAB0,S3TAB1);
 
		break;
 
		case 0x08://sonde4
			read_temp_code (S4RAM);	//27 du tableau
			read_ram (S4NUM);
			disp_temp_b (S4TAB0,S4TAB1);
 
		break;
 
		case 0x80://exit
		echap();
 
		break;
 
		}
 
 
 
}

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
extern byte ow_tab[45];
extern byte ow_temp1_tab[9];	//9 byte du contenu de la ram
extern byte ow_temp2_tab[9];
extern byte ow_temp3_tab[9];
extern byte ow_temp4_tab[9];
extern byte ow_temp_deg_tab[4]; //4 byte contenant la temp des 4 sondes sans decimale
extern int ow_temp_cent_tab[4];	//4 int contenant les décimales des 4 sondes
extern byte ow_th_tab[4]; 
extern byte ow_tl_tab[4];
 
#define S1NUM					1
#define S2NUM					2
#define S3NUM					3
#define S4NUM					4
 
#define S1RAM					0	// adresse tableau
#define S2RAM					8
#define S3RAM					16
#define S4RAM					24
 
#define S1TAB0					ow_temp1_tab[0]
#define S1TAB1					ow_temp1_tab[1]
#define S2TAB0					ow_temp2_tab[0]
#define S2TAB1					ow_temp2_tab[1]
#define S3TAB0					ow_temp3_tab[0]
#define S3TAB1					ow_temp3_tab[1]
#define S4TAB0					ow_temp4_tab[0]
#define S4TAB1					ow_temp4_tab[1]
 
#define S1DEG					ow_temp_deg_tab[0]
#define S1CENT					ow_temp_cent_tab[0]
#define S2DEG					ow_temp_deg_tab[1]
#define S2CENT					ow_temp_cent_tab[1]
#define S3DEG					ow_temp_deg_tab[2]
#define S3CENT					ow_temp_cent_tab[2]
#define S4DEG					ow_temp_deg_tab[3]
#define S4CENT					ow_temp_cent_tab[3]

Là ton code est sans doutes trop détaillé par rapport à ta question (en plus d'être difficilement compréhensible pour ceux qui ne font pas d'embarqué).

Cependant, on comprend mieux ta question.

Au lieu de multiplier les #define pour des structures de données dont le contenu est similaire, tu pourrais utiliser des enum pour rendre tes indices parlants, et créer un tableau à deux dimensions pour manipuler les données.

Voilà un code totalement fantaisiste, n'ayant rien à voir avec le tiens, mais qui, je l'espère, illustrera ce que tu peux faire.

(code adapté pour compiler sous gcc qui n'est certainement pas ton compilateur)
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 #include <stdio.h> /* mon compilateur ne connaît pas byte */ #define byte unsigned char enum { DATA1, DATA2, MOD1, MOD2, TRUC, MACHIN, BIDULE, TOTO, TITI }; enum { SONDE_NORD, SONDE_SUD, SONDE_EST, SONDE_OUEST }; void recupere_valeurs(byte s[]) { /* simulation de la récupération de valeurs */ s[DATA1] = 0; s[DATA2] = 1; s[MOD1] = 2; s[MOD2] = 3; s[TRUC] = 4; s[MACHIN] = 5; s[BIDULE] = 6; s[TOTO] = 7; s[TITI] = 8; } int mon_calcul(byte a, byte b) { return a + b; } int main(void) { byte s[4][9]; int n; for (n = SONDE_NORD; n <= SONDE_OUEST; n++) { recupere_valeurs(s[n]); } printf("Mon calcul pour Sonde Nord : %d\n", mon_calcul(s[SONDE_NORD][DATA1], s[SONDE_NORD][DATA2])); if (s[SONDE_NORD][TOTO] < s[SONDE_SUD][TITI]) printf("Toto au Nord a plus froid que Titi au Sud\n"); return 0; }
Plus d'infos sur enum là : http://c.developpez.com/cours/bernar...gne/node92.php

Tu pourrais aussi créer un tableau à une dimension port stocker les données de tes 4 sondes, utilisant un enum pour pouvoir énumérer les sondes, mais de type struct comprenant les 9 bytes, si cela est faisable compte tenu de la façon dont tu récupères tes données, et si tu n'as pas besoin d'énumérer les 9 bytes, mais juste de pouvoir les nommer. Tu aurais alors accès aux données en faisant quelque chose comme s[SONDE_NORD].data1

http://c.developpez.com/cours/bernar...gne/node78.php

Eks

21/08/2014, 22h47
lcd27

Merci Eks,
#define byte unsigned char :D Eh oui j'utilise GCC et j'avais totalement oublié de préciser le compilateur avec lequel je travaille

Je n'ai jamais utilisé les énums mais pourquoi pas je vais creuser le sujet, je ne connais pas du tout

J'explique un peu plus le process si cela peut donner une idée à un lecteur

Ce que j'ai fait
J'ai 4 sondes de température reliées en one wire sur 4 ports du micro, mon driver one wire fonctionne correctement en écriture comme en lecture. Ces sondes n'ont pas un emplacement déterminé je récupère donc les 64 bits du code rom de la sonde pour pouvoir lui affecter sa position en accord avec le menu.
Je récupère mes données en lot dans 4 tableaux de 9 bytes. J'utilise les deux premiers byte pour effectuer les calculs de température et je replace les résultats dans dans 4 x 2 tableaux Le premier (x4)contient un byte des degrés et le second(x4) un int des décimales (4chiffres) résultats que je peux afficher

J'incrémente ou décremente les décimales et éventuellement les degrés pour étalonner la température

Ce qui me reste à faire
Calculer l'offset entre température brut et étalonnée, l'additionner ou le soustraire à la valeur brute, ne conserver que deux décimales, les ranger dans un tableau et afficher cette température en permanence

Devant le nombre d'accès aux divers tableaux, j'ai fait une pause car je me suis rapidement aperçu que ma façon de faire allait rapidement ressembler à une usine à gaz et qu'il serait difficile de revenir en arrière
J'en ai déduit que la suite dépendait beaucoup de la façon de coder cette partie de programme d'autant plus que que le byte 2, 3 et 8 sont également à utiliser

Merci
Cordialement
Olivier