El make8 sólo funciona con CCS. A mí me gusta más hacerlo de esta manera que es ANSI C:Código: [Seleccionar]int8 Data_H, Data_L;
int16 DataLong;
Data_H=DataLong>>8;
Data_L=DataLong & 0xFF;
Aunque si el truncado funciona como dice Bruno el programa es más sencillo, pero ojo, luego te puedes volver loco para entenderlo.
.................... DataLong=0x0000;
0010: BCF 03.5
0011: CLRF 22
0012: CLRF 21
.................... Data_H=0x01;
0013: MOVLW 01
0014: MOVWF 23
.................... Data_L=0x02;
0015: MOVLW 02
0016: MOVWF 24
....................
.................... //Proceso lento
.................... Data_H=DataLong>>8;
0017: MOVF 22,W
0018: MOVWF 23
.................... Data_L=DataLong & 0xFF;
0019: MOVF 21,W
001A: MOVWF 24
....................
.................... //Optimizado en ensamblador
.................... Data_H=make8(DataLong,1);
001B: MOVF 22,W
001C: MOVWF 23
.................... Data_L=DataLong; //casting implícito
001D: MOVF 21,W
001E: MOVWF 24El make8 sólo funciona con CCS. A mí me gusta más hacerlo de esta manera que es ANSI C:Código: [Seleccionar]int8 Data_H, Data_L;
int16 DataLong;
Data_H=DataLong>>8;
Data_L=DataLong & 0xFF;
Aunque si el truncado funciona como dice Bruno el programa es más sencillo, pero ojo, luego te puedes volver loco para entenderlo.
Cuidado Nocturno, acuérdate que ese tipo de instrucciones son lentas y en estos días de mini-concursos no nos podemos dar el lujo de gastar más microsegundos. :mrgreen:
Cada rotación de bit implica más de una instrucción en ensamblador y MAKE8 solo usa 2 instrucciones máximo. Pero hice un descubrimiento, CCS optimizó el código e ignoró las 8 rotaciones e incluso ignoró la AND que aplicas:Código: [Seleccionar].................... DataLong=0x0000;
0010: BCF 03.5
0011: CLRF 22
0012: CLRF 21
.................... Data_H=0x01;
0013: MOVLW 01
0014: MOVWF 23
.................... Data_L=0x02;
0015: MOVLW 02
0016: MOVWF 24
....................
.................... //Proceso lento
.................... Data_H=DataLong>>8;
0017: MOVF 22,W
0018: MOVWF 23
.................... Data_L=DataLong & 0xFF;
0019: MOVF 21,W
001A: MOVWF 24
....................
.................... //Optimizado en ensamblador
.................... Data_H=make8(DataLong,1);
001B: MOVF 22,W
001C: MOVWF 23
.................... Data_L=DataLong; //casting implícito
001D: MOVF 21,W
001E: MOVWF 24
Por lo que el código MAKE8 y el código de rotaciones de Nocturno son exactamente lo mismo... después de ser optimizados.
Pero si el compilador no es optimizado habrá que buscar una instrucción integrada del compilador que haga el trabajo rudo más rápido como MAKE8.
#OPT
--------------------------------------------------------------------------------
Syntax:
#OPT n
Elements:
All Devices: n is the optimization level 0-9
PIC18XXX: n is the optimization level 0-11
Purpose:
The optimization level is set with this directive. This setting applies to the entire program and may appear anywhere in the file. The PCW default is 9 for full optimization. PIC18XXX devices may utilize levels 10 and 11 for extended optimization. Level 9 may be used to set a PCW compile to look exactly like a PCM compile for example. It may also be used if an optimization error is suspected to reduce optimization.
Examples:
#opt 5
#include <18F252.h>
#device adc=10
#fuses XT, nowdt,
#use delay(clock= 4000000) //Ajusta las rutinas de retardo para operar a 32Mhz( 4 x 8Mhz), con el pll activado
#use RS232(baud=9600,xmit=pin_c6,rcv=pin_c7)
void main()
{
int16 dato= 0x3479;
int low_long, high_long;
low_long= make8(dato,0);
high_long= make8(dato,1);
printf("%X %X", high_long, low_long);
while(true);
}
Hola a todos Necesito mandar un INT16 a otro micro madiante protocolo SPI El problema es que nisiquiera logro partirlo en 2 INT8 Las instrucciones en este
o cualquier otro foro parecen simples pero llevo ya 3 dias con lo mismo y nada funciona Esto es lo que e probado entre otras cosas:
//DECLARACIONES
int16 pru1=1320;
int8 v8,v16;
int8 posicion;
//......................................
v8=make8(pru1,0);
v16=make8(pru1,1);
//FRACASO 2.................................
posicion=&pru1
v8=make8(posicion,0);
v16=make8(posicion,1);
//FRACASO 3................................
v8=make8(*(&pru1),0);
v16=make8(*(&pru1),1);
//FRACASO 4................................
v8=pru1>>8;
v16=pru1 & 0xff;
//En todos los casos el RESULTADO ES V8=40 V16=5
Me gustaria saber que es lo que hago mal ¿make8 necesita alguna libreria? E oido ablar de macros en referencia a make16
desde luego el que yo e hecho en make8 no es valido #define make8(Variable,Bit) *(&Variable+Bit)
Si fuese por esto cual es el macro adecuado para lo que yo necesito
saludos
Si e visto que le pasa la posicion en dos partes desde el principio pero a esto le veo dos pegas
De que me sirve pasarle una posicion de memoria cuando lo que necesito es pasarle un contenido de esta (sus 2 punteros) una vec que llege a la 0x0528 del otro de que me va a servir me veo en las mismas lo que necesito es meterle el dato
y la otra es si pru1=1320 deja de ser puntero y lo que hace es combertirse en una posicion mediante make8 o lo que sea Como se yo que la 0x0528 No esta ocupada por el contenido de otra variable y asi acabar falseando datos O lo que es peor sea una zona reservada al micro. Esta ultima duda se me pasa tambien cuando veo "write_eeprom(posicion,pru1);"
EDIT:
Usar unionCódigo: C
Si a por lo ultimo es a por lo que e ido acavo de probarlo pero le falta ago o me falta algo amy Cuando declaro la estructura (eso a mi me parece lo que es) El compilador me da un monton de errores en lineas que no tienen nada que ver con ella Si cambio 'struct' por 'union' pasa lo mismo.
No puedo olvidarme del "tipo" de variable, cuando justo lo que necesito es este "tipo" es imprescindible Aunque ahora me dedique a hacer pruebas a lo bestia pasando datos descomunales a intencion de hacerlo lo mas rapido posible (Esto no es necesario en proyecto original, pero si el float)
Volviendo al principio que es EnviarSPI((shor int *)&datoFloat,sizeof(datoFloat)); ¿fucion,macro,define? EnviarSPI No esta declarado en ningun sitio
¿que es lo que hace darte el tamaño de float?