LAB 8 - Interrupciones Externas con PIC

CURSO DE PROGRAMACIÓN DE MICROCONTROLADORES PIC

PARTE A: Programación de Microcontroladores PIC de MICROCHIP.

INTERRUPCIONES EXTERNAS CON PIC

 

CAPACIDAD TERMINAL

• Utilizar al microcontrolador en aplicaciones de control electrónico.
• Desarrollar y ejecutar programas en un microcontrolador PIC
• Programar y configurar interfaces básicas del microcontrolador.

COMPETENCIA ESPECIFICA DE LA SESION

• Conocer las INTERRUPCIONES de un microcontrolador PIC

• Conocer las INTERRUPCIONES EXTERNAS del PIC y su funcionamiento.

CONTENIDOS A TRATAR

• Interrupciones de un PIC
• Interrupciones EXTERNAS de un PIC
• Programa de aplicación con interrupciones.

RESULTADOS

• Diseñan y optimizan sistemas y procesos para cumplir con las condiciones establecidas y gestionando adecuadamente los recursos materiales y humanos.

MATERIALES Y EQUIPO

• CCS Compiler instalado.
• Entrenador de PICS
• PIC16F877A
• Guía de Laboratorio. El trabajo se desarrolla de manera GRUPAL.
• PC con Software de simulación.

MARCO TEÓRICO:

Las interrupciones  en un PIC son desviaciones de flujo de control del programa originadas asincrónicamente por diversos sucesos que no dependen del programador, es decir, ocurren en cualquier momento.

Las interrupciones PIC ocurren por sucesos externos como la generación de una interrupción por flanco PIC, una interrupción externa PIC cambiando el nivel en un PIN del microcontrolador o eventos internos tales como el desbordamiento de un contador, terminación del conversor análogo a digital, entre otras.

El comportamiento del microcontrolador ante la interrupción es similar al procedimiento que se sigue al llamar una función desde el programa principal. En ambos casos se detiene la ejecución del programa en curso, se guarda la dirección a donde debe retornar cuando termine de ejecutar la interrupción, atiende o ejecuta el programa correspondiente a la interrupción y luego continua ejecutando el programa principal, desde donde lo dejo cuando fue interrumpido.

Tipos de Interrupciones PIC

Aqui nombramos 10 diferentes causas que producen una interrupción PIC, por lo tanto el primer paso de la rutina de interrupción será identificar la causa de la interrupción.

• Interrupción externa PIC RB0/INT
• Interrupción por cambio lógico en el puerto B (pines RB7 a RB4)
• Interrupción por desborde del timer 0 (TMR0)
• Interrupción por desborde del timer 1 (TMR1)
• Interrupción por comparación exitosa exitosa en TMR2
• Interrupción del comparador
• Interrupción del transmisor del USART
• Interrupción del receptor del USART
• Interrupción del módulo CCP
• Interrupción del EEPROM

Interrupciones PIC en CCS

Vamos a ver como podemos utilizar las interrupciones en un PIC utilizando el PIC C Compiler CCS. Lo que veremos aqui puedes aplicarlo en cualquier microcontrolador de Microchip, por ejemplo esto sirve para las interrupciones PIC 18F4550 CCS, Interrupciones PIC 16F877A, Interrupciones PIC 16F84 o cualquier otro. A modo de ejemplo lo mostraremos como usar las interrupciones PIC en el 18F887.

Los pasos que se deben seguir para atender una interrupción, son los siguientes

• Digitar la función correspondiente a la interrupción. La función debe comenzar con # y la interrupción correspondiente, por ejemplo para la función de interrupción por RB0 se digita #int_EXT
•  En el programa principal, habilitar las interrupciones en forma global, con la instrucción: enable_interrupts(GLOBAL);
•  En el programa principal, habilitar la interrupción correspondiente, como ejemplo se muestra como habilitar la interrupción externa por RB0: enable_interrupts(INT_EXT);

Existen diferentes tipos de interrupción en el microcontrolador, algunas de ellas se mencionan a continuación:
#INT_EXT              INTERRUPCIÓN EXTERNA
#INT_RTCC            DESBORDAMIENTO DEL TIMER0(RTCC)
#INT_RB                  CAMBIO EN UNO DE LOS PINES B4,B5,B6,B7
#INT_AD                  CONVERSOR A/D
#INT_EEPROM   ESCRITURA EN LA EEPROM COMPLETADA
#INT_TIMER1      DESBORDAMIENTO DEL TIMER1
#INT_TIMER2     DESBORDAMIENTO DEL TIMER2

PROGRAMA PRINCIPAL	INTERRUPCIÓN RB0	INTERRUPCIÓN RB4-RB7	OTRAS INTERRUP.
VOID main () { instrucciones.....   }	#INT_EXT void IntRB0() { instrucciones.....   }	#INT_RB void NOMBRE( ) { instrucciones.....   }	#INT ........ void NOMBRE() { instrucciones.... }

 

EXPERIENCIA # 1: INTERRUPCIÓN EXTERNA DESDE RBO :

Vamos a realizar un primer ejemplo utilizando esta interrupción para entender el funcionamiento básico.

DIAGRAMA ESQUEMÁTICO:

CÓDIGO DE PROGRAMACIÓN EN PIC C COMPILER:

// INTERRUPCIÓN RB0 #include <16f877a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz int16 tiempo=500; #INT_EXT void IntRB0() { output_toggle(PIN_E0); } void main(VOID) { enable_interrupts (INT_ext); //activar interrupcion externa ext_INT_edge (H_TO_L); //configuracion:interrupcion cuando señal esta en alta enable_interrupts (GLOBAL); //todas las interrupciones activadas output_low (PIN_E0); WHILE (true) { output_high (PIN_C0) ; delay_ms (tiempo) ; output_low (PIN_C0); delay_ms (tiempo) ; } }

EXPERIENCIA # 2: INTERRUPCIÓN EXTERNA USANDO RB4-RB7 :

Vamos a realizar un primer ejemplo utilizando esta interrupción para entender el funcionamiento básico.

DIAGRAMA ESQUEMÁTICO:

 

/******************************************************************************
#include <16f628a.h> //pic a utilizar
#fuses INTRC,NOWDT,NOPROTECT,PUT //ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz
//******************************************************************************
//VARIABLES
//******************************************************************************
int i=0; //contador para tabla BCD
int tabBCD[10]={0,1,2,3,4,5,6,7,8,9};//BCD 0-9
//******************************************************************************
//LLAMADA FUNCION INTERRUPCION
//******************************************************************************
#INT_RB
void NOMBRE( )
{
if(input(PIN_B6))
{
i++; //incremento contador indice tabBCD
if(i>9) //¿se ha mostrado digito 9?
i=0; //SI -> restaura valor indice(para mostrar digito 0)
output_a(tabBCD[ i ]); //muestra por porta digito 7 segmentos
}
if(input(PIN_B7))
{
i--; //incremento contador indice tabBCD
if(i==255) //¿se ha mostrado digito menor a 0?
i=9; //SI -> restaura valor indice(para mostrar digito 9)
output_a(tabBCD[ i ]); //muestra por porta digito 7 segmentos
}
}
//******************************************************************************
//PROGRAMA
//******************************************************************************
void main(void)
{
enable_interrupts(INT_RB); //activar interrupcion rb4:7
enable_interrupts(GLOBAL); //activar interrupciones

while(1){}
}
/******************************************************************************/

Link de video

https://youtu.be/5T4vsGSUbbI