Ejemplos de programas en

Ensamblador 8086
Utilizar los registros:

ORG 100h
mov ax, 10 ;AX=10
mov bx, 00F9h ;BX=0xF9
inc bx ;BX++
add ax, 4 ;AX=AX+4
mov cx,45 ;CX=45
sub cx,cx ;CX=CX-CX
ret

Utilizar Loop:

ORG 100h
MOV CX, 5
MOV BX, 1
MOV DL, 2
comienzo:
MOV AX, BX
MUL DX
MOV BX, AX
LOOP comienzo
RET

Potencia:

name "potencia" ;8 chars DOS

org 100h
mov cx, num2
mov ax, num1
inicio:
mov bx,num1
mul bx ;ax = ax * bx
loop inicio
mov num3,ax ;copiamos el resultado
ret
;Variables "db" para byte y "dw" para word
num1 dw 0Ah
num2 dw 03h
num3 dw 0h

Raiz cuadrada:

org 100h
siguiente:
inc r
mov ax, r
mul ax
cmp ax, m
jbe siguiente ;(r*r) MENOR O IGUAL a m
dec r
ret

;Variables
m dw 146
r dw 0 ;Al final debe ser r=sqrt(m).

Arreglos:

name "arreglo"
org 100h
;un areglo se puede acceder a travez de []
mov cx, 9 ;cuantos elementos voy a recorrer, empezamos con el 9
inicio:
mov si, cx
mov dl, v[si]
cmp dl, mayor
jng siguiente:
mov mayor,dl
siguiente:
loop inicio
ret
v db 1,32,64,32,98,12,5,21,91,38
mayor db 0

Saber si un numero es mayor:

name "mayor"
org 100h
mov AX, 5
mov BX, 5
;mov DX, AX

;CX el valor más grande entre AX Y BX

;AX-BX mayor a 0
sub AX,BX
js A_MENOR_B
mov CX,AX
jmp FIN
A_MENOR_B:
mov CX,BX
FIN:

;mov AX,DX
ret

Multiplicacion:

ORG 100h
MOV AL, 200 ; AL = 0C8h
MOV BL, 4
MUL BL ; AX = 0320h (800)

RET

Interrupciones (Ejemplo de 21h):

name "int01"
org 100h
mov ah, 1 ;Leer un caracter de la entrada estandar
int 21h ;Llamada al sistema operativo (DOS)
mov tecla, al
mov ah, 2 ;imprime un simbolo a la consola
mov dl, simbolo ;el caracter a mostrar, en este caso la E
int 21h ;Llamada al DOS

inc tecla
mov ah, 7 ;NO imprime un simbolo a la consola
mov dl, tecla ;
int 21h ;Llamada al DOS

ret
;Variables
tecla db 0
simbolo db 45H
;ah que queres hacer
;ah = 1 guarda caracter en al
;ah = 2 escribe un caracter en la consola. El ascii del cacacter a
imprimir se pone el dl
;AH = 7 es igual a el ah=2 pero el resultado no se ve en pantalla
;ah = 9 imprime una cadena en la consola. Considera el caracter $ como
fin de cadena.
;La direccion de la cadena se expresa en DX

Cadenas:

org 100h
mov msg[2], 34H
mov dx, offset msg
mov ah, 9
int 21h
ret
msg db "hello world $"

Cambiar a mayúsculas:

name "int02"
ORG 100H
lectura:
mov ah,7
int 21h

mov tecla, al
cmp al,13
jz fin:
cmp tecla, 122 ;si tecla es mayor a 122 entonces ir a fin3 (tecla >
122)
ja fin3
cmp tecla,96 ;si tecla no es mayor a 96 ir a fin3 (tecla <= 96)
jng fin3
sub tecla, 32 ;si es 'a' hasta 'z' entonces restarle 32
fin3:
mov ah,2
mov dl,tecla
int 21h
jmp lectura
fin:
ret
tecla db 0

Procedimientos:

org 100h
mov bx, 5h
mov ax, 10h
call inicializar
inc ax
ret
inicializar PROC
MOV ax, 1234h
ret
inicializar ENDP

Interrupción 13h (Gráficos)

org 100h
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

Ejercicios resueltos en Ensamblador

8086
Ejercicio 1: Escribir un código 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 código 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 código 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 dígitos, 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 número 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
número y la segunda una operación, 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