Interrupciones en un

microcontrolador.

Interrupciones en un microcontrolador. 1
Interrupciones en un microcontrolador. 2
INTERRUPCIÓN

INTERRUMPE EL FLUJO ACTUAL DEL SISTEMA PARA

EJECUTAR SU SOLICITUD.

• Las interrupciones 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 .

Interrupciones en un microcontrolador. 3
Interrupciones en un microcontrolador. 4
Cuando ocurre una interrupción, el microcontrolador:

1. Guarda el estado actual:

2. Ejecuta el manejador de la
interrupción: Rutina de
Servicio de Interrupción o
ISR (Interrupt Service
Routine), encargado de
gestionar el evento que
causó la interrupción.

3. Retorna al programa
principal.

Interrupciones en un microcontrolador. 5
Ejemplos.
• Las interrupciones son útiles para
responder de manera rápida a
eventos externos o internos sin tener
que revisar constantemente el estado
de los periféricos, lo que ahorra
tiempo y recursos en la ejecución del
programa principal (evitando el
polling o sondeo continuo).

Interrupciones en un microcontrolador. 6
TIMERs
• Los TIMER o temporizadores son módulos integrados en
el PIC que permite realizar cuentas tanto de eventos
internos como externos.

• Cuando la cuenta es interna se habla de temporización

y cuando la cuenta es externa se habla de contador.

Interrupciones en un microcontrolador. 7
Tipos de (INT) Cambio en el
pin RB0/INT

interrupcio Externas

nes
(Port Change Interrupt )
Cuando hay un cambio
en los pines RB4 a RB7

Interrupciones del
temporizador (Timer
Interrupts)
Tipos de interrupciones

Interrupciones del
convertidor
analógico-digital
(ADC Interrupt)

Interrupción de
transmisión/recepció
internas
n del puerto serie
(USART Interrupts)

Interrupciones del
módulo CCP
(Capture/Compare/P
WM)

Interrupciones por
desbordamiento del
EEPROM (EEPROM
Write Interrupt)

Interrupciones en un microcontrolador. 8
Interrupciones en un microcontrolador. 9
Interrupciones en C

En el compilador C, la directiva habitual en el

manejo de las interrupciones es #INT_xxxx.

Especifica que la función que le sigue es una

función de interrupción; además, no necesita más
parámetros.

Interrupciones en un microcontrolador. 10
 #include <16F887.h>
#fuses NOWDT, HS
#use delay(clock=20000000)

EXT // Rutina de interrupción externa en el pin RB0/INT

#INT_EXT
void ext_isr(void) {
Indica que esta función será llamada
automáticamente cuando ocurra una // Código que se ejecuta cuando ocurre una interrupción en
interrupción externa en el pin RB0/INT
RB0/INT. }

void main() {
INT_EXT
// Configuración inicial
set_tris_b(0b00000001)
#INT_EXT output_b(0x00);
ext_int_edge(L_TO_H);
enable_interrupts(INT_EXT);
enable_interrup(GLOBAL);
Esta interrupción se activa cuando
ocurre un cambio en el estado del pin
RB0, ya sea en un flanco de subida
(bajo a alto) o en un flanco de bajada
while (TRUE) {
(alto a bajo), según cómo se configure. // Código principal
}
}
Interrupciones en un microcontrolador. 11
Hoja de datos

Interrupciones en un microcontrolador. 12
 • ext_int_edge (H_TO_L); La interrupción es por flanco
de bajada (activa el flag INTF).

• ext_int_edge (L_TO_H); La interrupción es por

FLACOS flanco de subida (activa el flag INTF).

• enable_interrupts (nivel);
• nivel es una constante definida en un fichero de
cabecera

Interrupciones en un microcontrolador. 14
Interrupciones en un microcontrolador. 15
 • Encender y apagar,
Ejemplo 1 consecutivamente, un LED en la
patilla RB7 cuando se produzca un
cambio de nivel en la pin RB0

Interrupciones en un microcontrolador. 16
 …
#INT_EXT
ext_isr(){
Encender y apagar el RB7;
}
Encender y apagar,
consecutivamente, un LED en la main {
patilla RB7 cuando se produzca un CONFIGURAR SALIDA RB7
cambio de nivel en la patilla RB0
CONFIGURAR COMO ENTRADA R0B
enable_interrupts(int_ext);
ext_int_Edge(L_TO_H);
enable_interrup(GLOBAL);

while (1){
….
}
}

Interrupciones en un microcontrolador. 17
Interrupciones en C

En el compilador C, la directiva habitual en el

manejo de las interrupciones es #INT_xxxx.

Especifica que la función que le sigue es una

función de interrupción; además, no necesita más
parámetros.
Interrupciones en un microcontrolador. 19
 #INT_RB
void RB_ISR() {
if (input(PIN_B4)) { //
output_high(PIN_D0); // Enciende el LED en RD0
} else {

RB }
output_low(PIN_D0); // Apaga el LED en RD0

Interrupción en los pines RB4 }

a RB7 del puerto B.
void main() {
Esta interrupción se activa // Configuración inicial
cuando hay un cambio en
set_tris_b(0xF0);
cualquiera de esos pines, es
decir, cuando el estado set_tris_d(0x00);
lógico de alguno de los pines enable_interrupts(GLOBAL);
cambia de 1 a 0 o de 0 a 1. enable_interrupts(INT_RB);

while(TRUE) {
// Loop principal
// El microcontrolador espera cambios en los pines RB4-RB7
#INT_RB }
}

Interrupciones en un microcontrolador. 20
Interrupciones en C

En el compilador C, la directiva habitual en el

manejo de las interrupciones es #INT_xxxx.

Especifica que la función que le sigue es una

función de interrupción; además, no necesita más
parámetros.

Interrupciones en un microcontrolador. 21
Interrupciones en un microcontrolador. 22
Interrupciones en un microcontrolador. 23
 TIMER

Interrupciones en un microcontrolador. 24
TIMER0
Es un contador (registro) de 8
bits, incrementado por hardware
y programable.
• Se puede insertar un
prescaler, es decir, un divisor
de frecuencia programable que
• Interrupción del Timer0 puede dividir por 2, 4, 8, 16, 32,
(TMR0 Overflow) 64, 128 o 256.
• Fuente: Desbordamiento del • La frecuencia de conteo es una
Timer0. cuarta parte de la frecuencia de
reloj (fosc/4). Posteriormente,
• Descripción: Ocurre cuando el con el uso del prescaler se
Timer0 se desborda y vuelve a puede dividir la frecuencia.
cero.
Interrupciones en un microcontrolador. 25
Interrupciones en un microcontrolador. 26
CONTADOR
• TMR0 trabaja como contador
se le introducen los impulsos
desde el exterior por el pin
RA4/T0CKI (TMR0 External
Clock Input).

• Su misión es "contar" el
número de acontecimientos Contador: cuenta los eventos
externos
externos representados por
los impulsos que se aplican al
pin T0CKI.
Interrupciones en un microcontrolador. 27
TEMPORIZADOR
• Cuando el TMR0 trabaja
como temporizador cuenta
los impulsos de Fosc/4.
• Se usa para determinar
intervalos de tiempo
concretos. Estos impulsos
tienen una duración
Temporizador: cuenta los pulsos internos de re
conocida de un ciclo
máquina que es cuatro
veces el periodo de la señal
de reloj.
Interrupciones en un microcontrolador. 28
• El tiempo de desbordamiento
del TIMER0 se calcula según

T = (TCM)(Prescaler)(256 – Carga
TMR0)

Interrupciones en un microcontrolador. 29
TIMER0 en C
Configuración:

setup_timer_0 (modo);

Para escribir un valor en el registro :

set_timer0 (valor);

Para leer el valor actual del registro:

valor = get_timer0 ();

Interrupciones en un microcontrolador. 30
Modo. setup_timer_0
(modo);
• RTCC_INTERNAL : temporizador interno, usando el
reloj interno del microcontrolador como fuente de
temporización

Interrupciones en un microcontrolador. 31
Modo. setup_timer_0
(modo);
• RTCC_EXT_L_TO_H en el CCS C Compiler se refiere al
uso del Timer0 en el modo de contador externo,
donde el Timer0 incrementa su valor en respuesta a
transiciones de bajo a alto (Low to High) en un pin
externo, específicamente en el pin RA4/T0CKI

Interrupciones en un microcontrolador. 32
Modo. setup_timer_0
(modo);
• El modo RTCC_DIV_64 en el compilador CCS C se
refiere a la configuración del prescaler del Timer0
(también llamado RTCC) para que divida la frecuencia
del reloj o el número de eventos externos entre 64..

Interrupciones en un microcontrolador. 33
• Los distintos modos se pueden agrupar mediante el
empleo de símbolo |.

setup_timer_0 (RTCC_DIV_2 | RTCC_EXT_L_TO_H);

Interrupciones en un microcontrolador. 34
Interrupciones en un microcontrolador. 35
EJEMPLO
Generar una señal cuadrada
de 1KHz utilizando la
interrupción del TIMER0

Interrupciones en un microcontrolador. 36
 …
#INT_TIMER0

EJEMPLO void timer0_isr() {

set_timer0(178);
output_toggle(PIN_B0);
Generar una señal cuadrada }
de 1KHz utilizando la
interrupción del TIMER0. void main() {
setup_timer_0(RTCC_INTERNAL | RTCC_DIV_32);
set_timer0(178);
PIN de salida RB0. enable_interrupts(INT_TIMER0);
enable_interrupts(GLOBAL);

while(TRUE) {
// El programa principal puede estar vacío, ya que
la generación de la onda se maneja en la interrupción
}
}

Interrupciones en un microcontrolador. 37
Interrupciones en un microcontrolador. 38
Actividad-Practica

Generar una señal cuadrada de 0.5

KHz utilizando la interrupción del
TIMER0.
Utilizando el relog externo
PIN de salida RB0.

Interrupciones en un microcontrolador. 39
Sensor de distancia

Entrega
4 de Nov 2024

https://www.youtube.com/shorts/o7Km2CsPW10

Interrupciones en un microcontrolador. 42
TIMER1
Uso del TIMER1 en el PIC16F887a con CCS C Compiler

•Propósito del TIMER1: Se utiliza para contar el tiempo transcurrido en aplic

aciones como control de tiempo, generación de señales

Contador de 16 bits:
•El TIMER1 es un contador de 16 bits, lo que le permite contar hasta 65535 (0x
FFFF) antes de reiniciarse.

Divisores de Prescaler:
•Incluye un prescaler configurable con divisores de 1:1, 1:2, 1:4 y 1:8, lo que p
ermite ajustar la frecuencia de conteo.

Interrupciones en un microcontrolador. 43
TIMER1 en C
Configuración:

setup_timer_1 (modo);

Para escribir un valor en el registro :

set_timer1 (valor);

Para leer el valor actual del registro:

valor = get_timer1 ();

Interrupciones en un microcontrolador. 44
Interrupciones en un microcontrolador. 45
LCD

Interrupciones en un microcontrolador.
•Soporta comunicación en modo de 4 bits y 8 bits
para enviar datos.

51
4 bits

Interrupciones en un microcontrolador. 52
#include <lcd.c>
lcd_init ();
Es la primera función que debe ser llamada. Borra el LCD y lo
configura en el formato de 4 bits, con dos líneas y con caracteres de
5 x 8 puntos, en modo encendido, cursor apagado y sin parpadeo..
lcd_gotoxy (byte x , byte y);
Indica la posición de acceso al LCD. Por ejemplo, (1,1) indica la
primera posición de la primera línea y (1,2) indica la primera
posición de la segunda línea.
lcd_putc (char s); S es una variable de tipo char. Esta función
escribe la variable en la posición correspondiente. Si, además, se
indica: \f se limpia el LCD. \n el cursor va a la posición (1,2). \b el
cursor retrocede una posición.
Interrupciones en un microcontrolador. 53
printf
• printf (string)
• printf (cstring, values...)
• printf (fname, cstring, values...)
String es una cadena o un array de caracteres, values es
una lista de variables separadas por comas y fname es
una función.

Interrupciones en un microcontrolador. 54
 #include <LCD_test_3.h>

#define LCD_ENABLE_PIN PIN_D0

#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D3
#define LCD_DATA5 PIN_D4
#define LCD_DATA6 PIN_D5
#define LCD_DATA7 PIN_D6

#include <lcd.c>

void main()
{
lcd_init();
while(TRUE)
{
lcd_putc("\f");
lcd_gotoxy(1,1); // Mueve el cursor a la
posición (1,1)
printf (lcd_putc, "Hello! :)");
delay_ms(2000);
lcd_putc("\f");
lcd_gotoxy(1,2); // Mueve el cursor a la posición
(1,2)
printf (lcd_putc, " Hola! .( ");
delay_ms(2000);
}
Interrupciones en un microcontrolador. 55
}
 #include <LCD_test_3.h>
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D3
#define LCD_DATA5 PIN_D4
#define LCD_DATA6 PIN_D5
#define LCD_DATA7 PIN_D6

#include <lcd.c>

void main()
{
lcd_init();
int contador = 0;
while(TRUE) {
lcd_putc("\f");
lcd_gotoxy(1,1); // Mueve el cursor a la posición (1,1)
printf(lcd_putc, "Puntos: %d", contador);
lcd_gotoxy(1,2); // Mueve el cursor a la posición (1,2)
printf(lcd_putc, "Puntos Hex: %X", contador);
contador++;
if (contador > 10) { // Si llega al límite
contador = 0;
}
delay_ms(1000); // Espera 1 segundo antes de
actualizar el LCD
}
}
Interrupciones en un microcontrolador. 56
Sensor ultrasonico

Pines:

Vcc: Pin de alimentación. (5V)

Trigger: Pin de disparo. Este pin es una
entrada, ( se tiene que conectar a una salida del
)
Echo: Este pin es una salida del sensor, (por lo
que ha de ser conectado a una entrada del ).
Gnd: Pin negativo de alimentación.

Interrupciones en un microcontrolador. 57
 1) Aplicar un pulso de 10uS
en el pin trigger para
comenzar con la medición.

2) El sensor envía una

serie de 8 pulsos de 40KHz
y pone el pin de Echo a
nivel alto.

3) El pin Echo permanecerá

a nivel alto hasta que se
reciba el eco de los pulsos
de 40KHz.
https://cursos.mcielectronics.cl/2022/12/06/como-
funciona-el-sensor-ultrasonico-hc-sr04-y-como-se-
conecta-con-arduino/

Interrupciones en un microcontrolador. 58
Interrupciones en un microcontrolador. 59
#include <16f877a.h> delay_us(10);
#use delay(clock=20Mhz, crystal) output_low(TRIG_PIN);
#fuses NOWDT, HS, NOPROTECT set_timer1(0);

#define LCD_ENABLE_PIN PIN_D0 while(!input(ECHO_PIN)){

#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
set_timer1(0); // Reiniciar el TIMER1 al inicio del
#define LCD_DATA4 PIN_D3 pulso
#define LCD_DATA5 PIN_D4 }
#define LCD_DATA6 PIN_D5
#define LCD_DATA7 PIN_D6
while(input(ECHO_PIN)){
valor = get_timer1(); // Obtener el ancho del pulso en
#define TRIG_PIN PIN_B0 // Pin de salida para el TRIG
TIMER1
#define ECHO_PIN PIN_B1 // Pin de entrada para el ECHO
}
#include <lcd.c>

void main()
{ lcd_putc("\f");
int16 valor; lcd_gotoxy(1,2);
printf(lcd_putc,"Distancia: %Lu", valor);
lcd_init(); valor=0;
setup_timer_1(T1_Internal|T1_DIV_BY_2);
set_timer1(0); delay_ms(500); // Esperar medio segundo antes de la
próxima medición
while(TRUE) }
{ }
valor=0;
output_low(TRIG_PIN);
delay_us(2);
output_high(TRIG_PIN);
Interrupciones en un microcontrolador. 60
Convertidor Analógico – Digital y
Digital – Analógico

Interrupciones en un microcontrolador. 61
Conversión de señal analógica a
señal digital.

•El módulo de conversión se

caracteriza por parámetros como
los siguientes:
••​Rango de entrada.
••​Número de bits.
••​Resolución.
••​Voltaje de fondo de escala.
• •​Tiempo de conversión.
••​Error de conversión.

Interrupciones en un microcontrolador. 62
 𝑉 𝐼𝑁
𝑁

Resolución. 2 −1

El módulo que utilizan los PIC de

gama media tiene un número de
bits de 10, por lo que su resolución voltaje de de entrada
es:
el número de bits del convertidor.

Los PICs permiten cambiar EL VOLTAJE de

referencia en un valor absoluto (de 0 a +Vref) o en
un margen (de –Vref a +Vref).

Interrupciones en un microcontrolador. 63
PIC16F877A

Interrupciones en un microcontrolador. 64
Interrupciones en un microcontrolador. 65
Módulo AD en C
• setup_adc (modo);
Configurar el módulo ADC (Convertidor A

• setup_adc_ports (valor); configura

• set_adc_channel (canal); se usa p

• valor = read_adc (); leer el valor d

Interrupciones en un microcontrolador. 66
setup_adc (modo);

Interrupciones en un microcontrolador. 67
setup_adc_ports (valor);

Interrupciones en un microcontrolador. 68
Interrupciones en un microcontrolador. 69
 #include <16f877a.h>
#device ADC=10
#use delay(clock=20Mhz, crystal)

. Convertidor ADC y pantalla LCD #define LCD_ENABLE_PIN PIN_D0

#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D3
#define LCD_DATA5 PIN_D4
#define LCD_DATA6 PIN_D5
#define LCD_DATA7 PIN_D6
#include <lcd.c>

void main() {
int16 adc_value; // Entero largo
float voltage;

// Configuración del ADC y LCD

setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_DIV_16);
lcd_init();
while(TRUE) {
set_adc_channel(0); // Leer valor ADC
delay_us(30); // Tiempo de adquisición
adc_value = read_adc();
// Convertir valor ADC a voltaje
voltage = (float)adc_value * 5.0 / 1023 ;
// Mostrar voltaje en la pantalla LCD
lcd_gotoxy(1, 1);
printf(lcd_putc, "Volt : %f", voltage);
lcd_gotoxy(1, 2);
printf(lcd_putc, "ADC: %LU", adc_value);
delay_ms(1000); // Actualizar cada segundo
}
}

Interrupciones en un microcontrolador. 70
 #include <16f877a.h>
#device ADC=10
#use delay(clock=20Mhz, crystal)

Convertidor ADC y pantalla LCD . #define LCD_ENABLE_PIN PIN_D0

SENSOR DE TEMPERATURA. #define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D3
#define LCD_DATA5 PIN_D4
#define LCD_DATA6 PIN_D5
#define LCD_DATA7 PIN_D6
#include <lcd.c>

void main() {
int16 adc_value; // Entero largo
float voltage;

// Configuración del ADC y LCD

setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_DIV_16);
TMP36 lcd_init();
while(TRUE) {
set_adc_channel(0); // Leer valor ADC
delay_us(30); // Tiempo de adquisición
adc_value = read_adc();
// Convertir valor ADC a voltaje
voltage = (float)adc_value * 5.0 / 1023 ;
voltage = (voltage- 0.5 ) * 100.0;
// Mostrar voltaje en la pantalla LCD
lcd_gotoxy(1, 1);
printf(lcd_putc, “temperatura : %f", voltage);
lcd_gotoxy(1, 2);
printf(lcd_putc, "ADC: %LU", adc_value);
delay_ms(1000); // Actualizar cada segundo
}
}

Interrupciones en un microcontrolador. 71
 #include <16f877a.h>
#device ADC=10
#use delay(clock=20Mhz, crystal)

Convertidor ADC y pantalla LCD . #define LCD_ENABLE_PIN PIN_D0

SENSOR DE TEMPERATURA. #define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D3
#define LCD_DATA5 PIN_D4
#define LCD_DATA6 PIN_D5
#define LCD_DATA7 PIN_D6
#include <lcd.c>

void main() {
int16 adc_value; // Entero largo
float voltage;

// Configuración del ADC y LCD

setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_DIV_16);
TMP36 lcd_init();
while(TRUE) {
set_adc_channel(0); // Leer valor ADC
delay_us(30); // Tiempo de adquisición
adc_value = read_adc();
// Convertir valor ADC a voltaje
voltage = (float)adc_value * 5.0 / 1023 ;
voltage = (voltage- 0.5 ) * 100.0;
// Mostrar voltaje en la pantalla LCD
lcd_gotoxy(1, 1);
printf(lcd_putc, “temperatura : %f", voltage);
lcd_gotoxy(1, 2);
printf(lcd_putc, "ADC: %LU", adc_value);
delay_ms(1000); // Actualizar cada segundo
}
}

Interrupciones en un microcontrolador. 72
 #include <16f877a.h>
#device ADC=10
#use delay(clock=20Mhz, crystal)

Convertidor ADC y pantalla LCD . #define LCD_ENABLE_PIN PIN_D0

SENSOR DE TEMPERATURA. #define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D3
#define LCD_DATA5 PIN_D4
#define LCD_DATA6 PIN_D5
#define LCD_DATA7 PIN_D6
#include <lcd.c>

void main() {
int16 adc_value; // Entero largo
float voltage;

// Configuración del ADC y LCD

setup_adc_ports(AN0_VREF_VREF);
setup_adc(ADC_CLOCK_INTERNAL););
TMP36
lcd_init();
while(TRUE) {
set_adc_channel(0); // Leer valor ADC
VREF 2.41V delay_us(30); // Tiempo de adquisición
Divisor voltaje de VDD y VSS
adc_value = read_adc();
// Convertir valor ADC a voltaje
voltage = (float)adc_value * 2.41 / 1023 ;
voltage = (voltage- 0.5 ) * 100.0;
// Mostrar voltaje en la pantalla LCD
lcd_gotoxy(1, 1);
printf(lcd_putc, “temperatura : %f", voltage);
lcd_gotoxy(1, 2);
printf(lcd_putc, "ADC: %LU", adc_value);
delay_ms(1000); // Actualizar cada segundo
}
}
Interrupciones en un microcontrolador. 73
Interrupciones en un microcontrolador. 74