1.3.- Interrupciones.

1.3.1 Hardware.
1.3.2 Software.

Una interrupcin es una operacin que suspende la ejecucin de un programa de modo que
el sistema pueda realizar una accin especial. La rutina de interrupcin ejecuta y por lo
regular regresa el control al procedimiento que fue interrumpido, el cual entonces reasume
su ejecucin.

1.3.1.- Hardware.
Las interrupciones hardware ocurren cuando un dispositivo necesita atencin del
procesador y genera una seal elctrica en la lnea IRQ que tiene asignada. Esta seal
es recogida y procesada por el controlador de excepciones PIC antes de ser enviada al
procesador, lo que puede realizarse de dos formas, segn el tipo de interrupcin sea
enmascarable o no enmascarable.

Cuando se habla de una significa que, bajo control del software, el procesador puede
aceptar o ignorar (enmascarar) la seal de interrupcin. Para ello se enva una seal
a la patilla INTR, y el procesador la atiende o la ignora en funcin del contenido de un
bit (IF) en un registro (FLAGS) que puede estar habilitado o deshabilitado. En el
primer caso, cuando se recibe la seal, el procesador concluye la instruccin que
estuviese en proceso y a continuacin responde con una combinacin de seales en
algunas de sus patillas componiendo una sucesin de dos seales INTA ("Interrupt
Acknowledge".

La primera seal es simplemente un aviso; la segunda es una peticin para que el

PIC coloque en el bus de datos un Byte con el nmero de interrupcin, de forma que
el procesador pueda localizar el servicio solicitado.

El valor recibido (0-255) es multiplicado por 4 para calcular la direccin del vector
correspondiente en la tabla de vectores de interrupcin, lo que se realiza mediante un
desplazamiento binario de dos posiciones a la izquierda.
 Interrupcin no enmascarable significa que la interrupcin no puede ser
deshabilitada por software. Este tipo de interrupciones ocurren cuando se recibe una
seal en la patilla NMI ("Nonmaskable Interrupt") del procesador. Se reservan para
casos en que es crtica la respuesta, por ejemplo que se detecte un error de paridad en
la memoria. Adems son de prioridad ms alta que las enmascarables.

Arriba.

1.3.2.- Software.
Los procesadores Intel de la gama x86 y compatibles, disponen de una
instruccin INT que permite generar por software cualquiera de los 256 tipos de
interrupcin anteriormente descritos. El proceso seguido es exactamente el mismo que
si se recibe una interrupcin hardware en la patilla INTR, salvo que en este caso se
conoce el tipo de interrupcin, y no se requiere ningn ciclo INTA.

Este tipo de interrupciones son de prioridad ms alta que las de hardware

(enmascarables y no enmascarables), de forma que si se recibe una interrupcin
hardware mientras que se ejecuta una software, esta ltima tiene prioridad.

FUNCIONES DE LA BIOS

Las funciones de la BIOS se invocan, desde los programas de usuario, ejecutando una
interrupcin software con un cierto valor inicial en los registros. La BIOS emplea un cierto
rango de interrupciones, cada una encargada de una tarea especfica:

INT 10h: Servicios de Vdeo (texto y grficos).

INT 11h: Informe sobre la configuracin del equipo.
INT 12h: Informe sobre el tamao de la memoria convencional.
INT 13h: Servicios de disco (muy elementales: pistas, sectores, etc.).
INT 14h: Comunicaciones en serie.
INT 15h: Funciones casette (PC) y servicios especiales del sistema (AT).
INT 16h: Servicios de teclado.
INT 17h: Servicios de impresora.
INT 18h: Llamar a la ROM del BASIC (slo mquinas IBM).
INT 19h: Reinicializacin del sistema.
INT 1Ah: Servicios horarios.
INT 1Fh: Apunta a la tabla de los caracteres ASCII 128-255 (8x8 puntos).

FUNCIONES DEL DOS

El DOS emplea varias interrupciones, al igual que la BIOS; sin embargo, cuando se
habla de funciones del DOS, todo el mundo sobreentiende que se trata de llamar a la INT
21h, la interrupcin ms importante con diferencia.

INT 20h: Terminar programa (tal vez en desuso).

INT 21h: Servicios del DOS.
INT 22h: Control de finalizacin de programas.
INT 23h: Tratamiento de Ctrl-C.
INT 24h: Tratamiento de errores crticos.
INT 25h: Lectura absoluta de disco (sectores lgicos).
INT 26h: Escritura absoluta en disco (sectores lgicos).
INT 27h: Terminar dejando residente el programa (en desuso).
INT 28h: Idle (ejecutada cuando el ordenador est inactivo).
INT 29h: Impresin rpida en pantalla (no tanto).
INT 2Ah: Red local MS NET.
INT 2Bh-2Dh: Uso interno del DOS.
INT 2Eh: Procesos Batch.
INT 2Fh: Interrupcin Multiplex.
INT 30h-31h: Compatibilidad CP/M-80.
INT 32h: Reservada.
Un programa en lenguaje ensamblador estar formado por una secuencia de sentencias.
Cada sentencia ocupa una sola lnea y tiene la siguiente estructura:

[etiqueta] [operacin] [operandos] [;comentarios]

Los cuatro campos de una sentencia son opcionales, si no aparece ninguno de ellos (una
lnea en blanco) tendramos una sentencia vaca.

Las sentencias se dividen en dos tipos:

* Instrucciones:

Estas sentencias representan rdenes al procesador y tras el proceso de compilacin

generan cdigo ejecutable.

* Directivas:

Estas sentencias dirigen el proceso de compilacin o construccin del programa ejecutable.

No generan cdigo ejecutable. Normalmente se utilizan para aumentar la legibilidad del
cdigo fuente.

Estructura de un fichero en lenguaje ensamblador

Los ficheros de cdigo fuente escritos en lenguaje ensamblador se organizan en lneas.

Cada una de las lneas del fichero puede contener una directiva, una instruccin o ambas
cosas a la vez en los casos en que sea posible.

Todos los ficheros fuente tienen que adecuarse a una estructura fija dividida en secciones.

La estructura a seguir se muestra a continuacin:

escala EQU 1000 ;Definicin de constantes simblicas

ORIGEN 7F40h ;Definicin del origen de carga del
programa
INICIO ini ;Definicin de la etiqueta que
marca la
;primera instruccin a ejecutar
del programa
.PILA 100h ;Definicin de la pila
.DATOS ;Definicin de los datos del
programa
dato1 VALOR 12h

.CODIGO ;Definicin del cdigo del
programa
INI: MOV R5, R4

FIN
No existe una convencin establecida para la estructura de un programa en lenguaje
ensamblador (no como sucede con otros lenguajes, como C/C++). Como regla de oro, es
necesarios la declaracin de dos segmentos, la de cdigo (CODE) y la de pila (STACK). En
total, hay 4 segmentos principales: Segmento de datos, Segmento de cdigo, Segmento de
pila y Segmento Extra.

Los diferentes segmentos tienen las siguientes funciones:

Segmento de datos: Contiene la direccin donde inicia la declaracin de variables. Aqu,

escribiremos nuestras variables.
Segmento de cdigo: Contiene la direccin de inicio donde se encuentran las instrucciones
del programa. Aqu, escribiremos todo el cdigo de nuestro programa
Segmento de pila: Contiene la direccin donde se encuentra la pila.
Segmento Extra: Contiene la direccin donde podemos almacenar datos extras.
 2.4.- Operadores Lgicos.

AND (y lgico).

Realiza una operacin de Y lgico entre el operando origen y destino quedando el resultado
en el destino. Son vlidos operandos byte o palabra, pero ambos del mismo tipo.

Ejemplos:
AND AX, BX
AND BL, BYTE PTR ES:[SI+10H]

NOT (No lgico).

Realiza el complemento a uno del operando destino, invirtiendo cada uno de sus bits. Los
indicadores no resultan afectados.

Ejemplo:
NOT AX

OR (O lgico).

Realiza una operacin O lgico a nivel de bits entre los dos operandos, almacenndose
despus el resultado en el operando destino.

Ejemplo:
OR AX, BX

XOR (O exclusivo).

Operacin OR exclusivo a nivel de bits entre los operandos origen y destino almacenndose
el resultado en este ltimo.

Ejemplo:
XOR DI, AX
 2.5.- Desplazamiento.

eal.
cular.

2.5.1- Lineal.
SHL (Desplazamiento lgico a la izquierda).

Mediante esta instruccin podemos desplazar a la izquierda los bits de un registro o

posicin de memoria. Esto que puede parecer poco prctico, es muy til en determinadas
situaciones. Por ejemplo, es la manera ms rpida y cmoda de multiplicar por 2.

SHR (Desplazamiento lgico a la derecha).

Desplaza a la derecha los bits del operando destino el nmero de los bits especificados en el
segundo operando. Los bits de la izquierda se llena con cero. Si el nmero de bits a
desplazar es 1 se puede especificar directamente en el caso en que no ocurra se pone el
valor en CL:

Arriba.

2.5..2- Circular.
RCL (Rotacin a la izquierda con acarreo).

Rotar a la izquierda los bits del operando destino junto con el indicador de acarreo CF el
nmero de bits especificado en el segundo operando. Si el nmero de bits a desplazar es 1,
se puede especificar directamente, en caso contrario el valor debe cargarse en CL y
especificar CL como segundo operando. No es conveniente que CL sea mayor de 7, en
bytes; 15, en palabras.

RCR (Rotacin a la derecha con acarreo).

Rotar a la derecha los bits del operando destino junto con el indicador de acarreo CF el
nmero de bits especificado en el segundo operando. Si el nmero de bits es 1 se puede
especificar directamente; en caso contrario su valor debe cargarse en CL y especificar CL
como segundo operando:

ROL (Rotacin a la izquierda).

Rota a la izquierda los bits del operando destino el nmero de bits especificado en el
segundo operando, que puede ser 1 CL previamente cargado con el valor del nmero de
veces.

ROR (Rotacin a la derecha).

Rota a la derecha los bits del operando destino el nmero de bits especificado en el segundo
operando. Si el nmero de bits es 1 se puede poner directamente, en caso contrario debe
ponerse a travs de CL.
 2.6.- Procesos de Control.

2.6.1 Banderas.
2.6.2- Cadenas.

NOP (Operacin nula).

Realiza una operacin nula, es decir, el microprocesador decodifica la instruccin y pasa a

la siguiente. Realmente se trata de la instruccin XCHG AX,AX.

ESC (Salida a un coprocesador).

Se utiliza en combinacin con procesadores externos, tales como los coprocesadores de

coma flotante o de E/S, y abre al dispositivo externo el acceso a las direcciones y operandos
requeridos. Al mnemnico ESC le siguen los cdigos de operacin apropiados para el
coprocesador as como la instruccin y la direccin del operando necesario.

HLT (Parada hasta interrupcin o reset).

El procesador se detiene hasta que se restaura el sistema o se recibe una interrupcin. Como
en los PC se producen normalmente 18,2 interrupciones de tipo 8 por segundo (del
temporizador) algunos programadores utilizan HLT para hacer pausas y bucles de retardo.
Sin embargo, el mtodo no es preciso y puede fallar con ciertos controladores de memoria.

LOCK (Bloquea los buses).

Es una instruccin que se utiliza en aplicaciones de recursos compartidos para asegurar que
no accede simultneamente a la memoria ms de un procesador. Cuando una instruccin va
precedida por LOCK, el procesador bloquea inmediatamente el bus, introduciendo una
seal por la patilla LOCK.

WAIT (Espera).

Provoca la espera del procesador hasta que se detecta una seal en la patilla TEST. Ocurre,
por ejemplo, cuando el coprocesador ha terminado una operacin e indica su finalizacin.
Suele preceder a ESC para sincronizar las acciones del procesador y coprocesador.
 2.6.1 Banderas.
Las banderas proveen una manera de obtener informacin acerca de del estado actual de la
mquina y el resultado de procesamiento de una instruccin. La plataforma IA-32 utiliza un
registro de 32 bits llamado EFLAGS que contiene las banderas. Las banderas ms
comunmente usadas son las siguientes:

Bandera Bit Nombre

CF 0 Bandera de acarreo (carry flag)
PF 2 Bandera de paridad (parity flag)
AF 4 Bandera de acarreo auxiliar (adjust flag)
ZF 6 Bandera de cero (zero flag)
SF 7 Bandera de signo (sign flag)
DF 10 Bandera de direccin (direction flag)
OF 11 Bandera de desbordamiento (overflow flag)

La bandera de acarreo se activa cuando se produce acarreo en una suma o multiplicacin, o

un "prstamo" en una resta entre nmeros sin signo. La bandera de paridad se usa para
indicar si el resultado, en un registro, de una operacin matemtica es vlido.

La bandera de paridad se usa para indicar si el resultado, en un registro, de una operacin

matemtica es vlido.

La bandera de acarreo auxiliar se utiliza en operaciones matemticas con nmeros

decimales codificados en binario (BCD). Se activa si hay acarreo presente.

La bandera de cero se activa si el resultado de una operacin aritmtico lgica es cero.

La bandera de signo muestra el bit ms significativo del resultado de una operacin, el cual
denota el signo del nmero.

La bandera de direccin controla la seleccin de autoincremento (D=0) o autodecremento

(D=1) de los registros %edi o %esi durante las operaciones con cadenas de caracteres. La
bandera de direccin slo se utiliza con las instrucciones para el manejo de cadenas de
caracteres.

La bandera de desbordamiento se utiliza en la aritmtica de enteros con signo cuando un

nmero sobrepasa la capacidad de representacin del registro.

Arriba.
 2.6.2.- Cadenas.
CMPS/CMPSB/CMPSW (Compara cadenas).

Compara dos cadenas restando al origen el destino. Ninguno de los operandos se alteran,
pero los indicadores resultan afectados. La cadena origen se direcciona con registro SI
sobre el segmento de datos DS y la cadena destino se direcciona con el registro DI sobre el
segmento extra ES. Los registros DI y SI se autoincrementan o autodecrementan segn el
valor del indicador DF en una o dos unidades, dependiendo de si se trabaja con bytes o con
palabras. Cadena origen y cadena destino son dos operandos redundantes que slo indican
el tipo del dato (byte o palabra) a comparar, es ms cmodo colocar CMPSB o CMPSW
para indicar bytes/palabras. Si se indica un registro de segmento, ste sustituir en la cadena
origen al DS ordinario.

Ejemplo:

LEA SI, ORIGEN

LEA DI, DESTINO
CMPSB

MOVS/MOVSB/MOVSW (Mover cadena).

Transfiere un byte o una palabra de la cadena origen direccionada por DS:SI a la cadena
destino direccionada por ES:DI, incrementando o decrementando a continuacin los
registros SI y DI segn el valor de DF en una o dos unidades, dependiendo de si se trabaja
con bytes o con palabras. Cadena origen y cadena destino son dos operandos redundantes
que slo indican el tipo del dato (byte o palabra) a comparar, es ms cmodo colocar
MOVSB o MOVSW para indicar bytes/palabras. Si se indica un registro de segmento, ste
sustituir en la cadena origen al DS ordinario.

Ejemplo:
LEA SI, ORIGEN
LEA DI, DESTINO
MOVSW

STOS/STOSB/STOSW (Almacena cadena).

Transfiere el operando origen almacenado en AX o AL, al destino direccionado por el

registro DI sobre el segmento extra. Tras la operacin, DI se incrementa o decrementa
segn el indicador DF (vanse CLD y STD) para apuntar al siguiente elemento de la
cadena. Cadena_destino es un operando redundante que slo indica el tipo del dato (byte o
palabra) a cargar, es ms cmodo colocar STOSB o STOSW para indicar bytes/palabras.

Ejemplo:
LEA DI, DESTINO
MOV AX, 1991
STOSW

REP/REPE/REPZ/REPNE/REPNZ (Repetir).

REP repetir operacin de cadena

REPE/REPZ repetir operacin de cadena si igual/si cero
REPNE/REPNZ repetir operacin de cadena si no igual (si no 0)

Estas instrucciones se pueden colocar como prefijo de otra instruccin de manejo de

cadenas, con objeto de que la misma se repita un nmero determinado de veces
incondicionalmente o hasta que se verifique alguna condicin. El nmero de veces se indica
en CX.

Prefijo Funcin Instrucciones

-------------------- ------------------------------------------- ------------------
REP Repetir CX veces MOVS, STOS
REPE/REPZ Repetir CX veces mientras ZF=1 CMPS, SCAS
REPNE/REPNZ Repetir CX veces mientras ZF=0 CMPS, SCAS
Ejercicios resueltos en Ensamblador 8086
Rodrigo Paszniuk | 2013-05-20 | No hay comentarios
25

En este artculo les voy a dejar los programas ms importantes que he hecho en
Ensamblador. La mayora de los programas eran tareas que me dio mi profesor en la
universidad.

Ejercicio 1: Escribir un cdigo que verifique si dos cadenas son iguales

org 100h
comienzo:
mov si, x
mov al, msg2[si]
cmp msg[si], al ;comparar letra por letra las cadenas, si uno no coincide
manda directamente a fin y termina el programa
jne fin:
cmp msg[si], "$" ;si es el final y el programa llega aca, quiere decir
que son iguales
jz final:
inc x
loop comienzo
final:
mov dx, offset msg3
mov ah, 9
int 21h
fin:
ret
msg db "hello world $"
msg2 db "hello world $"
msg3 db "Son iguales $"
x dw 0

Ejercicio 2: Escribir un cdigo que verifique si una cadena es subcadena de otra.

Por ejemplo: la Mu es subcadena de Hola Mundo.

La cadena: 233 es subcadena de la cadena 2122432234

org 100h
mov si, 0 ;ponemos si en 0
comienzo:
mov al, msg2[0] ;copiar la primera letra de la palabra a al
cmp msg[si],"$" ;si es el fin de la cadena mandar a final
jz final
cmp msg[si], al ;comparar si encuentra la primera letra de la cadena
jne seguir

mov di, 1 ;poner en 1 di

comprobar:
mov al, msg2[di]
 mov bx, di
cmp msg[si+bx], al ;posicion de la letra coincidente + di, comparar con
la cadena
jne seguir ;si no coincide mandar a seguir

inc di ;incrementar di para seguir recorriendo cadena

cmp msg2[di],"$" ;si es el fin de la cadena y el programa llego aca

quiere decir que la cadena es parte de la palabra
jz resultado

loop comprobar ;bucle para recorrer cadena

seguir:
inc si ;para seguir recorriendo la palabra
loop comienzo ;bucle principal para recorrer palabra
resultado:
mov dx, offset msg3 ;copiar msg3 a dx
mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
int 21h ;mostrar contenido en dx
final:
ret
msg db "Hola Mundo$"
msg2 db "ola$"
msg3 db "Si es subcadena$"

Ejercicio 3: Escribir un cdigo que verifique que todas los caracteres de una cadena se
encuentran en otra.

Por ejemplo: todas las letras de la cadena casa se encuentran en escaso. Pero no todas
las letras de cerro se en cuentran en recanate

org 100h
mov si, 0 ;ponemos si en 0
comienzo:
cmp msg[si],"$" ;si es el fin de la cadena mandar a final
jz resultado

mov di, 0 ;poner en 0 di

comprobar:
mov al, msg2[di] ;copiar msg2 con su posicion a al
cmp msg[si], al ;comparar msg con su posicion con al
jz seguir ;si se encuentra entonces continua

inc di ;incrementar di para seguir recorriendo cadena

cmp msg2[di], "$" ;si es que llega al final y no encontro coincidencia,
entonces ya termina el programa
jz final

loop comprobar ;bucle para recorrer

seguir:
inc si ;para seguir recorriendo la palabra
loop comienzo ;bucle principal para recorrer palabra
resultado:
mov dx, offset msg3 ;copiar msg3 a dx
mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
int 21h ;mostrar contenido en dx
final:
ret
msg db "cerro$"
msg2 db "recanate$"
msg3 db "Si se encuentran todos los caracteres$"

Ejercicio 4: Escribir una programa que reciba una cadena ingresada por teclado, terminada
en ENTER. Luego que elimine todos los caracteres que no son dgitos, sin utilizar una
variable auxiliar.

ORG 100H
mov si, 0
lectura:
mov ah,1
int 21h

cmp al,13
jz resultado:

cmp al, 57 ;si tecla es mayor a 57 entonces ir a fin3 (tecla > 57)
ja fin3
cmp al,47 ;si tecla no es mayor a 47 ir a fin3 (tecla <= 47)
jng fin3
mov bx[si], al ;si es un digito entonces guardo en bx

inc si ;incrementa si

fin3:

jmp lectura

resultado:
mov ah,00h ;limpia la pantalla
mov al,03h
int 10h
mov bx[si], "$"
mov dx, offset bx
mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
int 21h ;mostrar contenido en dx
ret

Ejercicio 5: Escribir un programa que tome una cadena que representa un nmero decimal
y escriba su equivalente octal

org 100h ; inicio de programa

mov si, 0
mov al, 0

cadAnum:
cmp cad[si], "$"
jz seguir
 mov bl, 10
mul bl
sub cad[si], '0'
add al, cad[si]

inc si
loop cadAnum

seguir:
mov cx, si
mov si, 0
mov bl, 8
pasar:
div bl ;dividir al con bl
mov oct[si], ah ;copiar a la cadena oct el resultado sobrante de la
division
inc si ;incrementar si
loop pasar
fina:
cmp ah, 0
jnz final
mov oct[si], al
final:
;mov dx, offset res
;mov ah, 9 ;preparar ah con 9 para la interrupcion 21h
;int 21h ;mostrar contenido en dx
ret
cad db "64$"
oct db 0

Ejercicio 6: Escribir un programa que tome tres cadenas, la primera y la tercera

representan un nmero y la segunda una operacin, por ejemplo: 329, -, 21 e
imprima el resultado 308

org 100h ; inicio de programa

include 'emu8086.inc' ;Incluye funciones de libreria emu8086
; DEFINE_SCAN_NUM
; DEFINE_PRINT_STRING
DEFINE_PRINT_NUM
DEFINE_PRINT_NUM_UNS
mov si, 0
mov al, 0
;Convertir primera cadena a numero
cadAnum:
cmp cad1[si], "$"
jz seguir

mov bl, 10
mul bl
sub cad1[si], '0'
add al, cad1[si]

inc si
loop cadAnum

seguir:
mov aux1, al
;Convertir segunda cadena a numero
mov si, 0
mov al, 0
cadAnum2:
cmp cad3[si], "$"
jz seguir2

mov bl, 10
mul bl
sub cad3[si], '0'
add al, cad3[si]

inc si
loop cadAnum2

seguir2:
mov bl, al
mov al, aux1
;realizar operaciones normalmente teniendo ya los dos numeros decimales
cmp cad2, "-"
jz resta
cmp cad2, "+"
jz suma
cmp cad2, "*"
jz multi
cmp cad2, "/"
jz divi
resta:
sub al, bl
jmp fin
suma:
add al, bl
jmp fin
multi:
mul bl
jmp fin
divi:
div bl
jmp fin

fin:
mov bx, ax
mov ah,09
lea dx,msg
int 21h
mov ax, bx
call PRINT_NUM
ret
cad1 db "10$"
cad2 db "-"
cad3 db "2$"
aux1 db ?
aux2 dw ?
msg dw "El resultado es: $"
Ejercicio 7: Escribir un programa que imprima X en la pantalla hasta que se presiones
ESC.

name "keybrd"
org 100h
; print a welcome message:
mov dx, offset msg
mov ah, 9
int 21h
;============================
; eternal loop to get
; and print keys:
wait_for_key:
; check for keystroke in
; keyboard buffer:
mov dh, pos
mov dl, pos
mov bh, 0
mov ah, 2
int 10h ;Movemos el cursor
mov al,'X'
mov bh,0
mov bl,1
mov cx,1
mov ah,09h
inc pos ;Imprimimos una x
int 10h
mov ah, 1
int 16h
jz wait_for_key
; get keystroke from keyboard:
; (remove from the buffer)
mov ah, 0
int 16h
; print the key:
mov ah, 0eh
int 10h
; press 'esc' to exit:
cmp al, 1bh
jz exit
jmp wait_for_key
;============================
exit:
ret
msg db "Type anything...", 0Dh,0Ah
db "[Enter] - carriage return.", 0Dh,0Ah
db "[Ctrl]+[Enter] - line feed.", 0Dh,0Ah
db "You may hear a beep", 0Dh,0Ah
db " when buffer is overflown.", 0Dh,0Ah
db "Press Esc to exit.", 0Dh,0Ah, "$"
pos db 1
end

Ejercicio 8: Escribir un programa que ordene un vector de mayor a menor.

name "arreglo-mayor"
org 100h
mov cx, 8
bucle1:
mov c, cx

mov bx, cx
mov cx, 9

bucle2:
mov si, cx
mov ah, v[si-1]
cmp ah,v[bx-1]
jnge seguir ;Si v[8] < v[7] no hacer nada, sino:
mov dh, v[bx-1] ;Copiar v[7] en dh
mov dl, v[si-1] ;Copiar v[8] en dl
mov v[bx-1], dl ;Copiar dl en v[7]
mov v[si-1], dh ;Copiar dh en v[8]
seguir:
loop bucle2

mov cx, c
loop bucle1
ret
v db 2,32,64,32,98,12,5,21,91
c dw 0

Ejercicio 9: Escribir un programa que halle el MCM Y MCD

; Programa que calcula el MCD y MCM de dos numeros decimales (soporta

numeros de 8 bits o 1 byte)
mov cont,1 ;inicializar variable cont en 1
bucle:
mov ah,0
mov al,cont
mov bl,nro1
div bl
cmp ah,0 ;si el resto de la division del contador con el nro1 es igual 0
je parte1
bc:
inc cont ;incrementar el contador
jmp bucle ;bucle hasta que encuentre el MCM

parte1: ;si nro1 es multiplo del contador

mov ah,0
mov al,cont
mov bl,nro2
div bl
cmp ah,0 ;compara si el resto de la division del contador con el nro2 es
0
je parte2
jmp bc ;si el nro2 no es multiplo del contador regresa a bucle1
parte2: ;si el nro1 y el nro2 son multiplos del contador
mov al,cont
mov MCM,al ;guarda el MCM
jmp parte3 ;ir a final
 parte3: ;una vez que tengamos el MCM primero multiplicar nro1 * nro 2
mov al, nro1 ;con ese resultado, dividir por el MCM de nro1 y nro2 y
tenemos el MCD
mov bl, nro2
mul bl
mov bl, MCM
div bl
mov MCD, al
ret ;fin del programa

cont db 0 ;cont = contador

MCM db 0 ;en esta variable se guarda el MCM
MCD db 0 ;en esta variable se guarda el MCD
nro1 db 48 ;numero1 decimal
nro2 db 60 ;numero2 decimal

Ejercicio 10: Escribir un programa que dibuje una diagonal en la pantalla.

mov cx,1
mov al, 13h
mov ah, 0
int 10h ; set graphics video mode.

bucle1:
mov dx, cx
mov al, color ;AL = pixel color
mov ah, 0ch ;Change color for a single pixel
int 10h ;set pixel

cmp cx, 101 ;llegar hasta 100 x 100 (va en diagonal)

jz fin

inc cx ;DX = row.

add color, 2 ;para cambiar colores
jmp bucle1 ;CX = column
fin:
ret
color db 1

Ejercicio 11: Escribir un programa que lea un archivo y cuente cuantas palabras terminan
con la letra a.

name "archivo3"
org 100h
mov al, 0 ;modo de acceso para abrir arhivo, modo lectura/escritura
mov dx, offset archivo ;offset lugar de memoria donde esta la variable
mov ah, 3dh ;se intenta abrir el archivo
int 21h ;llamada a la interrupcion DOS
jc error ; si se prendio la bandera c ir a error

mov handle, ax ;si no paso mover a lo que le dio el SO

jmp leer

error:
; ....
 ;leer archivo
leer:
mov bx, handle
mov cx, 1
mov dx, offset leido
mov ah, 3fh
int 21h

cmp ax, 0 ;ax queda en 0 cuando llega a EOF

jz FIN ;si es 0 entonces va a fin para cerrar archivo

;Detectar palabras que terminan con a

mov dl, leido[0]

cmp dl, " " ;comparar si es espacio

jz mostrar ;si es espacio entonces ir a mostrar

jmp abajo ;si no es espacio entonces ir a abajo

mostrar:
cmp aux, "a" ;compara si el anterior es a
jnz abajo

inc cont ;si es a entonces incrementar contador

abajo:
mov aux, dl ;guardar en aux lo que hay en dl para comparar en la proxima
vuelta
jmp leer

FIN:

;cerramos archivo
mov bx, handle
mov ah, 3eh
int 21h

ret

archivo db "C:\prueba.txt", 0 ;ascii del nombre del archivo

leido db "$"
handle dw ? ;identificador del arhivo
aux db "$"
cont db 0