Escribir variables int32 en eeprom externa

[Agustina]

Hola! he estado trabajando con una eeprom externa por i2c y se me ha presentado un problema, trato de escribir una variable int32 en la eeprom, pero luego al leerla, lee cualquier otro numero  les adjunto el programa


/////////////////////////////Funcion para escribir float en eeprom///////////////////////////
WRITE_FLOAT_EXT_EEPROM(long int n, long data) {

   int i;

   for (i = 0; i < 4; i++)

     write_ext_eeprom(i + n, *(&data + i) ) ;

}


/////////////////////////////Funcion para leer float en eeprom///////////////////////////

long READ_FLOAT_EXT_EEPROM(long int n) {

   int i;

   long data;

   for (i = 0; i < 4; i++)

     *(&data + i) = read_ext_eeprom(i + n);

   return(data);

}

luego dentro del main para escribir y leer la variable coloco esto:


write_float_ext_eeprom(218,factor_int);
lcd_putc("\fleyendo...");
delay_ms(1000);
factor_int=read_float_ext_eeprom(218);
printf(lcd_putc,"\f%8.7w",factor_int);
delay_ms(1000);

me podrian aconsejar a ver si puedo detectar el problema?
Muchas gracias!! 

[Nocturno]

¿Cómo tienes declarada la variable factor_int?

[MGLSOFT]

Ademas existe la posicion 218 en esa memoria??

[RedPic]

Independiente de todo los demás: Una variable declarada como Long es de 16 bits (int16) no de 32 bits (int32) luego data solo tiene dos bytes de largo y tus funciones estan escribiendo y leyendo cuatro  por lo tanto los resultados no pueden ser mas que aleatorios y cualquier parecido con la realidad es mera coincidencia.   

Declara las variables de 32 bits como int32 y vuelve a probar. 

Un saludo.

PD1: Del manual de CCS ... By default the compiler treats SHORT as one bit, INT as 8 bits and LONG as 16 bits.
PD2: Tambien puedes redeclarar tus tipos de variables con #TYPE SHORT=8, INT=16, LONG=32

[MGLSOFT]

Hay una libreria de CCS que esta hecha para hacer este trabajito.
Se llama External_EEprom.c

Alli las funciones son algo diferentes a las que escribiste.

Código: [Seleccionar]

// Purpose:    Write a floating point number to external eeprom
// Inputs:     1) An eeprom address. Four eeprom locations will be used.
//             2) The floating point number to write to external eeprom
// Outputs:    None
void write_float_ext_eeprom(EEPROM_ADDRESS address, float data)
{
   int8 i;

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


// Purpose:    Read a floating point number from external eeprom
// Inputs:     An eeprom address
// Outputs:    The floating point number read from the external eeprom
float read_float_ext_eeprom(EEPROM_ADDRESS address)
{
   int8 i;
   float data;

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

   return data;
}
RedPic tiene razon, como siempre...

[Agustina]

muchas gracias por las respustas!!!    ahora probare para ver si todo funciona bien 
El problema de las variables LONG lo resolvi luego de dejar este post  pero el problema seguia igual, asique probaré con las demás sugerencias!!!

Muchisisisisisimas gracias!!  en unas horas les cuento si todo salió bien!

[Agustina]

  no se soluciono, ya no se que hacer... uso las funciones de external_eeprom.c y tampoco... factor int es un int32, cuando lo incremento y lo muestra en el display, muestra los valores que ingreso por ejemplo 3079843 que es un int32, pero cuando lo guardo en la eeprom al leerlo lee un valor que nunca excede los 255 (int8) ... no entiendo que estoy haciendo mal 

[vszener]

¿Tu eeprom puede soportar 32-bits?es decir, de que tamaño son sus registros...


Suerte!!!

[MGLSOFT]

Todos los datos son de 8 bits en estas rutinas, solo que cada una ocupa 4 posiciones de 8 bits indexadas a partir de la posicion inicial, tanto para la escritura como para la lectura funciona asi, lee las rutinas y veras que es asi.

 

[Agustina]

no logre hacer funcionar lasrutinas que provee CCS para el manejo de enteros de 32 bits... asique cree una que se entiende un poco mas y anda a la perfeccion, se las dejo por si alguien tiene el mismo problema! 


void write_int32_ext_eeprom(int16 direccion, int32 dato)
   {
   int dato_0,dato_1,dato_2,dato_3;

   dato_3 = make8(dato,3);   //MSB
   dato_2 = make8(dato,2); 
   dato_1 = make8(dato,1); 
   dato_0 = make8(dato,0); 

   write_ext_eeprom(direccion,dato_3);
   direccion++;
   write_ext_eeprom(direccion,dato_2);
   direccion++;
   write_ext_eeprom(direccion,dato_1);
   direccion++;
   write_ext_eeprom(direccion,dato_0);
   return;
   }


int32 read_int32_ext_eeprom(int16 direccion)
   {
   int32 dato;
   int dato_0,dato_1,dato_2,dato_3;
   
   dato_3=read_ext_eeprom(direccion);
   direccion++;
   dato_2=read_ext_eeprom(direccion);
   direccion++;
   dato_1=read_ext_eeprom(direccion);
   direccion++;
   dato_0=read_ext_eeprom(direccion);

   dato=make32(dato_3,dato_2,dato_1,dato_0);
   return(dato);
   }

[jeremylf]

Tengo el mismo problema yo en estos momentos pero con las funcion para escribir y leer variables float =S Alguien podria asegurar que las funciones del external_eeprom.c del ccs funcionan correctamente? y sino, mostrar alguna otra forma de poder leer/escribir float n una eeprom?

Gracias.
Un saludo.

[RICHI777]

Hola, suponiendo que tengamos funciónes que escriban y lean desde/hacia EEPROM a nivel byte se podrian hacer dos funciones que sirvan para cualquier tipo de dato, doy el ejemplo para un int32 independiente del largo que tenga.

Código: [Seleccionar]

void SaveInt32ToEEprom( int16 Address, int32 Data )
{
  /* Se instancia un buffer de igual tamaño del tipo da dato, no me debe importar el tamaño, el compilador lo resolvera en tiempo de compilacion */
  int8 MyBuffer[sizeof(int32)]; 
  int8 Index;

  /* Copio el Dato al buffer */
  memcpy( Buffer, &Data, sizeof( int32 ));

  /* Salvo en EEPROM */
  for ( Index = 0; Index < sizeof( int32 ); Index ++ )
  {
      write_ext_eeprom(Address ++, Buffer[Index]);
  }
}

int32 GetInt32FromEEprom( int16 Address )
{
  /* Se instancia un buffer de igual tamaño del tipo da dato, no me debe importar el tamaño, el compilador lo resolvera en tiempo de compilacion */
  int8 MyBuffer[sizeof(int32)]; 
  int32 Temp;
  int8 Index;

  /* Leeo de EEPROM */
  for ( Index = 0; Index < sizeof( int32 ); Index ++ )
  {
      Buffer[Index] = read_ext_eeprom(Address ++);
  }

  /* Copio el Dato al buffer */
  memcpy( &Temp, Buffer, sizeof( int32 ));

  return( Temp );
}

La función se puede adaptar a cualquier tipo de dato por ejemplo float, reemplazando los int32 por float. Cabe aclarar que estas funciones estan escritas en ANSI C, lo que es necesario para su implementación es que el compilador soporte la función de la RTL memcpy y el operador sizeof

Saludos !

[MLO__]

Hola.

Las funciones si funcionan y muy bien  , claro que a 8 bits. Si quieres guardar un float, debes pasarlo a string y guardarlo de esa manera en la memoria, por ejemplo, si quieres guardar 2.34, lo pasas a {'2', '.', '3', '4'} y ocuparias 4 registros de la memoria. Para leerlo, simple   , pasas el string a float y ya.

Saludos.

[firepic]

Saludos a todos!

Miguel, respeto tu experiencia y opiniones, muy maduras siempre. Ahora bien, imagínate un número float, digamos -12.038,56... Eso llevado a string serán mucho más de 4 registros de memoria, cierto? Por eso es que me parece un poco ineficiente ese método, a menos que estés seguro de que los valores siempre serán pequeños. De lo contrario, creo que lo mejor es usar apuntadores para guardar los 4 registros que componen la variable float en la eeprom externa, como lo que propone Richi.
 
Ahora bien, Jeremy, CCS provee una librería llamada FLOATEE que es justamente para hacer ese trabajito. Y funciona a la perfección!
Si mal no recuerdo, las instrucciones son: write_float_ext_eeprom y read_float_ext_eeprom... usando esas no tendrás problemas. Solo debes cuidar bien la dirección de la memoria a escribir, debes ir incrementando de cuatro en cuatro de un dato a otro, razón obvia.

Ok nos leemos! 

[MLO__]

Hola.

Tranquilo Javier      jajaja ...... no sabia que habia esa libreria .. hoy, gracias a ti, la vengo a ver!!!!  normalmente no trabajo con numeros cuya parte entera sea grande y con mas de 2 decimales (por lo de la resolucion, no puedo asegurarla!!!), pero ahora que la vi, le voy a dar muuucho uso!!!

Saludos