Config. 2 puertos seriales con 1 interrupcion(#INT_RDA)

[25javier]

Hola listeros,nescito usar dos puertos seriales del pic,uso uno por hard y otro por soft(usando STREAM) ..andan los dos bien..el tema es que cuando trato de usar la interrupcion(#INT_RDA) para ver cuando recibo datos solo lo puedo hacer con el puerto por hard..hay alguna manera de que entre a la interrupcion cuando llegan datos a cualquiera de los dos puertos y dentro de la interrupcion distinguir por que puerto entro??
gracias por adelantado
saludos
Javier

#USE RS232(BAUD=9600, XMIT=PIN_C7, RCV=PIN_C6, STREAM=PIC)
#USE RS232(BAUD=9600, XMIT=PIN_B2, RCV=PIN_B3, STREAM=PC)

[Chaly29]

Hola 25javier, los PIC poseen un conjunto de instrucciones que esta definido desde fabrica, por lo tanto no es opcional que tú lo configures, lo que puedes hacer es que la entrada serial que responde con el software justo sea la misma (por ejemplo) que el pin RB0, por lo tanto al recibir una transmisión este pin generaría la interrupción correspondiente al mismo, y tu si por medio de software tendrás que deducir cual de las dos entradas a sido leyendo el flag correspondiente para las 2 interrupciones posibles.

Espero te sea de utilidad, un saludo y suerte.

Atte. CARLOS

[manex_1987]

prueba a usar la directiva kbhit() , es lo que se usa para el rs232 por soft.

[lovando]

Debes usar una rutina de atencion de interrupcion en puerto B, por ejemnplo en RB0....

Hay que habilitarla


ext_int_edge(H_TO_L);
enable_interrupts(INT_EXT);
           

Te dejo un programa que comunica 2 PC mendiante el PIC....



////////////////////////////////////////////////////////////////////////////////
//  Configuracion Global                                                      //
//                                                                            //

#include <16F648a.h>
#fuses INTRC_IO,NOWDT,PUT,BROWNOUT,NOPROTECT,MCLR,NOLVP,NOCPD
#use delay(clock=4000000)
#use rs232(baud=9600,parity=N,xmit=PIN_B5,rcv=PIN_B0,bits=8,stream=PC,errors)
#use rs232(baud=9600,parity=N,xmit=PIN_B2,rcv=PIN_B1,bits=8,stream=PC2ors)
//
// baud=38400 maximo usando 4 Mhz
//
////////////////////////////////////////////////////////////////////////////////

/******************************************************************************/
/* Definicion de buffers para recivir los chars de los puertos PC/PC2      */

#define BUFFER_SIZE 30        //Tamaño del buffer...depende de la aplicación que queramos.
BYTE buffer[BUFFER_SIZE];
BYTE next_in = 0;             //posición del siguiente carácter de entrada
BYTE next_out = 0;            //posición del siguiente carácter de salida

#define BUFFER_SIZE2 30       //Tamaño del buffer...depende de la aplicación que queramos.
BYTE buffer2[BUFFER_SIZE2];
BYTE next_in2 = 0;            //posición del siguiente carácter de entrada
BYTE next_out2 = 0;           //posición del siguiente carácter de salida


/********* Rutina de atencion de Interrupcion puerto serie¨PC2  ***********/

#int_rda   // Interrupcion Received Data Available en UART.

//guarda los datos recibidos en el UART provenientes del PC2 eun
//buffer, usando la interrupción rda.
//esto garantiza que no se pierdan datos y que el programa no se quede colgado a
//la espera de recibir algo que no llega
//
// NOTA: Funcion no distingue caracteres especiales como
 ni

/******************************************************************************/

rda_isr() {
int t;                              // t, variable para memorizar el indice
buffer[next_in]=fgetc(r520m);       // Guarda en buffer[] el char recibido desde PC2
t=next_in;                          // t registra y memoriza el valor actual del indice del buffer.
next_in=(next_in+1) % BUFFER_SIZE;  // incrementa el indice para saber si el buffer esta lleno
if(next_in==next_out)               // Compara el indice/tamaño del buffer entrada y salida
next_in=t;                          // Buffer lleno !!. Restaura el indice (tamaño) del buffer
}

/********* Rutina de atencion de Interrupcion puerto serie del PC  ************/

#int_EXT  // Interupcion Externa en RB0. Rutina identica a int_rda, pero
/*                                       sobre otro buffer                    */
/******************************************************************************/

ext_isr() {
int t2;
buffer2[next_in2]=fgetc(PC);              // Guarda datos provenientes de PC
t2=next_in2;                              // en buffer2[];
next_in2=(next_in2+1) % BUFFER_SIZE2;
if(next_in2==next_out2)
next_in2=t2;                              // Buffer lleno !!
}



//************************  Rutinas Varias  ***********************************/
// Reflejan en el puerto PC lo recivido sobre el puerto PC2, o viceversa
//*****************************************************************************/

// Evaluación estado del Buffer:
// - Si buffer no esta lleno, es posible seguir recibiendo datos y completar
//   posiciones restantes vacías del buffer.
// - Si buffer lleno, próximo caracter recivido será almacenado en la primera
//   posicion del buffer, borrando de esa forma el contenido anterior en dicha
//   posición.
//
//   Para seguir completando el buffer, debe darse que next_in!=next_out, osea
//   que sean distintos. Recordar que el buffer recivido se refleja en el buffer
//   de transmision sobre el otro puerto rs232 o stream.
//
//   Definicion de variable que indica presencia de datos en buffer.
//
//   #define b_kbhit (next_in!=next_out)
//
//   Esta definición/afirmación esta dada como la desigualdad entre los indices,
//   lo que indica que hay datos en el buffer_in, faltando que sean transfereidos
//   al buffer_out. Cuando esta condicion no se cumple, la afirmacion es falsa.
//
//   Ejemplo: while(b_kbhit) {output_high(pin_A1) }, el código entre parentesis
//   se ejecuta siempre que b_kbhit sea TRUE o verdadera, osea, netx_in!=next_out.
//   Si se da que netx_in==next_out, el buffer esta lleno, con lo cual hay que
//   tomar una desicion de accion ante esta condición, como descartar los datos entrantes
//   o sobre-escribir las primeras posiciones del buffer_in.

#define b_kbhit   (next_in!=next_out)        // Se evalua que sean distintos,si son diferentes
#define b_kbhit_2 (next_in2!=next_out2)      // es que hay datos ...
                                             // != Inequality
                                             // b_kbhit corresponde a la pregunta
                                             // ¿ Es next_in distinto a next_out ?
char b_getc() {
char c;
while(!b_kbhit);                             // ! = Logical negation operator
//while(next_in!=next_out);
c=buffer[next_out];                          // Copia caracter entrante al buffer
next_out=(next_out+1) % BUFFER_SIZE;         // de salida.
return (c);
}


char b_getc_2() {
char c2;
while(!b_kbhit_2);
//while(next_in2!=next_out2) ;
c2=buffer2[next_out2];
next_out2=(next_out2+1) % BUFFER_SIZE2;
return (c2);
}



/***************  Rutina Principal   ************************/


void main() {

ext_int_edge(H_TO_L);            // Habilita interrupcion por flanco H_to_L
                                 // que corresponde a la transision del Start
                                 // bit del protocolo RS232.
enable_interrupts(INT_EXT);      // Habilita interrupcion externa en RB0 (rcv=PIN_BO)
enable_interrupts(int_rda);      // Habilita interrupcion por RDA(received Data Available)
enable_interrupts(GLOBAL);       // Habilita interrupciones global

fprintf(PC2,"Probando PC2
";
fprintf(PC,"Probando PC
";

while(1) {                                // LOOP infinito
fprintf(PC2,"
Andando...
";
fprintf(PC,"
Andando...
";

// El programa imprime en el puerto PC lo que recibe en el buffer del puerto PC2
// y viceversa. El buffer es circular (tamaño de 30 bytes)


while(1) {
        if(b_kbhit) {                  // Si hay datos provenientes de PC2,
        //if(next_in!=next_out) {
         fputc(b_getc(),PC);           // PC enviar los char a PC

         }
        if(b_kbhit_2) {                // Si hay datos provenientes de PC,
        //if(next_in2!=next_out2) {
         fputc(b_getc_2(),PC2);      // enviar los char a PC2
//         fputc(b_getc_2(),PC);
         }
         }

}                                      // FIN funcion de LOOP infinito

}



Esto funciona perfecto.......


saludos

[25javier]

buensimo el ejemplo!!graciasssssssssss
javier