enregistrer des int dans une EEPROM dont les adresses sont en byte

**Aliveli** · 30/05/2007, 00h34

Bonjour,

Je ne m y connais pas trop en programation d EEPROM comment faire en sorte que par exemple je puisse mettre un int dans une eeprom qui stocke des bytes? Dois je allouer deux adresses de l eeprom et/ou utiliser un tableau et comment?

Quelle est la meilleure methode ?

Merci

**Emmanuel Delahaye** · 30/05/2007, 08h17

Envoyé par Aliveli

Je ne m y connais pas trop en programation d EEPROM comment faire en sorte que par exemple je puisse mettre un int dans une eeprom qui stocke des bytes? Dois je allouer deux adresses de l eeprom et/ou utiliser un tableau et comment?

Quelle est la meilleure methode ?

Pour savoir si c'est une question de méthode (conception) ou de spécification, il faut savoir si ces données font partie d'un système fermé (l'écrivain et le ou les lecteurs font partie de la même application) ou si c'est une système ouvert (l'écrivain et le ou les lecteurs peuvent appartenir à des applications différentes).

Pour un système fermé, le choix du format des données revient à la conception. La méthode choisie doit être celle qui est la plus proche des contraintes naturelles de la machine.

taille d'un int
endianness
alignement

en principe, un pointeur de type int sur une adresse paire devrait couvrir la plupart des besoins :

Exemple (valeurs arbitraires, en supposant que l'EEPROM est mappée en mémoire) :

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
 
#define BASE_EEPROM 0x1000
 
/* un int en EEPROM + 10h */
#define OFFSET_MY_DATA 0x10
#define ADR_MYDATA ((volatile int *) (BASE_EEPROM + OFFSET_MY_DATA))
 
   /* ecriture 
       Appliquer la procedure d'écriture. 
       Ca peut etre plus ou moins complexe selon l'EEPROM
   */
    e2prom_write (OFFSET_MY_DATA, 1234);
 
   /* lecture */
   int x = *ADR_MYDATA;

Si le système est ouvert, on ne peut préjuger du format interne des données. Il est donc nécessaire de définir un format commun indépendant des contraintes matérielles. Cette définition se fait alors octet par octet (MSB en tête en général), ainsi que les accès en écriture et en lecture (à coup d'opérateurs bit à bit). C'est un peu plus lent, mais c'est portable. Pour optimiser, on peut utiliser éventuellement les fonctions htons() et ntohs().

**Engineering** · 30/05/2007, 08h37

Bonjour,
Cela dépend de la façon d'écriture :direct ou via un protocole de communication.

Envoyé par Aliveli

Bonjour,

Je ne m y connais pas trop en programation d EEPROM comment faire en sorte que par exemple je puisse mettre un int dans une eeprom qui stocke des bytes? Dois je allouer deux adresses de l eeprom et/ou utiliser un tableau et comment?

Quelle est la meilleure methode ?

Merci

**bpy1401** · 30/05/2007, 11h05

Bonjour,

Si ton Eeprom peut écrire uniquement des bytes, tu devra alors faire plusieurs accés en écriture dans ton eeprom, octet par octet et ceci quelque soit le type d'accés (eeprom interne ou externe). tu peux garder ta fonction e2prom_write, mais cette fonction devra ressemblé à ceci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
void e2prom_write (int addr, int data) 
{
   int i;
   for (i=0;i<sizeof(int);i++) 
   {
     e2prom_write_byte(addr+i,(unsigned char)(data&0xFF));
     data /= 256;
   }
}

Si tu connais la taille du int , tu peux alors supprimer la boucle for en appelant autant de fois que nécessaire la focntion e2prom_write_byte

Cordialement

**Aliveli** · 30/05/2007, 16h12

Bonjour,

Voila dans mon programme à base de microcontrolleur, je dois sauvegarder les valeurs des configs
dans une EEPROM de façon à ce que lors d'un reset je puisse avoir les dernières configurations.

Pour ce j'ai fait au depart un code qui ecrivait bien dans l'eeprom malgrès que j'écrivais des types int dans une addresse de type char de la EEPROM
car un reverification avec printf me donne les valeurs saisies (ex: seuil_bas = 150 et seuil_haut = 280).

A priori lorsque le programme tourne ça fonctionne bien ( car avec un printf je relis les valeurs saisies)
mais si je fait un reset j'ai comme valeur à cette adresse d'EEPROM pour seuil_bas 150 et pour seuil_haut = 255).
Apparement comme c'est un byte il y a depassement

Mon premier code d'ecriture sur l'eeprom:

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
23
24
25
26
27
28
 
	if(env_choice=='0')													
       {
 
		seuil_bas0=seuil_bas;
                EEP2408_ADDRESS = 0x62;  //addresse du seuil_bas niveau 0
		EEP2408_VALUE = seuil_bas0;
    	        EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
	EEP2408_ADDRESS = 0x66;  //addresse du seuil_haut niveau 0
		seuil_haut0=seuil_haut;
		EEP2408_VALUE = seuil_haut0;
		EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
       }     
 
	else if(env_choice=='1')                                            //2905
       {     
	EEP2408_ADDRESS = 0x70;  //addresse du seuil_bas niveau 1
		seuil_bas1=seuil_bas;
		EEP2408_VALUE = seuil_bas1;
		EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
	EEP2408_ADDRESS = 0x74;  //addresse du seuil_haut niveau 1
		seuil_haut1=seuil_haut;
		EEP2408_VALUE = seuil_haut1;
		EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
		}

Mon premier code d'initialisation pour charger les valeurs se trouvant dans l'EEPROM:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
EEP2408_ADDRESS = 0x62; //Force l'adresse ou doit être écrit les data du
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
seuil_bas0 =EEP_READ;
 
EEP2408_ADDRESS = 0x63; //Force l'adresse ou doit être écrit les data du
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
seuil_haut0 =EEP_READ;

donc je pense faire comme ceci convertir mes int en char avant de les stocker en eeprom et ce avec des tableaux ?

Mon nouveau code d'ecriture sur l'eeprom:

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
23
24
25
26
27
28
29
30
31
 
seuil_bas0=seuil_bas;
arraybas[0]=(seuil_bas0 & 0xff000000) >> 24;
arraybas[1]=(seuil_bas0 & 0xff0000) >> 16;
arraybas[2]=(seuil_bas0 & 0xff00) >> 8;
arraybas[3]=(seuil_bas0 & 0xff);
 
EEP2408_ADDRESS = 0x62;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[0];
EEP2408_ADDRESS = 0x63;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[1];
EEP2408_ADDRESS = 0x64;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[2];
EEP2408_ADDRESS = 0x65;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[3];
 
 
seuil_haut0=seuil_haut;
arrayhaut[0]=(seuil_haut0 & 0xff000000) >> 24;
arrayhaut[1]=(seuil_haut0 & 0xff0000) >> 16;
arrayhaut[2]=(seuil_haut0 & 0xff00) >> 8;
arrayhaut[3]=(seuil_haut0 & 0xff);
 
EEP2408_ADDRESS = 0x66;  //addresse du seuil_haut niveau 0
EEP2408_VALUE = arraybas[0];
EEP2408_ADDRESS = 0x67;  //addresse du seuil_haut niveau 0
EEP2408_VALUE = arraybas[1];
EEP2408_ADDRESS = 0x68;  //addresse du seuil_haut niveau 0
EEP2408_VALUE = arraybas[2];
EEP2408_ADDRESS = 0x69;  //addresse du seuil_haut niveau 0
EEP2408_VALUE = arraybas[3];

Mais alors comment dois je faire pour initialiser, charger ces valeurs de l'EEPROM dans mes variables après un reset ?

Merci

**Aliveli** · 31/05/2007, 14h03

Rebonjour,

Voila, je pense que je n'ai pas était clair, ce que j'ai posé comme question dans ce dernier topic c'est que ayant stocké das valeurs dans l'eeprom je voulais savoir comment les restituer vers une variable lorsque le système redemarre en sachant que je les stocke ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
seuil_bas0=seuil_bas;
arraybas[0]=(seuil_bas0 & 0xff000000) >> 24;
arraybas[1]=(seuil_bas0 & 0xff0000) >> 16;
arraybas[2]=(seuil_bas0 & 0xff00) >> 8;
arraybas[3]=(seuil_bas0 & 0xff);
 
EEP2408_ADDRESS = 0x62;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[0];
EEP2408_ADDRESS = 0x63;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[1];
.....
..

Je ne sais pas si ce que je fait ici est juste mais si c'est le cas comment dois je faire après un reset pour restituer ces 4 indices des tableaux dans une variable ou plutot aller prendre des addresses 62 à 65 de l'eeprom le contenu pour les mettre dans une variable int?

Merci

**bpy1401** · 31/05/2007, 15h35

Bonjour aliveli

Est ce que cette solution te conviendrais

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
23
24
 
typedef union 
{
  int globalValue;
  struct 
  {
    unsigned char llb;
    unsigned char lmb;
    unsigned char mlb;
    unsigned char mmb;
  } byte;
} intVarField;
 
....
 
 
   intVarField var;
   int variableFinale;
 
   var.byte.mmb = e2prom_read(62);
   var.byte.mlb = e2prom_read(63);
   var.byte.lmb = e2prom_read(64);
   var.byte.llb = e2prom_read(65);
   variableFinale = var.globalValue;

Vérifie l'aspect MSB-LSB, car je ne connais pas ta cible

Cordialement

**Emmanuel Delahaye** · 31/05/2007, 19h04

Envoyé par briand patrick

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
typedef union 
{
  int globalValue;
  struct 
  {
    unsigned char llb;
    unsigned char lmb;
    unsigned char mlb;
    unsigned char mmb;
  } byte;
} intVarField;

Une structure est tout sauf portable...

**Aliveli** · 31/05/2007, 21h36

Bonsoir,

Merci je vais tester ce code mais en quoi ça peut ne pas être bon Emmanuel ? Tu voudrais dire que pour certains compilateur ça n'ira pas? Mais je travaille sur un platforme non pas PC mais système embarqué donc c'est bien specifique la portabilité je pense dans mon cas dependra plus du compilateur est-ce correct?

Merci

**Emmanuel Delahaye** · 31/05/2007, 22h47

Envoyé par Aliveli

Merci je vais tester ce code mais en quoi ça peut ne pas être bon Emmanuel ? Tu voudrais dire que pour certains compilateur ça n'ira pas? Mais je travaille sur un platforme non pas PC mais système embarqué donc c'est bien specifique la portabilité je pense dans mon cas dependra plus du compilateur est-ce correct?

On ne sait pas ce que le compilateur va mettre aujourd'hui comme padding entre les champs, ni ce qu'il fera demain (nouvelle version, changement de plateforme...) Je conseille de privilégier des solutions indépendantes de la plateforme (tableau de unsigned char + opérateurs bit à bit).
...

**bpy1401** · 01/06/2007, 09h27

Emmanuel a écrit:
On ne sait pas ce que le compilateur va mettre aujourd'hui comme padding entre les champs, ni ce qu'il fera demain (nouvelle version, changement de plateforme...) Je conseille de privilégier des solutions indépendantes de la plateforme (tableau de unsigned char + opérateurs bit à bit).

je suis d'accord avec toi sur la portatbilité, car cette solution n'est pas la plus portable qui existe. Après c'est un compromis entre portabilité et efficacité. Je travail sur un projet ou la portabilité est l'objectif principal et on utilise toujours les unions et champs de bits. Pour éviter ces problèmes de portabilité, on a inclus tout ces types dans un seul fichier H qui est spécifique au compilateur.

Pour la portabilité, on ne devrait aussi retirer aussi le "int" et le remplacer par long ou short en fonction de la taille de ton int.

Aliveli, as tu vérifer que ton "int" est codé sur 4 bytes, pour les petits microcontoleurs c'est souvent 2 bytes.

Cordialement

**Aliveli** · 01/06/2007, 10h19

Merci Emmanuel, je vois clair rmaintenant mais c'est dommage que lorsqu'on est en système embarqué la mémoire est un frein donc si il s'agit de faire un tableau avec indices de 255 on monte vite en memoire mais je sais pas combien il en faudrait pour mon cas?

Sinon la solution de Briand Patrick est bien pour l'initialisation car ça permet de relire les contenus des addresses dans l'eeprom et de les stocker dans une seule variable, je l'ai fait ainsi:

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
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
 
 
///// declarations: 
 intVarField var;
   int variableFinale;  	//type_volume
 
  intVarField var1;
   int variableFinale1;   //seuil_bas0
 
  intVarField var2;
   int variableFinale2;  //	seuil_haut0
 
  intVarField var3;
   int variableFinale3;  //seuil_bas1
 
  intVarField var4;
   int variableFinale4;  //	seuil_haut1
 
  intVarField var5;
   int variableFinale5;  //seuil_bas2
 
  intVarField var6;
   int variableFinale6;  //	seuil_haut2
 
 
////lecture eeprom à l'initialisation :
EEP2408_ADDRESS = 0x61; //Force l'adresse ou doit être écrit les data 
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
//type_volume=EEP_READ; //0106 test?
var.byte.mmb = EEP_READ;
 
EEP2408_ADDRESS = 0x62; //Force l'adresse ou doit être écrit les data
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
var.byte.mlb = EEP_READ;
 
EEP2408_ADDRESS = 0x63; //Force l'adresse ou doit être écrit les data 
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
var.byte.lmb =EEP_READ;
 
EEP2408_ADDRESS = 0x64; //Force l'adresse ou doit être écrit les data
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");	
var.byte.llb =EEP_READ;
 
variableFinale = var.globalValue;
type_volume= variableFinale ;
 
//
 
EEP2408_ADDRESS = 0x65; //Force l'adresse ou doit être écrit les data
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
//seuil_bas0=EEP_READ;
var.byte.mmb = EEP_READ;
 
EEP2408_ADDRESS = 0x66; //Force l'adresse ou doit être écrit les data
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
var.byte.mlb = EEP_READ;
 
EEP2408_ADDRESS = 0x67; //Force l'adresse ou doit être écrit les data 
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
var.byte.lmb =EEP_READ;
 
EEP2408_ADDRESS = 0x68; //Force l'adresse ou doit être écrit les data
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");	
var.byte.llb =EEP_READ;
 
variableFinale1 = var.globalValue;
seuil_bas0 = variableFinale1 ;
 
//
 
//
 
EEP2408_ADDRESS = 0x69; //Force l'adresse ou doit être écrit les data
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
//seuil_haut0=EEP_READ;
var.byte.mmb = EEP_READ;
 
EEP2408_ADDRESS = 0x70; //Force l'adresse ou doit être écrit les data 
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
var.byte.mlb = EEP_READ;
 
EEP2408_ADDRESS = 0x71; //Force l'adresse ou doit être écrit les data
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
var.byte.lmb =EEP_READ;
 
EEP2408_ADDRESS = 0x72; //Force l'adresse ou doit être écrit les data
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");	
var.byte.llb =EEP_READ;
 
variableFinale2 = var.globalValue;
seuil_haut0 =   variableFinale2 ;
//
....

mais seul soucis c'est que la phase d'ecriture devait être adaptée au paravant en consequence. il faut que j'adapte aussi en consequence mais
j'ai ça comme code il faudrait autre chose mais quoi exactement pour bien faire?

code d'ecriture sur l'eeprom:

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
 
	if(env_choice=='0')													
       {
 
    seuil_bas0=seuil_bas;
    EEP2408_ADDRESS = 0x65;  //addresse du seuil_bas niveau 0                  EEP2408_VALUE = seuil_bas0;
     EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
    EEP2408_ADDRESS = 0x69;  //addresse du seuil_haut niveau 0
    seuil_haut0=seuil_haut;
    EEP2408_VALUE = seuil_haut0;
    EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
     }
 
if(env_choice=='1')													
       {
   ....

Avec ces codes le programme compile bien marche mais je ne sais pas avoir la dernière config lorsque je fais un reset, je pense que le problème vient de mon code d'ecriture sur l'eeprom, comment pourrais je ecrire de façon à ce corriger ce problème?

Merci

**Aliveli** · 01/06/2007, 12h27

Merci Birand Patrick,

Effectivement j'ai tester le sizeof du int mais j'ai une drôle de valeur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
printf("int seuil_bas = %d bytes\n",sizeof(int));

me donne :

int seuil_bas = 767 bytes

Bizarre quand même.

Deplus, je sais que lorsque je fait des printf en hex avec des %X defois il ajoute 2 caractères en plus par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
printf(" DATA = %Xh\n",val_lue);

si le contenu est 6E ça peut me donner par exemple:

DATA 6E66h

si le contenu n'est pas defini generalement c'est :

DATA 66h ou DATA h

Ce phenomene je ne comprend pas son origine ?
Mais donc pour la taille de int on ne sait pas ou j'ai fait une erreure de codage?

Merci

**bpy1401** · 01/06/2007, 17h21

Bonjour aliveli

Si tu veux connaitre la taille du int va voir dans la documentation du compilateur. Moi, je ne pose pas la question, car je n'utilise jamais ce type de donnée.
pour les 8 bits, j'utilise un char,
pour les 16 bits, un short
et pour les 32 bits un long.

pour l'ecriture en EEPROM, j'ai regardé ton code
on dirait que la ligne EEP2408_VALUE = seuil_bas0; est derrierre le commentaire //adresse du seuill_bas niveau 0
Je ne sais pas si cela vient du copier/coller dans le fourm, sinon cela voudrait dire que ta varaible EEP2048_VALUE n'est pas initialisée.

L'écriture en eeprom n'est pas une action simple, il me faudrait voir le code de la fonction EEP2408_write_byte et en connaitre un peu plus sur ton hardware (eeprom externe, interne).

bon week end
Cordialement

**Emmanuel Delahaye** · 01/06/2007, 18h01

Envoyé par briand patrick

Bonjour aliveli

Si tu veux connaitre la taille du int va voir dans la documentation du compilateur. Moi, je ne pose pas la question, car je n'utilise jamais ce type de donnée.
pour les 8 bits, j'utilise un char,
pour les 16 bits, un short
et pour les 32 bits un long.

Ce genre de raisonnement est dangereux car non portable.

**Aliveli** · 03/06/2007, 12h02

bonjour,

Oui j'ai regarde les spec de mon compilateur et effectivement les int sont en 2 bytes et les char en 1 byte.
mes variables:

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
23
24
 
 
char env_choice;  //0805
char range_choice;  //2805
int seuil_bas;     //2805
int seuil_haut;   //2805
int seuil_bas0;
int seuil_haut0;
int seuil_bas1;
int seuil_haut1;
int seuil_bas2;
int seuil_haut2;
 
 
char arraybas[4]; 
char arrayhaut[4];
 
 
int ss; //2805
double result; //2805
unsigned char Val_lue; //2805
 
unsigned char aa,bb,cc,dd;  //0106
unsigned char ee,ff,gg,hh;  //0106

Donc je dois rechanger mon code de stockage dans l'eeprom:

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
 
seuil_bas0=seuil_bas;
arraybas[0]=(seuil_bas0 & 0xff000000) >> 24;
arraybas[1]=(seuil_bas0 & 0xff0000) >> 16;
arraybas[2]=(seuil_bas0 & 0xff00) >> 8;
arraybas[3]=(seuil_bas0 & 0xff);
 
EEP2408_ADDRESS = 0x62;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[0];
EEP2408_ADDRESS = 0x63;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[1];
EEP2408_ADDRESS = 0x64;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[2];
EEP2408_ADDRESS = 0x65;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[3];

Par celui ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
seuil_bas0=seuil_bas;
arraybas[0]=(seuil_bas0 & 0xff00) >> 8;
arraybas[1]=(seuil_bas0 & 0xff);
 
EEP2408_ADDRESS = 0x62;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[0];
EEP2408_ADDRESS = 0x63;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = arraybas[1];

Est ce correct ?

Et pour mon code de lecture dans l'eeprom et ecriture dans mes variables, j'ai ça:

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
EEP2408_ADDRESS = 0x61; //Force l'adresse ou doit être écrit les data
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    type_volume=EEP_READ;
 
EEP2408_ADDRESS = 0x62;  //addresse du seuil_bas niveau 0
	EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    aa=EEP_READ;
 
EEP2408_ADDRESS = 0x63;  //addresse du seuil_bas niveau 0
	EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    bb=EEP_READ;
EEP2408_ADDRESS = 0x64;  //addresse du seuil_bas niveau 0
	EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    cc=EEP_READ;
EEP2408_ADDRESS = 0x65;  //addresse du seuil_bas niveau 0
	EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    dd=EEP_READ;
 
seuil_bas0=(aa<<24) | (bb<<16) | (cc<<8) | dd;
 
 
EEP2408_ADDRESS = 0x66;  //addresse du seuil_haut niveau 0
	EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    ee=EEP_READ;
 
EEP2408_ADDRESS = 0x67;  //addresse du seuil_haut niveau 0
	EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    ff=EEP_READ;
EEP2408_ADDRESS = 0x68;  //addresse du seuil_haut niveau 0
	EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    gg=EEP_READ;
EEP2408_ADDRESS = 0x69;  //addresse du seuil_haut niveau 0
	EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    hh=EEP_READ;
 
seuil_haut0=(ee<<24) | (ff<<16) | (gg<<8) | hh;

Est ce correct et surtout est ce que la methode est bonne ? Car je ne parviens pas a mettre dans une variable de type int des variables de types char, on peut surement arriver a faire ça en 2-3 lignes ou nimporte comment mais on devrait y arriver quand même???

Merci

**bpy1401** · 03/06/2007, 20h03

Bonjour aliveli

Pour le format de tes données , c'est correct.
Maintenant il reste à voir la routine d'écriture et de lecture en eeprom.

Est ce toi qui les a écrit ?, et si oui, peut t'on voir ce code ?

Une autre question, pourquoi utilise tu un tableau comme variable intermédiaire. Il faut toujours économiser la RAM
j'aurais donc écrit le code comme ca

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
EEP2408_ADDRESS = 0x62;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = seuil_bas >> 8;
EEP2408_ADDRESS = 0x63;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = (seuil_bas & 0xff);

Cordialement

**Aliveli** · 04/06/2007, 03h58

Bonjour Patrick Briand,

En fait je viens de réediter mon post j'avais quelques erreurs de commentaires. Et de plus j'ai ajouter comme tu me demandes le code d'ecriture sur variables et de lecture dans l'eeprom.

C'est vrai c'est une très bonne idée pourquoi utiliser en plus un tableau ? on gagnera pour la mémoire et on evitera surment des erreurs en plus.

Merci

**bpy1401** · 04/06/2007, 07h21

Bonjour Aliveri

Il y une incohérance entre la lecture et l'écriture. Tu écris deux octets et tu en relis 4.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
EEP2408_ADDRESS = 0x62;  //addresse du poid fort du seuil_bas niveau 0
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
aa=EEP_READ;
 
EEP2408_ADDRESS = 0x63;  //addresse du poid faible du seuil_bas niveau 0
EEP2408_read_byte(EEP2408_ADDRESS);
printf("\n");
bb=EEP_READ;
 
seuil_bas0=(aa*256) + bb;

Cordialement

**Aliveli** · 04/06/2007, 17h12

Effectivement Patrick,

tu avais raison de plus pour ma variable type_volume, je n'aiavais egalement pas une bonne enregistrement en eeprom.

Là j'ai corrigé en supprimant les tableaux comme tu m'as conseillé et là c'est nickel Merci.
Je remets mon code qui marche bien, ça peut aider d'autres personnes.

Mes variables:

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
 
char env_choice;  //0805
char range_choice;  //2805
int seuil_bas;     //2805
int seuil_haut;   //2805
int seuil_bas0;
int seuil_haut0;
int seuil_bas1;
int seuil_haut1;
int seuil_bas2;
int seuil_haut2;
 
//char arraybas[4]; 
//char arrayhaut[4];
 
unsigned char aa,bb,cc,dd;  //0106
unsigned char ee,ff,gg,hh;  //0106
unsigned char ii,jj,kk,ll;  //0106
unsigned char tva,tvb;  //0406

Pour l'ecriture en eeprom:

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
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
 
...
 
EEP2408_ADDRESS = 0x61;  //addresse du type_volume environnement //2905
		EEP2408_VALUE = type_volume>>8;
		EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
		EEP2408_ADDRESS = 0x62;  //addresse du type_volume environnement //2905
		EEP2408_VALUE = (type_volume & 0xff);
		EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
 
 
	if(env_choice=='0')													//2905
       {
          seuil_bas0=seuil_bas;  
 
EEP2408_ADDRESS = 0x63;  //addresse du seuil_bas niveau 0 
EEP2408_VALUE = seuil_bas>>8;
EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
EEP2408_ADDRESS = 0x64;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = (seuil_bas & 0xff);
EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
 
seuil_haut0=seuil_haut;
 
EEP2408_ADDRESS = 0x65;  //addresse du seuil_haut niveau 0
EEP2408_VALUE = seuil_haut>>8;
EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
EEP2408_ADDRESS = 0x66;  //addresse du seuil_haut niveau 0
EEP2408_VALUE = (seuil_haut & 0xff);
EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
 
		}     
 
	else if(env_choice=='1')                                            //2905
       {  
seuil_bas1=seuil_bas;
 
EEP2408_ADDRESS = 0x67;  //addresse du seuil_bas niveau 0  //0306
EEP2408_VALUE = seuil_bas>>8;
EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
EEP2408_ADDRESS = 0x68;  //addresse du seuil_bas niveau 0
EEP2408_VALUE = (seuil_bas & 0xff);
EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
 
seuil_haut1=seuil_haut;
 
EEP2408_ADDRESS = 0x69;  //addresse du seuil_haut niveau 0
EEP2408_VALUE = seuil_haut>>8;
EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
EEP2408_ADDRESS = 0x70;  //addresse du seuil_haut niveau 0
EEP2408_VALUE = (seuil_haut & 0xff);
EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
 
        }     
 
	if(env_choice=='2')                                               //2905
		{   
 
        seuil_bas2=seuil_bas;
 
		EEP2408_ADDRESS = 0x71;  //addresse du seuil_bas niveau 0  //0306
		EEP2408_VALUE = seuil_bas>>8;
		EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
		EEP2408_ADDRESS = 0x72;  //addresse du seuil_bas niveau 0
		EEP2408_VALUE = (seuil_bas & 0xff);
		EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
 
		seuil_haut2=seuil_haut;
 
		EEP2408_ADDRESS = 0x73;  //addresse du seuil_haut niveau 0
		EEP2408_VALUE = seuil_haut>>8;
		EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
		EEP2408_ADDRESS = 0x74;  //addresse du seuil_haut niveau 0
		EEP2408_VALUE = (seuil_haut & 0xff);
		EEP2408_write_byte(EEP2408_ADDRESS,EEP2408_VALUE);
 
 
		}
...

Pour la lecture de l'eeprom à l'initialisation après le reset:

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
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
 
 
EEP2408_ADDRESS = 0x61; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    tva=EEP_READ;
EEP2408_ADDRESS = 0x62; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    tvb=EEP_READ;
 
type_volume = (tva*256) + tvb;
 
 
//niveau0
EEP2408_ADDRESS = 0x63; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    aa=EEP_READ;
EEP2408_ADDRESS = 0x64; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    bb=EEP_READ;
 
seuil_bas0= (aa*256) + bb;
 
 
EEP2408_ADDRESS = 0x65; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    cc=EEP_READ;
EEP2408_ADDRESS = 0x66; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    dd=EEP_READ;
 
seuil_haut0= (cc*256) + dd;
 
 
//niveau1
EEP2408_ADDRESS = 0x67; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    ee=EEP_READ;
EEP2408_ADDRESS = 0x68; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    ff=EEP_READ;
 
seuil_bas1= (ee*256) + ff;
 
 
EEP2408_ADDRESS = 0x69; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    gg=EEP_READ;
EEP2408_ADDRESS = 0x70; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    hh=EEP_READ;
 
seuil_haut1= (gg*256) + hh;
 
 
//niveau2
 
EEP2408_ADDRESS = 0x71; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    ii=EEP_READ;
EEP2408_ADDRESS = 0x72; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    jj=EEP_READ;
 
seuil_bas2= (ii*256) + jj;
 
 
EEP2408_ADDRESS = 0x73; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    kk=EEP_READ;
EEP2408_ADDRESS = 0x74; //Force l'adresse ou doit être écrit les data du volume MIC >> PA
		EEP2408_read_byte(EEP2408_ADDRESS);
		printf("\n");
	    ll=EEP_READ;
 
seuil_haut2= (kk*256) + ll;

Merci à tous.

enregistrer des int dans une EEPROM dont les adresses sont en byte

C

Discussions similaires

Partager

Partager