1.

Tipos de interrupciones
Las interrupciones son esencialmente llamadas a subrutina generadas por los dispositivos fsicos, al
contrario de las subrutinas normales de un programa en ejecucin. Como el salto de subrutina no es
parte del hilo o secuencia de ejecucin programada, el controlador guarda el estado del procesador
en la pila de memoria y entra a ejecutar un cdigo especial llamado "manejador de interrupciones"
que atiende al perifrico especfico que gener la interrupcin. Al terminar la rutina, una instruccin
especial le indica al procesador el fin de la atencin de la interrupcin. En ese momento el
controlador restablece el estado anterior, y el programa que se estaba ejecutando antes de la
interrupcin sigue como si nada hubiese pasado. Las rutinas de atencin de interrupciones deben ser
lo ms breves posibles para que el rendimiento del sistema sea satisfactorio, por que normalmente
cuando una interrupcin es atendida, todas las dems interrupciones estn en espera.

Imagine que est esperando la visita de un amigo, al que llamaremos Juan. Usted y Juan han
acordado que cuando l llegue a su casa esperar pacientemente a que le abra la puerta. Juan no
debe tocar a la puerta porque alguien en la casa duerme y no quiere que le despierten.

Ahora usted ha decidido leer un libro mientras espera a que Juan llegue a la casa, y para comprobar
si ha llegado, cada cierto tiempo detiene la lectura, marca la pgina donde se qued, se levanta y va
hasta la puerta, abre y comprueba si Juan ha llegado, si ste todava no est en la puerta, esperar
unos minutos, cerrar la puerta y regresar a su lectura durante algn tiempo.

Como ver este es un mtodo poco eficiente para esperar a Juan porque requiere que deje la lectura
cada cierto tiempo y vaya hasta la puerta a comprobar si l ha llegado, adems debe esperar un rato
si todava no llega. Y por si fuera poco, imagine que Juan no llega nunca porque se le present un
problema, tuvo que cancelar la cita y no pudo avisarle a tiempo, o peor, que Juan ha llegado a la
puerta un instante despus que usted la cerraba. Juan, respetando lo acordado, espera un tiempo,
pero se cansa de esperar a que le abran y decide marcharse porque cree que ya usted no est en la
casa o no puede atenderlo. A este mtodo de atender la llegada de Juan lo llamaremos encuesta.

Veamos ahora otro mtodo. En esta ocasin simplemente se recuesta en el sof de la sala y
comienza a leer su libro, cuando Juan llegue debe tocar el timbre de la puerta y esperar unos
momentos a que le atiendan. Cuando usted oye sonar el timbre, interrumpe la lectura, marca la
pgina donde se qued y va hasta la puerta para atender a la persona que toca el timbre. Una vez
que Juan o la persona que ha tocado el timbre, se marcha, usted regresa a su asiento y retoma la
lectura justo donde la dej. Este ltimo es un mtodo ms eficiente que el anterior porque le deja
ms tiempo para leer y elimina algunos inconvenientes como el de que Juan nunca llegue o se
marche antes de que usted abra la puerta. Es, en principio, un mtodo simple pero muy eficaz y
eficiente, lo llamaremos atencin por interrupcin.

El primero de ellos, la encuesta, es un mtodo eficaz, pero poco eficiente porque requiere realizar
lecturas constantes y muchas veces innecesarias del estado del proceso que queremos atender. Sin
embargo, es muy utilizado en la programacin de microcontroladores porque resulta fcil de
aprender, la implementacin de cdigo con este mtodo es menos compleja y no requiere de
hardware especial para llevarla adelante. Por otra parte, la encuesta, tiene muchas deficiencias que
con frecuencia obligan al diseador a moverse hacia otros horizontes

El mundo est lleno de situaciones; de las cuales no podemos determinar ni cuando, ni como ni por
qu se producen, en la mayora de los casos lo nico que podemos hacer es enterarnos de que
determinada situacin, asociada a un proceso, ha ocurrido. Para ello seleccionamos alguna
condicin o grupo de condiciones que nos indican que el proceso que nos interesa debe ser
atendido, a este fenmeno, en el cual se dan las condiciones que nos interesa conocer, lo
llamaremos evento. En el segundo ejemplo vemos que para atender a Juan, ste debe tocar el
timbre, por tanto, la llegada de Juan es el proceso que debemos atender y el sonido del timbre es el
evento que nos indica que Juan ha llegado.

El mtodo de atencin a procesos por interrupcin, visto desde la ptica del ejemplo que utilic para
mostrarlo, es ms simple que el de la encuesta, pero no es cierto, el mtodo se complica porque
requiere que el microprocesador incorpore circuitos adicionales para registrar los eventos que le
indican que debe atender al proceso asociado y comprender estos circuitos y su dinmica no es una
tarea sencilla.

Los circuitos para la atencin a las interrupciones y todas las tareas que debe realizar el procesador
para atender al proceso que lo interrumpe son bastante complejos y requieren una visin diferente
de la que estamos acostumbrados a tener de nuestro mundo.

Los seres humanos no estamos conscientes de las interrupciones, en nuestro organismo existen
mecanismos que nos interrumpen constantemente, para ello tenemos a nuestro sistema sensorial,
pero no somos conscientes del proceso de interrupcin, aunque s de la atencin a las
interrupciones. Eso es porque incorporamos mecanismos que nos sacan rpidamente de la tarea que
estemos haciendo para atender una situacin que no puede o no debe esperar mucho tiempo. Bien,
esa misma es la idea que se incorpora en los microprocesadores para atender procesos que no
pueden esperar o que no sabemos cuando deben ser atendidos porque ello depende de determinadas
condiciones.

La cosa se complica en la secuencia de acciones a realizar desde el momento en que se desencadena

el proceso de interrupcin, hasta que se ejecuta el programa que lo atiende, y en la secuencia de
acciones posteriores a la atencin. Piense en cuantas cosas debe hacer su organismo ante una
interrupcin, utilicemos el segundo ejemplo para atender la llegada de Juan. Piense en cuantas cosas
su cerebro hace a espaldas de su conciencia, desde el momento en que suena el timbre hasta que
usted se encuentra listo (consciente de que es probable que Juan ha llegado) para abrir la puerta, y
todo lo que su cerebro debe trabajar para retomar la lectura despus que Juan se ha marchado. Todo
eso, excepto abrir la puerta y atender a Juan, lo hacemos de forma inconsciente porque para ello
tenemos sistemas dedicados en nuestro organismo, pero en el mundo de los microcontroladores
debemos conocer todos esos detalles para poder utilizar los mecanismos de interrupcin.

Los procesos de atencin a interrupciones tienen la ventaja de que se implementan por hardware
ubicado en el procesador, as que es un mtodo rpido de hacer que el procesador se dedique a
ejecutar un programa especial para atender eventos que no pueden esperar por mecanismos lentos
como el de encuesta.

En trminos generales, un proceso de interrupcin y su atencin por parte del procesador, tiene la
siguiente secuencia de acciones:

En el mundo real se produce el evento para el cual queremos que el procesador ejecute un programa
especial, este proceso tiene la caracterstica de que no puede esperar mucho tiempo antes de ser
atendido o no sabemos en que momento debe ser atendido.
El circuito encargado de detectar la ocurrencia del evento se activa, y como consecuencia, activa la
entrada de interrupcin del procesador.
La unidad de control detecta que se ha producido una interrupcin y levanta una bandera para
registrar esta situacin; de esta forma si las condiciones que provocaron el evento desaparecen y el
circuito encargado de detectarlo desactiva la entrada de interrupcin del procesador, sta se
producir de cualquier modo, porque ha sido registrada.
La unidad de ejecucin termina con la instruccin en curso y justo antes de comenzar a ejecutar la
siguiente comprueba que se ha registrado una interrupcin
Se desencadena un proceso que permite guardar el estado actual del programa en ejecucin y saltar
a una direccin especial de memoria de programas, donde est la primera instruccin de la subrutina
de atencin a interrupcin.
Se ejecuta el cdigo de atencin a interrupcin, esta es la parte consciente de todo el proceso
porque es donde se realizan las acciones propias de la atencin a la interrupcin y el programador
juega su papel.

Cuando en la subrutina de atencin a interrupcin se ejecuta la instruccin de retorno, se

desencadena el proceso de restauracin del procesador al estado en que estaba antes de la atencin a
la interrupcin.
2. Tipos de temporalizadores
Son circuitos sincrnicos para el conteo de los pulsos que llegan a su poder para conseguir la
entrada de reloj. Si la fuente de un gran conteo es el oscilador interno del microcontrolador es
comn que no tengan un pin asociado, y en este caso trabajan como temporizadores. Por otra
parte, cuando la fuente de conteo es externa, entonces tienen asociado un pin configurado
como entrada, este es el modo contador.
Los temporizadores son uno de los perifricos ms habituales en los microcontroladores y se
utilizan para muchas tareas, como por ejemplo, la medicin de frecuencia, implementacin de
relojes, para el trabajo de conjunto con otros perifricos que requieren una base estable de
tiempo entre otras funcionalidades. Es frecuente que un microcontrolador tpico incorpore ms
de un temporizador/contador e incluso algunos tienen arreglos de contadores. Como veremos
ms adelante este perifrico es un elemento casi imprescindible y es habitual que tengan
asociada alguna interrupcin. Los tamaos tpicos de los registros de conteo son 8 y 16 bits,
pudiendo encontrar dispositivos que solo tienen temporizadores de un tamao o con ms
frecuencia con ambos tipos de registro de conteo.

3. 3 Ejemplos Prcticos de interrupciones en Lenguaje C

3.1.

Generacin de seales PWM mediante interrupciones

#include <pic16f876a.h>
#define ESTADO_ON 0
#define ESTADO_OFF 1
unsigned char estado=0;
unsigned char T0ini;
//-- Interfaz entre la rutina de atencion a la int.
unsigned char Ton=0;
//-- Senal PWM
volatile unsigned char cont=0;
//-- Contador de ciclos
/*****************************************/
/* Rutina de atencion a la interrupcion */
/*****************************************/
void isr() interrupt 0
{
//-- En esta estado se activa el pulso
if (estado==ESTADO_ON) {

//-- Activar todos los leds

PORTB=0xFF;
//-- Valor para que est activo durante Ton ticks
T0ini=255-Ton;
//-- Pasar al estado siguiente
estado=ESTADO_OFF;

}
//---- En este estado se desactivan los pulsos
else {
//-- Desactivar todos los leds
PORTB=0x00;
//-- Valor para que est activo durante Toff ticks
T0ini=Ton;
//-- Pasar al estado inicial
estado=ESTADO_ON;
//-- Se ha generado un ciclo ms
cont++;
}
//-- Dar valor inicial del timer
TMR0=T0ini;

//-- Quitar flag de interrupcion

TMR0IF=0;

void main(void)
{
unsigned char i;
TRISB=0;
//-- Configurar Timer 0
//-- Modo temporizador
T0CS=0; PSA=0;
//-- Presscaler a 32
PS2=1; PS1=0; PS0=0;
//-- Activar interrupciones
TMR0IE=1;
GIE=1;
//-- El pwm se esta generando mediante interrupciones
//-- En el bucle principal haremos que los leds se vayan desvaneciendo
for (i=255; i>0; i--) {
//-- Genera la seal pwm
Ton=i;
//-- POner contador de ciclos a cero
cont=0;

//-- La senal se genera mediante int. Mientras tanto esperamos hasta

//-- que hayan pasado 10 ciclos. Aqu el PIC podra estar haciendo
//-- cualquier otra tarea
while(cont<10);
}
//-- Deshabilitar interrupciones
TMR0IE=0;
//-- Poner a 0 todos los leds
PORTB=0;
while(1);

3.2.

Transmisin de datos mediante interrupciones

#include <pic16f876a.h>
unsigned char i=0;
unsigned char cad[]={'h','o','l','a',0};

void sci_conf()
{
//-- Configurar valocidad puerto serie
//-- Velocidad SPBRG (dec)
//-- 9600

129

//-- 19200

64

//-- 57600

20

BRGH=1;
SPBRG=129; //-- 9600

//-- Configuracion puerto serie

SYNC=0; //-- Comunicacion asincrona

SPEN=1; //-- Habilitar puerto serie (pines)

CREN=1; //-- Habilitar receptor
TXEN=1; //-- Habilitar transmisor
}

/*****************************************/
/* Rutina de atencion a la interrupcion */
/*****************************************/
void isr() interrupt 0
{
//-- Enviar el siguiente caracter de la cadena, si no es el ultimo
if (cad[i]!=0) {

//-- Enviar caracter i

TXREG=cad[i];

//-- Apuntar al siguiente caracter a enviar

i++;
}
}

/*********************************/
/* Programa principal

*/

/*********************************/
void main(void)
{

unsigned char cont=0;

//-- Configurar puerto B para salida

TRISB=0;

//-- Configurar puerto serie

sci_conf();

//-- Activar las interrupciones

TXIE=1;
PEIE=1;
GIE=1;

while(1);
}

3.3.

Recepcin de datos mediante interrupciones

#include <pic16f876a.h>
#define LED RB1
volatile unsigned char c;

void sci_conf()
{
//-- Configurar valocidad puerto serie
//-- Velocidad SPBRG (dec)

//-- 9600

129

//-- 19200

64

//-- 57600

20

BRGH=1;
SPBRG=129; //-- 9600

//-- Configuracion puerto serie

SYNC=0; //-- Comunicacion asincrona
SPEN=1; //-- Habilitar puerto serie (pines)
CREN=1; //-- Habilitar receptor
TXEN=1; //-- Habilitar transmisor
}

/*****************************************/
/* Rutina de atencion a la interrupcion */
/*****************************************/
void isr() interrupt 0
{
//-- Quitar flag de interrupcion (hay que leer el dato)
c=RCREG;

//-Cambiar
/* rutina de servicio de interrupciones */
LED^=1;
}

led

de

estado

/*********************************/
/* Programa principal

*/

/*********************************/
void main(void)
{
//-- Configurar puerto B para salida
TRISB=0;

//-- Configurar puerto serie

sci_conf();

//-- Activar las interrupciones

RCIE=1;
PEIE=1;
GIE=1;

while(1);

}
4. 3 Ejemplos Prcticos de temporizadores en Lenguaje C
4.1.

/*Cabecera******************************************************/

unsigned cnt;

void interrupt() {

// Definir la variable cnt

cnt++;

// Con una interrupcin la cnt se incrementa en 1

TMR0 = 96;

// El valor inicial se devuelve en el temporizador TMR0

INTCON = 0x20;

// Bit T0IE se pone a 1, el bit T0IF se pone a 0

void main(){
OPTION_REG = 0x84; // Pre-escalador se le asigna al temporizador TMR0
ANSEL = 0;

// Todos los pines de E/S se configuran como digitales

ANSELH = 0;
TRISB = 0;

// Todos los pines de puerto PORTB se configuran

// como salidas
PORTB = 0x0;

// Reiniciar el puerto PORTB

TMR0 = 96;

// Temporizador T0 cuenta de 96 a 255

INTCON = 0xA0;
cnt = 0;

do {

// Habilitada interrupcin TMR0

// A la variable cnt se le asigna un 0

// Bucle infinito

if (cnt == 400) {
interrupciones

// Incrementar el puerto PORTB despus 400

PORTB = PORTB++; // Incrementar nmero en el puerto PORTB en 1

cnt = 0;

// Reiniciar la variable cnt

}
} while(1);

}
4.2.

Realizar una pausa de 1ms

#include <pic16f876a.h>
//-- Valor inicial del TMR0 para realizar una pausa de 1ms
//-- Divisor del prescar a 32
#define T0INI 100
#define LED RB1
/******************************/
/* Hacer una pausa de 1 ms
*/
/******************************/
void pausa_1ms()
{
//-- Dar valor inicial del timer
TMR0=T0INI;
//-- Flag de interrupcion a cero
T0IF=0;
//-- Esperar a que transcurra 1ms
while(T0IF==0);
}
void main(void)
{
TRISB1=0;
//-- Configurar Timer 0
//-- Modo temporizador
T0CS=0; PSA=0;
//-- Presscaler a 32
PS2=1; PS1=0; PS0=0;

while(1) {
pausa_1ms();
LED=1;
pausa_1ms();
LED=0;
}

4.3.

Realizar una pausa de 10ms

#include <pic16f876a.h>
//-- Valor inicial del TMR0 para realizar una pausa de 10ms
//-- Divisor del prescar a 256
#define T0INI 61
#define LED RB1
/******************************/

/* Hacer una pausa de 10ms

*/
/******************************/
void pausa_10ms()
{
//-- Dar valor inicial del timer
TMR0=T0INI;
//-- Flag de interrupcion a cero
T0IF=0;
//-- Esperar a que transcurra 1ms
while(T0IF==0);
}
void main(void)
{
TRISB1=0;
//-- Configurar Timer 0
//-- Modo temporizador
T0CS=0; PSA=0;
//-- Presscaler a 256
PS2=1; PS1=1; PS0=1;

while(1) {
pausa_10ms();
LED=1;
pausa_10ms();
LED=0;
}