Estructuras con datos estáticos

[manwenwe]

Hola, necesito guardar bastantes variables del tipo estructura en mi programa. El caso es que de todas estas varibale una sóla sería realmente una variable el resto serían datos que no cambiarían nunca... Pongo el ejemplo para que se vea mejor:

Código: [Seleccionar]

typedef struct{

int8 nombre[11];
int16 longitudFlash;
int16 longitudEeprom;
int16 primeraCeldaMemoriaEeprom;
int8 numeroPalabrasConfiguracion;


}dispositivo;

void initDispositivos(void){

dispositivo arrayDispositivos[20]; //este sería el array de variables tipo estructura que contienen datos que no van a ser modificados
dispositivo dispositivoActual; // en cambio esta variable si que se modificaría...

        //........

}

Me gustaría guardar todas las variables que no se modifcan como datos en rom(pues ocuparían mucha ram), pero realmente no se si se pueden guardar los datos de una estructura como estáticos y menos aún como se haría esto.

Además al tratarse de un array donde no están inicializados los datos, me tocaría inicializarlos dentro de la función initDispositivos y tampoco se si hay alguna forma de(función de alguna librería...) que modifique la rom en tiempo de ejecución. He visto funciones para copiar arrays de caracteres entre ram y rom en cualquiera de las combinaciones posibles, pero para estructuras no se si existe algo parecido.

Por último me gustaría plantear otra duda: ¿deben declararse e inicializarse los arrays de caracteres al mismo tiempo?. Yo suelo hacerlo siempre, pero hoy al intentar lo siguiente me topé con errores de compilación:

Código: [Seleccionar]

int8 miArray[6];
myArray = "HOLA!"
Creo que utilizando la función strcpy de la librería string.h se puede conseguir, pero me gustaría saber si hay otra alternativa.

Bueno, gracias de antemano a quien me puede echar un cable. Saludos!

[maunix]

Si usas C18 puedes recurrir a

#pragma romdata nombreseccion


donde nombreseccion debe estar definido en el linker file.

[manwenwe]

Lo sientos maunix pero no he entendido bien tu respuesta; tengo 3 cosas: la declaración de un typedef struct, la declaración de un array de variables del tipo estructura(anterior) y la inicialización de los datos que contienen las estructuras del array de estructuras... ¿de estas 3 cosas cuales deben ir dentro de
#pragma romdata nombreseccion?

[maunix]

A ver , vamos por partes.

1) El tipo de dato lo defines antes que nada, y no ocupa lugar en ROM.  Es simplemente una definición lógica que tu haces.  Pudieras tener miles de tipos de datos definidos en un software sin que por ello ocupes siquiera 1 byte.

2) Con pragma romdata nombreseccion simplemente le indicas al compilador que lo que sigue a continuación son datos en rom en la ubicación dada por nombreseccion.  Las secciones las defines en el archivo .lkr

3) Por último debajo de la sección declaras tu variable y la inicializas ahí mismo.  De esta forma, la variable queda en ROM inicializada como tu deseas.

Espero haber aclarado el punto, sino veré de buscar algún ejemplo.

Pero te repito es para C18.

[manwenwe]

Bueno, lo que me comentas maunix ya creo que lo entendí, sólo me costó un poco lo de cambiar el .lkr porque no había definido una nueva CODEPAGE... pero lo miré en el manual de C18 y sin problemas.

Estoy intentando lo siguiente en un archivo de cabecera:

Código: [Seleccionar]

#include <p18f4550.h>
#define int8 unsigned char
#define int16   unsigned short



typedef struct{

int8 nombre[11];
int16 longitudFlash;
int16 longitudEeprom;
int16 primeraCeldaMemoriaEeprom;
int8 numeroPalabrasConfiguracion;
int16 id;

}dispositivo;


#pragma romdata seccionDispositivos

rom const dispositivo arrayDispositivos[20];
arrayDispositivos[0].longitudFlash = 0x1FFF;

#pragma romdata

Pero no compila, parece ser que no puedo declarar y despues inicializar sino que debo hacerlo todo en la misma linea: digo esto porque si hago lo siguiente:

Código: [Seleccionar]

#pragma romdata seccionDispositivos

rom const int8 numero = 10;

#pragma romdata
... no tengo problema. El problema es que como se trata de un array de constantes de tipo estructura no puedo declarar e inicializar de golpe.

¿Hay alguna solución a esto?

También me gustaría saber la forma de acceder a estos datos, lo digo porque cuando accedes a datos de ram que estan en una sección declarada por ti y que sobrepasan algún banco... tienes que hacerlo a traves de un puntero... ¿es en el caso de la rom igual?

Mil perdones por ser tan pesado!!!!

[maunix]

Lo de que lo debes definir ahí mismo e inicializarlo es bastante obvio.  Una vez que lo pienses te darás cuenta porqué.

Fíjate, que estos datos que estas definiendo irán en la memoria de programa, almacenados como bytes.  De manera que al definir una variable en ROM estás definiendo en realidad una constante, no la cambiarás (salvo que reescribas la flash, pero eso sería entrar en esquisiteces) .  Es por ello que debe estar inicializada ahí mismo.

Por ende el compilador DEBE saber qué valores tomarán esas variables en rom!

Te digo como se hace

Código: C

1. #pragma romdata seccionDispositivos
2. rom char myarray[20] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
3.  
4. #pragma romdata

[manwenwe]

Gracias maunix, esto que me comentas ya lo pensaba... el problema es que aún así no soluciono nada. Tú has puesto un ejemplo para declarar e inicializar un array de chars... pero en mi caso es un array de structs. ¿Esto se puede inicializar al tiempo que se declara? Creo que no ... si me dices lo contrario me haces un gran favor jejejej

Se me olvidó preguntar... entre:

Código: [Seleccionar]

#pragma romdata seccionDispositivos
rom char myarray[20] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};

#pragma romdata
y:

Código: [Seleccionar]

rom char myarray[20] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};

¿La única diferencia es que en la primera opción tú decides en la sección de la rom donde se guardarán los datos? Lo siento es que no me aclaro con estas cosas, ni siquiera entiendo la diferencia entre los calificadores rom, static y const

[maunix]

Si, la ventaja es que usando el #pragma sabes donde estará ubicado el array.  Esto te sirve para lo que comente anteriormente, para que si usas alguna rutina de update de flash podrás actualizar/modificar el valor de las constantes mencionadas sin modificar el resto del software.  el resto del software podrá direccionar tranquilamente a tu variable. 

La aclaración es importante ya que cuando el código queda compilado las variables son FIJAS en su ubicación, entonces si las modificaste porque necesitabas cambiar algún parámetro el resto del software funcionará perfectamente y hará referencia a tu variable en rom de igual manera que siempre.

Volviendo a un array de struct, todo se puede inicializar!

Todo es cuestión de cómo sea tu struct

Te hago un dejo un ejemplo simple que tu podrás extender para arrays de structs más complejos.

Código: C

1. typedef struct  {
2.    unsigned char a;
3.    unsigned char b;
4. } Tdato;
5.  
6. #pragma romdata miseccion
7. rom Tdato myarray[3] = { {0,0} ,
8.                          {1,1} ,
9.                          {2,2} }

[manwenwe]

He probado lo que me comentas y funciona bien!!! Muchas gracias por toda tu ayuda maunix. Como de costumbre tienes soluciones para todo, se nota que eres un buen programador , espero algún dia llegar a saber la mitad que tú... por eso me estoy esforzando

Saludos

[maunix]

He probado lo que me comentas y funciona bien!!! Muchas gracias por toda tu ayuda maunix. Como de costumbre tienes soluciones para todo, se nota que eres un buen programador , espero algún dia llegar a saber la mitad que tú... por eso me estoy esforzando

Saludos

gracias, no creo saber tanto aunque es verdad que programo desde que tengo uso de razón jeje. 

En cuanto a lo del C18, tal vez solo sepa "antes" que vos, es todo