Problema con estructura y ram

[iNoXSteeL]

Hola a todos,

Trato de hacer un controlador, con el cual necesito incorporar esta estructura

Código: [Seleccionar]

struct Datos   //ESTRUCTURA DE DATOS PRINCIPAL
   {
   char   Nombre   [19];         
   int8   Dias;                 
   int8   Turn     [60][2];     
   int8   TurnInt  [60][2];     
   int8   Air      [60][2];     
   int8   AirInt   [60][2];     
   float  Temp     [60];         
   float  HistTemp [60];         
   float  Humi     [60];       
   float  HistHumi [60];         
   }Variedad[25];

He escogido un 18f4610, ya que me gustaría simularlo antes y según proteus es el que más ram tiene de los que dispone para simular 18f.

Apenas necesito 4 puertos de salidas y los del lcd y tal..

El problema es que no tiene tanta ram para esa estructura, mi intención es que estuviesen esos valores almacenados en una eeprom externa y cargar en ram sólo los necesarios para una variedad.

¿Cómo puedo hacer para tener esa estructura cargada en la eeprom o en la rom, y no tener tanta ram para ella?

Gracias de antemano, un saludo.

[migsantiago]

Hola, ¿todos son valores constantes?

[iNoXSteeL]

MigSantiago, si, pero son modificables manualmente mediante un menú, aunque una vez modificado y almacenado no varían, sólo cuando lo hace el usuario en pantalla.

Un saludo.

[migsantiago]

Mmhh

Se me ocurre que hagas las funciones de lectura y llenado de la struct. Esas funciones deben usar write_ext_eeprom() y read_ext_eeprom() para el caso de una eeprom externa. Ya hay funciones para grabar flotantes, int16 y demás tamaños y tipos en la eeprom externa.

Es lo más sencillo que se me ocurre.

[Suky]

18k de RAM necesitas?  Ni con un PIC24  No te queda otra que hacer lo que indica MigSantiago.

Saludos!

[iNoXSteeL]

Gracias por las respuestas,

Suki, probé con un PIC24 pero también decía que tururú 

MigSantiago, ¿Te importaría poner un breve ejemplo para orientarme? No se exactamente como dices de hacerlo.

Un saludo.

[Nocturno]

Hay alunos PIC32 con 64K de RAM, pero si te apañas bien con la EEPROM externa y no necesitas tanta potencia de cálculo, es una buena solución

[erdanieee]

Buenas iNoXSteeL,

si el procesador va lo suficientemente rápido podrías hacer un struct de punteros a funciones, que sean las encargadas de cargar el dato correspondiente en ram. Échale un vistazo a este post de Suky:

http://www.todopic.com.ar/foros/index.php?topic=29880.msg248824#msg248824

[migsantiago]

Inoxsteel, el archivo external_eeprom.c en la carpeta drivers de PICC contiene las siguientes funciones:

Código: [Seleccionar]

////////////////////////////////////////////////////////////////////////////////
////                          external_eeprom.c                             ////
////                                                                        ////
////       Utilities to write various data types to external eeprom         ////
////////////////////////////////////////////////////////////////////////////////
////                                                                        ////
////   void write_int1_ext_eeprom(address, int8 bitPosition, int1 data)     ////
////     Call to write one bit of data                                      ////
////                                                                        ////
////   int1 read_int1_ext_eeprom(address, int8 bitPosition)                 ////
////     Call to read one bit of data                                       ////
////                                                                        ////
////                                                                        ////
////   void write_int16_ext_eeprom(address, int16 data)                     ////
////     Call to write a 16 bit integer                                     ////
////                                                                        ////
////   int16 read_int16_ext_eeprom(address)                                 ////
////     Call to read a 16 bit integer                                      ////
////                                                                        ////
////                                                                        ////
////   void write_int32_ext_eeprom(address, int32 data)                     ////
////     Call to write a 32 bit integer                                     ////
////                                                                        ////
////   int32 read_int32_ext_eeprom(address)                                 ////
////     Call to read a 32 bit integer                                      ////
////                                                                        ////
////                                                                        ////
////   void write_float_ext_eeprom(address, float data)                     ////
////     Call to write a floating point number                              ////
////                                                                        ////
////   float read_float_ext_eeprom(address)                                 ////
////     Call to read a floating point number                               ////
////                                                                        ////
////////////////////////////////////////////////////////////////////////////////
Lo único que deberás hacer es integrarlas como subfunciones de una función que lea o escribe la estructura que propones.

[RICHI777]

Hola, me parece impractico tener todos esos valores siempre en RAM. Creo que la mejor solución es la que presento Mig. Deberias implementar funciones similares a estas:

Código: C

1. char *GetStructNombre( int8 Posicion );
2.  
3. void SetStructNombre( int8 Posicion, char * NuevoNombre );

La primera función devuelve un String C con el NOMBRE desde la memoria E2PROM, el parametro Posicion especifica cual de las 25 posiciones es la que pretendes. La segunda función escribe un nuevo NOMBRE en la memoria.
Y asi por cada miembro de la estructura, para implementarlas deberia usar las funciones que te detallo Mig y mappear la memoria E2PROM. Por ejemplo si el tamaño del nombre miembro de estructura es fijo podrias usar para esto desde el address 0x00 hasta 0x14 ( se incluye el terminador 0 ).

Con este metodo solo necesitas como máximo 240 bytes de RAM para almacenar algunos de los floats que definis en la estructura madre.

Saludos !

[iNoXSteeL]

Gracias por las respuestas,

Ya he pillado como se hace, lo tengo claro, dejaré la estructura como principal y con una función que contenga las subfunciones de la librería eeprom, leer o escribir en la estructura, así sólo contiene 1 elemento por variable y no los 18kb que hay .

Con eso el usuario al programar los datos, la funcion lee/escribe va relleando la eeprom y la estructura según convenga.

Probaré  a ver.

Gracias nuevamente.

Un saludo.

PD: No entiendo de donde salen los 18kb. Si hay 4 variables de 60x2 bytes + 4 de 60x32 bits + dos de 8 bits + 19 bits del char... X 25 variedades son casi 62Kb..?

[migsantiago]

Código: [Seleccionar]

struct Datos   //ESTRUCTURA DE DATOS PRINCIPAL
   {
   char   Nombre   [19];         
   int8   Dias;                 
   int8   Turn     [60][2];     
   int8   TurnInt  [60][2];     
   int8   Air      [60][2];     
   int8   AirInt   [60][2];     
   float  Temp     [60];         
   float  HistTemp [60];         
   float  Humi     [60];       
   float  HistHumi [60];         
   }Variedad[25];
19 + 1 + 120 + 120 + 120 + 120 + 240 +240 + 240 + 240 = 1460

1460 * 25 = 36,500 bytes

[RICHI777]

Hola, igual como bien indico Mig si lees de la estructura necesitas 1460 bytes de RAM exclusivo para eso, demasiado para mi gusto.

Saludos !

[iNoXSteeL]

Gracias por las respuestas,

MigSantiago, gracias por la aclaración, me había equivocado con la calculadora en los float 

Richi77, la estructura al final quedará así:

Código: C

1. struct Datos
2.    {
3.    char   Nombre   [19];
4.    int8   Dias;
5.    int8   Dia;
6.    int8   Turn     [2];
7.    int8   TurnInt  [2];
8.    int8   Air      [2];
9.    int8   AirInt   [2];
10.    float  Temp     ;
11.    float  HistTemp ;
12.    float  Humi     ;
13.    float  HistHumi ;
14.    }Variedad;

que si no me equivoco son 45 bytes, así si me funciona, la voy rellenando con las funciones R/W según convenga, así sólo carga ese poco en ram.

Por cierto, no he manejado eeprom externas, pero según comentas se añade el terminador siempre al final de cada byte?, entonces según la estructura inicial, almacenar todo eso supondría 436Kbits, que con una de 512 iría bien.

Gracias nuevamente.

Un saludo.

[migsantiago]

Inoxsteel, ¿estás seguro que declararás una variable dinámica tipo char?

Código: [Seleccionar]

char   Nombre   [];
CCS necesita un par de declaraciones extra para manipular memoria dinámica. Y qué decir si es dinámica en la eeprom externa, sería muy complicado.