Universidad Iberoamericana León

Microprocesadores y Prácticas

Práctica No. 5. Interrupciones.

Juan Felipe Caicedo Hernández

Daniel Godinez Rico

Myriam Cristina Jiménez Mares

Marzo 27 de 2020
 I. Objetivo
Realizar programas utilizando
interrupciones del microcontrolador.
II. Introducción
En el microcontrolador MSP430G2553
existe la posibilidad de utilizar todas las
entradas digitales como interrupciones
externas, lo cual nos ayuda a realizar
diversas aplicaciones, especialmente
aquellas que involucran control.
III. Marco teórico
Una interrupción es una instrucción que
suspende la ejecución de un programa,
para que este ejecute un proceso
prioritario. Las interrupciones son
sincronizaciones entre la ejecución del
programa y acontecimientos externos.
Las interrupciones son señales recibidas
por el procesador de un ordenador, lo que
indica la suspensión del curso actual y
ejecutar un código especifico. Las
interrupciones están administradas en un
espacio de memoria, llamado memoria
baja.
Existen 3 tipos de interrupciones
principales:
• Interrupciones internas de
hardware:
Son generadas por ciertos eventos que
surgen a raíz de la ejecución de un
programa. Son manejadas en su totalidad
por el hardware y no se pueden modificar.
• Interrupciones externas de
hardware:
En los periféricos hay dispositivos que
generan la interrupción. No es posible
desactivarlas y estás señales son manejas
por el circuito integrado.
• Interrupciones de software:
Pueden ser activada directamente
invocando el número de interrupción
deseada con la instrucción INT. Hay dos
categorías de este tipo de interrupciones:
DOS y BIOS. La diferencia entre ambas es
la interrupción del sistema operativo, son
más fáciles, pero también lentas (DOS)
para lograr el cometido en cambio las
interrupciones BIOS son más rápidas, pero
tienen la desventaja de ser parte del
hardware muy especificas y pueden varias
según el fabricante.
IV. Procedimiento
Al grupo de ingenieros en formación se les
solicita la realización de diferentes
programas que le dieran solución a una
problemática en particular, entre los
cuales:
Punto 1: Utilice 8 leds para mostrar 4
animaciones diferentes tipo “KITT el auto
increíble”, altérnelas con una interrupción.
Más de 10 animaciones diferentes se
pueden apreciar en el siguiente video:
https://youtu.be/t6FeyJoIXpU
En el siguiente código se realizar la
inicialización para los puertos, en donde se
indica todo el puerto 1 y será de uso digital,
por otra parte, el puerto 2 será usado
entrada y dentro de este también se digita
que en el P2.0 habrá una interrupción
externa, posteriormente se habilitan las
interrupciones globales y que se usará
como flanco de bajada. Además, se mueve
un #001h a un registro para poderle hacer Interrup inc R4
call #Retardo
las configuraciones solicitadas.
bic.b #001h, &P2IFG
mov.b #0FFh, &P1DIR reti
mov.b #000h, &P1SEL
mov.b #000h, &P2DIR El programa inicia con un #001h en R4,
mov.b #000h, &P2SEL por lo que por default salta a la etiqueta de
mov.b #001h, &P1OUT uno. En esta etiqueta se observa un
bis.b #001h, &P2IE
movimiento de los Leds ubicados en el
bic.b #001h, &P2IES
bic.b #000h, &P2IFG exterior, en ellos se indica un rla, que
bis.w #GIE, SR consiste en un desplazamiento del bit
Setup mov.b #001h, R4 inicial hacía la izquierda, seguido de una
comparación usada para indicar que llegó
En la etiqueta de Loop realizamos unas al último led y requiere saltar a la siguiente
comparaciones, por lo que, al ser igual en etiqueta. En la tercera etiqueta de esta
alguna de estas, saltará a una etiqueta sección del programa se indica la
correspondiente al proceso que deben de presencia de un rra, que consiste en el
ser mostrados en los Leds. Se realizan desplazamiento hacía la derecha del bit
cinco comparaciones en total, siendo la usado, éste cuenta con su contador que al
última la que nos permite reiniciar el igualarse con el número con el que se
programa y volver a empezar de cero, compara salta al Loop a ver en que parte
mientras se realiza nuevamente una debe de continuar.
interrupción.
Uno mov.w #008FFh, R15
Loop cmp #001h, R4 mov.b #000h, R6
jeq Uno proce rla &P1OUT
cmp #002h, R4 call #Retardito
jeq Dos inc R6
cmp #003h, R4 cmp #008h, R6
jeq Tres jne proce
cmp #004h, R4 mov.w #008FFh, R15
jeq Cuatro Proce rra &P1OUT
cmp #005h, R4 call #Retardito
jeq Setup dec R6
jmp Loop cmp #000h, R6
jne Proce
La interrupción del circuito va mediada jmp Loop
por un botón externo, que al ser presionado Si se realiza una interrupción, el registro
incrementa el registro R4, el cuál es
R4 tendrá #002h, y por lo tanto saltaría del
comparado y mandan el resultado por el
Loop a la etiqueta Dos, la cual ilustra una
puerto 1 de salida. Luego del incremento
anterior se llama a un retardo que se utiliza animación seccionada, por lo que se
como anti-rebote y se limpia la bandera de cargan 2 registros R7 y R8 en los cuales se
interrupción, lo que permite volver a les realiza un rra y un rla respectivamente,
interrumpir el programa e incrementar en con el fin de mostrar una secuencia de 4
otro momento. leds iguales, ambos empezando en el bit
más significativo y terminando en el
menos significativo. Realizando el mismo mov.w #0FFFFh, R15
Proce3 rrc R7
movimiento de forma contraria.
mov.b R7, &P1OUT
Dos mov.w #008FFh, R15 call #Retardito
mov.b #000h, R6 dec R6
mov.b #0F0h, R7 cmp #000h, R6
mov.b #00Fh, R8 jne Proce3
proce2 rra R7 jmp Loop
mov.b R7, &P1OUT
rla R8 Para finalizar, en este fragmento se
mov.b R8, &P1OUT encuentra la etiqueta Cuatro
call #Retardito correspondiente a la última animación,
inc R6
cmp #004h, R6
junto con los Retardos del programa,
jne proce2 siendo el primero un retardo variable y el
mov.w #008FFH, R15 último un retardo fijo de anti-rebote de la
Proce2 rla R7 interrupción. El programa encenderá 4 led
mov.b R7, &P1OUT
rra R8 y los apagará a una velocidad aproximada
mov.b R8, &P1OUT de 250 ms, por lo que se permitirá alternar
call #Retardito el encendido y apagado de los leds.
dec R6
cmp #000h, R6 Cuatro mov.w #0FFFFh, R15
jne Proce2 xor #00Fh, &P1OUT
jmp Loop call #Retardito
mov.w #0FFFFh, R15
En este fragmento de código se observa el xor #0F0h, &P1OUT
3er incremento proporcionado por ella call #Retardito
jmp Loop
interrupción. El retardo es diferente en
todos lo procesos y es por lo que cargamos Retardito dec R15
como #0FFFFh en R15, además de cmp #00000h, R15
inicializar el contador y R7 que será jne Retardito
ret
mostrado en las salidas del puerto 1. Para
comenzar, le hacemos rlc a R7 y al llegar Retardo mov.w #00FFFh, R15
al último led, se regresa mediante un rrc, Restar dec R15
cmp #00000h, R15
este proceso es mediado mediante
jne Restar
comparaciones que determinen el fin de ret
los leds lo que marca el inicio del siguiente
proceso. A continuación, el punto 2: - Realice un
dado electrónico del 0 al 9 (muestre su
Tres mov.w #0FFFFh, R15
resultado en un display de 7 segmentos).
mov.b #000h, R6
mov.b #001h, R7 -Comience con los leds apagados
proce3 rlc R7
mov.b R7, &P1OUT -Cuando oprima el botón1 (que funciona
call #Retardito
inc R6 como interrupción) muestre el número al
cmp #00Fh, R6 azar en los leds Un segundo botón “limpia
jne proce3 los leds” (no es interrupción).
Reporte diagrama de flujo.
Inicio mov.b #000h, R9
Inicialmente se define el puerto 1 como mov.b #000h, R5
salida, en este puerto estará ubicado el mov.w #Arreglo, R4
Arre bit.b #002h, &P2IN
display que recibirá las señales y las jnz Limpiar
ilustrará en el display. Se inicializa mov.b @R4+, R7
apagado y el puerto 2 se inicia como inc.b R5
cmp #00Ah, R5
digital y entrada. jne Arre
mov.b #0FFh, &P1DIR jmp Inicio
mov.b #000h, &P1OUT
Limpiar mov.b #000h, &P1OUT
mov.b #000h, &P1SEL
call #Retardo
mov.b #000h, &P2DIR
jmp Inicio
mov.b #000h, &P2SEL
En arreglo, lo único que contiene son los
Posteriormente indicamos que el vector de
valores que se mostraran mediante el
interrupción se encontrará en el puerto 2.0,
display de 7 segmentos.
se definirá como flanco de bajada y se
limpia la bandera, se realiza el uso de Arreglo .byte 03Fh, 006h, 05Bh,
interrupciones general mediante el #GIE, 04Fh, 066h, 06Dh, 07Dh, 047h, 07Fh,
SR. 067h

bis.b #001h, &P2IE La interrupción se ubica debajo de los

bic.b #001h, &P2IES Interrupt Vectors, mediante comando .sect
bic.b #001h, &P2IFG “.int03” indicado que la interrupción se
bis.w #GIE, SR
mov.b #000h, R7 ubica en el puerto 2 y el .short es el nombre
de la etiqueta a la que saltará una vez sea
En el main Loop, ingresamos una etiqueta usada la interrupción.
denominada Inicio, en donde declaramos
R9 y R5 como #000h, se declara un arreglo ; Interrupt Vectors
.sect ".reset"
y se mueve a R4. A continuación, se ; MSP430 RESET Vector
declaran bit test en el botón .short RESET
correspondiente con el fin de limpiar todo .sect ".int03"
el resultado, si no es presionado, R4 se .short Juanito
autoincrementa y lo pasará a R7, se
incrementa el contador de R5 y lo La interrupción permite mostrar por el
comparas con #00Ah, al llegar al mismo puerto 1 el valor que contenga en ese
valor de la etiqueta el programa se regresa momento R7, llamar a un retardo para el
a la etiqueta de inicio y empieza desde 0. anti revote y limpia la bandera en #001h y
Al presionar el botón del pin 2.1 saltará a finalizamos con un reti para que regrese a
la etiqueta Limpiar, en donde pondrá hacer el programa original.
#000h en la salida, y lo enviará a la
Juanito mov.b R7, &P1OUT
etiqueta de inicio, entonces el arreglo
call #Retardo
empezará desde 0 y permitirá nuevamente bic.b #001h, &P2IFG
el inicio de la elección aleatoria. reti
A continuación, el punto 3: Realice un
programa que:
Comienza con un display de 7 segmentos
completamente apagado y:
- Muestra en el display los números del 1h
al 9h si presiona el botón1.
- Muestra en el display las letras de la Ah
a la Fh si presiona el botón2.
- Cuando termina la animación actual,
regresa al programa principal (display
apagado).
- Pause la animación actual si presiona un
botón3 y salga de la pausa si presiona
nuevamente el mismo botón3. La pausa
debe funcionar tanto para los números
como para las letras.
Para comenzar, se describen los puertos
según el uso que estos tendrán dentro del
programa y es por esta razón que se
describe el puerto 1 estará habilitado como
salida y de complemento digital, de la
misma forma definimos el puerto 2, sin
embargo, este será únicamente usado
como entrada del sistema. Se carga
Arreglo y Arreglo2 en los registros R4 y
R5 respectivamente, posterior a esto,
definimos el P2.0 como entrada de la
interrupción y que responderá a los flancos
de bajada, se le realiza la limpieza a la
bandera de interrupción y se activan las
interrupciones globales.
mov.b #0FFh, &P1DIR
mov.b #000h, &P1SEL
mov.b #000h, &P2DIR
mov.b #000h, &P2SEL
mov.w #Arreglo, R4
mov.w #Arreglo2, R5
bis.b #001h, &P2IE
bic.b #001h, &P2IES
bic.b #001h, &P2IFG
bis.w #GIE, SR
mov.b #001h, R9
En este fragmento del programa se
describe el Loop, el cual comienza con las
cargas de los arreglos a sus registros
correspondientes, además de que se indica
que el display comienza apagado. Por otra
parte, se realizan unos movimientos a los
registros R& y R7, con el fin de ser usado
como contadores de los arreglos
posteriores, se le realiza un bit test en los
puertos donde se encuentran ubicados los
botones y en caso de ser diferentes de 0
saltarán a su etiqueta seleccionada.
Loop mov.w #Arreglo, R4
mov.w #Arreglo2, R5
mov.b #000h, &P1OUT
mov.b #009h, R6
mov.b #006h, R7
bit.b #002h, &P2IN
jnz num
bit.b #004h, &P2IN
jnz let
jmp Loop
En este caso se describe el proceso al que
salta al ser presionado el botón del P2.1, en
este se mostrarán los números del 1 al 9 en
el display. Para esto se hace uso de un
triple retardo, con el fin de apreciar de
manera correcta todos los números y al
regresar de esa subrutina se
autoincrementa el arreglo y envía el valor
actual al display, se compara R9 (dato
proporcionado por la interrupción) con
#001h y en caso de ser iguales, es porqué
la interrupción fue usada; continúa con el
proceso del decremento del contador de
los datos y hasta no ser igual seguirá
repitiendo este proceso, una vez el
contador sea igual regresará el Loop.
La interrupción realiza un XOR en R9 que
parte en #000h y al ser usada envía un
#001h n R9, lo que permite entrar en la
etiqueta Pausa1 y espera a que sea
presionada nuevamente la interrupción
para volver con el programa.
num mov.b #003h, R14
mov.b @R4+, &P1OUT Por último, se describe el vector de
call #Retardo2
cmp #001h, R9
interrupciones, en el cual se encuentra un
jeq Pausa1 XOR a R9 y se llama a la subrutina Retin,
Regreso1 dec.b R6 se procede a limpiar la bandera de
cmp #000h, R6 interrupción para poder volver a ser
jne num interrumpido el programa.
jmp Loop
Interrup xor.b #001h,R9
Arreglo .byte 006h, 05Bh, 04Fh,
call #Retin
066h, 06Dh, 07Dh, 047h, 07Fh, 067h
bic.b #001h, &P2IFG
reti
Pausa1 cmp #000h, R9 Retin mov.w #0FFFFh, R10
jeq Regreso1 Rst dec.w R10
jmp Pausa1 cmp #00000h, R10
jne Rst
En caso de ser presionado el botón ubicado ret
en el P2.3 saltará a la etiqueta let, en donde
se mostrarán las letras de la A a la F Punto 4: Realice un juego donde el
correspondientes aal 10 y 15 en decimal, objetivo es “atinarle al led central”.
es por esto que se autoincrementa el El jugador debe presionar un botón cuando
registro en donde se encuentra cargado el se ilumine el led de la posición central del
Arreglo2 y se compara #001h con R9, en arreglo, si se presiona en cualquier otro
caso de ser iguales, saltará a la etiqueta de momento significa que el jugador ha
Pausa2 dando por entendido de que fue perdido y se debe mostrar una secuencia
presionada la interrupción y una vez diferente que indique fin del juego.
vuelva a ser activada ésta misma, retornará Note que el tiempo de delay debe
y seguirá con el orden del programa, en modificarse para dificultar el nivel del
donde continuará con el autoincremento de juego.
R5 y enviándolo al display, una vez Si el jugador no presiona el botón la
terminado todo este proceso retornará al animación debe continuar con la misma
Loop a la espera de una nueva instrucción. velocidad (es decir, permanecer en el
mismo “nivel” de juego).
let mov.w #003h, R14 La animación se puede encontrar en el
mov.b @R5+, &P1OUT siguiente link:
call #Retardo2 https://www.youtube.com/watch?v=mg_
cmp #001h, R9
jeq Pausa2 De62Gf4U
Regreso2 dec.b R7
cmp #000h, R7 En este fragmento de código cuenta con la
jne let inicialización del programa solicitado, se
jmp Loop harán uso de 7 leds únicamente y por esta
Arreglo2 .byte 077h, 07Ch, 039h,
razón usamos #07Fh como función del
05Eh, 079h, 071h
Pausa2 cmp #000h, R9 puerto 1, así dejará el p1.7 habilitado para
jeq Regreso2 que en el se encuentre la interrupción,
jmp Pausa2 además, se indica que funcionará con
flancos de bajada. Se hacen cargas en R15, Cont mov.b #007h, R12
R13, R5 y R14 que funcionarán como Der rra R7
mov.b R7, &P1OUT
contador y variables para los retardos. call #Retardo
dec R12
mov.b #07Fh, &P1DIR cmp #000h, R12
mov.b #000h, &P1SEL jeq Loop
mov.b #000h, &P1OUT jmp Der
bis.b #080h, &P1IE
bis.b #080h, &P1IES
Esta parte del código ocurre posterior a la
bic.b #080h, &P1IFG
bis.w #GIE, SR
interrupción, la cual funciona atinándole al led
mov.b #007h, R14 del medio (el ubicado en la posición #008h),
mov.b #001h, R5 en caso de atinarle a ese led saltará a la etiqueta
mov.b #000h, R13 Lvl, en donde se incrementa la velocidad del
mov.w #00000h, R15 juego siendo un poco más complicado a
medida que se acierte y en caso de no atinar
En este fragmento se encuentra el Loop, se saltará a la etiqueta LoserxD descrita junto con
declaran variables en R6 y R7, siendo el el siguiente fragmento de código.
primero un contador de la cantidad de leds que
deben encender y el segundo el valor que Play call #Retardo2
pasará de led a led mediante un rla, es por eso mov.b #002h, R13
cmp #008h, R7
que R7 es enviado a la salida y un decremento
jeq Lvl
de R6 para seguir el conteo de los leds, si no jmp LoserxD
es igual el contador regresará a movin1, si
llegan a ser iguales saltará a la siguiente parte Lvl cmp #001h, R14
del código gracias al secuencialidad del jeq Ganadoorr
mismo. rra R14
jmp Int
Loop mov.b #007h, R6
mov.b #001h, R7 En caso de perder se mostrarán los leds
movin1 mov.b R7, &P1OUT apagados por un instante de tiempo, se mueve
call #Retardo #006h a R11 con la función de ser un contador
dec R6
y posterior a esto se declara un XOR con 07Fh
cmp #000h, R6
para que los leds se alternen entre encendido y
jeq Cont
rla R7 apagado y se modifica el retardo mediante
jmp movin1 R13. Al igualar el contador con el registro
volverá a tener #007h en R14 para igualar las
Siendo esta parte la animación contraria a la condiciones iniciales del juego, luego saltará a
anterior, se realiza un desplazamiento con rra la interrupción para volver al punto en donde
y el R7 es enviado a la salida con el fin de se había pausado inicialmente.
observar la animación correspondiente,
posteriormente se realiza un decremento a R12
y al llegar a #000h saltará al Loop para
reiniciar el movimiento y los valores de las
variables que habían sido modificadas con los
procesos previos.
 Retardo mov.b R14, R13
LoserxD mov.b #000h, &P1OUT Resta mov.w #0B000h, R11
mov.b #006h, R11 Res dec R11
Parpadea xor #07Fh, &P1OUT cmp #00000h, R11
mov.b #007h, R13 jne Res
call #Retardo2 dec R13
dec R11 cmp #000h, R13
cmp #000h, R11 jne Resta
jne Parpadea ret
mov.b #007h, R14
jmp Int Int bic.b #080h, &P1IFG
reti
En caso de finalizar el contador R14 que varia
la velocidad del retardo, saltará a la etiqueta Retardo2 mov.w #0B000h, R15
Ganadoorr para mostrar una animación similar quieromimir dec.w R15
jnz quieromimir
a la de perdedor mediante un XOR y un retardo
dec R13
muy corto y restaura el valor inicial de R14, jnz Retardo2
luego salta a la interrupción y retorna al punto ret
en donde fue interrumpido.
Pnnto 5: Realice un programa que
Ganadoorr mov.b #000h, &P1OUT
mov.b #00Fh, R11 muestre continuamente el código Gray en
Par xor.b #07Fh, &P1OUT 4 leds con un retardo de un delay entre
mov.b #001h, R13 cada número. El código tiene la
call #Retardo2 particularidad de cambiar solamente un bit
dec R11 entre cada número sucesivo.
cmp #000h, R11
jne Par
mov.b #007h, R14
jmp Int

En este último fragmento se describen los

retardos y la interrupción. En el Retardo inicial
R14 mueve el valor a R13 para que este no se
vea alterado y realiza el decremento del
retardo y luego de R13, para que al finalizar
este retardo retorne a la función siguiente de
donde fue llamado, dándole fin a la sub-rutina
número 1. A continuación se hace la
interrupción, en donde se realizar la limpieza
de la bandera para poder seguir siendo
interrumpida y saltará a las etiquetas anteriores
en donde incrementa la dificultad del juego o
se pierde la partida y requiere de reiniciar la
partida. Para finalizar, el Retardo2 que es
usado en las etiquetas de ganador y perdedor,
cuenta con la variación de R13 para aumentar
o disminuir el tiempo en que actúa el retardo.
Al presionar el switch correspondiente a la Loop mov.w #Arreglo, R4
interrupción 1, los leds deberán mostrar el mov.b #010h, R5
Inicio mov.b @R4+, R7
valor en binario del número actual de la mov.b R7, &P1OUT
secuencia durante un tiempo de 5 retardos call #Retardo
(sin parpadear, sólo mostrar el valor). dec R5
cmp #000h, R5
Al momento de presionar el switch jne Inicio
correspondiente a la interrupción 2, todos jmp Loop
los leds deberán parpadear el número de
Se va a tener 2 retardos diferentes, el
veces que corresponda al valor decimal del
primero es el retardo que usamos
número actual de la secuencia del código
generalmente pero el segundo retardo lo
Gray, con una duración de 3 retardos.
que hace es hacer nuestro primer retardo,
pero 3 veces, se agregan los valores que
En este proceso se usan 4 leds, así que se tomara nuestro arreglo.
declara el puerto 1 desde el pin 1.0 hasta el
Retardo mov.w #0FFFFh, R15
1.3 como salidas y los demás pines se Rst dec R15
quedan como entradas. Se habilitan las cmp #00000h, R15
interrupciones y se indica que lo jne Rst
ret
tendremos en el puerto 2 en los pines 2.0 y
2.1, muy importante limpiar la bandera. Retin mov.b #003h, R14
Rst2 call #Retardo
mov.w #Arreglo, R4 dec R14
mov.b #00Fh, &P1DIR cmp #000h, R14
mov.b #000h, &P1SEL jne Rst2
mov.b #000h, &P2DIR ret
mov.b #000h, &P2SEL Arreglo .byte 000h, 001h,
bis.b #003h, &P2IE 003h, 002h, 006h, 007h, 005h, 004h,
bic.b #003h, &P2IES 00Ch, 00Dh, 00Fh, 00Eh, 00Ah, 00Bh,
bic.b #003h, &P2IFG 009h, 008h
bis.b #GIE, SR
Declaramos que la interrupción esta en el
En el main loop movemos un #010h (16d) puerto 2 y se llamara interrupcion
.sect ".int03"
a R5, autoincrementas l arreglo y se mueve
.short Interrupcion
a R7 y así mismo se muestra por el
puerto1, se llama al retardo para notar el Cuando se activa la interrupción hacemos
cambio, se decrementa R5 y se compara dos preguntas, la primera es para sabr si
con 0, si no es igual vuelve a presiono el botón que esta en el pin 2.0, si
autoincrementar y repetir el proceso hasta lo presiono, se va a Bin, si no lo presiono,
que sea 0, una vez que sea 0, se reinicia el pregunta si presiono el botón que se
programa para que el arreglo vuelva a encuentra en el pin 2.1, si lo presiono. Se
tener sus valores desde el principio. va a Gray.
Interrupcion bit.b #001h, &P2IN Gray mov.b #000h, &P1OUT
jnz Bin mov.b R5, R6
bit.b #002h, &P2IN Cambio xor.b #00Fh, &P1OUT
jnz Gray call #Retin
xor.b #00Fh, &P1OUT
En la etiqueta Bandera, es a donde nos call #Retin
llevara despues de haber realizado lo dec R6
cmp #000h, R6
correspondiente de cada botón y lo único jne Cambio
que hará es que limpiara las banderas y jmp Bandera
regresara al programa original.
V. Cuestionario
Bandera call #Retardo
1. ¿Qué es el estado de latencia que
bic.b #003h, &P2IFG
reti experimenta el microcontrolador cuando
llega una interrupción? ¿Qué hace el micro
en este tiempo?
En bin mostramos por el puerto 1 la
Lo que ocurre es que el programa principal
variable R5 que es el que contiene
guardado nuestro valor en binario, hace una “pausa” termina la última
movemos un 5 a R6, se llama a un retardo instrucción que estaba ejecutando, cuando
para el anti revote, se decrementa R6 y se lo acabe de ejecutar, el micro realizara las
compara con 0, si aun no es 0 vuelve a instrucciones que estén dentro de las
decrementarse hasta ser 0, cuando sea 0 se interrupciones hasta que encuentre la
ira a la etiqueta bandera. instrucción “reti” para que regrese a la
línea de código siguiente donde se quedó
antes de que llegara la interrupción
Bin mov.b R5, &P1OUT
mov.b #005h, R6
Retardo2 call #Retardo
dec R6 2. Explique con sus propias palabras cuál
cmp #000h, R6
jne Retardo2 es la diferencia entre las interrupciones y
jmp Bandera las subrutinas.

En Gary apagamos los leds, R5 lo La diferencia es que una subrutina tienes

movemos a R6 y hacemos XOR (cambia a
0 los que están en 1 y viceversa) al puerto
1 e los pines 1.0 al 1.3, llamamos a nuetsro
segundo retardo para que haga un retardo
triple, volvemos hacer XOR a los mismos
leds, nuevamente llamamos al retardo
triple, decrementas R6 hasta y se compara
con 0, si aun no es cero, vuelves a hacer
ambos XOR, una vez que llega a 0, se va a
la etiqueta Bandera.
que mandar llamarla para que ejecute la
subrutina y sale de ella hasta que llegue a
“ret”, mientras que en la interrupción, el
programa se ejecuta de manera normal
pero aquí no se hace ningún tipo de
pregunta o llamado, simplemente que
cuando se presiona el botón, deja de hacer
el programa, ejecuta lo que contenga la
interrupción y regresa a donde se quedó en
el programa original.
3. Explique con sus propias palabras en
qué cambia su lógica de programación y
algoritmo al realizar el ejercicio 1 con
interrupciones y sin ellas
Nos sirve más programar con
interrupciones ya que cuando no las
usamos, tenemos que adivinar cunado el
programa pase por ese punto para que
pueda funcionar y es muy probable que
puedan perderse datos, mientras que, con
interrupciones, se activa sin importar en
que pare del programa este y es menos
probable que pierdas valores.
4. - ¿Para qué sirve y dónde se usaba el
código Gray?
El código gray se utiliza para sistemas de
posición lineal o angular, principalmente
para la robótica para la información de
posición sobre un eje particular mediante
discos codificados. (Electrónica Unicrom,
s.f.)
5.- Después de ver el video “Why
programming is important” y “You should
learn to program” responda de forma
individual las siguientes preguntas: ¿ud.
cree que programar es una habilidad
necesaria o útil?, ¿por qué?
Juan: Yo pienso que este tipo de
conocimientos si son importantes de
aprender, hoy por hoy son solo los
especializados quienes tienen buen manejo
de este tipo de herramientas, pero no es de
sorprenderse que en un futuro se convierta
en una habilidad útil. En la época antigua,
el conocimiento de la lectura era de muy
pocos, con el paso del tiempo hemos visto
la necesidad de tener ese tipo de
habilidades. Es una habilidad útil, que
permitirá en un futuro tener mayor
variedad de los campos de acción.
Daniel: Creo que para mí como estudiante
de ingeniería Mecatrónica es fundamental
el aprender a programar ya que es la base
de mi carrera, pero para personas que no lo
estudia, siento que no es tan necesario
saberlo, ya que, aunque usas diariamente
artículos que son programados, son de
fácil uso y no es necesario saber programar
o saber su programación para usar dichos
artículos.
6.- ¿En qué consiste el proyecto “Precious
Plastic”?
Es un método de reciclado que se originó
en Holanda por Dave Hakkens, esto
consiste en fomentar que los residuos
plásticos que están en plazas, parques, ríos
etc. Sean procesados mediante un proceso
de maquina el cual ayudaría a limpiar el
medio ambiente, así como generar
empleos para la realización de estas
máquinas y la manipulación y generar
ingreso a las personas que lleve a vender
su plástico recolectado, el proceso por el
que pasaría este plástico son 4 máquinas:
Trituradora, extrusora, inyectora,
moldeadora. (Gregorio, s.f.)
7.- ¿Cuánto paga por cada clase de
Microprocesadores I y Prácticas?
Al ser una materia de 9 créditos, el
semestre cuesta $11,040.00 Pesos, por
Semana son $690.00 Pesos y por clase son
$230.00 Pesos.
VI. Conclusiones
Juan: Las interrupciones son procesos
sumamente importantes en programas de
alta complejidad y/o mediana
complejidad, pues este tipo de
herramientas permite dejar un proceso
principal corto y optimizado, y que al
momento de detectar una interrupción éste
priorice otra parte del programa que al
brindarle solución retornará al programa
principal. Es decir, se puede usar un
programa optimizado y solamente
interrumpirlo para cumplir otras funciones
complementarias. ¡MAGIC! jaja
Daniel: En esta práctica a pesar de que
aún hay dudas sobre cómo se utilizan las
interrupciones de forma adecuada, me
sirvió para saber en qué es lo que me está
fallando para poder reforzarlo con
práctica.
VII. Bibliografía
1. Bibing.us.es. (2020). [online].
Recuperado de:
http://bibing.us.es/proyectos/abrep
roy/11301/fichero/Memoria%252
FCap%C3%ADtulo+2.pdf+
[Accessed 14 Feb. 2020].
2. Vargas, L. (2011). 7. Puertos de
Entrada y Salida - Curso PIC
MikroBasic. [online]. Recuperado
de:
https://sites.google.com/site/curso
picmikrobasic/puertos-de-entrada-
y-salida [Accessed 14 Feb. 2020].
3. Enrique, C. (9 de mayo de
2017). Algorítmica y Programas.
Obtenido
de: https://sites.google.com/site/p
ortafoliocarlosmacallums/unidad-
i/lenguajeensamblador
4. Ramos, C. L. (29 de Enero de
2020). Computer Hoy. Obtenido
de https://computerhoy.com/notici
as/tecnologia/little-peanut-robot-
cuarentena-coronavirus-571173
5. Electrónica Unicrom. (s.f.).
Obtenido de Electrónica Unicrom:
https://unicrom.com/codigo-gray/
6. Gregorio. (s.f.). socialab. Obtenido
de socialab:
https://comunidad.socialab.com/c
hallenges/Comprometidos2016/id
ea/26335
7. Las instrucciones en
ensamblador,(2020). [online].
Recuperado de:
http://moisesrbb.tripod.com/unida
d5.htm.
 Anexos

Figrua . Diagrama de flujo de punto 5.