Problema de compilación (Punteros en CCS)

[PicMinor]

¡ Saludos al grupo !

Tengo que almacenar una gran serie de datos en la memoria de programa que incluyen arrays de distinto tamaño. He intentado utilizar este código pero no compila. Me da el error "Expression must evaluate to a constant"

¿Alguien puede orientarme?

Código: [Seleccionar]


struct Estructura {
long Valor_Long;
  char Valor_Char;
  long *Array_Long;
};

static const long Array_A[] = {
386, 491, 187, 290,
};

static const long Array_B[] = {
503, 177, 431, 714, 874, 102,
};

static const struct Estructura Valores[] = {
{ 12345,
67,
Array_A,
},

{ 54321,
76,
Array_B,
},

};



¡ Gracias por anticipado !

[Jorge555]

¿Si quitas const de la última declaración, valores, te sigue dando el error? Estás asignando la dirección del puntero como constante, puntero que a lo mejor no se ha colocado todavía en memoria en la compilación. Pregunto ya que no sé mucho de C.

[man3s]

Que tal amigo, con que elimines el modificador "const" de Array_A y Array_B dejara de arrojarte ese error.

Saludos

[PicMinor]

Por supuesto si elimino const me compila. El problema es que si quiero almacenar unos 100 array de cada tipo no me caben en RAM.

[Jorge555]

 Añadiendo en la declaración del puntero que es puntero a una constante?, const long *Array_long

[PicMinor]

Nada, que no hay forma.

Respecto a lo de quitar const en la declaración de los arrays os adjunto un pequeño código que no se puede compilar por insuficiente RAM

Código: [Seleccionar]

#include <16F886.h> // Cabecera del Micro Utilizado

struct Estructura {
long Valor_Long;
   char Valor_Char;
   long *Array_Long;
};

long Array_A[] = {
386, 491, 187, 290, 386, 491, 187, 290, 386, 491, 187, 290, 386, 491, 187, 290, 945, 777, 187, 290, 945,
};

long Array_B[] = {
503, 177, 431, 714, 874, 102, 503, 177, 431, 714, 874, 102, 503, 177, 431, 714, 874, 102, 431, 714, 874, 102,
};

long Array_C[] = {
386, 491, 187, 290, 386, 491, 187, 290, 386, 491, 187, 290, 386, 491, 187, 290, 386, 491, 187, 290, 386,
};

long Array_D[] = {
503, 177, 431, 714, 874, 102, 503, 177, 431, 714, 874, 102, 503, 177, 431, 714, 874, 102, 431, 714, 874, 102,
};

long Array_E[] = {
386, 491, 187, 290, 386, 491, 187, 290, 386, 491, 187, 290, 386, 491, 187, 290, 386, 491, 187, 290, 386,
};

long Array_F[] = {
503, 177, 431, 714, 874, 102, 503, 177, 431, 714, 874, 102, 503, 177, 431, 714, 874, 102, 431, 714, 874,
};

long Array_G[] = {
386, 491, 187, 290, 386, 491, 187, 290, 386, 491, 187, 290, 290, 386, 491, 187, 290, 333, 491, 187, 290, 888
};

long Array_H[] = {
503, 177, 431, 714, 874, 102, 503, 177, 431, 714, 874, 102, 503, 177, 431, 714, 874, 102, 431, 714, 874,
};


const struct Estructura Valores[] = {
{ 12345,
67,
Array_A,
},

{ 54321,
76,
Array_B,
},

{ 12345,
67,
Array_C,
},

{ 54321,
76,
Array_D,
},

{ 12345,
67,
Array_E,
},

{ 54321,
76,
Array_F,
},

{ 12345,
67,
Array_G,
},

{ 54321,
76,
Array_H,
},
};

void main() {

}


La única solución es asignar longitud fija al array en la declaración de la estructura pero hay que darle la máxima por lo que al crear la estructura se desperdicia una cantidad tremenda de memoria de programa, sobre todo si los arrays son de longitud muy desigual, lo que es mi caso precisamente.

A ver si a alguien se le ocurre la manera de compilar este código.

[MerLiNz]

Lo correcto es pasarte a un mcu con mas RAM. No puedes mezclar datos de RAM con ROM puesto que no se interpretan de la misma forma, los datos en la ROM se hacen transferencias hacia la ram para "usarlos", sin embargo los datos en la RAM simplemente se utilizan directamente.

[RALF2]

El uso de la memoria rom para almacenar datos en el ccs es posible, pero tiene ciertos detalles tecnicos que aun la gente de ccs no a logrado afinar.
Yo te recomendaria que si tienes que almacenar muchos datos utilices una memoria externa y si necesitas velocidad que esta se comunique por spi 
De hecho los ejemplos que trae la ayuda del ccs; he incluso en las nuevas caracteristicas que trae el ccs 5.xxx tienen errores  , si puedes date un paseo por el foro de ccs y veras lo que digo.

Saludos

[BrunoF]

Me parece que lo más sencillo sería repartir las cosas en dos arrays unidimensionales, todos constantes.

Un con todos los elementos:

static const unsigned int16 Valores[] = {
      12345,
      67,      
      386, 491, 187, 290,    //ex Array_A

      54321,
      76,      
      503, 177, 431, 714, 874, 102,  //ex Array_B
};

y el otro con los indices y tamaños de cada array:

const unsigned int16 offsetLen[] = {0, 6, 6, 8};           //offset of first element , length of first element, offset of second element, length of second element, etc...
            
Los length se podrían suprimir si calcula todo mendiante sólo los offsets.