Programmation en C

[Jack52]

Hello,

Je cherche à écrire un float dans l'eeprom de mon pic 16f877a !
Pour ce faire j'ai le programme ci-dessous:

void ecrire(int ref_temp)
{
	WERR = 0;
	WR = 0;
	EEIF = 0;
	EEADR = adr;
	EEDATA = ref_temp;
	EEPGD = 0; 
	GIE = 0;
	WREN = 1;
	EECON2 = 0b01010101;
	EECON2 = 0b10101010;
	WR = 1;
	while(WR==1)
	{
	}
	WREN = 0; 
}

Le problème c'est que le float fait 4 octets, donc je pense que c'est à cause de sa que ça bloque !

Auriez vous une idée ??

Merci d'avance !
-----

[micka_ch]

Salut,

Si tu as des fonctions pour lire et écrire un octet dans ton EEPROM tu peux t'inspirer du code suivant :

//Ecriture d'un float de 32 bits (4 octets) dans l'EEPROM
void EEPROM_write_float(unsigned int aStartAddress,float *aPointer)
{      
        char i;
        char *aTempPointer=(char *)aPointer;           
        
        for(i=0;i<4;i++)
        {
            EEPROM_write(aStartAddress+i,*aTempPointer);
            aTempPointer++;    
        }
        
}
  
//Lecture d'un float de 32 bits (4 octets) dans l'EEPROM
float EEPROM_read_float(unsigned int aStartAddress)
{
        float aReturnValue=0;
        char *aTempPointer=(char *)&aReturnValue;
        char i;
        
        for(i=0;i<4;i++)
        {
            *aTempPointer=EEPROM_read(aStartAddress+i);
            aTempPointer++;    
        }
           
        return aReturnValue;
}

Meilleurs salutations

[Jack52]

Merci de ta réponse,

Mais je ne me suis pas encore intéressé au pointeur !
Vu que mon float vaut "x,xxx", je vais le multiplier par 1000 pour le mettre dans un long !
Je pourrais ensuite le décaler pour récuperer 2 int ^^

Méthode barbare @:

Merci beaucoup

[Tryph]

Salut,

je crains que ça ne suffise pas à résoudre ton problème.
un int est codé sur 2 octets et il va donc falloir décomposer ton long en 4 chars en fait.

c'est ni plus ni moins que ce que fait le code que t'a copié micka_ch.
si tu n'as pas encore étudié les pointeurs, je te conseille plutôt de t'y mettre. c'est un concept que certains ont un peu de mal à comprendre, mais avec quelques bons tuto et des exemples, on fini par s'y faire et ça rend de très nombreux services.

[A voir en vidéo sur Futura]

[Jack52]

Bonjour à vous,

Je vais donc me lancer dans le pointage

Petite question avec le programme de Micka_CH comment dois-je déclarer ma sous fonction "ecrire" :

void ecrire(????, ?????)

Comme sa :

void ecrire(int adr, *point)

??

Merci d'avance

[micka_ch]

Salut,

Les paramètres de la fonction EEPROM_write sont :
- L'adresse de l'EEPROM en int où l'on veut écrire la donnée
- La donnée en unsigned char

Pour ma part j'utilise un microcontroleur AT90CAN128 de chez Atmel mes fonctions EEPROM_write et EEPROM_read sont codé de la manière suivante :

void EEPROM_write (unsigned int uiAddress, unsigned char ucData)
{
    /* Wait for completion of previous write */
    while(EECR & (1<<EEWE));
    /* Set up address and data registers */
    EEAR = uiAddress;
    EEDR = ucData;
    /* Write logical one to EEMWE */
    EECR |= (1<<EEMWE);
    /* Start eeprom write by setting EEWE */
    EECR |= (1<<EEWE);
}

unsigned char EEPROM_read(unsigned int uiAddress)
{
   /* Wait for completion of previous write */
   while(EECR & (1<<EEWE));
   /* Set up address register */
   EEAR = uiAddress;
   /* Start eeprom read by writing EERE */
   EECR |= (1<<EERE);
   /* Return data from data register */
   return EEDR;
}

Le code dépend du process d'écriture/lecture et des registres propres à l'EEPROM (voir le datasheet de ton uC).

Salutations

[Jack52]

Merci bien,

Je test sa de suite avec mon pic !

[Jack52]

Après 1h, toujours rien de bien satisfaisant : en moyenne 15 erreures par ligne de prog !

Merci Microchip et Mplab !

[micka_ch]

Salut,

J'ai écris un petit programme en C, avec CodeBlock IDE et MinGW comme compilateur, pour te montrer comment on utilise ces fonctions.

Voici le code :

#include <stdio.h>
#include <stdlib.h>


//Tableau de bytes pour simuler une EEPROM de 128 bytes
unsigned char EEPROM[128];

//Ecriture d'une donnée dans l'EEPROM
void EEPROM_write(unsigned int aAddress,unsigned char aData)
{
    EEPROM[aAddress]=aData;
}

//Lecture d'une donnée de l'EEPROM
unsigned char EEPROM_read(unsigned int aAddress)
{
    return EEPROM[aAddress];
}

//Ecriture d'un float de 32 bits (4 octets) dans l'EEPROM
void EEPROM_write_float(unsigned int aStartAddress,float *aPointer)
{
        char i;
        char *aTempPointer=(char *)aPointer;

        for(i=0;i<4;i++)
        {
            EEPROM_write(aStartAddress+i,*aTempPointer);
            aTempPointer++;
        }

}

//Lecture d'un float de 32 bits (4 octets) dans l'EEPROM
float EEPROM_read_float(unsigned int aStartAddress)
{
        float aReturnValue=0;
        char *aTempPointer=(char *)&aReturnValue;
        char i;

        for(i=0;i<4;i++)
        {
            *aTempPointer=EEPROM_read(aStartAddress+i);
            aTempPointer++;
        }

        return aReturnValue;
}

//Test des fonctions
int main()
{
    float FloatToSave=0.0,ReadFloat=0.0;
    int i,Adresse;

    for(i=0;i<32;i++)
    {
        //Calcul de l'adresse
        Adresse=(i*4);

        //Génération d'un float aléatoire
        FloatToSave=((float)(rand()))/((float)(rand()));

        //Affichage de la valeur sauvgardé
        printf("Valeur sauvgrade a l'adresse %d : %f\n",Adresse,FloatToSave);

        //Sauvgarde de la valeur
        EEPROM_write_float(Adresse,&FloatToSave);

        //Lecture de la valeur
        ReadFloat=EEPROM_read_float(Adresse);

        //Affichage de la valeur sauvgardé
        printf("Valeur lue a l'adresse       %d : %f\n",Adresse,ReadFloat);

        //Test si les 2 valeurs sont égales
        if(ReadFloat==FloatToSave)
        {
            printf("************* TEST n %d OK ****************\n\n",i+1);
        }
        else
        {
            printf("************* TEST n %d KO ****************\n\n",i+1);
        }

    }

    return 0;
}

Un aperçu de ce qui est imprimé dans le terminal windows est en pièce jointe.

Une chose a faire attention avec la fonction EEPROM_write_float() , on doit passé un int et un pointeur sur un float. Si t'a variable est de type :

float temperature=21.42;

Tu doit récupérer le pointeur associé a cette variable avec le caractère '&' devant :

EEPROM_write_float(Adresse, &temperature);

En espérant que cela puisse t'aider.

A+