EJERCICIOS

Hacer una investigación sobre como hacer una suma y una resta(poner un ejemplo).

Explica el funcionamiento que tiene el siguiente código.

Describe el funcionamiento del siguiente código

1. mov ax,123
2. mov bx,321
3. add ax,bx

Describe el funcionamiento del siguiente código

1. mov ax,125
2. mov bx,31
3. sub ax,bx
 Ejemplos de programas en
Ensamblador 8086
Primer programa para entender como 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 ;counter to 100h
mov cx, num2
mov ax, num1
inicio:
mov bx,num1
mul bx ;ax = ax * bx
 loop inicio ;c--

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"

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 p
one 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 ca
dena.
;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

Archivos:

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, 5
mov dx, offset leido
mov ah, 3fh
int 21h

;cerramos archivo
mov bx, handle
mov ah, 3eh
int 21h
 ;imprimir el contenido de leido
mov dx, offset leido
mov ah, 9
int 21h

ret

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

leido db "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$"
handle dw ? ;identificador del arhivo

Interrupción 13h (Gráficos)

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
En este artículo les voy a dejar los programas más importantes que he hecho en Ensamblador.
La mayoría de los programas eran tareas que me dio mi profesor en la universidad.
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 i
guales
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 cade
na
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 deci
r 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

Contador 0 al 9 en ensamblador
.model small
.stack 100
.data
.code
.startup
mov cx,00h ; inicializo contador en cero

repite:
mov dl,cl ; muevo el valor del contador a dl para imprimir
inc cl ; incremento el contador en uno
add dl,30h ; sumo 30h a dl para convertirlo al codigo ascii y
poder imprimirlo
mov ah,02h ; funcion para imprimir un caracter
int 21h ; imprimo
cmp cl,10 ; compara si en el contador hay un 10
je salir ; si la comparacion es verdadera salta a salir
jne repite ; sino es verdadera la ultima comparacion regresa a
repite
salir:
.exit
end

Area y perimetro de un rectangulo en ensamblador

; programa que calcula el area y perimetro de un rectangulo
; by angel
.model small
.stack 100
.data
dos equ 2 ; declaracion de constante=2
m1 db 10,13,"Introduce la base: $"
m2 db 10,13,"Introduce la altura: $"
m3 db 10,13,10,13,"Area: $"
m4 db 10,13,"Perimetro: $"
m5 db "Area y perimetro de un rectangulo",10,13,'$'
base db 0
altura db 0
unidades db 0
decenas db 0
.code
.startup
call cls

; imprime titulo
mov ah,09h
lea dx,m5
int 21h
; imprime introduce la base
lea dx,m1
int 21h

; pide la base
mov ah,01h
int 21h
sub al,30h
mov base,al

; imprime introduce la altura

mov ah,09h
lea dx,m2
int 21h

; pide la altura
mov ah,01h
int 21h
sub al,30h
mov altura, al

;*********************** calcula area

mov al,base
mul altura ; multiplica: al * altura y el resultado queda en al
aam
mov decenas,ah
mov unidades,al

; imprime el area es
mov ah,09h
lea dx,m3
int 21h
call imprime2digitos

;******************** calcula perimetro

mov al,dos
mul base
mov bl,al

mov al,dos
mul altura
mov cl,al

add bl,cl
mov al,bl
aam
mov decenas,ah
mov unidades,al

; imprime el perimetro es
mov ah,09h
lea dx,m4
int 21h

call imprime2digitos
.exit

cls proc near

mov ah,00h
mov al,03h
int 10h
ret
endp
impcar proc near
add dl,30h
mov ah,02h
int 21h
ret
endp

imprime2digitos proc near

; imprime decenas
mov dl,decenas
call impcar
; imprime unidades
mov dl,unidades
call impcar
ret
endp

end

Suma, resta, multiplicacion y division en ensamblador

; suma, resta, multiplicacion y division sin tomar en cuenta el
acarreo

; el 13,10 es un salto de linea

.model small
.stack 100
.data
msj1 db 'Numero 1: ','$'
msj2 db 13,10,'Numero 2: ','$'
msj3 db 13,10,'Suma: ','$'
msj4 db 13,10,'Resta: ','$'
msj5 db 13,10,'Multiplicacion: ','$'
msj6 db 13,10,'Division: ','$'
linea db 13,10,'$'
var1 db 0
var2 db 0
.code
.startup

call limpia
mov ah,09h
lea dx, msj1 ;desplegar numero 1:
int 21h

call leer ;lee primer numero

sub al,30h ;restar 30h para obtener el numero
mov var1,al ;lo guardo en var1
mov ah,09h
lea dx, msj2 ;desplegar numero 2:
int 21h

call leer ;lee segundo numero

sub al,30h ;restar 30h para obtener segundo valor
mov var2,al ;guardar en var2
mov bl,var2 ;mover a bl

;******************* SUMA
add bl,var1 ; realizo la suma de var2(bl) y var1 y el resultado
queda en bl
mov ah,09h
lea dx,msj3 ;imprimir suma
int 21h
mov dl,bl ;pongo en dl el numero a imprimir var2(bl)
add dl,30h ; agrego 30h para obtener el caracter
mov ah,02h ;imprime un caracter
int 21h

;******************RESTA
mov bl,var1
sub bl,var2
mov ah,09h
lea dx,msj4 ;desplegar resta:
int 21h
mov dl,bl ;mover resta a dl para imprimir
add dl,30h ;sumar 30 para obtener caracter
mov ah,02h ;imprimir un caracter
int 21h

;******************MULTIPLICACION
mov ah,09h
lea dx,msj5 ;desplegar mult
int 21h

mov al,var1
mov bl,var2
mul bl ;mult al=al*bl
mov dl,al ;mover al a dl para imprimir
add dl,30h ;sumar 30 para obtener caracter
mov ah,02h ;imprimir caracter
int 21h

;*****************DIVISION
mov ah,09h
lea dx,msj6 ;desplegar div
int 21h
xor ax,ax ;limpiamos el registro ax.
mov al,var2
mov bl,al
mov al,var1
div bl ; divide AX/BX el resultado lo almacena en AX, el residuo
queda en DX
mov bl,al
mov dl,bl
add dl,30h
mov ah,02h
int 21h
.exit

; ****************PROCEDIMIENTOS
salto proc near
mov ah,09h
lea dx,linea
int 21h
mov dl,00h
ret
salto endp

leer proc near

mov ah,01h;leer caracter desde el teclado
int 21h;lee primer caracter
ret
leer endp

limpia proc near

mov ah,00h
mov al,03h
int 10h
ret
limpia endp
end
Imprimir numero de tres digitos en ensamblador
; Programa que imprime un valor de 3 digitos en ensamblador
; autor: angel

.model small
.stack 100
.data
c db 0
d db 0
u db 0
.code

mov al,198 ; asigno un valor de 3 digitos en decimal a AL

aam ;separa SIEMPRE lo que hay en AL por: AH=19 Y AL=8
mov u,al ; guardo el 8 a las unidades
mov al,ah ; muevo lo que tengo en AH a AL para poder volver a
separar los numeros

aam ; separa lo qe hay en AL por: AH=1 Y AL=9

mov c,ah ; guarda el AH=1 a las centenas
mov d,al ; guarda el AL=9 a las decenas

mov ah,02h ; funcion para imprimir un caracter

mov dl,c ; muevo las centenas a DL para poder imprimir
add dl,30h ; sumo 30h a DL para imprimir el numero real y no
otro caracter
int 21h ; imprime 1

mov dl,d
add dl,30h
int 21h ; imprimie 9

mov dl,u
add dl,30h
int 21h ; imprime 8
.exit
end

Abecedario en ensamblador
.model small
.stack 100
.data
mayus db 65
minus db 98
.code
.startup
mov ah,00h ;limpia pantalla
mov al,03h
int 10h
mov cx,13 ;hacer 13 veces

repite:
mov ah,02h
mov dl,mayus
int 21h
mov dl,minus
int 21h
add mayus,2
add minus,2
loop repite
.exit
end

Imprimir cadena en ensamblador

.model small
.stack 100
.data
msg db 'hola mundo$'
.code
; inicializacion de variables
mov ax, @data
mov ds,ax

mov ah,09h ;funcion para imprimir una cadena

lea dx, msg ; carga a dx lo qe hay en msg
int 21h ; imprime la cadena
.exit
end

Imprimir un caracter en ensamblador

.model small

.stack 100

.code

mov ah, 02h ; funcion para imprimir un caracter

mov dx, 64 ; mover un 64 a Dx para imprimir en pantalla

int 21h ; ejecuta la funcion

.exit

end