Cómo emular punteros a constantes en CCS

[Nocturno]

Está bien clarito en el manual del compilador: "En CCS no se admiten punteros a constantes".

Pero me niego a pensar que no haya forma de hacer lo que pretendo, aunque no soy capaz de encontrarla.

Resumiendo, tengo esta constante:

char const consigna[] = {"Me encanta que los planes salgan bien\0"};

Y tengo esta función, que va perfecta con variables string no constantes:
void glcd_texto(  char *text )

Pues bien, si llamo a la función de esta guisa:
glcd_texto(consigna);

me devuelve esta palabrota:
Error: Attempt to create a pointer to a constant

He probado múltiples combinaciones, pero no consigo que furule, ¿alguna sugerencia?

[RedPic]

Querido Manolo, con la iglesia hemos topado. 

Por activa y por pasiva lo he intentado y el muro me ha sido insalvable. Me uno a tu petición: Si alguien conoce un truco para solventar esto por favor que lo haga público y recibirá mis gracias mas efusivas, saltarinas, festeras y aplausibles ... 

[IIIC]

Creo que ese problema ya lo solventaron, aqui un extracto para la version 4 de ccs

busquen en el tema "Variable length constant strings" de la pagina   http://www.ccsinfo.com/content.php?page=v4compiler

y de ahi en adelante encontraran la solucion.

[Modulay]

¿Probaste con esto?

char const consigna[] = {"Me encanta que los planes salgan bien\0"};
char *texto;

texto = consigna;
glcd_texto( texto );

[Nocturno]

No entiendo cómo dice CCS que en su versión 4 ya funcionan los punteros a constantes, puesto que no para de salirme el dichoso Error: Attempt to create a pointer to a constant.

He encontrado una solución que no me gusta, por el consumo de recursos que representa, pero que al menos funciona. Si establecemos al principio del programa el siguiente parámetro:
#device PASS_STRINGS=IN_RAM
el compilador copiará las constantes a la RAM antes de trabajar con ellas y las utilizará normalmente.

Si alguien consigue lo de los punteros a constantes, sigo estando interesado. Gracias

[djpalas]

Hola amigos!!


Viendo en la web CCS sale "Version 4 adds new ways of allowing pointers to constant data. First, Version 4 adds pointers to constants"

Según  he visto en los ejemplos usan punteros constantes a datos constantes. Prueba estos cambios a ver como va.

Código: C++

1. char const consigna[] = {"Me encanta que los planes salgan bien\0"}; // Me suena del EquipoA, aqui seria el Equipo TodoPIC  :D :D
2. const char *ptr;
3.  
4. ptr = consigna[];
5. glcd_texto(ptr);

Supongo que en la función se necesita un puntero que no sea constante, por lo que se podría hacer la siguiente modificación en la función:

Código: C++

1. void glcd_texto( const char *ptrfijo ){   // Admitimos punteros constantes
2.  
3. char *text;      // Creamos un puntero variable
4. text = ptrfijo;   // Asignamos la dirección de memoria del puntero constante al puntero fijo con el que se trabajará
5.  
6. //.... instrucciones que haya .....
7. }

Otro asunto sería la creación de sobrecargas de funciones, que no estoy seguro si lo admitiría el CCS. Si lo admite sería mejor solución

PD: Hace mucho que no toco punteros, así que pruebalo y ya me contaras Manolo.

Saludos!
Diego J.

[Nocturno]

Lo he probado, querido DJ, pero sigue fallando. No entiendo cómo dicen que ya funciona... 

[PalitroqueZ]

bueno nocturno, si no puedes conseguirlo, tendras que hacerlo a lo clásico: usar el puntero del primer carácter y después hacer un barrido de direcciones.

Salu2
Pedro

[IIIC]

Realmente aun no he tenido la necesidad de implementar ese tipo de codigo, pero haciendo unas pruebas  he encontrado que de estas dos formas me compilan perfecto.

////////////EJEMPLO 1:

void glcd_texto(  char *text );

void main()
{
  const char consigna[] = "Me encanta que los planes salgan bien\0";
  char *ptr;

     ptr = consigna;

     glcd_texto(  ptr );
}


void glcd_texto(  char *text ){}


////////////Ejemplo 2

void glcd_texto(  char *text );

void main()
{
char consigna[] = "Me encanta que los planes salgan bien\0";
char *ptr;

ptr = &consigna[0];

     glcd_texto(  ptr );
}

void glcd_texto(  char *text ){}


espero ayude en algo. saludos

[Nocturno]

Nada, que no hay manera. La primera de tus opciones sí compila, pero no funciona; en vez de el mensaje correcto aparece texto en arameo. El puntero no apunta donde debería.

El segundo ejemplo ni me compila, me aparece este error "Expenting an identifier" en esta línea:
ptr=&consigna[0];

[reiniertl]

Manolo la  primera línea debe estar bien, el problema es que ese puntero está apuntando a memoria de programas y por tanto creo que tendrías que utilizar el operador sizeof() para obtener el tamaño del dato y luego cuando incrementes el índice le pasas ese valor por ejemplo:


int16 addres;
for(int i = 0; i < strlen(consigna); i++)
  {
     addres = ptr + sizeof(consigna[0])*i;
     putc(&addres);
  }

Espero que con eso elimines las jerigonzas. Dime si sale bien para guardarlo en mi sesoteca.

Saludos Reinier

[Nocturno]

Ah, claro. Si le quito "const" sí funciona, pero entonces deja de ser una constante.

No entiendo bien tu ejemplo, Reinier. ¿De dónde sale "ptr"?

[RedPic]

Claro, sin const es una variable que ocupa RAM, con const es una constante que ocupa ROM

El truco estriba en usar una porcion de ROM direccionandola como si fuese RAM. En el curso que dimos sobre dsPIC éstos lo hacían directamente .... Pero parece que en los 16F y los 18F esto es más dificil (cuanto menos)

[Nocturno]

Sí, con C30 y dsPIC sale fácil. De hecho ya lo uso y por eso estoy encabezonado con conseguirlo en CCS para 18F.

Avanzando en mi investigación, observo que el printf se lo traga bien sin distinguir si son constantes o no. Ahora intento comparar el tratamiento que el comando "printf" hace de las strings que están en RAM  con el que hace de las que están en ROM.

Pego aquí un trozo de programa y su compilación. Sólo tiene dos líneas, cuya única diferencia es que en la primera intento imprimir la constante "yo" y en la segunda el string "consigna", que no es constante:

Código: ASM

1. 71:                   printf (glcd_caracter,yo);
2.   04CA    6A31     CLRF 0x31, ACCESS
3.   04CC    5031     MOVF 0x31, W, ACCESS
4.   04CE    DD9A     RCALL 0x4
5.   04D0    2A31     INCF 0x31, F, ACCESS
6.   04D2    6E00     MOVWF 0, ACCESS
7.   04D4    6A34     CLRF 0x34, ACCESS
8.   04D6    6E33     MOVWF 0x33, ACCESS
9.   04D8    DE87     RCALL 0x1e8
10.   04DA    0E0F     MOVLW 0xf
11.   04DC    5C31     SUBWF 0x31, W, ACCESS
12.   04DE    E1F6     BNZ 0x4cc
13. 72:                   printf (glcd_caracter,consigna);
14.   04E0    6AEA     CLRF 0xfea, ACCESS
15.   04E2    0E08     MOVLW 0x8
16.   04E4    6EE9     MOVWF 0xfe9, ACCESS
17.   04E6    0E00     MOVLW 0
18.   04E8    10EF     IORWF 0xfef, W, ACCESS
19.   04EA    E010     BZ 0x50c
20.   04EC    CFEA     MOVFF 0xfea, 0x32
21.   04F0    CFE9     MOVFF 0xfe9, 0x31
22.   04F4    6A34     CLRF 0x34, ACCESS
23.   04F6    CFEF     MOVFF 0xfef, 0x33
24.   04FA    DE76     RCALL 0x1e8
25.   04FC    C032     MOVFF 0x32, 0xfea
26.   0500    C031     MOVFF 0x31, 0xfe9
27.   0504    2AE9     INCF 0xfe9, F, ACCESS
28.   0506    B4D8     BTFSC 0xfd8, 0x2, ACCESS
29.   0508    2AEA     INCF 0xfea, F, ACCESS
30.   050A    D7ED     BRA 0x4e6

Ahora ya estoy de fango hasta las orejas, porque el ASM y yo no nos llevamos bien. Si alguno de vosotros lo ve claro en eso que he pegado, agradeceré su ayuda.

[PalitroqueZ]

Claro, sin const es una variable que ocupa RAM, con const es una constante que ocupa ROM

El truco estriba en usar una porcion de ROM direccionandola como si fuese RAM. En el curso que dimos sobre dsPIC éstos lo hacían directamente .... Pero parece que en los 16F y los 18F esto es más dificil (cuanto menos)

ahora que analizo mejor el comentario de Diego,  pienso que la aplicación de punteros a constantes si es fáctible, porque la idea es liberar la RAM de las largas tablas y dejar esto para la ROM, el problema es que para acceder a ella se necesita un puntero.

dicho de otra forma, los datos declarados como constantes se alojan en la ROM y su acceso es a través de su dirección.

es lo mismo que dijo RedPic, estoy viendo que en los PIC18 existe una instrucción TBLRD para leer y TBLWT para escribir en  la memoria de programa. pero ya es ensamblador