Guardar un float en eeprom interna del PIC en C18

[ESTECA55]

Hola muchachos, resulta que quiero guardar un dato que esta en float (32bit) en la eeprom interna del pic, y no se como hacerlo, siempre había guardado un dato tipo char de solo 8 bit utilizando el código que recomienda el manual del C18:

void escribirEEPROM (char dir, char dat)
{
    EECON1bits.EEPGD = 0;   /* WRITE step #1 */
     EECON1bits.WREN = 1;    /* WRITE step #2 */
     EEADR = dir;            /* WRITE step #3 */
     EEDATA = dat;          /* WRITE step #4 */
     EECON2 = 0x55;          /* WRITE step #5 */
     EECON2 = 0xaa;          /* WRITE step #6 */
     EECON1bits.WR = 1;      /* WRITE step #7 */
     while (!PIR2bits.EEIF)  /* WRITE step #8 */
    ;
     PIR2bits.EEIF = 0;      /* WRITE step #9 */
}

lo puse dentro de una función.

Con eso no tuve problema, pero ahora con los 32 bit se me complico, no abra alguna función ya hecha para esto o me tengo que poner a desarmar el dato y guardarlo utilizando 4 veces esta función.

Por cierto estoy utilizando el compilador C18 de microcip.

O al menos, como lo hacen en algún otro compilador de C como CCS, en una de esas puedo sacar la idea de ahi.
Saludos

[MGLSOFT]

Ya tienes un Byte para guardar en eeprom..

El resto es guardar en 4 bytes consecutivos los 4 bytes consecutivos del dato float.

Al leerlos hay que volver a cargarlos en ese orden...

Pregunta:
Porque hacer una funcion para leer un byte si C18 ya la tiene??
En C:\MCC18\src\pmc_common\EEP hay tres funciones listas para usar, llamadas busy_eep, read_b y write_b.

Estan listas para leer o escribir un byte...

[ESTECA55]

hola marcos!!!!

Gracias por el dato.

Se nota que soy nuevo en el C18 jajaja Busque las funciones esas que me imagine que estaban y no las encontre, asi que improvise!!!

Ahora me pongo con eso, voy a ver como desagrupar el float!!

Saludos

[jhonastad]

Hola ESTECA55 yo tambien estoy guardando datos tipo float en una eeprom, pero uso 16f877a no se si sea lo mismo que con una 18 pero te envio el codigo por si te seirve saludos.

Código: [Seleccionar]

int16 escribe_eeprom(int16 address, float data){                                             
   
  byte buffer[sizeof(float)];  
  byte index;

  memcpy(buffer, &data, sizeof(float));
 
  for (index = 0; index < sizeof(float); index++)
        write_eeprom(address++, buffer[index]);

  return(address);
}                                                                                             
//_____________________________________________________________________________________________
float lee_eeprom(int16 address){                                                               

byte buffer[sizeof(float)];
float temp;
byte index;

address = address - 4;

for (index = 0; index < sizeof(float); index++)
        buffer[index] = read_eeprom(address++);   

memcpy(&temp, buffer, sizeof(float));
 
return(temp);
}

[ESTECA55]

Gracias por el dato!

Al final use una estructura, buscando en el foro encontré que maunix hace un tiempo comento este método, paso a describir:

Declaración de la estructura:

Código: [Seleccionar]

typedef union integer16 {
  struct {
     unsigned unsigned char byteLow;
     unsigned unsigned char byteHigh;
  };
  unsigned unsigned int value;
};
Luego declaro las variables que quiero utilizar con esa estructura:

Código: [Seleccionar]

union integer16 var0;

union integer16 var1;
Y por ultimo un ejemplo de como utilizarlo:

Código: [Seleccionar]

var1.value = 65535 - (promedio/20); // accedo al int de 16 bit

TMR0H=var1.byteHigh; // Copio la parte Alta el int16
TMR0L=var1.byteLow;  // Copio la parte Baja el int16

// para guardarlo en la eeprom de manera similar:

Write_b_eep(10,var1.byteHigh);
Write_b_eep(11,var1.byteLow);
Es muy interesante y cómodo esto de las estructuras, ocupa muy poco código, ya que lo que hace la estructura es darle dos nombre a los byte de la ram, o sea supongamos que lo declaramos en la posición 0, la 0 se llama var1.byteHigh, la 1 var1.byteLoy y las dos juntas formando el int se llaman var1.value.

Saludos