[PIC] Utilisation de l'EEPROM

[invite3c35244f]

Bonjour tout le monde...
bon, je crois que je vais essayé de faire un exemple bien précis avec ceux que vous m'avez donné en début de post..
Bonne journée à tous

PS: que penses tu du lien ...
-----

[Seb.26]

PS: que penses tu du lien ...

ça devrait marcher, mais c'est dommage de te limiter aux int ... utilise plutôt un (char*) ... ce sera générique et plus petit comme code ...

J'aurais bien vu un truc comme ça :

void SaveIntoEEPROM( uShort adr, uChar *ptr, uChar len )
{
  while( len-- )
  {
    writeEEPROM ( adr++,  *ptr++ );
  }
}

...

{
  float toto;
  ...
  SaveIntoEEPROM( 0x103, (uChar*)&toto, sizeof(toto) );
  ...
}

Il faut vraiment tout te faire !!!

[invite3c35244f]

Je te remercie...

Je vais écrire toutes mes fonctions au propre et je les post...

[Seb.26]

Je te remercie...

de nada

Je vais écrire toutes mes fonctions au propre et je les
post...

Bah, ça y est, t'as tout, non ? ... à la limite, il te manque le ReadFromEEPROM() ... mais je te le laisse celui là ...

[invite3c35244f]

Voila donc mes 2 fonctions "d'écriture":

/***************************************************************
Nom   : void writeEEPROM ( int addr, char data);
Role  : Ecrire dans l'EEPROM
****************************************************************/
void writeEEPROM ( unsigned short addr, char data)
{
  static unsigned char GIE_Status;
  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
  EEDATA = data;	        // Data to be written in EEPROM
  EEPGD = 0;		        // Access data EEPROM memory
  CFGS = 0;		        // Access Flash program or data EEPROM memory
  WREN = 1;		        // Allows write cycles to Flash program/data EEPROM

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

  EECON2 = 0x55;			// Required sequence to start write cycle
  EECON2 = 0xAA;			// Required sequence to start write cycle
  WR = 1;		                // Initiates a data EEPROM erase/write cycle
  while(WR);		                // Wait for completion of write sequence

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

  EEIF = 0;		//The write operation is not complete or has not been started
  WREN = 0;		//Inhibits write cycles to Flash program/data EEPROM
}

/***************************************************************
Nom   : SaveIntoEEPROM (unsigned short addr, unsigned char *ptr,  unsigned char dataLen)
Role  : Ecrire dans l'EEPROM 
****************************************************************/
void SaveIntoEEPROM (unsigned short addr, unsigned char *ptr,  unsigned char dataLen)
{
  while (dataLen--)
    {
      writeEEPROM ( addr++, *ptr++);
    }
}

et voila son utilisation:

float MyFloat;
{
MyFloat = 25.52;
...
SaveIntoEEPROM (0x100, (unsigned char *)&MyFloat,  sizeof(MyFloat));
...
}

Par contre dans ma fonction writeEEPROM, comment je "modifie la data", je la remplace par *ptr? (j'ai un peu de mal avec les pointeur je crois...)
merci encore de ton aide Seb.26

[invite3c35244f]

Et j'ai jeté un oeil pour venir lire...sachant que l'on connait le tpe de varible que l'on vient lire, on peut faire de même:

ReadIntoEEPROM (unsigned short addr, unsigned dataLen)
{
 while(dataLen--)
   {
     readEEPROM (addr++);
   }
}

exemple si je veut lire la valeur de MyFloat:

ReadIntoEEPROM(0x100, sizeof(MyFloat));

Par contre, comment stocké après lecture l'ensemble des valeur lu dans la boucle while?
Merci encore

[invite6a878e16]

Je ferais quelque chose du genre:

Une fonction pour lire un octet

/* lecture d'un octet */
uChar Read_eeprom( uChar Adresse )
{
	
	EEADR = Adresse;			//pointe l'adresse souhaitée
	EECON1 = EECON1 & 0x3F;	// CFGS = 0: donne accès à l'EEPROM
	
	EECON1bits.RD = 1;			//lance la lecture
	return EEDATA;				// renvoie la donnée

}

Et une 2e pour lire une chaîne qui transmet l'information grâce à un pointeur:

void Read_string_eeprom(uShort addr, uChar dataLen, uChar *String )
{
 while(dataLen--)
   {
     *String++ = Read_eeprom (addr++);
   }
}

(j'ai mis uChar dataLen, mais si tu veux pour pouvoir lire toute l'EEPROM d'un coup, il faudrait uShort dataLen. ça serait gourmand en RAM...)

String est un pointeur. Il contient l'adresse mémoire de la variable qui va stocke les données en RAM. (Place de la donnée)
Quand on fait String++, on incrémente l'adresse. En clair on se déplace dans la mémoire RAM (on va à la case suivante)

Quand on met *String, c'est pour accéder au contenu de l'adresse pointée par String. ( adressage indirect )

Quand on met, *String++ = Read_eeprom (addr++);:
1) Read_eeprom retourne la donnée lue
2) on place cette donnée en RAM à l'endroit indiqué par String avec *String (l'étoile signifie qu'on modifie le contenu à l'adresse indiquée, sans l'étoile ça on changerait d'adresse)
3) on modifie l'adresse. On passe à la case suivante avec le ++. (le ++ intervient en dernier)

Utilisation:

float Nb_virgule;
uChar Petit_entier;

Petit_entier = Read_eeprom( Adresse: un nombre ou une variable pour indiquer l'adresse );
Read_string_eeprom( Adresse, sizeof( Nb_virgule ), &Nb_virgule );

Nb_virgule est une variable toute simple. Quand on met Nb_virgule, on obtient une valeur. &Nb_virgule permet de donner l'adresse où est stocké (le début de) la valeur.

[Seb.26]

Mouais ... bof-bof ...

void ReadIntoEEPROM( uShort addr, uChar dataLen, uChar* pDest )
{
  while(dataLen--)
  {
    *pDest++ = readEEPROM( addr++ );
  }
}

Pour l'utiliser :

float toto;
ReadIntoEEPROM( 0x1234, sizeof(toto), (uChar*)&toto );

[invite3c35244f]

Bonjour tout le monde...

je vous remercie pour vos conseils...par contre, je me pose toujours une question, dois je réaliser une conversion de type après la lecture de l'EEPROM??
exemple:

 
Float tension_seuil;
ReadIntoEEPROM ( 0x00, sizeof(tension_seuil), (unsigned char*)&ftension_seuil );
if (tension_seuil >= 13.5)
{...
}

et ma deuxième question, puis je utiliser ces fonctions (ReadIntoEEPROM et SaveIntoEEPROM) avec n'importe quel type de variables?

Merci encore
Bonne journée à tous..

[invite6a878e16]

Ben si tu relis bien tout le sujet, oui tu peux utiliser ces fonctions pour n'importe quel type de variable. (d'où l'importance d'ailleurs du transtypage que j'ai oublié dans l'utilisation de Read_string_eeprom)


PS: ta question énerve un peu. On a l'impression que tu as attendu qu'on te file tout sans chercher à comprendre. Par contre si tu n'as pas compris les pointeurs, cherche des tutos, des bouquins, pose des questions parce que sinon tu vas vraiment galérer

[invite3c35244f]

Bonjour Agahaz,

je suis désolé si ma question t'énerve...c'est vrai que j'en pose pas mal et que souvent j'ai les mêmes réponses, car je lis mal les précédentes mais ce n'était pas le but...
C'est vrai que je suis débutant en programmation, et que j'ai quelques lacunes et parfois je cherche plus souvent la réponse par le biais du forum qu'en recherchant dans des tutos...mais je crois que je vais devoir mettre le nez dedans pour les pointeurs...
Par contre:

On a l'impression que tu as attendu qu'on te file tout sans chercher à comprendre.

Avant de vous demander, j'avais déja fais des recherches sur le stockage en EEPROM, mais j'ai eu bcp de mal à l'adapter à mon utilisation, à cause de mon manque de connaissances, j'en suis conscient...c'est pour ça que je vous remercie.
Bonne fin de journée

[Seb.26]

je vous remercie pour vos conseils...par contre, je me pose toujours une question, dois je réaliser une conversion de type après la lecture de l'EEPROM??

ça fait un moment que je te dis de lire des cours de C, car visiblement tu as pas mal de lacunes sur certains points en effet ...

Et là tu as besoin de jouer avec les pointeur ... ce qui n'est pas forcement simple ...

... en gros :

Toute variable est en fait un ou plusieurs octets en RAM ( uChar = 1 octet, uSort = 2 ... )

Si pour une raison ou une autre, ces octets sont modifiés, c'est alors ta variable qui est modifiée (logique).

L'arithmétique des pointeur est un des sports les plus sympa en C ... là, on utilise &toto ( le '&' ) pour dire que l'on souhaite obtenir l'adresse en RAM des octets de la variable toto qui est un float par exemple ...

Mais nos fonctions Read/Write accepte un pointeur d'octets (uChar*) comme paramètre ... on dit donc au compilo que l'on sait ce que l'on fait : on force le cast : "(uchar*)&toto"

Important :

L'unité d'un pointeur n'est pas l'octet, mais la taille du type pointé.
Un tableau est un pointeur.

uShort buffer[2];
uShort *pTiti;
uChar *pTutu;

//pTutu = buffer; // Error : type mismatch in assignment
pTiti = buffer;
pTutu = (uChar*)buffer;

*pTiti = 0xFFFF;
*pTutu = 0x00;

pTiti++;
pTutu++;

*pTiti = 0x5555;
*pTutu = 0x77;

à la fin de ce code :
buffer[0] == 0x0077
buffer[1] == 0x5555