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

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

Citation:

---

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:

---

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().

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

Citation:

---

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

---

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:

---

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

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:

---

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:

---

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:

---

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

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:

---

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

Bonjour aliveli

Est ce que cette solution te conviendrais

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

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

Citation:

---

Envoyé par briand patrick

Code:

---

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...

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

Citation:

---

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).
...

Citation:

---

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

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:

---

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:

---

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

Merci Birand Patrick,

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

Code:

---

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:

---

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

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

Citation:

---

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.

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:

---

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:

---

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:

---

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:

---

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

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:

---

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

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

Bonjour Aliveri

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

Code:

---

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

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:

---

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:

---

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:

---

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.