Instituto Tecnológico de Lázaro Cárdenas

Departamento de Ingeniería Eléctrica y Electrónica

“2020, Año de Leona Vicario, Benemérita Madre de la Patria”

INSTITUTO TECNOLÓGICO DE
LÁZARO CÁRDENAS

ApLICACIONES CON MICROCONTRALODORES

NOMBRE DE LA PRACTICA:
1.2 VARIACION DE SECUENCIAS Y VELOCIDAD POR
INTERRUPCIONES

NOMBRE DEL ALUMNO:

YEPEZ NUÑEZ CRISTIAN EDUARDO

NÚMERO DE CONTROL:
19560199

CARRERA:
INGENIERÍA ELECTRÓNICA

INSTRUCTOR:
M.C. JULIO CESAR GALLO SANCHEZ

Cd. Lázaro Cárdenas, Mich. A 12 de septiembre del 2022.

Av. Melchor Ocampo # 2555, Col. Cuarto Sector, C.P. 60950, Cd. Lázaro Cárdenas, Michoacán,
Teléfono (753) 53 7 19 77, 53 2 10 40, 53 7 53 91, Ext. 121 e-mail: electronica01@itlac.mx
www.tecnm.mx | www.itlac.mx.
INTRODUCCION

En este documento se redacta el desarrollo la práctica número 2 de la materia de aplicaciones

con microcontroladores del presente año 2022, de 7 semestre de la carrera de ingeniería
electrónica.

La práctica consiste en un variador de velocidad y de secuencias de luces a través de las

interrupciones externas del microcontrolador, se usará dos push button configurados como
pull up, es decir, que cuando no estén presionados mande un 1 lógico y cuando se presionen
se mande un lógico, el microcontrolador que trae integrado la tarjeta es el PIC18F45K50,
este microcontrolador es el que se estará trabajando durante todo el curso.

Cabe aclarar que este pequeño instructivo se ha creado con la finalidad de explicar lo más
detallado posible para que la persona que este leyendo este documento para que se pueda
replicar de una manera exitosa.
DESARROLLO

Lista de materiales

Cantidad Material
1 Microcontrolador PIC18F45K50
2 Resistencia de 39 KΩ
2 Push button
1 Protoboard

Lo que se realizara en esta práctica es hacer uso de las interrupciones externas del
microcontrolador. Las interrupciones son eventos que hacen que el microcontrolador deje de
realizar la tarea actual y pase a efectuar otra actividad. Al finalizar la segunda actividad
retorna a la primera y continúa a partir del punto donde se produjo la interrupción, cabe
aclarar que las interrupciones deben ser instrucciones cortas ya que si el programa no regresa
lo más pronto posible al programa principal deja de ser una interrupción, en la siguiente
imagen se representa un descripción grafica que básicamente son dos push button, uno para
cambiar de secuencia de leds que estarán conectadas a l puerto ya que es el único de los
puertos que está completo y el otro botón para incrementar la velocidad

39 KΩ

39 KΩ
En la siguiente imagen se muestra los pines del microcontrolador PIC18F45K50 en donde
están las interrupciones externas del microcontrolador las cuales son: IN0, INT1 e INT2. Se
usarán las INT0 e INT1 que son los pines RB0 que se usará para incrementar la velocidad de
la secuencia y RB1 para cambiar la secuencia respectivamente.

En la siguiente imagen se muestra los pines RB0 y RB1 de la tarjeta donde está integrado el
PIC18F45K50.
Después de la explicación sigue la elaboración del código en el software MPLAB IDE,
comenzando en las siguientes líneas de código se configura como se trabajara el
microcontrolador, los parámetros que se configuran son la velocidad del microcontrolador
que este caso se está usando la mayor velocidad a la que puede trabajar que son 48 MHz, se
agrega la librería del microcontrolador, además se aparta un proporción de la memoria de
trabajo del microntrolador para la programación a través del puerto USB (Bootloader) esto
para no tener que usar el Programador físico.

#include "18f45k50.h" //librería del microcontrolador

#use delay(internal=48MHz) //velocidad del mircrontrolador
#build(reset=0x02000,interrupt=0x02008) // Bootloader
#org 0x0000, 0x1FFF { }

Después se declaran 3 variable auxiliares, sec y vel serán para cambiar la secuencia y otra
para incrementar la velocidad respectivamente, y s para ir desplegando los valores de los
vectores que se desplegarán en el módulo de leds que está conectado al puerto A.

int sec,vel;
int s=0;

Seguimos la la declaración de variables en este caso se declaran vectores de diferentes

tamaños que básicamente lo que hacen son guardar datos como una tabla para luego
desplegarse por posición por posición a través de la variable s que se declaró anteriormente.

const char sec1[7]={0x81,0xC3,0xE7,0xFF,0xE7,0xC3,0x81};

const char sec2[16]={0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,

0x40,0x20,0x10,0x08,0x04,0x02,0x01};
 const char sec3[21]={0x00,0x02,0x03,0x04,0x07,0x08,0x0F,0x10,
0X1F,0x20,0x2F,0x30,0x3F,0x40,0x4F,0x70,
0x7F,0x80,0x8F,0xF0,0xFF};

const char sec4[32]={0x00,0x01,0x03,0x07,0x0F,0x1F,0x3F,0x7F,0xFF,

0xFE,0xFC,0xF8,0xF0,0xE0,0xC0,0x80,0x00,0x80,
0xC0,0xE0,0xF0,0xF8,0xFC,0xFE,0xFF,0x7F,0x3F,
0x1F,0x0F,0x07,0x03,0x01};

const char sec5[8]={0X18,0x2C,0x7E,0xFF,0x7E,0x2C,0x18,0x00};

dentro de la función principal main, en estas líneas de código se habilitan las interrupciones
que se usaran, en este caso INT0 y INT1y a su vez si se activaran con flanco de posición
positivo o negativos.

enable_interrupts(GLOBAL);
enable_interrupts(INT_EXT1);
enable_interrupts(INT_EXT);
ext_int_edge(1,L_TO_H);
ext_int_edge(0,L_TO_H);

tomando de ejemplo la INT con la primera línea de código se activa la interrupción, con la
segunda línea se da de alta la interrupción y finalmente con la tercera línea de código se
estable si se activara con un flanco de posición negativo o positivo en este caso se declaró de
L_TO_H que quiere decir de LOW_TO_HIGH que es de bajo a alto.

enable_interrupts(GLOBAL);
enable_interrupts(INT_EXT);
ext_int_edge(0,L_TO_H);
Después dentro de la función principal main, y a su vez dentro de un for infinito se pregunta
primeramente usando switch case se pregunta por el estado de la variable sec para desplegar
la secuencia en el módulo de leds conectados al puerto A.

switch(sec)
{
case 1: if(s== 7)
{
s=0;
}
output_A(sec1[s]);
s++;break;
case 2: if(s==16)
{
s=0;
}
output_A(sec2[s]);
s++;break;
case 3: if(s==21)
{
s=0;
}
output_A(sec3[s]);
s++;break;
case 4: if(s==32)
{
s=0;
}
output_A(sec4[s]);
s++;break;
case 5: if(s==8)
 {
s=0;
}
output_A(sec5[s]);
s++;break;
}

Tomado por el ejemplo para cuando sec = 1, entra al caso 1, sec 1 es la secuencia 1 que es
un vector de 7 posiciones, se pregunta si s es igual al número de posiciones del vector se
iguala 0 para que se vuelva a ejecutar la secuencia, por el contrario se manda el dato de la
posición del vector del valor que tenga s en ese momento y se incrementa, de igual forma se
hace lo mismo con los demás casos.

case 1: if(s== 7)
{
s=0;
}
output_A(sec1[s]);
s++;break;
de igual forma con switch case se hacen diferentes casos para el cambio de la velocidad,
dependiendo del valor que tenga la variable vel se ejecutara la secuencia a la velocidad del
caso.

switch(vel){

case 1:delay_ms(1000);break;
case 2:delay_ms(500);break;
case 3:delay_ms(250);break;
case 4:delay_ms(100);break;
case 5:delay_ms(80);break;

}
En la interrupción 0 primero se estable fuera de la función principal main con #int_ext, se le
pone un nombre cualquiera y dentro de ella se pregunta por el estado de la variable vel que
recordando este programa solo tiene 6 diferentes velocidades si es igual a 6 se reinicia a 1 de
lo contario se incrementa se espera 2 ms por el rebote del botón y finalmente regresa a la
función principal.

#int_ext
void Velocidad__()
{

if(vel == 6)
vel = 1;
else
vel++;

delay_ms(2);
}

En la interrupción 1 primero se estable fuera de la función principal main con #int_ext1, se

le pone un nombre cualquiera y dentro de ella se pregunta por el estado de la variable sec que
recordando este programa solo tiene 6 diferentes secuencias si es igual a 6 se reinicia a 1 de
lo contario se incrementa se espera 2 ms por el rebote del botón y finalmente regresa a la
función principal.

#int_ext1
void secuencia__()
{
if(sec == 6)
sec = 1;
else
sec++;

delay_ms(2);
}
Código del programa

#include "18f45k50.h"
#use delay(internal=48MHz)
#build(reset=0x02000,interrupt=0x02008)
#org 0x0000, 0x1FFF { }

// zona para declarar variables

int sec,vel;
int s=0;

const char sec1[7]={0x81,0xC3,0xE7,0xFF,0xE7,0xC3,0x81};

const char sec2[16]={0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,

0x40,0x20,0x10,0x08,0x04,0x02,0x01};

const char sec3[21]={0x00,0x02,0x03,0x04,0x07,0x08,0x0F,0x10,

0X1F,0x20,0x2F,0x30,0x3F,0x40,0x4F,0x70,
0x7F,0x80,0x8F,0xF0,0xFF};

const char sec4[32]={0x00,0x01,0x03,0x07,0x0F,0x1F,0x3F,0x7F,0xFF,

0xFE,0xFC,0xF8,0xF0,0xE0,0xC0,0x80,0x00,0x80,
0xC0,0xE0,0xF0,0xF8,0xFC,0xFE,0xFF,0x7F,0x3F,
0x1F,0x0F,0x07,0x03,0x01};

const char sec5[8]={0X18,0x2C,0x7E,0xFF,0x7E,0x2C,0x18,0x00};

void main(void){

//Set_tris_a(0xff);
//output_a(0xff);

enable_interrupts(GLOBAL);
enable_interrupts(INT_EXT1);
enable_interrupts(INT_EXT);
ext_int_edge(1,L_TO_H);
ext_int_edge(0,L_TO_H);

for (;;)
{

switch(sec)
{
case 1: if(s== 7)
{
s=0;
}
output_A(sec1[s]);
s++;break;
case 2: if(s==16)
{
s=0;
}
output_A(sec2[s]);
s++;break;
case 3: if(s==21)
{
s=0;
}
output_A(sec3[s]);
s++;break;
 case 4: if(s==32)
{
s=0;
}
output_A(sec4[s]);
s++;break;
case 5: if(s==8)
{
s=0;
}
output_A(sec5[s]);
s++;break;
}

switch(vel){

case 1:delay_ms(1000);break;
case 2:delay_ms(500);break;
case 3:delay_ms(250);break;
case 4:delay_ms(100);break;
case 5:delay_ms(80);break;

}
#int_ext
void Velocidad__()
{

if(vel == 6)
vel = 1;
else
vel++;

delay_ms(2);
}

#int_ext1
void secuencia__()
{

if(sec == 6)
sec = 1;
else
sec++;

delay_ms(2);
}}
Fotos de la practica en físico
CONCLUSION

Con esto último se concluye esta práctica de la secuencia de luces con velocidad variable por
interrupciones externas.

Este pequeño proyecto en MPLAB IDE, aunque puede muy insignificante las secuencias de
luces están por todas partes en los vehículos hogareños, vehículos grandes, camiones de
cargar, en el entrenamiento, como indicaciones las secuencias de luces nos indican cierta
instrucción, o ya sea que se utilice como una forma de entrenamiento como en los juegos de
ferias en los, en los vehículos de transporte de material peligroso y agregando un extra de
que si puede variar la velocidad de estas se puede tener una alta área de aplicación.