Guardar datos EEPROM (float)

[blackburne44]

Hola, quisiera poder guardar un float en la memoria EEPROM interna de un pic 16f887, para despues poderlo mandar por rs-232. 

[Suky]

Utiliza el buscador del foro, el tema ya se ha tratado en varias oportunidades.

[blackburne44]

Hola Suky, me he fijado en los otros post, pero no he entendido bien:

La funcion write_eeprom(adress,value) guardaria un valor de 8 bits no?

[MerLiNz]

si, si sabes que un float tiene 32bits, tendrias que hacer 4 grabaciones y 4 lecturas para cargarlo, para convertir los 32bits a 8 tienes varias opciones, punteros, uniones, desplazamiento de bits, alguna funcion...

el desplazamiento de bits seria

variable>>24;
variable>>16;
variable>>8;
variable;

ya a tu gusto si quieres guardar del bit mas alto al bit mas bajo o  al contrario.

[blackburne44]

Gracias MerLinZ, por la ayuda. Mira, encontre una libreria en internet que tiene la funcion write_float_eeprom().
A continuacion dejo la libreria:

////////////////////////////////////////////////////////////////////////////////
////                          Lib_Int_EEProm.c                              ////
////////////////////////////////////////////////////////////////////////////////
////                                                                        ////
////   void write_int1_eeprom(address, int8 bitPosition, int1 data)         ////
////     Call to write one bit of data                                      ////
////                                                                        ////
////   int1 read_int1_eeprom(address, int8 bitPosition)                     ////
////     Call to read one bit of data                                       ////
////                                                                        ////
////   void write_int16_eeprom(address, int16 data)                         ////
////     Call to write a 16 bit integer                                     ////
////                                                                        ////
////   int16 read_int16_eeprom(address)                                     ////
////     Call to read a 16 bit integer                                      ////
////                                                                        ////
////   void write_int32_eeprom(address, int32 data)                         ////
////     Call to write a 32 bit integer                                     ////
////                                                                        ////
////   int32 read_int32_eeprom(address)                                     ////
////     Call to read a 32 bit integer                                      ////
////                                                                        ////
////   void write_float_eeprom(address, float data)                         ////
////     Call to write a floating point number                              ////
////                                                                        ////
////   float read_float_eeprom(address)                                     ////
////     Call to read a floating point number                               ////
////                                                                        ////
////////////////////////////////////////////////////////////////////////////////

#ifndef INTERNAL_EEPROM_UTILITIES
#define INTERNAL_EEPROM_UTILITIES

// Used to adjust the address range
#ifndef INT_EEPROM_ADDRESS
#define INT_EEPROM_ADDRESS  int8
#endif

////////////////////////////////////////////////////////////////////////////////
//// Internal EEPROM Functions
////////////////////////////////////////////////////////////////////////////////

// Purpose:    Write one bit to internal eeprom --------------------------------
// Inputs:     1) An eeprom address
//             2) The bit position (LSB == 0)
//             3) The bit to write
// Outputs:    None

void write_int1_eeprom(INT_EEPROM_ADDRESS address, int8 bitPosition, int1 data){

   int8 stored_data;

   stored_data = read_eeprom(address);

   if(data){
      bit_set(stored_data, bitPosition);
   }else{
      bit_clear(stored_data, bitPosition);
   }
   write_eeprom(address, stored_data);
}


// Purpose:    Read one bit from internal eeprom -------------------------------
// Inputs:     1) An eeprom address
//             2) The bit position (LSB == 0)
// Outputs:    The bit read from internal eeprom

int1 read_int1_eeprom(INT_EEPROM_ADDRESS address, int8 bitPosition){

   return bit_test(read_eeprom(address), bitPosition);
}


// Purpose:    Write a 16 bit number to internal eeprom ------------------------
// Inputs:     1) An eeprom address
//             2) The 16 bit number to write to internal eeprom
// Outputs:    None

void write_int16_eeprom(INT_EEPROM_ADDRESS address, int16 data){

   int8 i;

   for(i = 0; i < 2; ++i){
     write_eeprom(address + i,*(&data + i));
   }
}


// Purpose:    Read a 16 bit number from internal eeprom -----------------------
// Inputs:     An eeprom address
// Outputs:    The 16 bit number read from internal eeprom

int16 read_int16_eeprom(INT_EEPROM_ADDRESS address){

   int8  i;
   int16 data;

   for(i = 0; i < 2; ++i){
     *(&data + i) = read_eeprom(address + i);
   }
   return(data);
}


// Purpose:    Write a 32 bit integer to internal eeprom -----------------------
// Inputs:     1) An eeprom address
//             2) The 32 bit number to write to internal eeprom
// Outputs:    None

void write_int32_eeprom(INT_EEPROM_ADDRESS address, int32 data){

   int8 i;

   for(i = 0; i < 4; ++i){
     write_eeprom(address + i,*(&data + i));
   }
}


// Purpose:    Read a 32 bit integer from internal eeprom ----------------------
// Inputs:     An eeprom address
// Outputs:    The 32 bit integer read from internal eeprom

int32 read_int32_eeprom(INT_EEPROM_ADDRESS address){

   int8  i;
   int32 data;

   for(i = 0; i < 4; ++i){
     *(&data + i) = read_eeprom(address + i);
   }
   return data;
}


// Purpose:    Write a floating point number to internal eeprom ----------------
// Inputs:     1) An eeprom address. Four eeprom locations will be used.
//             2) The floating point number to write to internal eeprom
// Outputs:    None

#separate
void write_float_eeprom(INT_EEPROM_ADDRESS address, float data){

   int8 i;

   for(i = 0; i < 4; ++i){
     write_eeprom(address + i,*(&data + i));
   }
}


// Purpose:    Read a floating point number from internal eeprom ---------------
// Inputs:     An eeprom address
// Outputs:    The floating point number read from the internal eeprom

#separate
float read_float_eeprom(INT_EEPROM_ADDRESS address){

   int8 i;
   float data;

   for(i = 0; i < 4; ++i){
     *(&data + i) = read_eeprom(address + i);
   }
   return data;
}

#endif

Mi programa:

#include <Test.h>
#include <HDM64GS12.c>
#include <graphics_1.c>
#include <1wire.c>
#include <ds1820.c>
#include <lib_int_eeprom.c>

int8 Pro[]= "PROYECTO";
int8 Ter[]= "TERMOMETRO";
float temperatura_antigua ;
float temperatura_nueva ;
char palabra [16];

void main()
{
  setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
 
  glcd_init(ON);
  delay_ms(20);
  glcd_rect(10,10,110,58,no,on);
  glcd_rect(18,18,68,28,no,on);
  glcd_rect(38,38,100,48,no,on);
  glcd_text57(20,20,Pro,1,on);
  glcd_text57(40,40,Ter,1,on);
  delay_ms(1500);
  glcd_fillScreen(0);
  glcd_rect(10,25,110,42,no,on);
 
while (1) {

  temperatura_nueva = ds1820_read ();                      // Se vuelve a leer el sensor y este valor se escribe
                                                           // en una nueva variable

if (temperatura_nueva != temperatura_antigua){             // Se compara la temperatura vieja con la nueva
  glcd_rect(50,30,105,40,yes,OFF);                          // Se borra la temperatura vieja
  sprintf(palabra,"TEMP = %3.1f &C",temperatura_nueva);    // Se vuelve a crear un array de valores
  glcd_text57(15, 30,palabra, 1, ON);
  temperatura_antigua = temperatura_nueva ;
  }
  }
  write_float_eeprom(00, temperatura_nueva);
  }

El problema es que, haciendo la simulacion en proteus, no logro ver si realmente se esta escribiendo la eeprom del pic. Mi pregunta seria, como hacer para verlo, y si alguien nota algun problema en el programa, si me podria ayudar. Gracias

[MGLSOFT]

Las memorias eeprom internas o externas no tienen duración infinita, deberás ver cuando grabarlas y utilizarlas a conciencia, sino vas a tener varias posiciones de memoria menos a la vuelta de un tiempo de uso.
Si es interna al PIC, significa cambio del PIC, y si es externa, el cambio de la memoria externa.
Revisalo en tu programa si es absolutamente necesario grabar siempre o en el momento que el pic se queda sin energía (detectado por el Brown out) hacerlo en ese momento.

Respecto al simulador, mira los datos de eeprom, en la posición de memoria que elegiste (00, según se ve en programa) y las tres contiguas deberá estar tu dato guardado.

[MerLiNz]

para ver si lo que has escrito concuerda haz un read_eeprom de la misma direccion despues de escribirlo, y lo guardas en alguna variable, asi en el isis puedes ver si concuerda.

[Suky]

Exactamente, en CCS existe la librería para guardar los datos float en memoria, es lo que se ha charlado en varios post   Y mucho cuidado con lo que comenta MGLSOFT, así como lo implementas quedas con la memoria inútil en un par de segundos 

[blackburne44]

Antes que nada, nuevamente les quiero agradecer por su ayuda. Lo estuve pensando, la idea es almacenar el valor de una temperatura (se encuentra en una variable del tipo float, por eso mi consulta), y enviarla a traves de un conector DB-9 por rs-232 hacia un computadora. Viendo bien lo que dijo MGLSOFT, pense en colocarle externamente un pulsador en un pin del PIC, para poder grabar "a voluntad" el valor de la temperatura en la eeprom interna ( de esta manera, solucionaria el problema de estar grabando todo el tiempo, y cortarle la vida util a la memoria). Despues podria colocar otro pulsador para realizar el envio del dato por rs-232 a la pc.

[blackburne44]

Pude guardarlo en el eeprom del pic (aunque veo muy poco cambio de los registros cuando guardo una temperatura, observandolo en el isis proteus). Pero cuando lo quiero trasmitir por rs 232, probandolo con el virtual terminal, solo me figura una "C" en la salida  . No sabran porque puede ser?  . Les dejo el codigo:

#include <Test.h>
#include <HDM64GS12.c>
#include <graphics_1.c>
#include <1wire.c>
#include <ds1820.c>
#include <lib_int_eeprom.c>

int8 Pro[]= "PROYECTO";
int8 Ter[]= "TERMOMETRO";
float temperatura_antigua ;
float temperatura_nueva ;
char palabra [16];
int8 guar[]= "Guardando";
int8 tempe[]= "Temperatura";
int8 trans[]= "Transmitiendo...";

void main()
{
  setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
 
  glcd_init(ON);
  delay_ms(20);
  glcd_rect(10,10,110,58,no,on);
  glcd_rect(18,18,68,28,no,on);
  glcd_rect(38,38,100,48,no,on);
  glcd_text57(20,20,Pro,1,on);
  glcd_text57(40,40,Ter,1,on);
  delay_ms(1500);
  glcd_fillScreen(0);
  glcd_rect(10,25,110,42,no,on);
 
while (1) {

  temperatura_nueva = ds1820_read ();                      // Se vuelve a leer el sensor y este valor se escribe
                                                           // en una nueva variable

if (temperatura_nueva != temperatura_antigua){             // Se compara la temperatura vieja con la nueva
  glcd_rect(50,30,105,40,yes,OFF);                          // Se borra la temperatura vieja
  sprintf(palabra,"TEMP = %3.1f &C",temperatura_nueva);    // Se vuelve a crear un array de valores
  glcd_text57(15, 30,palabra, 1, ON);
  temperatura_antigua = temperatura_nueva ;
  }
if (input(PIN_A0)){
  glcd_text57(2, 10,guar, 1, ON);
  glcd_text57(60, 10,tempe, 1, ON);
  write_float_eeprom(00,temperatura_nueva);
  delay_ms(1500);
  glcd_rect(2,10,126,20,yes,off);
  }
if (input(PIN_A1)){
  glcd_text57(10,50,trans,1,on);
  delay_ms(1500);
  printf (read_float_eeprom(00));
  glcd_rect(10,50,100,60,yes,off);
  }
}
}

[MerLiNz]

esto es porque estas enviando el float, tu lo que quieres supongo es que envie los numeros en formato leible, seria asi:

printf("%f",read_float_eeprom(00));

[blackburne44]

Muchas gracias merlinz. El problema estaba en la parte de hardware en el proteus, y tambien lo que hice es enviar un "char" mediante la funcion "sprintf"

[josefe]

Buenas gente, tengo unas duditas y a tambien a aportar un poco a este tema.

La libreria ya viene con pic c y se llama asi #include <internal_eeprom.c>

En proteus si se puede simular la eeprom utilizando un archivo .bin, metanse en mis mensajes que por alli ahi uno donde pedi ayuda y se explico bien el tema.

ahora estoy con problemas en la eeprom con pic c, en mikroc anda al pelo pero me estoy cambiando a ccs y como todo cambio tiene sus altas y bajas.

Hago esto

Código: [Seleccionar]

int16 valor2, valor3;

         valor2=88;
         write_int16_eeprom(07,valor2);
         delay_ms(100);
        valor=read_int16_eeprom(07);
        delay_ms(100);
        printf ( lcd_putc,"\f");
        printf ( lcd_putc, valor3 );
Pero en el LCD no aparece nada, aque se debera esto.