Problemas con el paso de punteros en C CCS v4.104

[ariznaf]

Hola amigos.
Estoy teniendo un problema muy extraño con el paso de punteros a una cadena de caracteres.

Cuando paso un puntero a una cadena de caracteres, a una función, el puntero cambia de valor.
El puntero fuera de la función es de tipo

char *pos;
La función está declarada como
int funcion(char *c)

El puntero pos antes de la llamada apunta a la posición adecuada, tomando un valor tal como 0x002A (un número de 16bits).
Cuando lo paso, resulta que la variable c toma un valor tal como 0x2A (lo que parece que es un puntero de 8 bits).

El primer caracter lo leo correctamente, pero cuando incremento el puntero c dentro de la función (c++) en vez de apuntar a la posición 0x2B que es donde se encuentra el siguiente caracter, pasa a tomar el valor 0x01.


Lo curioso es que hay veces que funciona y otras no, sin haber cambiado nada en la función es sí, si no en otras partes del programa que nada tienen que ver.

Sospecho que algo tenga que ver con la paginación de la memoria (el hecho de que esté distrubuida en bancos) y que sea un bug del compilador.

He probado a usar la declaración de punteros de 16 y 8 bits (con #device *=8 y 16).
Pero el problema es el mismo.
Cuando lo declaro como de 16 bits, si el puntero fuera apunta a 0x002A, cuando lo recibe pasa a valer 0x00 y ya no apunta a donde debe.

Sólo funcionó algunas veces cuando los declaro como de 8 bits.

Estoy desesperado.... ¿alguna idea?
Gracias.

Por cierto, estoy usan la versión del compilador CCS 4.104 y el entorno MPLAB de microchip.

[AngelGris]

En Hi Tech, cuando hago una función a la cual le paso un puntero y sé que no voy a modificar la cadena la defino así

Código: C

1. void WriteStrLcd (const char *palabra)

[Suky]

En Hi Tech, cuando hago una función a la cual le paso un puntero y sé que no voy a modificar la cadena la defino así

Código: C

1. void WriteStrLcd (const char *palabra)

En CCS no se puede.


ariznaf muestranos código por favor.


Saludos!

[AngelGris]

Gracias por la aclaración, yo nunca sé bien que se puede hacer en cada compilador y encima ahora hace rato que no hago nada.

[ariznaf]

La verdad es que este compilador de CCS me tiene un poquito harto.

Desde luego no es un compilador ANSI C.
Ahora tengo que acabar ya lo que estoy con él, pero creo que probaré el de Hitech a ver si es un compilador más estándar.

Ahora parece que me funciona con punteros de 8 bits, aunque estoy con las espaldas abiertas, pues en cuanto toque un poco el código seguro que vuelve a las andadas.

El código lo único que hace es recorrerse un buffer en el que están almacenados los comandos para ir interpretándolos.
Cuando tiene que leer un número en hexadecimal, llama a unas funciones que hacen la converisón (Hex2Int8 y Hex2Int16 según sea un entero de 8 bits o de 16 el que se espera leer).
Las funciones para la conversión son las siguientes:

Código: [Seleccionar]

//Convertir un caracter hexadecimal (0-9 y A-F) en su correspondiente
//valor numérico, de 0 15 (un nibble de 4 bits almacenado en la posición más baja
//del byte devuelto.
//Si el caracter pasado no es hexadecimal la función devuelve 0xFF (255).
//Los caracteres han de estar en mayúsculas.
int8 Hex2Nibble(char c)
{
if( (c >= 'A') && (c<='F') ) {
return 10+c- 'A';
} else if ( (c >= '0') && (c <= '9') ) {
return c- '0';
}
return 0xFF;
}

int8 Hex2Int8(byte *c,int &err)
{
int8 n, valor;
n= Hex2Nibble(*c);
err= (n==0xFF);
if( err ) return 0xFF;
valor = n<<4;
c++;
n= Hex2Nibble(*c);
err= (n==0xFF);
if( err ) return 0xFF;
return valor|n;
}

int16 Hex2Int16(byte *c,int &err)
{
int8 n;
int16 valor;
n= Hex2Nibble(*c);
err= (n==0xFF);
if( err ) return 0xFFFF;
valor = n<<12;
c++;
n= Hex2Nibble(*c);
err= (n==0xFF);
if( err ) return 0xFFFF;
valor |= n<<8;
c++;
n= Hex2Nibble(*c);
err= (n==0xFF);
if( err ) return 0xFFFF;
valor |= n<<4;
c++;
n= Hex2Nibble(*c);
err= (n==0xFF);
if( err ) return 0xFFFF;
return valor|n;
}


En la subrutina de procesar los comandos, tengo puesto un código como el siguiente:

Código: [Seleccionar]


Variable global:
char comando[16];

Subrutina:
................
               char * pos;

pos= comando;
//Leer el ID de la estación, si se produce un error al leerlo, ignorar el comando recibido.
id= Hex2Int8(pos,err);

.............

Al pasar pos a la función, el valor de pos cambia. Ya no parece ser un número de 16 bits, si no de 8.
Cuando incremento el puntero, resulta que en vez de pasar al caracter siguiente se va a otra parte de la memoria fuera de la cadena de comandos.

En alguna de las pruebas pos valía 0x002A antes de llamar a la subrutina.
Nada más entrar, c tomaba el valor 0x2A, el *c contenía el caracter adecuado, con lo que la primera parte del número se leía bien.
Al incrementar el puntero, pasaba a tomar el valor 0x01 en vez de 0x2B y por supuesto *c ya no tenía el valor adecuado, si no un caracter cualquiera.

Lo raro rarísimo es que unas veces me pasaba y otras no.

He probado con punteros de 16 bits (#device *=16) pero entonces parece que siempre funciona mal.
Con punteros de 8 bits, unas veces va bien, pero cuando añado código por otros lados (que no tienen nada que ver con estas subrutinas) a veces deja de funcionar.