¿Cuál es la explicación?

[Nocturno]

Tengo un programa que no me funciona si hago esto:
                posmem=(40*y)+(x/8);

y sin embargo va perfecto cuando hago esto:
   posmem=(40*y);
   posmem+=(x/8);

¿Sabéis a qué puede ser debido?

Gracias

[gauchosuizo]

hola

como has definido las variables posmem, x y y??

Aloha

[Nocturno]

Posmem es long, las otras dos son int.

[pocher]

La verdad que no le veo mucho sentido, si la forma: posmem=(40*y)+(x/8); no va bien, la 2ª forma posmem=(40*y); posmem+=(x/8); también tendría que fallar.

Si defines todas las variables como long las dos formas te deben de funcionar.

Un saludo

[J1M]

prueba con esto:

posmem=((40*y)+(x/8));

quizá no solucione nada, pero a veces al CCS se le va la pinza con el tema de parentesis.

saludos!

[Nocturno]

He probado ambas alternativas, la de definir todo long y la de poner más paréntesis, pero no soy capaz de que funcione.
Bueno, sólo era curiosidad; al fin y al cabo, dividido en dos líneas no hace cosas raras.

Por cierto, no es CCS, es C30

[damago]

Miedo me da ese compilador si te hace eso .
Ya que estas con el tema de la curiosidad... exale un vistazo al ensamblador que genera esas instrucciones para ver k ha hexo el compilador...y nos lo cuentas ... o pegalo aqui.

Un saludo.

[Nocturno]

Este es el Disassembly listing:
Ete funciona

Codigo:279:                  posmem=(40*y);
00033A  90402E     mov.b [0x001c+2],0x0000
00033C  FB0080     se.b 0x0000,0x0002
00033E  200280     mov.w #0x28,0x0000
000340  B98800     mul.ss 0x0002,0x0000,0x0000
000342  DE80CF     asr 0x0000,#15,0x0002
000344  980720     mov.w 0x0000,[0x001c+4]
000346  980731     mov.w 0x0002,[0x001c+6]
280:                  posmem+=(x/8);
000348  78001E     mov.w [0x001c],0x0000
00034A  200082     mov.w #0x8,0x0004
00034C   90011     repeat #17
00034E  D80002     div.sw 0x0000,0x0004
000350  B90161     mul.su 0x0000,#1,0x0004
000352  90002E     mov.w [0x001c+4],0x0000
000354  9000BE     mov.w [0x001c+6],0x0002
000356  410000     add.w 0x0004,0x0000,0x0000
000358  498081     addc.w 0x0006,0x0002,0x0002
00035A  980720     mov.w 0x0000,[0x001c+4]
00035C  980731     mov.w 0x0002,[0x001c+6]

Ete no funciona

Codigo:279:                  posmem=(40*y)+(x/8);
00033A  90402E     mov.b [0x001c+2],0x0000
00033C  FB0080     se.b 0x0000,0x0002
00033E  200280     mov.w #0x28,0x0000
000340  B98A00     mul.ss 0x0002,0x0000,0x0008
000342  78001E     mov.w [0x001c],0x0000
000344  200082     mov.w #0x8,0x0004
000346   90011     repeat #17
000348  D80002     div.sw 0x0000,0x0004
00034A  400004     add.w 0x0000,0x0008,0x0000
00034C  DE80CF     asr 0x0000,#15,0x0002
00034E  980720     mov.w 0x0000,[0x001c+4]
000350  980731     mov.w 0x0002,[0x001c+6]

[tornar]

A mi a veces me ha pasado lo mismo usando expresiones matematicas con el CCS, inlcuso a veces no llegaba a coger un a=a+y, y habia que ponerle a+=y. Creo que lo mejor que se puede hacer en estos casos es enviar un e-mail al servicio tecnico de CCS, alertando de este problema, para que en proximas versiones lo corrijan.

[rakla23]

Hola Nocturno, le he echado un vistazo al codigo,  pero tengo duda en alguna de las operaciones. Tienes el pdf del ensamblador de ese compilador o la direccion donde encontrarlo?.... por saber que ha hecho mal....

Un saludo.

[Nocturno]

¿El ensamblador del compilador?, no sé cuál será ese documento. Donde sí vienen todas las instrucciones ASM que soportan los dsPIC es en su datasheet:
http://ww1.microchip.com/downloads/en/DeviceDoc/70083g.pdf

De todas formas, creo que ya sé dónde está el error. Es que en mi programa en C30 mezclo el C con algunas instrucciones ASM en la que uso determinados acumuladores. Sospecho que alguno de esos acumuladores es usado también en ese trozo de programa y de ahí viene el lío.

Para que esto sea así, cuando divido la operación en dos líneas, es probable que no use ese acumulador y sí otros.

[damago]

Hola nocturno, soy la pantera rosa (rakla23 ) jeje.... ya ves, mi novia tb se mete en otros foros de miarroba y ni me di cuenta con que nick estaba

Me bajao el pdf que me has puesto y le he estado dando vueltas al codigo y no veo el error...vamos a comentarlo a ver si alguien ve el gazapo:

Ete funciona

Codigo:279:                  posmem=(40*y);

00033A  90402E     mov.b [0x001c+2],0x0000 ; copia "y" (variable de 8 bits) en la direccion 0

00033C  FB0080     se.b 0x0000,0x0002 ; extiende el signo, a tamaño de palabra de 16 bits (el signo es el bit de mayor peso) y lo guarda en la direccion 2.
; ej: si era 0x47 -> 0x0047
; si era 0x83      -> 0xff83
; asi tenemos representado ay sea positivo o negativo el numero en 16 bits.
00033E  200280     mov.w #0x28,0x0000 ; copiamos el 40 en la direecion 0

000340  B98800     mul.ss 0x0002,0x0000,0x0000 ; multiplica el word 0 y 2 (16bits x 16 bits)

000342  DE80CF     asr 0x0000,#15,0x0002 ; vuelve a extender el signo, ahora a long (4bytes)
; si el bit de mayor peso del resultado es 0,  positivo. Si era 1, pues es negativo
; ej:  0x4511 -> 0x00004511
;       0xf255   ->0xfffff255

000344  980720     mov.w 0x0000,[0x001c+4]

000346  980731     mov.w 0x0002,[0x001c+6] ; guardamos esa operacion en long

280:                  posmem+=(x/8); ; nueva operacion

000348  78001E     mov.w [0x001c],0x0000 ; copiamos "x" (tamaño 16 bit) en al direccion 0

00034A  200082     mov.w #0x8,0x0004 ; copiamos 8 en al direccion 4

00034C   90011     repeat #17 ; NO ENTIENDO??? xk repite 18 veces la siguiente instruccion ????

00034E  D80002     div.sw 0x0000,0x0004 ; divide x entre 8

000350  B90161     mul.su 0x0000,#1,0x0004 ; multiplica por 1 el resultado, simplemente para pasar el resultado de word a long

000352  90002E     mov.w [0x001c+4],0x0000

000354  9000BE     mov.w [0x001c+6],0x0002

000356  410000     add.w 0x0004,0x0000,0x0000

000358  498081     addc.w 0x0006,0x0002,0x0002 ; suma resultado operacion anterior y el de la de ahora

00035A  980720     mov.w 0x0000,[0x001c+4]

00035C  980731     mov.w 0x0002,[0x001c+6] ; guarda resultado

ME PARECE TODO OK,....menos el repeat que no se k hace aqui

-----------------

Ete no funciona

Codigo:279:                  posmem=(40*y)+(x/8);

00033A  90402E     mov.b [0x001c+2],0x0000 ; copia "y" (8bits) en la direccion 0

00033C  FB0080     se.b 0x0000,0x0002 ; extiende el signo a 16bit y lo copia en la direccion 2

00033E  200280     mov.w #0x28,0x0000 ; copia el 40 a la direccion 0

000340  B98A00     mul.ss 0x0002,0x0000,0x0008; multiplica la direccion 0 y 2 (tamaño 16x16 bits)....es decir como antes los byte 0 y 1 forman un operando y el 2 y 3 el otro operando
; el resultado queda guardado en los byte 8,9,10,11 (4byte). Solo nos interesan el 8 y 9
000342  78001E     mov.w [0x001c],0x0000 ;copiamos "x" (tamaño 16bit) en la direccion 0

000344  200082     mov.w #0x8,0x0004; copiamos 8 en la direccion 4

000346   90011     repeat #17; ??????????????

000348  D80002     div.sw 0x0000,0x0004 ; dividimos y el resultado queda guardado en la direccion 0

00034A  400004     add.w 0x0000,0x0008,0x0000; sumamos la operacion anterior y la de ahora

00034C  DE80CF     asr 0x0000,#15,0x0002 ; extendemos el signo a long

00034E  980720     mov.w 0x0000,[0x001c+4]

000350  980731     mov.w 0x0002,[0x001c+6] ; guardamos resultado

TAMBIEN ME PARECE CORRECTA, y no lo es...xo no se porque...

Que querias decir con que igual usabas algunas de estas direcciones ? es decir....aunque las uses en otro trozo de programa...todo este codigo lo ejecuta junto (es una linea en C)...no hay instrucciones tuyas por medio que fastidien la operacion...

Ves el fallo en el comentario del codigo?? pensare un poco mas....
Enga, un saludo. Dani.

[Nocturno]

Gracias por tu extenso análisis, Dani. Lo que quiero decir con lo del uso del acumulador es lo siguiente.
En mi programa hay determinados arrays que recorro en ASM, y mantengo un puntero a la dirección que estoy leyendo en cada momento en acumuladores del micro, de esta forma:
asm(" mov.w #_buf,w13  "; // mueve el puntero buf al acumulador 13
No es w13 el único que uso, también lo hago con w10 y w5.

Pues bien, lo que me pasa es que el programa se vuelve loco cuando lo compilo con la instrucción posmem=(40*y)+(x/8);  pero no cuando lo fracciono en dos partes. Lo de que "se vuelve loco" no significa que no haga bien la operación, sino que luego hace cosas raras, por lo que sospecho que está usando uno de los acumuladores y poniéndole un valor distinto al que tenía yo, por lo que la lectura del array se va al carajo.

[damago]

ahora si lo entiendo. Entonces retiro lo de que me daba miedo ese compilador

un saludo. Dani.

[pikman]

Hola, a mi me paso algo parecido, pero en CCS, anuque quise probarlo en C30 , no se que pasa que no anda ahora, instale el MPLAB 7.0 y anda el  C30, pero prueba esto, a ver que pasa y me cuentas.

posmem=(40*(long)y)+((long)x/8);

saludos

ARIEL