Interpretacion de codigo CCS C

[mariacontenis]

Un Saludo!!!.


Alguien me puede ayudar a interpretar este codigo escrito en CCS C por favor?.

Código: CSS

1. #include <18F8722.h>
2.          #device ADC=10
3.          #priority timer0
4.        
5.          #fuses WDT,WDT1024,H4,NOPROTECT,NOIESO,NOBROWNOUT,NOPUT,NOCPD,noSTVREN,nODEBUG,NOLVP,NOWRT,NOCPB,NOEBTRB,NOEBTR,CCP2C1,NOWRTD,NOWRTC,NOWRTB,NOFCMEN,LPT1OSC,MCLR,NOXINST,MCU,BBSIZ4K            
6.          #use delay(clock=40000000, crystal=10000000,RESTART_WDT)
7.          #use rs232(baud=19200,xmit=PIN_G1,rcv=PIN_G2,parity=N,bits=8,restart_wdt,stream=HYPERTERMINAL)        
8.          #byte porta=0xF80 #byte portb=0xF81 #byte portc=0xf82 #byte portd=0xf83 #byte porte=0xf84 #byte portf=0xf85 #byte portg=0xf86 #byte porth=0xf87 #byte portj=0xf88
9.                                                                                                                                                                                                        
10.          int timerCont=0;                                                            // Para incrementar la cuenta del timer0
11.          int cont_Seg_Falla=0;                                                                                          
12.          int timerActivo = 0;                                                          // Se almacenará el estado del timer. Si está activo estara en 1, si no en 0.
13.          int vectorFalla[14];
14.          int t_vectorFalla[14]={0,0,0,0,0,0,0,0,0,0,0,0,0};
15.          int a=0, hayFalla=0;                                                          // Variable "a" comodín, es decir, se hace uso de ella desde varias funciones.
16.          const char msgAdvertencia[]=" > Advertencia del sistema: Se estan enviando ALERTAS";
17.          
18.          #INT_TIMER0                                                                   // Función que es llamada por el TIMER0 cuando se produce un desbordamiento.
19.          void TIMER0_isr(void)
20.          {
21.          if(timerActivo==1)                                                            // Bandera para poner en marcha la cuenta del timer
22.              timerCont++;                                                              // En esta variable se lleva la cuenta de los segundos transcurridos ya que el TMR0 se dispara cada 1 segundos.
23.          
24.          if(hayFalla==1)
25.              {
26.               cont_Seg_Falla++;
27.              }
28.          output_toggle(PIN_C5);
29.          set_timer0(26474);
30.          }
31.                  
32.          void main()
33.          {        
34.          porta=0x00; portb=0x00; portc=0x00; portd=0x00; porte=0x00; portf=0x00; portg=0x00; porth=0x00; portj=0x00;
35.          set_tris_a(0b11001111); set_tris_b(0b11011111); set_tris_c(0b10000000); set_tris_d(0b00000000); set_tris_e(0b00000000);
36.          set_tris_f(0b00000001); set_tris_g(0b00110100); set_tris_h(0b00000000); set_tris_j(0b00000000);        
37.          
38.          setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256);                                    // desborda cada 1 segundo                
39.          set_timer0(26474);
40.          disable_interrupts(INT_TIMER0);
41.          enable_interrupts(INT_RDA);
42.          enable_interrupts(GLOBAL);        
43.  
44.          a = 0;
45.          enable_interrupts(INT_TIMER1);
46.          
47.          while(TRUE)
48.          {      
49.                  
50.          for(a=0;a<14;a++)
51.          {
52.          if(vectorFalla[a]==1 && t_vectorFalla[a]==0)  
53.          {
54.          if(hayFalla==1)
55.          {
56.          hayFalla=1;                                                                  
57.          timerActivo=1;                                                                
58.          }
59.          else                                                                          
60.          {
61.          hayFalla=1;                                                                  
62.          timerActivo=1;
63.          }                                                                            
64.              
65.          t_vectorFalla[a]=1;
66.          }
67.          else if(vectorFalla[a]==0 && t_vectorFalla[a]==1)
68.          {
69.          t_vectorFalla[a]=0;
70.          timerActivo = 0;
71.          hayFalla = 0;
72.          }
73.          }
74.          
75.          if(timerActivo==1)
76.          {
77.          enable_interrupts(INT_TIMER0);                                                
78.          }
79.          else
80.          {
81.          timerCont = 0;
82.          }
83.          if(timerCont>=5 && timerActivo==1)
84.          {
85.          disable_interrupts(INT_TIMER0);                                                        
86.          fputs(msgAdvertencia, HYPERTERMINAL);                                        
87.          
88.          timerCont = 0;
89.          hayFalla = 0;
90.          timerActivo = 0;
91.          }
92.          
93.          }
94.          }

En realidad la parte que no comprendo es lo siguiente:

Código: C

1. #INT_TIMER0                                                                   // Función que es llamada por el TIMER0 cuando se produce un desbordamiento.
2.          void TIMER0_isr(void)
3.          {
4.          if(timerActivo==1)                                                            // Bandera para poner en marcha la cuenta del timer
5.              timerCont++;                                                              // En esta variable se lleva la cuenta de los segundos transcurridos ya que el TMR0 se dispara cada 1 segundos.
6.          
7.          if(hayFalla==1)
8.              {
9.               cont_Seg_Falla++;
10.              }
11.          output_toggle(PIN_C5);
12.          set_timer0(26474);
13.          }

Y esto de va ligado....

Código: C

1. for(a=0;a<14;a++)
2.          {
3.          if(vectorFalla[a]==1 && t_vectorFalla[a]==0)  
4.          {
5.          if(hayFalla==1)
6.          {
7.          hayFalla=1;                                                                  
8.          timerActivo=1;                                                                
9.          }
10.          else                                                                          
11.          {
12.          hayFalla=1;                                                                  
13.          timerActivo=1;
14.          }                                                                            
15.              
16.          t_vectorFalla[a]=1;
17.          }
18.          else if(vectorFalla[a]==0 && t_vectorFalla[a]==1)
19.          {
20.          t_vectorFalla[a]=0;
21.          timerActivo = 0;
22.          hayFalla = 0;
23.          }
24.          }
25.          
26.          if(timerActivo==1)
27.          {
28.          enable_interrupts(INT_TIMER0);                                                
29.          }
30.          else
31.          {
32.          timerCont = 0;
33.          }
34.          if(timerCont>=5 && timerActivo==1)
35.          {
36.          disable_interrupts(INT_TIMER0);                                                        
37.          fputs(msgAdvertencia, HYPERTERMINAL);                                        
38.          
39.          timerCont = 0;
40.          hayFalla = 0;
41.          timerActivo = 0;
42.          }

Gracias por su ayuda!!.

[Eduardo2]

...
En realidad la parte que no comprendo es lo siguiente:

Código: [Seleccionar]

#INT_TIMER0             // Función que es llamada por el TIMER0 cuando se produce un desbordamiento.
void TIMER0_isr(void)
{
    if(timerActivo==1)  // Bandera para poner en marcha la cuenta del timer
        timerCont++;    // En esta variable se lleva la cuenta de los segundos
                        // transcurridos ya que el TMR0 se dispara cada 1 segundos.
    if(hayFalla==1)
    {
        cont_Seg_Falla++;
    }
    output_toggle(PIN_C5);
    set_timer0(26474);
}
....

- La interrupción se genera por overflow del Timer0 cada 1".   Pero para que esto ocurra debe presetearse el timer cada vez con 26474, de lo contrario el overflow ocurriría cada 1.6"
( 2^16 - tiempo/(prescaler*tclk) =  2^16 - 1000000/(256*0.1) = 26474 )

- Si  timerActivo se  incrementa timerCont (lleva los segundos transcurridos).   Es redundante comparar si timerActivo ya que cuando no lo está se desactiva la interrupción.

- Si hayfalla cuenta los segundos.

- PIN_C5 parpadea cada 2" indicando que la interrupción está ocurriendo.

Pero parte de esto ya estaba comentado en el mismo código.   Tal vez deberías ser mas precisa con tu duda.

[mariacontenis]

Gracias por atenderme.
Ahora me a quedado más que clara esa parte.

Sería mucho pedir si me explicas la siguiente parte...

Código: C#

1. for(a=0;a<14;a++)
2.          {
3.          if(vectorFalla[a]==1 && t_vectorFalla[a]==0)  
4.          {
5.          if(hayFalla==1)
6.          {
7.          hayFalla=1;                                                                  
8.          timerActivo=1;                                                                
9.          }
10.          else                                                                          
11.          {
12.          hayFalla=1;                                                                  
13.          timerActivo=1;
14.          }                                                                            
15.              
16.          t_vectorFalla[a]=1;
17.          }
18.          else if(vectorFalla[a]==0 && t_vectorFalla[a]==1)
19.          {
20.          t_vectorFalla[a]=0;
21.          timerActivo = 0;
22.          hayFalla = 0;
23.          }
24.          }
25.          
26.          if(timerActivo==1)
27.          {
28.          enable_interrupts(INT_TIMER0);                                                
29.          }
30.          else
31.          {
32.          timerCont = 0;
33.          }
34.          if(timerCont>=5 && timerActivo==1)
35.          {
36.          disable_interrupts(INT_TIMER0);                                                        
37.          fputs(msgAdvertencia, HYPERTERMINAL);                                        
38.          
39.          timerCont = 0;
40.          hayFalla = 0;
41.          timerActivo = 0;
42.          }

Te comento que está parte era de un sistema que enviaba unas alarmas de falla si ocurría algún evento en cada una de ellas.

La falla no se enviaba de inmediato al momento de ocurrir, si no que esperaba algunos x segundos corroborando que siguiera está falla y pasados estos x segundos ya enviaba la advertencia.

Gracias.

[Eduardo2]

Código: [Seleccionar]

    for(a=0;a<14;a++)
    {
        if(vectorFalla[a]==1 && t_vectorFalla[a]==0)
        {
            if(hayFalla==1)
            {
                hayFalla=1;
                timerActivo=1;
            }
            else
            {
                hayFalla=1;
                timerActivo=1;
            }

            t_vectorFalla[a]=1;
        }
        else if(vectorFalla[a]==0 && t_vectorFalla[a]==1)
        {
            t_vectorFalla[a]=0;
            timerActivo = 0;
            hayFalla = 0;
        }
    }
Si vectorFalla[a]==1 && t_vectorFalla[a]==0   entonces  activa timerActivo y hayFalla.

En la comparacion if(hayFalla==1) hay un error porque cualquiera sea el estado hace lo mismo.

Cuando vectorFalla[a] se desactiva  resetea  t_vectorFalla[a] ,  timerActivo y  hayFalla

Código: [Seleccionar]

        if(timerActivo==1)
        {
            enable_interrupts(INT_TIMER0);
        }
        else
        {
            timerCont = 0;
        }
No necesita explicacion.

Código: [Seleccionar]

        if(timerCont>=5 && timerActivo==1)
        {
            disable_interrupts(INT_TIMER0);
            fputs(msgAdvertencia, HYPERTERMINAL);

            timerCont = 0;
            hayFalla = 0;
            timerActivo = 0;
        }
Pasados 5" se manda el mensaje y se resetea    timerCont ,  hayFalla y  timerActivo

No tiene sentido usar la condición timerActivo ya que para llegar a la cuenta de 5 debe estarlo y luego se resetea.