Las instrucciones de CCS que permiten controlar la interrupción 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 interrupción en flanco de bajada. Si se quiere por flanco de subida se coloca (L_TO_H) enable_interrupts(GLOBAL); // habilitación global de todas las interrupciones. enable_interrupts(INT_EXT); // habilitación de las interrupciones externas. Las dos últimas instrucciones deben estar activadas en la función principal para que pueda detectar la interrupción si ocurre en el puerto B.

Proyecto : En el siguiente proyecto, se utiliza la interrupción 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 interrupción, en la cual, un LED se prende y se apaga cinco veces.

PROGRAMA: //USO DE LA INTERRUPCIÓN 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

set_tris_d(0b00000000). PORT_B=0. Cada pulso es un ciclo de máquina del oscilador de reloj. el registro se incrementa cada 4 periodos de la señal de reloj. n<=5. delay_ms(500). } } TEMPORIZADOR 0    Configurable como temporizador o contador de 8/16 bits. output_low(PIN_B3). Pre – escalar de 8 bits. si el divisor de frecuencia (preescalar) está deshabilitado. PORT_D=0. enable_interrupts(INT_EXT). } } void main(void) { set_tris_b(0b00000001). delay_ms(500). puede contar 256 pulsos. delay_ms(300). Función del temporizador en el desborde. n++){ output_high(PIN_B3).#byte PORT_A=0xf80 int n =0. #int_ext PortB_Interrupt() //Función para la interrupción { ext_int_edge(H_TO_L). Interrupción por desbordamiento. while(TRUE){ output_high(PIN_D0). USO DEL TIMER0 EN MODO DE 8 BIT COMO TEMPORIZADOR El temporizador TMR0 al usar el registro 8 bits. delay_ms(300). enable_interrupts(GLOBAL). for(n=1. Instrucciones CCS: void DesbordeTimer0(). output_low(PIN_D0). . es decir.

Como se requiere un tiempo de 1 s y trabajando con un oscilador de 4 MHZ.25 us. #use delay (clock=4000000) int contador. //Cada 16 interrupciones cambia de valor contador=0. El Periodo del oscilador Toscilador = 1/ 4 Mhz = 0. Escribamos el programa: #include <18F4550. NOPROTECT. Otra forma de fijar los valores en el timer0. } SET_TIMER0(12). TMR0 Interno con 8 bits. SETUP_TIMER_0(RTCC_DIV_256|RTCC_INTERNAL|RTCC_8_BIT). Fija el valor inicial del timer para que empiece la cuenta. } main(void) { contador =0. if (contador == 16){ output_bit(PIN_D0. Esta instrucción sirve para fijar el preescalar a 256. Habilita la interrupción del temporizador 0.SETUP_TIMER_0(RTCC_DIV_256|RTCC_INTERNAL|RTCC_8_BIT). es necesario reducirlo a un menor valor y para luego mediante programación utilizando un temporizador completar el tiempo. se procede…. ENABLE_INTERRUPTS( GLOBAL ). Con estos datos se tiene un tiempo de: Tiempo = 4 * 0. 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. Para esto. 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. NOPUT. NOWRT.25 * (256 – 12) * 256 = 62 464 us. setup_counters(RTCC_INTERNAL|RTCC_8_BIT.RTCC_DIV_256). Habilitación global de todas las interrupciones. SET_TIMER0(valor). NOLVP.h> #fuses XT. TMR0 Interno con 8 bits SET_TIMER0(12). ENABLE_INTERRUPTS( INT_Timer0 ). no se puede temporizar un tiempo tan alto. output_d(0x00). //Preescalar a 256. * 16 = 999 424 us ~ 1 segundo). PS1. #int_Timer0 void DesbordeTimer0() { contador = contador +1. PS0 = 1 1 1). NOWDT. NOCPD //Órdenes para el programador. ENABLE_INTERRUPTS( INT_Timer0 ). set_tris_d(0x00). .!input(PIN_D0)). Para completar 1 segundo se debe repetir 16 veces (62 464 us.

ENABLE_INTERRUPTS( GLOBAL ). NOCPD //Órdenes para el programador .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 . USO DEL TIMER0 EN MODO DE 16 BIT COMO TEMPORIZADOR El TMR0 trabajando en modo de 16 bits.RTCC_DIV_256). TMR0 Interno con 16 bits. NOWRT. Presescalar a 256. o tambén. while(TRUE) { restart_wdt(). puede contar hasta 65536 pulsos de la Fosc/4. En este caso para trabajar con 16 bits la instrucción CCS.h> #fuses XT.25us*256) = ~ 3906 TMR0 = 65536 .TMR0= 1000000/(4*0. NOPUT. que se utiliza es: SETUP_TIMER_0(RTCC_DIV_256|RTCC_INTERNAL). Otra forma de fijar los valores en el timer0. Utilizando la ecuación determinamos el valor a cargar el temporizador TMR0. } } La figura muestra el circuito utilizado.3906 = 61630 = $F0BE. NOWDT. NOLVP. Por el puerto RD0 se requiere sacar una señal cuadrada de 2 s (1s en alto y 1s en bajo). 65536 . Escribamos el programa: #include <18F4550. NOPROTECT. setup_counters(RTCC_INTERNAL.

} } 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. RTCC_EXT_L_TO_H: Detecta el cambio de bajo a alto. //Cada 16 interrupciones cambia de valor SET_TIMER0(0xf0be). while(TRUE) { restart_wdt(). NOCPD //Órdenes para el programador . Como el registro del temporizador 0. ENABLE_INTERRUPTS( INT_Timer0 ). Escribamos el programa: //USO DEL TIMER0 EN MODO DE 8 BIT COMO CONTADOR #include <18F4550. La instrucción 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. Un LED conectado en RD0 cambia de estado cada 5 pulsos que ingresan por RA4. SETUP_TIMER_0(RTCC_DIV_256|RTCC_INTERNAL). en 8 bits cuenta hasta 256. se prende y se apaga cada 500 ms. ENABLE_INTERRUPTS( GLOBAL ). El TMR0 trabaja en modo de contador cuando cuenta los pulsos provenientes de una señal externo que se ingresa por el puerto RA4/TOCI. NOWDT. el TIMER0 se carga con 251. NOWRT. NOLVP. set_tris_d(0x00).!input(PIN_D0)). } void main() { output_d(0x00). //Presescalar a 256.#use delay (clock=4000000) #INT_Timer0 void DesbordeTimer0() { output_bit(PIN_D0. TMR0 Interno con 16 bits SET_TIMER0(0xf0be). Para detectar de alto a bajo colocar RTCC_EXT_H_TO_L: RTCC_DIV_1: Divisor de frecuencia 1. PUT. para que se produzca el desborde.h> #fuses XT. NOPROTECT. En el siguiente ejercicio un LED conectado en el puerto RB0.

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

NOWRT. 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.!input(PIN_D0)). NOWDT. RTCC_EXT_L_TO_H: Detecta el cambio de bajo a alto. Escribamos el programa: //USO DEL TIMER0 EN MODO DE 16 BIT COMO CONTADOR #include <18F4550. valor con el cual se fija el TIMER0. NOCPD //Órdenes para el programador #use delay (clock=4000000) #INT_Timer0 void DesbordeTimer0() { output_bit(PIN_D0. para que cuente 5 pulsos y se produzca el desborde es 65531 (FFFB).h> #fuses XT. //Cada 5 impulsos cambia de valor SET_TIMER0(0xFFFB). } . la instucción 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. PUT.USO DEL TIMER0 EN MODO DE 16 BIT COMO CONTADOR Para modo de 16 bits. NOPROTECT. por tanto. NOLVP.

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

Sign up to vote on this title
UsefulNot useful