Las instrucciones de CCS que permiten controlar la interrupcin por el cambio de estado en el puerto RB0 son: #int_ext // esta

directiva invoca a las interrupciones externas. ext_int_edge(H_TO_L); //habilita la interrupcin en flanco de bajada. Si se quiere por flanco de subida se coloca (L_TO_H) enable_interrupts(GLOBAL); // habilitacin global de todas las interrupciones. enable_interrupts(INT_EXT); // habilitacin de las interrupciones externas. Las dos ltimas instrucciones deben estar activadas en la funcin principal para que pueda detectar la interrupcin si ocurre en el puerto B.

Proyecto : En el siguiente proyecto, se utiliza la interrupcin RB0. El programa inicia prendiendo y apagando un LED que est conectado al puerto RD0. Cuando existe un cambio de estado en puerto RB0, es decir, cuando se accione el pulsador, se genera una interrupcin, en la cual, un LED se prende y se apaga cinco veces.

PROGRAMA: //USO DE LA INTERRUPCIN EXTERNA RBO #include <18F4550.h> #fuses HS, NOPROTECT, NOWRT, NOPUT, NOWDT, NOLVP, NOCPD //rdenes para el programador #use delay (clock=12000000) #byte PORT_D=0xf83 #byte PORT_B=0xf81

#byte PORT_A=0xf80 int n =0; #int_ext PortB_Interrupt() //Funcin para la interrupcin { ext_int_edge(H_TO_L); for(n=1; n<=5; n++){ output_high(PIN_B3); delay_ms(300); output_low(PIN_B3); delay_ms(300); } } void main(void) { set_tris_b(0b00000001); set_tris_d(0b00000000); PORT_B=0; PORT_D=0; enable_interrupts(GLOBAL); enable_interrupts(INT_EXT); while(TRUE){ output_high(PIN_D0); delay_ms(500); output_low(PIN_D0); delay_ms(500); } }

TEMPORIZADOR 0

Configurable como temporizador o contador de 8/16 bits. Pre escalar de 8 bits. Interrupcin por desbordamiento. USO DEL TIMER0 EN MODO DE 8 BIT COMO TEMPORIZADOR El temporizador TMR0 al usar el registro 8 bits, puede contar 256 pulsos. Cada pulso es un ciclo de mquina del oscilador de reloj, es decir, si el divisor de frecuencia (preescalar) est deshabilitado, el registro se incrementa cada 4 periodos de la seal de reloj. Instrucciones CCS: void DesbordeTimer0(). Funcin del temporizador en el desborde.

SETUP_TIMER_0(RTCC_DIV_256|RTCC_INTERNAL|RTCC_8_BIT). Esta instruccin sirve para fijar el preescalar a 256, TMR0 Interno con 8 bits. setup_counters(RTCC_INTERNAL|RTCC_8_BIT,RTCC_DIV_256). Otra forma de fijar los valores en el timer0. SET_TIMER0(valor). Fija el valor inicial del timer para que empiece la cuenta. ENABLE_INTERRUPTS( INT_Timer0 ). Habilita la interrupcin del temporizador 0. ENABLE_INTERRUPTS( GLOBAL ). Habilitacin global de todas las interrupciones. En el presente proyecto se va ha utilizar el temporizador 0 en modo de 8 bits para generar un retardo de tiempo de 1 s. Como se requiere un tiempo de 1 s y trabajando con un oscilador de 4 MHZ, no se puede temporizar un tiempo tan alto, es necesario reducirlo a un menor valor y para luego mediante programacin utilizando un temporizador completar el tiempo. Para esto, se procede. El Periodo del oscilador Toscilador = 1/ 4 Mhz = 0.25 us. Tiempo = 4 * Toscilador * (256-TMR0L) * Rango Divisor de Frecuencia Carguemos TMR0 = 12 (A partir de aqu el temporizador deber contar 244 ciclos) Divisor de frecuencia (preescalar) 256 (PS2, PS1, PS0 = 1 1 1). Con estos datos se tiene un tiempo de: Tiempo = 4 * 0.25 * (256 12) * 256 = 62 464 us. Para completar 1 segundo se debe repetir 16 veces (62 464 us. * 16 = 999 424 us ~ 1 segundo). Escribamos el programa: #include <18F4550.h> #fuses XT, NOPROTECT, NOWRT, NOPUT, NOWDT, NOLVP, NOCPD //rdenes para el programador. #use delay (clock=4000000) int contador; #int_Timer0 void DesbordeTimer0() { contador = contador +1; if (contador == 16){ output_bit(PIN_D0,!input(PIN_D0)); //Cada 16 interrupciones cambia de valor contador=0; } SET_TIMER0(12); } main(void) { contador =0; output_d(0x00); set_tris_d(0x00); SETUP_TIMER_0(RTCC_DIV_256|RTCC_INTERNAL|RTCC_8_BIT); //Preescalar a 256, TMR0 Interno con 8 bits SET_TIMER0(12); ENABLE_INTERRUPTS( INT_Timer0 );

ENABLE_INTERRUPTS( GLOBAL ); while(TRUE) { restart_wdt(); } } La figura muestra el circuito utilizado.

USO DEL TIMER0 EN MODO DE 16 BIT COMO TEMPORIZADOR El TMR0 trabajando en modo de 16 bits, puede contar hasta 65536 pulsos de la Fosc/4. En este caso para trabajar con 16 bits la instruccin CCS, que se utiliza es: SETUP_TIMER_0(RTCC_DIV_256|RTCC_INTERNAL). Presescalar a 256, TMR0 Interno con 16 bits, o tambn. setup_counters(RTCC_INTERNAL,RTCC_DIV_256). Otra forma de fijar los valores en el timer0. Por el puerto RD0 se requiere sacar una seal cuadrada de 2 s (1s en alto y 1s en bajo). Utilizando la ecuacin determinamos el valor a cargar el temporizador TMR0. 65536 - TMR0 = Tiempo / 4 * Toscilador * Rango Divisor de Frecuencia Tiempo 1s = 1000000 us Rango Divisor de frecuencia (pre-escalar) = 256 Toscilador= 1/4MHZ = 0.25us 65536 - TMR0= 1000000/(4*0.25us*256) = ~ 3906 TMR0 = 65536 - 3906 = 61630 = $F0BE. Escribamos el programa: #include <18F4550.h> #fuses XT, NOPROTECT, NOWRT, NOPUT, NOWDT, NOLVP, NOCPD //rdenes para el programador

#use delay (clock=4000000) #INT_Timer0 void DesbordeTimer0() { output_bit(PIN_D0,!input(PIN_D0)); //Cada 16 interrupciones cambia de valor SET_TIMER0(0xf0be); } void main() { output_d(0x00); set_tris_d(0x00); SETUP_TIMER_0(RTCC_DIV_256|RTCC_INTERNAL); //Presescalar a 256, TMR0 Interno con 16 bits SET_TIMER0(0xf0be); ENABLE_INTERRUPTS( INT_Timer0 ); ENABLE_INTERRUPTS( GLOBAL ); while(TRUE) { restart_wdt(); } }

USO DEL TIMER0 EN MODO DE 8 BIT COMO CONTADOR Para utilizar el TMR0 como contador recuerde que se debe seleccionar los bits TOSE y TOCS del registro T0CON. El TMR0 trabaja en modo de contador cuando cuenta los pulsos provenientes de una seal externo que se ingresa por el puerto RA4/TOCI. La instruccin en CCS que permite utilizar como contador al temporizador es: SETUP_TIMER_0(RTCC_DIV_1|RTCC_EXT_L_TO_H | RTCC_8_BIT): RTCC_8_BIT: TMR0 contador de 8 bits. RTCC_EXT_L_TO_H: Detecta el cambio de bajo a alto. Para detectar de alto a bajo colocar RTCC_EXT_H_TO_L: RTCC_DIV_1: Divisor de frecuencia 1. En el siguiente ejercicio un LED conectado en el puerto RB0, se prende y se apaga cada 500 ms. Un LED conectado en RD0 cambia de estado cada 5 pulsos que ingresan por RA4. Como el registro del temporizador 0, en 8 bits cuenta hasta 256, para que se produzca el desborde, el TIMER0 se carga con 251. Escribamos el programa: //USO DEL TIMER0 EN MODO DE 8 BIT COMO CONTADOR #include <18F4550.h> #fuses XT, NOPROTECT, NOWRT, PUT, NOWDT, NOLVP, NOCPD //rdenes para el programador

#use delay (clock=4000000) #BYTE port_b= 0xf81 #BYTE port_b= 0xf83 #INT_Timer0 void DesbordeTimer0() { output_bit(PIN_D0,!input(PIN_D0)); //Cada 5 impulsos cambia de valor SET_TIMER0(251); } main(void) { output_d(0x00); SETUP_TIMER_0(RTCC_DIV_1|RTCC_EXT_L_TO_H | RTCC_8_BIT); //Preescalar 1, Flanco de subida, TMR0 contador de 8 bits. SET_TIMER0(251); ENABLE_INTERRUPTS ( INT_Timer0 ); ENABLE_INTERRUPTS ( GLOBAL ); while(TRUE) { output_low(PIN_B0); //led off delay_ms(500); output_high(PIN_B0); //led on delay_ms(500); } } La figura muestra el circuito utilizado:

USO DEL TIMER0 EN MODO DE 16 BIT COMO CONTADOR Para modo de 16 bits, la instuccin en CCS es: SETUP_TIMER_0(RTCC_DIV_1|RTCC_EXT_L_TO_H):

SETUP_TIMER_0: Utiliza el temporizador TMR0 RTCC_DIV_1: Divisor de frecuencia 1. RTCC_EXT_L_TO_H: Detecta el cambio de bajo a alto. Para detectar de alto a bajo colocar RTCC_EXT_H_TO_L Realizando el mismo ejemplo anterior, se tiene el TMR0 cuenta hasta 65536 pulsos, por tanto, para que cuente 5 pulsos y se produzca el desborde es 65531 (FFFB), valor con el cual se fija el TIMER0. Escribamos el programa: //USO DEL TIMER0 EN MODO DE 16 BIT COMO CONTADOR #include <18F4550.h> #fuses XT, NOPROTECT, NOWRT, PUT, NOWDT, NOLVP, NOCPD //rdenes para el programador #use delay (clock=4000000) #INT_Timer0 void DesbordeTimer0() { output_bit(PIN_D0,!input(PIN_D0)); //Cada 5 impulsos cambia de valor SET_TIMER0(0xFFFB); }

main() { output_d(0x00); SETUP_TIMER_0(RTCC_DIV_1|RTCC_EXT_L_TO_H); //TMR0 con 16 bits SET_TIMER0(0xFFFB); ENABLE_INTERRUPTS ( INT_Timer0 ); ENABLE_INTERRUPTS ( GLOBAL ); while(1) { output_low(PIN_B0); //led off delay_ms(500); output_high(PIN_B0); //led on delay_ms(500); //restart_wdt(); } }