[PIC] Utilisation de l'EEPROM

[jorg1n]

Bonjour,

voilà, j'utilise un PIC 18F4525, qui dispose de 1024 octet en EEPROM, et je souhaite utiliser cette mémoire afin de sauvegarder des paramètres, j'ai fais mes deux fonctions afin d'écrire et lire cette mémoire:

/***************************************************************
Nom   : void writeEEPROM ( char addr, char data);
Role  : Ecrire dans l'EEPROM
****************************************************************/
void writeEEPROM ( char addr, char data)
{
EEADR = addr;			// EEPROM Memory location
EEDATA = data;			// Data to be written in EEPROM
EECON1bits.EEPGD = 0;		// Enable EEPROM write
EECON1bits.CFGS = 0;		// Enable EEPROM write
EECON1bits.WREN = 1;		// Enable EEPROM write

EECON2 = 0x55;			// Required sequence to start write cycle
EECON2 = 0xAA;			// Required sequence to start write cycle
EECON1bits.WR = 1;		// Required sequence to start write cycle

while(EECONbits.WR);		// Wait for completion of write sequence

PIR2bits.EEIF = 0;		//Disable EEPROM write
EECON1bits.WREN = 0;		//Disable EEPROM write

}



/***************************************************************
Nom   : void readEEPROM ( char addr );
Role  : Lire une valeur dans l'EEPROM
****************************************************************/
void readEEPROM ( char addr )
{
char data;
EEADR = addr;			// EEPROM Memory location
EECON1bits.EEPGD = 0;		// Enable Read sequence
EECON1bits.CFGS = 0;		// Enable Read sequence
EECON1bits.RD = 1;		// Enable Read sequence

data = EEDATA;
return data;

}

Mais voila, je souhaiterai avoir un peut plus d'informations pour la manière de définir les adresses, car j'ai une quarantaine de variables à stocker.
D'après ce que j'ai lu dans la documentation(page 83 - section 7.1), l'adresse de stockage peut varier entre 0x00 et 0x3FF. mais comment définir l'adresse sans réécrire une une autre donnée déja écrite?
merci d'avance
-----

[jorg1n]

Personne n'a une petite idée??

[freepicbasic]

tu fais addr ++;
et la nouvelle données dans data

[invite6a878e16]

Salut

Tu fais comme Freepicbasic a dit quand tu appelles la fonction

Sauf qu'ici avec tes fonctions tu peux adresser seulement les 256 premiers octets. C'est voir si ça te suffit ou pas.
Si tu veux pouvoir adresser le 1024 octets, il faut que addr soit en int et utiliser en EEADRH

[A voir en vidéo sur Futura]

[jorg1n]

Bonjour,

alors voila j'ai étudié un peu plus ce que j'avais besoin et il me faut stocker en tout 65 variables. Par contre mes variables sont de différentes formes, j'ai des "float" ( 12,5 par exemple )et des entiers (1289 par exemple ), comment me conseillez vous de les stocker, pensez vous que je dois utiliser les 1024 de mémoire, 256 Octets ne suffiraient ils pas? j'ai un peu de mal a définir les adresses en fait.
Pouvez vous m'aider?
Merci d'avance

[Seb.26]

NB: Coupe les IT pendant la "séquence" du Write() ...

[RISC]

Salut,

Alors voila j'ai étudié un peu plus ce que j'avais besoin et il me faut stocker en tout 65 variables. Par contre mes variables sont de différentes formes, j'ai des "float" ( 12,5 par exemple )et des entiers (1289 par exemple ), comment me conseillez vous de les stocker, pensez vous que je dois utiliser les 1024 de mémoire, 256 Octets ne suffiraient ils pas? j'ai un peu de mal a définir les adresses en fait.

Si tu as déjà déclaré toutes tes variables, il suffit de regarder le fichier .map généré par l'éditeur de liens (si tu as activé l'option). Il te montrera :
* le nombre d'octets nécessaires à chaque variable (cela dépend uniquement de son type)
* le nombre d'octets total utilisés dans l'E2PROM

Pour cela il suffit de modifier les options du linker comme suit dans MPLAB :

Project > Build Options > Project > onglet MPASM Assembler > Menu déroulant "Categories" > Output > coche "Generate cross-reference file"

Cela génèrera un fichier xxxxxx.map et tu pourras voir les adresses des données en E2PROM ;=)

Si tu n'as pas encore déclaré toutes tes variables, il faut déterminer combien d'octets sont nécessaires pour chaque type de variable (char, int, float), compter combien tuen as de chaque et ...faire l'addition.

a+

[jorg1n]

Merci pour vos explications et conseils...

alors j'ai listé tous ce que j'ai...et ça donne 30 float et 35 int à stocker dans l'EEPROM, donc après calcul, 4 octets pour un float et 2 pour un int ...j'utiliserai donc 190 octets de mon EEPROM.. j'ai de la marge...

Par contre je veut bien avoir quelques explication au point de vue soft,...
Avant de stocker mes valeurs tel qu'elles sont, c-a-d en int ou en float, je dois les convertir en char, et ensuite réaliser la procédure d'écriture??en ajoutant l'annulation des IT...

Dites moi si je me trompe??
Merci encore

[jorg1n]

Voila j'ai modifié mon programme pour interdire les interruptions lors de l'écriture:

void writeEEPROM ( char addr, char data)
{
static unsigned char GIE_Status;
EEADR = addr;			// EEPROM Memory location
EEDATA = data;			// Data to be written in EEPROM
EECON1bits.EEPGD = 0;		// Enable EEPROM write
EECON1bits.CFGS = 0;		// Enable EEPROM write
EECON1bits.WREN = 1;		// Enable EEPROM write

GIE_Status = INTCONbits.GIE;    //Save global interrupt enable bit
INTCONbits.GIE=0;               //Disable global interrupts

EECON2 = 0x55;			// Required sequence to start write cycle
EECON2 = 0xAA;			// Required sequence to start write cycle
EECON1bits.WR = 1;		// Required sequence to start write cycle
while(EECONbits.WR);		// Wait for completion of write sequence

INTCONbits.GIE=GIE_Status;      //Restore the original global interrupt status

PIR2bits.EEIF = 0;		//Disable EEPROM write
EECON1bits.WREN = 0;		//Disable EEPROM write
}

j'espère que c'est correct...
par contre j'ai un truc que je ne comprend pas...
c'est le principe de conversion, car on vient pas stocké le float ou le int directement dans l 'EEPROM, faut d'abord la convertir en char si je ne me trompe pas, et là je suis perdu!!!
float en char....int en char...
pouvez vous me guidez un peu....

[jorg1n]

Je peux peut etre définir ma variable data en int ...non?

[freepicbasic]

float MyFloat;

DATA = * ( (char *) MyFloat);
DATA = * ( (char *) MyFloat +1);
DATA = * ( (char *) MyFloat +2);
DATA = * ( (char *) MyFloat +3);

ou bien
DATA = ( (char *) MyFloat )[0];
DATA = ( (char *) MyFloat )[1];
DATA = ( (char *) MyFloat )[2];
DATA = ( (char *) MyFloat )[3];

ou bien
char *ptr;
ptr = (char *) MyFloat;
DATA = ptr[0];
DATA = ptr[1];
DATA = ptr[2];
DATA = ptr[3];

ou bien
char *ptr;
ptr = (char *) MyFloat;
DATA = *(ptr++);
DATA = *(ptr++);
DATA = *(ptr++);
DATA = *ptr;

[Seb.26]

Pour enregistrer tes x variables, plusieurs solution, des bonnes et des moins bonnes ...

AMA les moins bonnes, c'est de tout faire à la main, bonjour la galère, et le code inutile ...

Une autre solution pas trop mal, c'est de te faire une fonction :

SaveIntoEEPROM( uChar *dataAdr, uChar dataLen, uChar destAdr );

NB: "uChar = unsigned char" chez moi ...

Et tu appelle la fonction :

...
float f1;
...

{
 int adr = 0;
 SaveIntoEEPROM((uChar*)&f1, sizeof(f1), adr);
 adr += sizeof(f1);
}

Pour rendre le tout un peu mieux, tu peux inclure l'adr de dest dans le module de SaveIntoEEPROM() et l'auto incrémenter ... Ajoute alors un fonction Init_SaveIntoEEPROM() qui remet à 0 l'adr, et utilise toujours le même ordre pour tes variables.

De la même façon, fais toi des fonction de lecture float_ReadFromEEPROM(), int_ReadFromEEPROM().

Malheureusement pour toi, le C n'autorise (sauf erreur de ma part) pas la différenciation de fonction par le type de retour, donc tu dois mettre un préfixe avec le type.

Une solution un poil plus "belle" c'est de te faire un tableau de structure avec un pointeur ( void* ) et une longueur, comme ça, tu n'as plus qu'une fonction "Load" et une "Save" ... et un tableau unique pour définir quelle variables sont enregsitrées/chargées ...

[freepicbasic]

 void SaveIntoEEPROM((uChar*) ptr, char len, char adr)
{
char i;
for (i=0;i<len;i++) {
    writeEEPROM ( adr,  *ptr);
    ptr++;
    }

}

[Seb.26]

 void SaveIntoEEPROM( uChar *ptr, char len, char adr)
{
char i;
for (i=0;i<len;i++) {
    writeEEPROM ( adr,  *ptr);
    ptr++;
    }

}

C'est pour moi plus "correct" ...
( Ton code fonctionnait parfaitement )

[jorg1n]

Je vous remercie, mais je voudrais mieux comprendre.
Si j'ai une valeur, par exemple toto qui est un short int, qui vaut 25, et je souhaite la stocké en EEPROM, je dois d'abord la convertir en char pour ensuite la stocker, je ne me trompe pas?? donc ma variable toto qui vaut 25 sera stocké en EEPROM sous forme de 2 char (2 octets)?

Ensuite je n'ai pas trop compris le principe avec le float?es ce que je garde la virgule? comment je viens relire la variable? dois je convertir le float en char avant?je suis un peu perdu...

Sinon, j'ai réalisé un tableau avec la liste de mes variables a stocké, avec leur adresses, si vous pouviez me dire ce que vous en pensez, et si le principe est bon (J'ai fixé les adresses en fonction de la taille de la variable et j'ai laissé 1 octet libre entre chaque donnée)
Je vous remerci d'avance

[Seb.26]

Ensuite je n'ai pas trop compris le principe avec le float?es ce que je garde la virgule? comment je viens relire la variable? dois je convertir le float en char avant?

Quel que soit le type de ta variable, elle n'en reste pas moins que 'x' octet(s) en RAM, tout comme un char d'ailleurs ...

Donc si tu lis les x octets qui composent ta variable (via son adresse), ou que tu les écris, et bien tu accède à ta variable sous la forme d'un tableau de x octets.
Evidement, modifier 'intelligemment' une variable demande de connaitre son format en RAM ... Mais ce n'est pas ton besoin, si enregistrer et recharger une variable te suffit, il faut juste veiller à remettre les octets dans le bon ordre : celui dans lequel tu les as trouvés !

je suis un peu perdu...

En effet ...

j'ai laissé 1 octet libre entre chaque donnée

Pourquoi faire ???

[jorg1n]

Bonjour,

après vérification, j'ai besoin de beaucoup plus d'espace, alors il faut que mes adresses soient supérieures à 0xFF, donc voila maintenant mes commandes, qu'en pensez vous??

/***************************************************************
Nom   : void writeEEPROM ( int addr, char data);
Role  : Ecrire dans l'EEPROM
****************************************************************/
void writeEEPROM ( int addr, char data)
{
  static unsigned char GIE_Status;
  EEADR=((addr)&0xff);	// Extraction des 8 bits faible de addr et les placent dans EEADR
  EEADRH=((addr)>>8);	// Extraction des 8 bits fort de addr et les placent dans EEADRH
  EEDATA = data;			// Data to be written in EEPROM
  EECON1bits.EEPGD = 0;		        // Enable EEPROM write
  EECON1bits.CFGS = 0;		        // Enable EEPROM write
  EECON1bits.WREN = 1;		        // Enable EEPROM write

  GIE_Status = INTCONbits.GIE;          //Save global interrupt enable bit
  INTCONbits.GIE=0;                     //Disable global interrupts

  EECON2 = 0x55;			// Required sequence to start write cycle
  EECON2 = 0xAA;			// Required sequence to start write cycle
  EECON1bits.WR = 1;		// Required sequence to start write cycle
  while(EECONbits.WR);		// Wait for completion of write sequence

  INTCONbits.GIE=GIE_Status;      //Restore the original global interrupt status

  PIR2bits.EEIF = 0;		//Disable EEPROM write
  EECON1bits.WREN = 0;		//Disable EEPROM write
}



/***************************************************************
Nom   : char readEEPROM ( int addr );
Role  : Lire une valeur dans l'EEPROM
****************************************************************/
char readEEPROM ( int addr )
{
  EEADR=((addr)&0xff);	// Extraction des 8 bits faible de addr et les placent dans EEADR
  EEADRH=((addr)>>8);	// Extraction des 8 bits fort de addr et les placent dans EEADRH	
  EECON1bits.EEPGD = 0;		// Enable Read sequence
  EECON1bits.CFGS = 0;		// Enable Read sequence
  EECON1bits.RD = 1;		// Enable Read sequence

data = EEDATA;
return data;

}

Merci d'avance

[Seb.26]

ça a l'air pas mal vu d'ici ...

ça marche ?

Avis 100% perso : << Le int c'est le mal >> ... Tu as besoin de 16b, donc utilise un short ... il est là pour ça ...

[jorg1n]

Je te remercie,

par contre, si j'écris :

  EEADR=(addr);	        // Extraction des 8 bits faible de addr et les placent dans EEADR
  EEADRH=((addr)>>8);	// Extraction des 8 bits fort de addr et les placent dans EEADRH

ça revient au même??

Et comme je le disais un peut plus haut, je souhaite fixer moi même les adresses des variables, mais je souhaiterai avoir une confirmation, que ce soit un int ou un float au départ, on converti la data en char, donc au final ça prendra que 1 octet par variables??
merci encore

[Seb.26]

par contre, si j'écris :

  EEADR=(addr);	        // Extraction des 8 bits faible de addr et les placent dans EEADR
  EEADRH=((addr)>>8);	// Extraction des 8 bits fort de addr et les placent dans EEADRH

ça revient au même??

Oui, normalement :

EEADR=((addr)&0xff);
EEADRH=((addr)>>8);

Est équivalent à :

EEADR = addr;
EEADRH = addr>>8;

Avec le second, tu auras peut être un Warning car tu mets un 16b dans un 8b ... ajoute un cast et ça roule.
( même si je pense qu'en fait ton compilo génèrera exactement le même code ... s'il est malin, il ne fera pas ton "((addr)&0xff)" )

Et comme je le disais un peut plus haut, je souhaite fixer moi même les adresses des variables, mais je souhaiterai avoir une confirmation, que ce soit un int ou un float au départ, on converti la data en char, donc au final ça prendra que 1 octet par variables??
merci encore

Tu vas tout convertir en char ???

T'es sûr que c'est ce que tu veux ???

[jorg1n]

Tu vas tout convertir en char ???

T'es sûr que c'est ce que tu veux ???

En fait, durant mon fonctionnement , j'ai des variables de types int et float, et je pensais les convertir en char pour le stockage en EEPROM, as tu une autre solution à me proposer?? je n'ai peut etre pas choisi la bonne...
au niveau taille mémoire, c'est une 1024.

Merci pour tes conseils...

[Seb.26]

Le truc, c'est que convertir un int ( quel taille ça fait un int dans ton compilo ? ) en char, ça fait du dégat !!! ... idem pour un float ...

[jorg1n]

ça fait du dégat !!!

Comment ça??
En ce qui concerne la taille d'un int dans mon compilateur (PIC18 de IAR), je ne sais pas du tout, mais ça doit être 4 octets...
Comment me conseilles tu de réaliser mon stockage en EEPROM??
Merc id'avance

[Seb.26]

Comment ça??

Bah si t'as un long qui vaut 0x12345678, quand tu le place dans un char, il devient 0xFF ou 0x12, ou 0x78 ... tu as un peu perdu toutes tes données ...

Pour le int ... en gros, tu ne sais pas la taille de la variable, mais tu l'utilise sans te poser de questions ... original ...
<< Le int c'est le mal !!! >>

[Seb.26]

Comment me conseilles tu de réaliser mon stockage en EEPROM??

Bah tu écris tes variables dans ton eeprom, sans les modifier ... normalement quoi ... revois le début du post, il me semble qu'on t'avais filé des routines ...

[jorg1n]

J'ai regardé dans la documentation de mon compilateur :
signed short 16 bits -32768 to 32767
unsigned short 16 bits 0 to 65535
signed int 16 bits -32768 to 32767
unsigned int 16 bits 0 to 65535
Donc 2 octets...autant pour moi...

[Seb.26]

J'ai regardé dans la documentation de mon compilateur :
signed short 16 bits -32768 to 32767
unsigned short 16 bits 0 to 65535
signed int 16 bits -32768 to 32767
unsigned int 16 bits 0 to 65535
Donc 2 octets...autant pour moi...

C'est pour ça que je dis que le int c'est le mal ... sa taille est fonction du compilateur et de la cible ... rien de tel pour faire des bugs ou pour gaspiller de la RAM ...

[jorg1n]

Mes int ne monteront pas au dessus de 16 bits donc 2 octets, soit déclaré en tant que signed short : -32768 à 32767.
et en ce qui concerne mes floats, là c'est 32 bits donc 4 octets...

[jorg1n]

Au final, le problème est...
comment stocké un int en EEPROM et un float en EEPROM, sachant que j'ai de la place?
Car après RE étude de la documentation du PIC, EEDATA est un mot de 8bits, donc comment est il possible d'enregistrer des mots de 16bits ou plus??
J'ai trouvé ce lien là...puis je partir de là ??
http://www.cfdev.fr/softmicro.html#EEPROM
Merci d'avance pour votre aide

[Seb.26]

On t'a déjà donné la méthode en début de post ...