Departamento de Eléctrica y Electrónica

Microprocesadores y Microcontroladores

Práctica 2.3
Docente: Ing. Elember Guanoluiza

Estudiantes: Tomás Espinoza, Esteban Rivera

Nivel: Cuarto Semestre

NRC: 8523

Mayo 2020 - Septiembre 2020 Sangolquí

PRÁCTICA 2.4
PRÁCTICA DE APLICACIÓN
PRÁCTICA 2.4 Simular en emu8086 los siguientes ejercicios:
1. Ordenar dos números que se ingresan por teclado el mayor se imprima en el puerto de I/O del
display de 7 segmentos.
2. Que se prendan las luces amarillas de todos los semáforos, sistema ceda el paso para la
noche.
3. Juego de luces en el semáforo usando desplazamiento izq y der:
Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.
Prender un led de izq – der – izq, un solo led prendido a la vez.
4. Juego de luces en el semáforo usando tablas:
Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.
Prender un led de izq – der – izq, un solo led prendido a la vez.

EAMI:

Paso 1 - E (Entender el problema)

Identificación del Problema

1. Ordenar dos números que se ingresan por teclado el mayor se imprima en el puerto de I/O
del display de 7 segmentos.

Para este problema se ha solicitado comparar dos números con el fin de determinar el mayor,
dicho número será impreso en el puerto I/O (de entradas y salidas ), el método en el cual se
mostrará el resultado es con un display de 7 segmentos.

2. Que se prendan las luces amarillas de todos los semáforos, sistema ceda el paso para la
noche.

Se solicita encender una luz a un momento determinado del día , como es el caso de la noche
con el fin de que los vehículos puedan transitar con precaución. En esos momentos se
identifica la hora a la que comienza el proceso y se da la orden de encender las luces
amarillas tomando el tiempo.

3. Juego de luces en el semáforo usando desplazamiento izq y der:

Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.

En este programa se solicita encender luces una a la vez utilizando desplazamientos,

dependiendo del lado al que decidamos realizar dicho desplazamiento el programa ejecutará
una acción diferente teniendo así un código para prender de uno en uno de izquierda a
derecha y de uno en uno de derecha a izquierda
4. Juego de luces en el semáforo usando tablas:

Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.
Prender un led de izq – der – izq, un solo led prendido a la vez.

Similar a lo solicitado anteriormente en este problema debemos encender luces una a la vez
utilizando desplazamientos, dependiendo del lado al que decidamos realizar dicho
desplazamiento el programa ejecutará una acción diferente, en este caso existirán mas
combinaciones, teniendo así un código para prender de uno en uno de izquierda a derecha, de
uno en uno de derecha a izquierda y uno que va de izquierda a derecha y posteriormente a
izquierda

Paso 2 - A (Análisis matemático)

1. Ordenar dos números que se ingresan por teclado el mayor se imprima en el puerto de I/O
del display de 7 segmentos.

Se comparan dos números, y se almacena el mayor para luego mostrarlo en un display de 7

segmentos.

CMP A,B

2. Que se prendan las luces amarillas de todos los semáforos, sistema ceda el paso para la
noche.

Se almacena en binario la posición en la que están encendidas todas las luces amarillas y se
carga al virtual device trafic_lights.

3. Juego de luces en el semáforo usando desplazamiento izq y der:

Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.

En este programa se solicita encender luces una a la vez utilizando desplazamientos,

dependiendo del lado al que decidamos realizar dicho desplazamiento el programa ejecutará
una acción diferente teniendo así un código para prender de uno en uno de izquierda a
derecha y de uno en uno de derecha a izquierda

Para los desplazamientos, primero se declara el número, para este caso en binario, y a continuación
se utilizara el comando shl (desplazamiento a la izquierda) o shr (desplazamiento a la derecha), y
para el desplazamiento nos ayudaremos del registro CL en el cual almacenamos la cantidad de
puestos que queremos desplazar nuestro registro AL y luego lo mostramos en el display

4. Juego de luces en el semáforo usando tablas:

 Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.
Prender un led de izq – der – izq, un solo led prendido a la vez.

Se ingresan las tablas que contienen los valores de cada posición que va a tomar el virtual
device, y luego se le carga una a una cada fila, al terminar de cargar la última fila, para la
siguiente, se reinicia, y vuelve a ingresar desde la primera.

Paso 3 - M (Modelamiento)

1. Ordenar dos números que se ingresan por teclado el mayor se imprima en el puerto de I/O
del display de 7 segmentos.

2. Que se prendan las luces amarillas de todos los semáforos, sistema ceda el paso para la
noche.
3. Juego de luces en el semáforo usando desplazamiento izq y der:

Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.

4. Juego de luces en el semáforo usando tablas:

 Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.
Prender un led de izq – der – izq, un solo led prendido a la vez.

Paso 4 - I (Implementación)

1. Ordenar dos números que se ingresan por teclado el mayor se imprima en el puerto de I/O del
display de 7 segmentos.

INCLUDE 'emu8086.inc'

ORG 100h
.model small
.stack 100
.data ;se declaran las variables
num1 dw 0000h ;variable num1 inicializada en 0
num2 dw 0000h ;variable num1 inicializada en 0
aux1 dw 0000h ;variable aux1 inicializada en 0

;MENU para mostrar

menu1 DB 0Dh, 0Ah, 0Ah, "Comparacion de dos numeros - LED Display$",0Dh,0Ah
 operando1 DB 0Dh,0Ah,0Ah,"Escribe el primer numero: $", 0Dh,0Ah
operando2 DB 0Dh,0Ah,0Ah,"Escribe el segundo numero: $", 0Dh,0Ah
mensaje DB 0Dh,0Ah,0Ah,"El numero mayor entre ambos aparece en el LED Display: $"
pregunta DB 0Dh,0Ah,0Ah,"Desea salir?(1:SI - 0:NO): $"

.code
imprimir macro string ;se imprime el macro
mov dx, offset string
mov ah, 9 ;muevo 9 a AH
int 21h
endm

escribir macro ;escribo en macro

MOV AH 1 ;muevo 2 a AH
INT 21H
endm
;CODIGO
MOV AX, @data ;muevo la data a AX
MOV DS, AX ;muevo AX a DS

decProc proc near

CALL CLEAR_SCREEN ;llamo a clear_Screen para limpiar la pantalla
imprimir menu1 ;imprimo el menu 1
imprimir operando1 ;imrprimo el operando 1

CALL scan_num ;llamo a scam_num para obtener el valor del numero

MOV num1,CX ;muevo CX a num1
MOV AX, 0000h ;muevo 0000h a AX
MOV AX, num1 ;muevo num1 a AX

imprimir operando2 ;imprimo operando2

CALL scan_num ;llamo a scam_num para obtener el valor del numero

MOV num2, CX ;muevo CX a num2
MOV BX, 0000h ;muevo 0000h a BX
MOV BX, num2 ;muevo num2 a BX
MOV AX, num1 ;muevo num1 a AX
CALL comparacion ;llamo a comparacion
out 199, AX ;muestro el valor de AX en el LED Display
imprimir mensaje ;muestro un mensaje

imprimir pregunta
CALL scan_num ;llamo a scam_num para obtener el valor del numero
MOV num1,CX ;muevo CX a num1
 CALL preg ;llamo a preg
CALL decProc ;llamo a decProc
decProc endp ;termino decProc

preg: ;defino preg

CMP num1, 0001h ;comparo 0001h con num1
JE out ;Se interrumpe y salta a out
RET ;Retorno

comparacion proc near

MOV AX, num1 ;muevo num1 a AX
MOV BX, num2 ;muevo num2 a BX
CMP AX, BX ;comparo el valor de BX con el de AX
JC intercambio ;salto a intercambio
RET ;Retorno

intercambio proc near

MOV CX, AX
MOV AX, BX
MOV BX, CX
RET

out:

;defino las llamadas del micro

DEFINE_SCAN_NUM
DEFINE_PRINT_STRING
DEFINE_PRINT_NUM
DEFINE_PRINT_NUM_UNS
DEFINE_PTHIS
DEFINE_CLEAR_SCREEN

; FIN del programa

hlt
2. Que se prendan las luces amarillas de todos los semáforos, sistema ceda el paso para la
noche.

#start=Traffic_Lights.exe#

name "traffic"

mov ax, todo_apagado ;Ax toma el valor del vector todo_apagado

out 4, ax ;Llamo al virtual device, traffic lights

mov si, offset situation ;Comienzo traslando el vector situacion al vector si

next:
mov ax, [si] ;AX toma el valor del vector si
out 4, ax ;Llamo a traffic lights y toma el valor del registro A

; Retardo de 5 segundos
mov cx, 4Ch
mov dx, 4B40h
mov ah, 86h
int 15h

add si, 2 ;conteo para las diferentes situaciones

cmp si, sit_end ;comparo si con sit_end
jb next ;salto a next
mov si, offset situation ;Si termina vuelve a comenzar
jmp next

; FEDC_BA98_7654_3210
situation dw 0000_0000_0000_0000b ;situacion inicial, luces apagadas
s1 dw 0000_0100_1001_0010b ;situacion luces amarillas estan encedidas
sit_end = $

todo_apagado equ 0000_0000_0000_0000b ;defino el vector inicial

3. Juego de luces en el semáforo usando desplazamiento izq y der:

Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.

.ORG 1000H ; origen del programa

MOV Dx, 12d
MOV Cx, 0 ;Referencia

INICIO:
MOV Ax,01H
OUT 04H,Ax
CALL RETARDO
CALL ID
MOV Ax,00H
 OUT 04H,Ax
CALL RETARDO
CALL DeI
MOV Ax,00H
OUT 04H,Ax
CALL RETARDO
CALL IDI
MOV Ax,00H
OUT 04H,Ax
CALL RETARDO
RET

ID:
INC Ax
CALL LUZ
CMP Ax, Dx
JZ DeI
JMP ID
RET

DeI:

DEC Ax
CALL LUZ
CALL RETARDO
CMP Ax, Cx
JZ IDI
JMP DeI
RET

IDI:
CALL ID
CALL DeI
RET

RETARDO:
MOV BL,10d
BEXT: MOV BH,5d
BINT: DEC BH
JNZ BINT
DEC BL
JNZ BEXT
RET
LUZ:
CMP AX,01h
JZ M1
CMP AX,02h
JZ M2
CMP AX,03h
JZ M3
CMP AX,04h
JZ M4
CMP AX,05h
JZ M5
CMP AX,06h
JZ M6
CMP AX,07h
JZ M7
CMP AX,08h
JZ M8
CMP AX,09h
JZ M9
CMP AX,010d
JZ M10
CMP AX,011d
JZ M11
CMP AX,012d
JZ M12
CMP AX,013d
JZ M13

M1:
MOV DX,AX
MOV CX,1h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M2:
MOV DX,AX
MOV CX,2h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
 MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M3:
MOV DX,AX
MOV CX,4h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M4:
MOV DX,AX
MOV CX,8h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M5:
MOV DX,AX
MOV CX,10h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M6:
MOV DX,AX
MOV CX,20h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M7:
MOV DX,AX
MOV CX,40h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M8:
MOV DX,AX
MOV CX,80h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M9:
MOV DX,AX
MOV CX,100h
MOV AX,CX
OUT 04h,AX
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M10:
MOV DX,AX
MOV CX,200h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M11:
MOV DX,AX
MOV CX,400h
MOV AX,CX
OUT 04h,AX
 CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M12:
MOV DX,AX
MOV CX,800h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET
M13:
MOV DX,AX
MOV CX,1000h
MOV AX,CX
OUT 04h,AX
CALL RETARDO
MOV AX,DX
MOV CX,0
MOV Dx, 12d
RET

HLT
4. Juego de luces en el semáforo usando tablas:

Prender un led de izq a der, de uno en uno, un solo led prendido a la vez.
Prender un led de der a izq, de uno en uno, un solo led prendido a la vez.
Prender un led de izq – der – izq, un solo led prendido a la vez.
#start=Traffic_Lights.exe#

mov ax, todo_apagado ;AX toma el valor del vector todo_apagado

out 4, ax ;Llamo al panel del control de trafico en el vector inicial en todo apagado

mov si, offset situation ;Comienzo tranlando el vector situacion al vector si

next: ;defino next

mov ax, [si] ;AX toma el valor del vector si
out 4, ax ;Llamo a panel de control de trafico y toma el valor del registro A

; Retardo de 1 segundo
mov cx, 000Fh
mov dx, 4240h
mov ah, 86h
int 15h

add si, 2 ;conteo para las diferenres situaciones

cmp si, sit_end ;comparo si con sit_end
jb next ;salto a next
mov si, offset situation ;Si el programa termina vuelve al inicio
jmp next ;salto a next

; FEDC_BA98_7654_3210
situation dw 0000_1000_0000_0000b
s1 dw 0000_0100_0000_0000b
s2 dw 0000_0010_0000_0000b
s3 dw 0000_0001_0000_0000b
s4 dw 0000_0000_1000_0000b
s5 dw 0000_0000_0100_0000b
s6 dw 0000_0000_0010_0000b
s7 dw 0000_0000_0001_0000b
s8 dw 0000_0000_0000_1000b
s9 dw 0000_0000_0000_0100b
s10 dw 0000_0000_0000_0010b
s11 dw 0000_0000_0000_0001b
s12 dw 0000_0000_0000_0001b
s13 dw 0000_0000_0000_0010b
s14 dw 0000_0000_0000_0100b
s15 dw 0000_0000_0000_1000b
s16 dw 0000_0000_0001_0000b
s17 dw 0000_0000_0010_0000b
s18 dw 0000_0000_0100_0000b
s19 dw 0000_0000_1000_0000b
s20 dw 0000_0001_0000_0000b
s21 dw 0000_0010_0000_0000b
s22 dw 0000_0100_0000_0000b
s23 dw 0000_1000_0000_0000b

sit_end = $ ;defino sit_end como un vector vacio

todo_apagado equ 0000_0000_0000_0000b