variable long a 2 int

[israelmx]

Hola amigos de todas partes  antes que nada feliz 2007 y mucho exito para este año en todos sus proyectos.

Tengo unas cuantas dudas, estoy haciendo un programa que recibe 2 bytes por la usart en una variable long, quiero separar esta variable long y hacerla en 2 int, como puedo hacerlo en CCS PICc soy nuevo y quiero ver como se puede hacer, aparte tengo problemas con la int de la usart al parecer cuando simulo con el mplab no la hace, les anexo el codigo, espero que me puedan ayudar.


#FUSES WDT                      //Watch Dog Timer
#FUSES INTRC_IO                 //Internal RC Osc, no CLKOUT
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES BROWNOUT                 //Reset when brownout detected
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection

#use delay(clock=4000000,RESTART_WDT)
#use rs232(baud=9600,parity=N,xmit=PIN_B2,rcv=PIN_B1,bits=8,restart_wdt)
#use fast_io(a)
#use fast_io(b)

#bit q4           =0x06.7
#bit q3           =0x06.6
#bit q2           =0x06.5
#bit q1           =0x06.4
#bit ledr        =0x06.3
#bit ledv        =0x06.0

int   control;

#bit btx     =control.0
#bit bobj     =control.1
#bit bled     =control.2

int ks=0, qs=0;

#int_RDA
RDA_isr(int &ks, int &qs)
{
   int caso, datl;
   long dato;
   dato=getc();
   caso=dato&&0xff00;
   swap(caso);
   
  switch (caso)
   {
      case 1: ks=datl; break;
      case 2: qs=datl; break;
   }
}

void main()
{
   setup_timer_0(RTCC_INTERNAL);setup_wdt(WDT_2304MS);
  setup_timer_1(T1_DISABLED);
  setup_timer_2(T2_DISABLED,0,1);
  setup_comparator(NC_NC_NC_NC);
  setup_vref(FALSE);
  enable_interrupts(INT_RDA);
  enable_interrupts(GLOBAL); 
  set_tris_a(0xff);
  set_tris_b(0x06);
   porta=0x00;
   portb=0x00;
   
   printf("Listo");

   
   while(true)
   {
      //output_high(ledv);
      ledv=1;
   }
   
}



Saludos.

[Nocturno]

En CCS los long tienen 16 bits. Hay varios tipos de int, aunque sospecho que te refieres al int8.

Si partimos de esa suposición, la forma de dividir un long en dos int sería la siguiente:

Código: [Seleccionar]

long Word;
int8 byteMSB, byteLSB;

byteMSB = Word >> 8;
byteLSB = Word & 0xFF;

[dhmejia]

Hay algunas cosas que no entiendo del código de israelmx:

#int_RDA
RDA_isr(int &ks, int &qs)
{
   int caso, datl;
   long dato;
   dato=getc();
   caso=dato&&0xff00;
   swap(caso);
   
  switch (caso)
   {
      case 1: ks=datl; break;
      case 2: qs=datl; break;
   }
}
*Para que recibes parámetros en la función que atiende la interrupción?  luego no les estas asignando valores a esos parámetros?
*Dentro del switch haces: Ks = datl, pero a la variable datl nunca le asignas un valor, o sería datl = Ks???
*La varible que recibe el dato del buffer la declaras como long (16 bits), pero hasta donde tengo entendido el buffer del PIC es de 8 bits, acaso el ccs puede hacer que el PIC maneje un buffer de 16 bits y se genere interrupción solo cuando se han recibido los dos bytes??

Desde mi punto de vista creo que tienes errores en el código, incluso creo que no necesitas separar ningún dato de 16 bits en dos de 8 bits, lo podrías hacer de esta forma:

int dato[2];
int numero_datos = 0;

#int_RDA
RDA_isr()
{
   int dato1, dato2;

   if(kbhitt())
   {
         dato[numero_datos] = getc(); //en el array datos quedan los dos bytes recibidos.
   }
   numero_datos++;
   if(numero_datos == 2) //si es 2, ya se recibieron los 2 bytes.
   {
       numero_datos = 0;
          ....//aca lo que quieras hacer con los bytes recibidos.
    }
}

Solo es otra idea que te doy para que pongas a funcionar tu programa, puede tener errores ya que fue hecho sin editor y medio a las carreras.

saludos,

[israelmx]

Muchas gracias nocturno y dhmejia, en efecto nocturno eso era lo que queria, pero tienes razon dhmejia, de hecho el codigo como comente lo escribi tratando de simular en el mplab y fue cuando me di cuenta que en efecto de todos modos el buffer del pic es de 8 bits y no podia recibir 2bytes de un jalon, el codigo que me pasaste va de maravilla asi que ya ni tengo que pasar la variable long a int, pero me funciona tambien el codigo nocturno porque gracias a eso ahora pase mis 2 bytes int a uno solo long.


Muchas gracias a los 2 por su ayuda, que hariamos varios de este foro sin uds y sin el foro

Saludos

[pikman]

Tarde pero bueno, hay en CCS una funcion para hacer eso, es MAKE8(), que lo que hace es extraer variables enteras desde int16 o long, tambien es posible programar la usart para recibir words por lo que se puede llegar a simplificar mucho tu requerimiento.

[israelmx]

muchas gracias pikman, con las 2 formas me va muy bien la de nocturno y la tuya, son muy hamables, para hacer que la usart reciba palabras es por medio de un buffer, verdad como comenta dhmejia o hay otra forma ??


Muchas gracias de antemano saludos

[pikman]

Pues la funcion MAKE hace lo que muestra mas arriba nocturno, para transmitir y recibir varialbles long es asi


#use rs232(baud=9600, xmit=PIN_A2,rcv=PIN_A3,LONG_DATA)

El manual dice:

LONG_DATA
 
Makes getc() return an int16 and putc accept an int16.  This is for 9 bit data formats.

Espero que te ayude.

 

[maunix]

Pues la funcion MAKE hace lo que muestra mas arriba nocturno, para transmitir y recibir varialbles long es asi


#use rs232(baud=9600, xmit=PIN_A2,rcv=PIN_A3,LONG_DATA)

El manual dice:

LONG_DATA
 
Makes getc() return an int16 and putc accept an int16.  This is for 9 bit data formats.

Espero que te ayude.

 

Una aclaración, es para el formato de 9 bits pero el dato en sí será (en lo común) de 8 bits y  el 9no bit sería el de paridad, o bien un 9no bit de datos.

De todas formas, nunca pensar en enviar/recibir una variable de 16 bits de esta forma.

La limitante está siempre en el PIC cuyo buffer de transmisión es de 8 bits.

[pikman]

Hola, MAUNIX, nunca la he probado, de cualquier manera me imagino que usara 2 variables de 8 bit para recibir un dato, claro que vaya a saber como hara, es cierto lo del buffer,  voy a probarlo.

[maunix]

Hola, MAUNIX, nunca la he probado, de cualquier manera me imagino que usara 2 variables de 8 bit para recibir un dato, claro que vaya a saber como hara, es cierto lo del buffer,  voy a probarlo.

pikman, yo no uso el CCS pero leyendo la breve descripción en inglés que has puesto, da a intuir precisamente que se envía/recibe 1 byte + el 9no bit que pudiera ser un bit de paridad y/o 9no bit de datos (a gusto del usuario aunque no tiene mucho gollete una transmisión de 9 bits de datos...)

Pensando de otra forma, tampoco veo muy loable que hagan una función para leer 2 bytes de la usart y guardarlos en una variable int, ya que esto no sería compatible con el modo interrupción por ejemplo.  Es decir, por hardware se leen si o si 1 solo byte y se genera un encendido del flag al arribar uno de estos. 

Saludos.

[pikman]

Si, MAURICIO, la verdad es que es cierto lo que comentas, pero como te explicaba nunca lo probe, solo que leo mucho el manual, luego dejo los comentarios de lo que hace pues puedo ver con el ICD en tiempo que es lo que pasa en el micro, despues te cuento.

[maunix]

Si, MAURICIO, la verdad es que es cierto lo que comentas, pero como te explicaba nunca lo probe, solo que leo mucho el manual, luego dejo los comentarios de lo que hace pues puedo ver con el ICD en tiempo que es lo que pasa en el micro, despues te cuento.

No te la compliques tanto, si ves el ASM generado podrás intuir que hace