problema con interrupciones xc8

[RSC]

buenas! tengo un problema con interrupciones y no le encuentro solucion
el problema es que entra a las interrupciones por timer sin que la condicion se cumpla    (sin que el flag del timer sea 1) lo comprobe porque:

al principio del programa basicamente tengo esto
habilito interrupciones
  INTCONbits.PEIE=1;
  INTCONbits.GIE=1;
 PIR1bits.TMR1IF=0;PIR2bits.TMR3IF=0;
no hago mas nada
dentro del codigo de las interrupciones que seria algo asi

void interrupt interrupcionDeAlta(void)
        {
if(PIR1bits.TMR1IF==1){   
 printf("hola");
PIR1bits.TMR1IF=0;
.
.
.
}
imprime muchisimos "hola" por la usart y en ningun momento le dije que trabaje el timer 
desde ya aprecio cualquier ayuda
saludos

[KILLERJC]

Podrias poner el codigo completo ?, Y primero se borra y luego se habilitan las interrupciones, y no al contrario.

Ademas un printf en una interrupcion es un problema grave. Perdiendo el sentido de tener una interrupcion.

[RSC]

aca esta el codigo, comente las cosas mas importantes, el printf en la interrupcion era solo para ver donde estaba el problema, no cumple PIR1bits.TMR1IF==1 pero igual entra y lo imprime
EDITO: recien lo estuve trabajando mas compilando y probando parte por parte, me di cuenta que el problema esta en esta parte del codigo (saque el resto para que el codigo sea mas entendible, si lo necesitas lo pongo de nuevo)

Código: C

1. unsigned char data;
2. int a;
3. char *buffer;
4.         char r1[14],pas1[4],pas2[4],pas3[4];
5.      int i,i1,i2,i3,i4,len,p,p1;
6.   unsigned long   newpaso1,newpaso2,newpaso3,oldpaso1,oldpaso2;
7.  
8.         int ia,ib,ic,v_pap;
9.  
10.         char j=0,cual,brazo_listo2=1;
11.  //volatile bit brazo_listo2;
12.  
13.      long pass1=3200,pass2=800,k=0,tmr1=0,tmr0=0;
14.      long tmr1,tmr3,pap1[3],pap2[3];
15. long h1=0,h2=0;
16.  
17. bool serialA_listo=false,brazo_listo,recibi_a=false,llenar_pap=true;
18.  
19.  
20. void interrupt interrupcionDeAlta(void)
21.         {
22.  
23. if(PIR1bits.TMR1IF==1){    printf("hola"); //este printf solamente lo puse para comprobar donde estaba el problema
24. PIR1bits.TMR1IF=0;
25. if(h2<pap1[j]*2){
26. LATBbits.LATB0=!LATBbits.LATB0;
27. WriteTimer1(tmr1);
28. h2++;
29. brazo_listo2=2;}//en el main defino "brazo_listo2=1" pero cuando inicia el programa me cambia este valor automaticamente a 2 aunque la condicion "PIR1bits.TMR1IF==1" no se cumpla. por eso puse el printf"hola" para verificar que el problema esta ahi
30. //else
31. if(h2==pap1[j]*2){
32. pap1[j]='e';brazo_listo2=1;j++;
33. if(j==3)j=0;
34. }
35. }
36.  
37. if(PIR2bits.TMR3IF==1){
38. PIR2bits.TMR3IF=0;
39. if(h1<pap2[j]*2){
40. LATBbits.LATB2=!LATBbits.LATB2;
41. WriteTimer3(tmr3);
42. h1++;
43. brazo_listo2=2;}
44. //else
45. if(h1==pap2[j]*2){
46. pap2[j]='e';brazo_listo2=1;j++;
47. if(j==3)j=0;
48. }
49. }
50.  
51. if(PIR1bits.RCIF==1){
52. PIR1bits.RCIF=0;
53. while(!DataRdyUSART());
54. data = getcUSART();
55. getsUSART(r1,data);
56. for(i2=0;i2<data;i2++){if(r1[i2]=='a') recibi_a=true;}
57. }
58. }
59.  
60. void putch(char c){
61. while(!TXIF) continue;
62. TXREG = c;
63. }
64.  
65.  
66.  
67. void main(void) {
68.   TRISB=0;
69.   i=0,i1=0,i2=0,i3=0;
70.    PIR1bits.TMR1IF=0;PIR2bits.TMR3IF=0;
71.   INTCONbits.PEIE=1;
72.   INTCONbits.GIE=1;
73.  
74.   OpenUSART(USART_TX_INT_OFF &USART_RX_INT_ON &USART_ASYNCH_MODE &
75.            USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH, 25);//brgh=25 => 48mhz
76.  while(BusyUSART());
77.  OpenTimer1( TIMER_INT_ON & T1_16BIT_RW & T1_SOURCE_INT & T1_PS_1_2 & T1_OSC1EN_ON & T1_SYNC_EXT_ON );
78.  OpenTimer3( TIMER_INT_ON & T3_16BIT_RW & T3_SOURCE_INT & T3_PS_1_2 & T3_SYNC_EXT_ON );
79.  
80.  pap1[0]='e';pap2[0]='e'; pap1[1]='e';pap2[1]='e'; pap1[2]='e';pap2[2]='e'; //pongo como "empty" a estos valores para despues rellenarlos en la funcion "pedir_pap"
81.  oldpaso1=0;oldpaso2=0;
82.    h1=0;h2=0;
83.  
84. }
85. }

saludos

[KILLERJC]

Una cosa mas, que PIC estas usando (veo que es un PIC18xx pero no se cual)?. Y para probar las cosas deberias quitar la mayor cantidad de cosas y solo dejar lo que te esta dando problemas.

Que supongo que es lo del OpenTimerx(), por que este lo configura y habilita
Estas intentando leer tambien pulsos externos? o Solo internos ?

Otro problema mas, no tenes un Loop infinito en el main, hay una llave de mas,

Solo decirte que acomode las rutinas de interrupcion, agregue un par de cosas, quite otras y las puse en otro lugar, y TENES MILLONES de variables para algo muy simple, no se por que tantas hay definidas. encima muchas definidas como variables de 32 bits!

ejemplo pap1 pap2 , estas guardando tipos char, que son de 8 bits! en variables de 32...
los tmr, incluso suponiendo que sean de 16 bits, estas usando 32 para eso. desperdiciando los otros 16, lo demas realmente no tengo idea para que son por eso no puedo decir mas nada sobre esas.

E identa tu codigo, lo hace mas legible. Gracias a eclipse que me lo hace solo :/ fue un poco mas simple

Código: C

1. unsigned char data;
2. int a;
3. char *buffer;
4. char r1[14],pas1[4],pas2[4],pas3[4];
5. int i=0,i1=0,i2=0,i3=0;                 // No se para que TANTOS indices
6. int i4,len,p,p1;
7. unsigned long   newpaso1,newpaso2,newpaso3;
8. unsigned long   oldpaso1=0;             // Variable para ...
9. unsigned long   oldpaso2=0;             // Variable para ...
10.  
11. int ia,ib,ic,v_pap;
12.  
13. char j=0,cual,brazo_listo2=1;
14. //volatile bit brazo_listo2;
15.  
16. long pass1=3200,pass2=800,k=0,tmr1=0,tmr0=0;
17. unsigned int tmr1,tmr3
18. char pap1[3]={'e','e','e'};             // Variable de ...
19. char pap2[3]={'e','e','e'};             // Variable de ...
20. long h1=0;                                              // Variable usada en ....
21. long h2=0;                                              // Variable usada en ....
22.  
23. bool serialA_listo=false,brazo_listo,recibi_a=false,llenar_pap=true;
24.  
25.  
26. void interrupt interrupcionDeAlta(void)
27. {
28.  
29.         if(PIR1bits.TMR1IF==1)
30.         {
31.                 WriteTimer1(tmr1);
32.                 PIR1bits.TMR1IF=0;
33.                 if(h2<pap1[j]*2)
34.                 {
35.                         LATBbits.LATB0=!LATBbits.LATB0;
36.                         h2++;
37.                         brazo_listo2=2;
38.                 }
39.         //else
40.                 if(h2==pap1[j]*2)
41.                 {
42.                         pap1[j]='e';
43.                         brazo_listo2=1;
44.                         j++;
45.                         if(j==3)j=0;
46.                 }
47.         }
48.  
49.         if(PIR2bits.TMR3IF==1){
50.                 WriteTimer3(tmr3);
51.                 PIR2bits.TMR3IF=0;
52.                 if(h1<pap2[j]*2)
53.                 {
54.                         LATBbits.LATB2=!LATBbits.LATB2;
55.                         h1++;
56.                         brazo_listo2=2;
57.                 }
58.                 //else
59.                 if(h1==pap2[j]*2)
60.                 {
61.                         pap2[j]='e';brazo_listo2=1;j++;
62.                         if(j==3)j=0;
63.                 }
64.         }
65.  
66.         if(PIR1bits.RCIF==1){
67.                 data = getcUSART();
68.                 //getsUSART(r1,data);   // Esto esta MAL MAL MAL
69.                 for(i2=0;i2<data;i2++)
70.                 {
71.                                 if(r1[i2]=='a')
72.                                         recibi_a=true;
73.                 }
74.         }
75. }
76.  
77. void putch(char c){
78.         while(!TXIF);
79.         TXREG = c;
80. }
81.  
82.  
83.  
84. void main(void) {
85.  
86.         TRISB=0;
87.  
88.         OpenUSART(USART_TX_INT_OFF &USART_RX_INT_ON &USART_ASYNCH_MODE &
89.                         USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH, 25);//brgh=25 => 48mhz
90.         while(BusyUSART());
91.         OpenTimer1( TIMER_INT_ON & T1_16BIT_RW & T1_SOURCE_INT & T1_PS_1_2 );
92.         OpenTimer3( TIMER_INT_ON & T3_16BIT_RW & T3_SOURCE_INT & T3_PS_1_2 );
93.  
94.         WriteTimer1(tmr1);
95.         WriteTimer3(tmr3);
96.         // Falta leer la USART para limpiar el flag de la misma
97.         PIR1bits.TMR1IF=0;
98.         PIR2bits.TMR3IF=0;     
99.         INTCONbits.PEIE=1;
100.         INTCONbits.GIE=1;      
101.        
102.         while(1)
103.         {
104.                
105.         }
106. }

[RSC]

uso un 18f4550, le quite el grueso del codigo y quedo algo mucho mas simple pero en realidad necesito la mayoria de estas variables, por ejemplo donde pongo pap1[0]='e'; donde pap es un long es para indicar que ya se utilizo y que se puede volver a procesar, porque en esa variable queda guardada un valor mayor de 16 bit, y tambien tenia el loop en el main pero lo borre sin querer 
en fin
hice un codigo con solamente el problema que tengo y el problema es el mismo por lo que el codigo seria equivalente

Código: C

1. void main(void) {
2.   OpenUSART(USART_TX_INT_OFF &USART_RX_INT_ON &USART_ASYNCH_MODE &
3.            USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH, 25);
4.  INTCON=0b11000000;
5.  T1CON=0b11011001;
6. PIE1bits.TMR1IE=1;
7. // o es equivalente a :OpenTimer1( TIMER_INT_ON & T1_16BIT_RW & T1_SOURCE_INT & T1_PS_1_2 & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF );
8.   PIR1bits.TMR1IF=0;
9. //  WriteTimer1(0x48E4); ponga o no ponga esta linea, el programa salta a la interrupcion indefinidamente
10.   while(1);
11. }
12. void interrupt interrupcion(){
13.  
14. if(PIR1bits.TMR1IF==1 )//la condicion se cumple siempre y no tengo un writetimer para el desbordamiento del timer
15. {
16.         PIR1bits.TMR1IF=0;
17.   printf("hola");
18. WriteTimer1(0x48E4);
19. }
20. }

tambien note que no responde al valor WriteTimer1(0x48E4); que equivale a un 1 segundo a 48mhz(tendria que imprimir "hola" cada un segundo pero lo hace muy rapido y todo el tiempo)
saludos

[KILLERJC]

tambien note que no responde al valor WriteTimer1(0x48E4); que equivale a un 1 segundo a 48mhz(tendria que imprimir "hola" cada un segundo pero lo hace muy rapido y todo el tiempo)

Me parece que hiciste mal los numeros...

A 48Mhz: Fcy = 83.33ns

Por lo tanto para que sea 1 segundo necesitarias que cuente:

Con preescaler 1:1  -  12.000.000
Con preescaler 1:2  -  6.000.000
Con preescaler 1:4  -  3.000.000
Con preescaler 1:8  -  1.500.000

16 bits podes representar hasta 65536
Por lo cual necesitarias casi 3 interrupciones de 50000 cuentas ( cargando 15536 ), para que tengas 1 segundo

[RSC]

hice mal las cuentas ^^ pero no era ese mi problema sino, el problema es que se activa el flag del timer sin que escriba en el 

[KILLERJC]

Bueno voy a decir que para mi el problema esta en las librerias de XC, como las OpenUSART, Write ... etc, En XC8 no estan los codigos de las mismas como en XC16.

Código: C

1. #include <stdint.h>
2.  
3. uint8_t contador,temp;
4.  
5. void main(void)
6. {
7.  
8.         OpenUSART(USART_TX_INT_OFF &USART_RX_INT_ON &USART_ASYNCH_MODE &
9.            USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH, 25);
10.  
11.         // No se si el OpenUSART por dentro me habilita o no las interrupciones, al igual que las prioridades, mejor me aseguro.
12.         INTCON = 0;
13.         RCONbits.IPEN = 0;
14.  
15.         T1CON=0b10110000;
16. //              ||||| ||_ Timer 1 Off
17. //              ||||| |__ Clock interno
18. //              |||||____ Oscilador deshabilitado
19. //              |||______ Preescaler 1:8
20. //              ||_______ Corre de otra fuente pero no del oscilador
21. //              |________ Habilito la lectura/escritura de 16bits
22.        
23.         //Habilito la interrupcion y flag
24.         PIE1bits.TMR1IE=1;
25.         PIR1bits.TMR1IF=0;
26.  
27.         // Por si las dudas lo hago separado, aun que el H esta buffeado
28.         TMR1H = 0x00;
29.         TMR1L = 0x00;
30.  
31.         //Activo ahora si las interrupciones
32.         INTCONbits.PEIE = 1;
33.         INTCONbits.GIE = 1;    
34.  
35.         while(1);
36. }
37.  
38.  
39. void interrupt interrupcion(void)
40. {
41.         // Int Timer1
42.         if(PIR1bits.TMR1IF)
43.         {
44.                 contador++;
45.                 if(contador >= 3 )
46.                 {
47.                         contador = 0;
48.                         PIR1bits.TMR1IF=0;
49.                         printf("hola");
50.                         TMR1H = 0x00;
51.                         TMR1L = 0x00
52.                 }
53.         }
54.        
55.         // Int UART, Si o si tiene que estar si lo habilitamos la interrupcion de RX
56.         if(PIR1bits.RCIF)
57.         {
58.  
59.                 // Necesario al tener un printf en el timer y que puede llegar otras cosas
60.                 if(RCSTAbits.OERR)
61.                 {
62.                         RCSTAbits.CREN = 0;
63.                         RCSTAbits.CREN = 1;
64.                 }
65.  
66.                 //Limpiamos flag
67.                 temp = RCREG;
68.         }
69. }

La otra seria quitar la UART y usar un led en ves de un printf, que seria mas pasable.

[RSC]

gracias, lo voy a probar en c18 y voy a bajar xc8 1.35 para probar, voy  aponer los resultados en cuanto los haga
saludos 

[RSC]

despues noches y dias...lo hice tal y como dijiste, tambien lo compile en c18 y nada... lo pense muchisimo y lo probe muchisimas veces y siempre el mismo error, o lo logro solucionar pero el timer se escribe con cualquier cosa o cuando esta funcionando bien de la nada se desborda y me reinicia todo, no se, mejor lo sigo viendo mañana, espero que el pic este dañado y no sea otra cosa

[KILLERJC]

Por que usas C18 ¿? y no XC8 ?

PD: No sabia que velocidad tenias la UART, sino lo hacia enteramente modificando registros.

[RSC]

porque queria probar otra posibilidad de tantas, en c18 y xc8 el problema es el mismo, trabajando a 48mhz el brgh de la uart esta a 5 que equivale a 500 kbaudios(si brgh = 25 => 115,2 kbaudios), voy a seguir intentando

[KILLERJC]

Acabo de darme cuenta un error que tuve, aca este codigo esta probado y funcionando:

Código: C

1. #include <stdint.h>
2. #include <xc.h>
3.  
4. uint8_t contador,temp;
5.  
6. void main(void)
7. {
8.  
9.         TRISB=0xFE;
10.        
11.         INTCON = 0;
12.         RCONbits.IPEN = 0;
13.  
14.         T1CON=0b10110000;
15. //              ||||| ||_ Timer 1 Off
16. //              ||||| |__ Clock interno
17. //              |||||____ Oscilador deshabilitado
18. //              |||______ Preescaler 1:8
19. //              ||_______ Corre de otra fuente pero no del oscilador
20. //              |________ Habilito la lectura/escritura de 16bits
21.        
22.         //Habilito la interrupcion y flag
23.         PIE1bits.TMR1IE=1;
24.         PIR1bits.TMR1IF=0;
25.  
26.         // Por si las dudas lo hago separado, aun que el H esta buffeado
27.         TMR1H = 0x00;
28.         TMR1L = 0x00;
29.  
30.         // Activo el Timer
31.         T1CONbits.TMR1ON = 1;
32.        
33.         //Activo ahora si las interrupciones
34.         INTCONbits.PEIE = 1;
35.         INTCONbits.GIE = 1;    
36.  
37.         while(1);
38. }
39.  
40.  
41. void interrupt interrupcion(void)
42. {
43.         // Int Timer1
44.         if(PIR1bits.TMR1IF)
45.         {
46.                 contador++;
47.                 PIR1bits.TMR1IF=0;                
48.                 TMR1H = 0x00;
49.                 TMR1L = 0x00;
50.                 if(contador > 23 )
51.                 {
52.                         contador = 0;
53.                         LATBbits.LATB0 ^= 1;
54.                 }
55.         }
56. }

Los fuses estan en otro archivo pero eso depende de tu aplicacion.

Si queres probar el codigo usa los 48Mhz, y podes medir con un osciloscopio o un multimetro el pin de RB0 el cual se va a poner a 1 y luego a 0. Cada 1 segundo.

EDIT con UART:

Código: C

1. #include <stdint.h>
2. #include <xc.h>
3.  
4. uint8_t contador;   // Variable usada para contar las veces de la interrupcion del timer 1
5. uint8_t temp;       // Variable usada para dumpear el valor recibido
6. uint8_t indice;     // Variable usada para enviar algo, va de 0 a 9 y se reinicia.
7.  
8. void main(void)
9. {
10.        
11.         INTCON = 0;
12.         RCONbits.IPEN = 0;
13.  
14.         /*
15.          * UART Setup
16.          *
17.          */
18.        
19.         //Configuracion de ports ( A pesar que inicialmente estan como entradas los escribo)
20.         TRISCbits.TRISC6 = 1;
21.         TRISCbits.TRISC7 = 1;
22.        
23.         // Configuracion de velocidad
24.         // 48Mhz / 16 * ( 25 + 1) = 115384 baudios
25.         SPBRG = 25;
26.         TXSTAbits.BRGH = 0;
27.         BAUDCONbits.BRG16 = 1;
28.        
29.         //Asincrono y habilito el receptor y transmisor
30.         TXSTAbits.SYNC = 0;
31.         RCSTAbits.SPEN = 1;
32.         TXSTAbits.TXEN = 1;
33.        
34.         // Habilito interrupcion de recepcion
35.         PIE1bits.RCIE = 1;
36.        
37.         //Comenzamos con la recepcion
38.         RCSTAbits.CREN = 1;
39.        
40.         /*
41.          * Timer 1 Setup
42.          *
43.          */
44.        
45.         T1CON=0b10110000;
46. //              ||||| ||_ Timer 1 Off
47. //              ||||| |__ Clock interno
48. //              |||||____ Oscilador deshabilitado
49. //              |||______ Preescaler 1:8
50. //              ||_______ Corre de otra fuente pero no del oscilador
51. //              |________ Habilito la lectura/escritura de 16bits
52.        
53.         //Habilito la interrupcion y flag
54.         PIE1bits.TMR1IE=1;
55.         PIR1bits.TMR1IF=0;
56.  
57.         // Por si las dudas lo hago separado, aun que el H esta buffeado
58.         TMR1H = 0x00;
59.         TMR1L = 0x00;
60.  
61.         // Activo el Timer
62.         T1CONbits.TMR1ON = 1;
63.        
64.         //Activo ahora si las interrupciones
65.         INTCONbits.PEIE = 1;
66.         INTCONbits.GIE = 1;    
67.  
68.         while(1);
69. }
70.  
71.  
72. void interrupt interrupcion(void)
73. {
74.         // Int Timer1
75.         if(PIR1bits.TMR1IF)
76.         {
77.                 contador++;
78.                 PIR1bits.TMR1IF=0;                
79.                 TMR1H = 0x00;
80.                 TMR1L = 0x00;
81.                 if(contador > 23 )
82.                 {
83.                         contador = 0;
84.                         TXREG = 0x30 + indice;
85.                         indice++;
86.                         if(indice == 10) indice = 0;
87.                 }
88.         }
89.        
90.         if(PIR1bits.RCIF)
91.         {
92.             // Solo para tirar el dato
93.             temp = RCREG;
94.         }
95. }

Este enviaria los numeros 0,1,2,3,4,5,6,7,8,9 y volveria a comenzar, ( sin comas ), cada un segundo.

[RSC]

no tuve tiempo de probar esos codigos pero se ven bien mañana los pruebo
en cuanto a mi problema parece que lo solucione, justo antes de escribir en el timer habilito el timer

Código: C

1. T1CONbits.TMR1ON=1;
2. WriteTimer1(tmr1);

y cuando el timer ya cumplio su condicion lo pongo a 0 dentro de la interrupcion

Código: C

1. T3CONbits.TMR3ON=0;

por ahora van bien los resultados y el flag del timer1 se pone a 1 unicamente cuando yo quiero
mañana sigo gracias 

[RSC]

lo acabo de probar y funciona perfecto tu codigo le puse un led, muchas gracias por la ayuda ya pude solucionar este problema