Manejo de Interrupciones en C

[handpic]

Hola a todos,

Creo que el manejo de interrupciones es algo básico en los pics.

He estado leyendo muchos problemas sobre la configuración, los niveles de ejecución (cuando los tienen)etc..

En mi caso, el gestor de interrupciones me restaura los valores de los registros al salir y yo quiero que los ponga como yo le digo dentro de la interrupción. Es por ello que decidí utilizar la instrucción #Int_GLOBAL, con la que creo que puedo anular el gestor.

El problema que ahora tengo es que al hacer esto, me sale un error en el compilador (Unprotected call in a #INT_GLOBAL) que yo interpreto que es porque no sitúo la función para la interrupción en la posición del vector interrupción (en mi caso la 0x04).

tampoco se muy bien como situar una instrucción que salte a la función principal al inicio del programa, tal como hacía en ensamblador, que lo solucionaba con un simple goto...,  para que no pase por la función de interrupción.

#INT_GLOBAL
void Global_isr() 
{
   if (INTF==1)
   {
   Int_Externa:  //Interrupción por detección de llegada de un flanco a RB0
      INTCON=0x00;
      FSR=puntero;
      INDF=TMR0;
      TMR0=0x00;
      if (flanco==1)
         {
         Ext_Int_Edge(L_to_H);
         flanco=0;
...... etc.
                                 
He intentado ponerle #org0x04 antes del código de la interrupcion, pero no me lo acepta tampoco.
He probado con #build pero tampoco ha resultado.

En ASM no hay estos problemas....

gracias...

[Suky]

En C las interrupciones se manejan de manera distinta, cada una tiene su función, por ejemplo:
Interrupción externa:
#int_EXT
EXT_isr()
{
…
}
Interrupción por Timer 1:
#int_timer1
timer1_isr()
{
…
}
El compilador salta a la función de interrupción cuando se detecta una interrupción. Es el propio compilador el encargado de generar el código para guardar y restaurar el estado del procesador.
También es el compilador quien borrará la interrupción (el flag). Sin embargo, nuestro programa es el encargado de llamar a la función ENABLE_INTERRUPT() para activar previamente la interrupción junto con el señalizador (flag) global de interrupciones.

En cambio la función que sigue a la directiva #INT_GLOBAL reemplaza al distribuidor de interrupciones del compilador; dicha función toma el control de las interrupciones y el compilador no salva ningún registro. Normalmente no es necesario usar esto y debe tratarse con gran prudencia.

La prioridad de las interrupciones se maneja con el siguiente comando:
#priority rtcc,rb

[elmasvital]

has probado #org 4,50?¿

tienes que poner el rango de inicio y el de fin

luego si tienes mas funciones debajo pones
#org default

por otro lado tambien existe goto en c...

[handpic]

Hola,

El problema es precisamente que el gestor salva los registros y los restaura. yo no quiero que los restaure, sino que los deje como yo digo en la interrupción.

Se me olvidaba, no se si he comentado que es en un 16f84. No tengo niveles de prioridad, no?, o el gestor de interrupciones lo crea por software?

Por otra parte, he probado a poner ORG 0x04, default, porque no se cuanto me va a ocupar  la función de la interrupción.
Supongo que lo que debo hacer es saltar a la función y me quito de problemas.

Saludos,

[mariano_pic]

precisamente estoy probando interrupciones y ya me funciono, esta no salva nada y produce 2 frecuencias una por el timer 0 y otra por retardos normales:

Código: [Seleccionar]

#include <16F84A.h>
// INTCON ----------------- ok
struct {
unsigned RBIF:1;
unsigned INTF:1;
unsigned T0IF:1;
unsigned RBIE:1;
unsigned INTE:1;
unsigned T0IE:1;
unsigned PEIE:1;
unsigned GIE:1;
} INTCON;
#byte INTCON = 0x0B


#FUSES NOWDT                      //NO Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading

#use delay(clock=4000000)
#use rs232(baud=9600,parity=N,xmit=PIN_A3,rcv=PIN_A2,bits=8)
#use FAST_IO(B)

byte flag;
#org 0x04, 0xff
interr(){
   if(flag==0){output_high(PIN_B0);flag=1;}else{output_low(PIN_B0);flag=0;}
   intcon.t0if=0;
   enable_interrupts(INT_RTCC);
   enable_interrupts(global);
   return;
}

void main()
{
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256);
   set_tris_b(0);
   output_b(0);
   set_timer0(0);
   flag=0;
   enable_interrupts(INT_RTCC);
   enable_interrupts(global);
   while(1){
   output_high(PIN_B1);
   delay_ms(200);
   output_low(PIN_B1);
   delay_ms(200);   
   }
   
}



[handpic]

Hola Mariano_pic,

He visto varias cosas...
No conocía la instrucción Struct, pero me tomo buena nota.

Has usado ORG con una posición inicial y una final, pero ¿has calculado cuanto ocupaba o lo has puesto a ojo?

Sales de las interrupciones con un return, es por costumbre del ASM o hay que salir así. Yo no termino con la instrucción retur.
Simplemente termino la funcioón y solo regresa. puede que ahí esté la cuestión del retorno....

Para que tengas una idea de lo que quiero hacer... quiero capturar una señal de llamada de un telefonillo, el mío es digital y se comunica con una central por una línea analógica para el audio y otra digital para las instrucciones.
Había pensado en capturar los diferentes bits contando el tiempo entre flancos y por eso uso la interrupción exterior y la del tmr0, que me hace de contador y de limitador de tiempo de un bit a la vez (si se desborda es que hemos sobrepasado el tiempo de un bit).

Estoy simulandolo en el Mplab, pero me hace cosas muy raras.... por ejemplo, el TMR0, el FSR, el INTCON... me aparecen como palabras de 16 bits en los valores binarios y cuando ejecuto un "enable_interrupts(global), no me pone a uno el bit 7 de intcon... algo me está fallando.

Ahora he puesto otro programa, pero tengo que aprender a manejarlo... y eso me llevará algún tiempo, aunque he encontrado unos cursos que valen sus bits en oro...

Saludos

[mariano_pic]

   struct, es un tipo de datos estructurado en c, y sirver para tener acceso directo a cada bit usando un punto,  para facilitar las cosas, el return tiene que estar ahi por que el compilador no save de la interrupcion, el vector lo saque al ojo  , aunque siempre pongo multiplos de una pagina de reserva, y con eso tienes para comenzar y avansar 

[Suky]

Yo cuando indico el espacio que ocupa una función, primero le coloco un espacio grande, compilo y me fijo el asm generado (en PICC sería C/AMS list) y ahí determino cuanto ocupa.

[handpic]

Gracias por los consejos´.

Lo que sigo sin entender es el return al final de la interrupción. Se supone que cuando termine de ejecutar la función de la interrupción, que debe ser llamada por el gestor de interrupciones, debe volver a éste para salir de ella.

En el caso del return, yo creo que tu fuerzas esa salida de la interrupción, saltandote el gestor y por eso no te restaura los registros..... eso creo.

Saludos,

[jeremylf]

Yo he usado el #INT_GLOBAL sin ningun problema, solo que para un 18F y en CCS 4.023.

Código: [Seleccionar]

#include <18F2550.h>

#fuses HSPLL, PLL5, CPUDIV1, NOWDT, PUT, NOPBADEN, NOPROTECT, NOLVP
#FUSES PROTECT
#FUSES CPB

#use DELAY (clock = 48 000 000)

#BYTE INTCON3 = 0xFF0
#BIT INT1IF = INTCON3.0

void IntExt(void);

void main(void)
{     
   delay_ms(603);
               
   disable_interrupts(GLOBAL);     
 
   ext_int_edge(1, L_TO_H);
   
   enable_interrupts(INT_EXT1);
   enable_interrupts(GLOBAL);

   while (true)
   { 
   }
}


#INT_GLOBAL
void ISR_GLOBAL(void)
{     
   IntExt();
}

void IntExt(void)
{     
   if (INT1F)
   {
      INT1IF = false;     

   }
}

Ojala te ayude.
Salu2.

[handpic]

Yo he usado el #INT_GLOBAL sin ningun problema, solo que para un 18F y en CCS 4.023.

Yo también uso CCS. y me pide que posicione el #int_global en la posición 0x04. Puede que para el 18F lo gestione de otra forma, la verdad es que no lo sé.

Tengo que probar todavía lo de poner inicio y final en el org y ya os cuento..... pero eso no será por lo menos hasta el martes......

Si alguien me puede aclarar si realmente hace falta el return para salir de la interrupción, quedaría agradecido, yo creo que no le hace falta, pero como os digo, hasta el martes no puedo probar las diferencias.

saludos,

[PHLAKO]

Hola amigos, saben, no entiendo

Me he quebrado la cabeza con la interrupcion de la USART, por llegada de datos, he probado de todas las maneras posibles y siempre lo mismo. Empezando por que estando en la interrupcion, no lee cuando pongo:

    if (PIR1bits.RCIF)
              { 
              LATBbits.RB0=1
               }

ahi pone a uno RB0, pero, se queda eternamente en ese loop, aunque ponga (PIR1bits.RCIF = 0;) entre medio.
la unica forma en que se sale del loop y funciona de buena manera es si le pongo en algun lado getUSART(),

Tambien tengo problemas cuando pongo:

   PIR1bits.RCIF = 0;
    if (PIR1bits.RCIF)
              { 
              LATBbits.RB0=1
               }

de todas formas pone a uno RB0.

Ya no se que hacer, si me pueden ayudar se los agradeceria.

saludos,
chaos

[elchecho]

Hola muchachos, para aquellos que estan aprendiendo a programar en PIC, los invito a que le den un vistazo a mi pagina donde explico como programar en PIC C.  tambien un poco de teoria de control, matlab entre otros.

http://controlautomaticoeducacion.com/

[Thulsa Doom]

Hola, tienes un estupendo manual en este mismo foro donde te explica muy bien lo de las interrupciones.

http://www.todopic.com.ar/foros/index.php?topic=31611.0

Te aconsejo que te hagas algún proyecto sencillo y lo simules en proteus paso a paso y así ves los saltos que hace

[KILLERJC]

Este es un tema de 2009.... esta reviviendo post hace rato, al menos que espere un tema nuevo.