Discussion :

[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

[Emmanuel Delahaye]

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]

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

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]

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]

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]

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]

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]

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]

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