WinkIntc

[Alejandro]

Hola a todos,

Necesito generar una interrupcion cada 45 seg, usando el RTCC, revisando la pagina de RedPIC he encontrado este codigo WinkIntc.c, funciona bien para valores de NInts<255, pero para valores mayores a este el pic se cuelga, quisiera saber que tengo que modificar para obtener lo que necesito?

Código: [Seleccionar]

// WinkIntc.c

#include <16f628.h>                    // Selecciona el PIC
#fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT // Opciones de configuración
#use delay(clock=4000000)              // Velocidad del Cristal : 4 Mhz
#use standard_io(B)                    // PORTB en estandar IO digital
#use fixed_io(b_outputs=PIN_B0)       // B0 como salida en PORTB

byte const NInts=7;                   // Numero de interrupciones para 0.25 Segundos

                                       // VARIABLES GLOBALES
                                       
char C_Ints=0;                         // Contador de Interrupciones ocurridas
char Flag=0;                           // Flag que cambia cada NInts interrupciones
char K=0;                              // Estado anterior del Flag


#int_RTCC                              // Interrupción por desbordamiento
RTCC_isr() {                           // del TIMER0 RTCC

   if(C_Ints > NInts){                 // Si las ints ocurridas > ints para 0.25 seg.

      if(Flag==0){
         Flag=1;
      }
      else{
         Flag=0;
      }

      C_Ints=0;                        // Reinicializo Contador de Ints
   }
   ++C_Ints;
}



void main(void) {

   setup_counters(RTCC_INTERNAL,RTCC_DIV_128); // Configuración de TIMER0 : Clock Interno y Presescaler 128
   setup_timer_1(T1_DISABLED);                 // para una RTCC cada 33.3 milisegundos -> 1 Segundo = 30 RTCC
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   enable_interrupts(INT_RTCC);                // Habilito Interrupcion RTCC
   enable_interrupts(global);                  // Habilito Interrupciones

   output_low(PIN_B0);                         // Empiezo apagando el Led
   

   
   do{                                         // Bucle infinito

      if(Flag!=K)
      {                                        // si ha cambiado flag
         if(Flag==0){ output_low(PIN_B0); }    // Si es 0 Apago el Led
         if(Flag==1){ output_high(PIN_B0); }   // si es 1 Enciendo el Led
         k=Flag;                               // Guardo estado anterior de Flag
      }

   }While(TRUE);

}



[jeremylf]

Pues cambia:
byte const NInts=7;

por:
unsigned int16 const NInys = 7;

Lo mismo con C_Ints.

Salu2.

[RedPic]

Exacto.

Con variables de 8 bits solo se puede contar desde 0 hasta 255 así que cambiándolas a int16 ampliaras el rango de control de 0 hasta 65.535, o si deseas mas aún puedes cambiarlas a int32 y entonces tendrás hasta 4.294.967.296

[Alejandro]

Hola jeremylf  y Redpic, si he hecho eso:

 

Pues cambia:
byte const NInts=7;

por:
unsigned int16 const NInts = 3375;

Pero cuando uso el mplab para simular y uso la opcion Run to cursor esta opcion aparece en gris no permitiendome hacer la simulacion, cosa que no ocurre cuando NInts<255 en donse la simulacion funciona OK, cual es mi error?

[jeremylf]

No olvides que la variable de 8 bits (char, byte, como quieras llamarlo) C_Ints, tambien debes cambiarla a 16 bits o mayor porque esta ligada a NInts en la interrupcion del TMR0.

Si a pesar de ello, te sige sin funcionar... por emulacion yo no confiaria tanto.

Salu2.

[RedPic]

Así debería funcionar para controlar hasta contar 65.535 interrupciones, al CCS no hace le hace falta el unsigned ya que lo asume por defecto. Solo habría que declarar signed si hiera u hiciese falta.

Código: C#

1. // WinkIntc.c
2.  
3. #include <16f628.h>                    // Selecciona el PIC
4. #fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT // Opciones de configuración
5. #use delay(clock=4000000)              // Velocidad del Cristal : 4 Mhz
6. #use standard_io(B)                    // PORTB en estandar IO digital
7. #use fixed_io(b_outputs=PIN_B0)       // B0 como salida en PORTB
8.  
9. const int16 NInts=7000;                   // Por ejemplo
10.  
11.                                        // VARIABLES GLOBALES
12.                                        
13. int16 C_Ints=0;                         // Contador de Interrupciones ocurridas
14. char Flag=0;                           // Flag que cambia cada NInts interrupciones
15. char K=0;                              // Estado anterior del Flag
16.  
17.  
18. #int_RTCC                              // Interrupción por desbordamiento
19. RTCC_isr() {                           // del TIMER0 RTCC
20.  
21.    if(C_Ints > NInts){                 // Si las ints ocurridas > ints para 0.25 seg.
22.  
23.       if(Flag==0){
24.          Flag=1;
25.       }
26.       else{
27.          Flag=0;
28.       }
29.  
30.       C_Ints=0;                        // Reinicializo Contador de Ints
31.    }
32.    ++C_Ints;
33. }
34.  
35.  
36.  
37. void main(void) {
38.  
39.    setup_counters(RTCC_INTERNAL,RTCC_DIV_128); // Configuración de TIMER0 : Clock Interno y Presescaler 128
40.    setup_timer_1(T1_DISABLED);                 // para una RTCC cada 33.3 milisegundos -> 1 Segundo = 30 RTCC
41.    setup_timer_2(T2_DISABLED,0,1);
42.    setup_comparator(NC_NC_NC_NC);
43.    setup_vref(FALSE);
44.    enable_interrupts(INT_RTCC);                // Habilito Interrupcion RTCC
45.    enable_interrupts(global);                  // Habilito Interrupciones
46.  
47.    output_low(PIN_B0);                         // Empiezo apagando el Led
48.    
49.  
50.    
51.    do{                                         // Bucle infinito
52.  
53.       if(Flag!=K)
54.       {                                        // si ha cambiado flag
55.          if(Flag==0){ output_low(PIN_B0); }    // Si es 0 Apago el Led
56.          if(Flag==1){ output_high(PIN_B0); }   // si es 1 Enciendo el Led
57.          k=Flag;                               // Guardo estado anterior de Flag
58.       }
59.  
60.    }While(TRUE);
61.  
62. }

[Alejandro]

Gracias por la ayuda, si funciona OK

[cerebro]

Exacto.

Con variables de 8 bits solo se puede contar desde 0 hasta 255 así que cambiándolas a int16 ampliaras el rango de control de 0 hasta 65.535, o si deseas mas aún puedes cambiarlas a int32 y entonces tendrás hasta 4.294.967.296

me quede pensando en esto... de esta manera se pueden temporizar intervalos de años con un int32  ?

[ppyote]

el 16f628 puede con 32bits? creo que no.... pero no estoy seguro....

[kain589]

Los datos nativos del 16f628 son de 8 bits, pero con aritmetica extendida es muy facil lograr alcanzar 32 bits o incluso mas.

[jeremylf]

En CCS es muy facil 

[ppyote]

es que en estos momentos estaba con un medidor de frequencia con el 16f628a, a lo mejor sera despiste mio por no probarlo pero...
ahora mismo lo probare y mirare resultados.... no quiero que se me demore mucho tiempo el micro haciendo calculos matematicos....
voy a ver...