;Programa HOLA MUNDO

DATOS SEGMENT
MENSAJE DB "HOLA MUNDO$"
DATOS ENDS
PILA

SEGMENT STACK "STACK"

DB 200 DUP(0)
PILA ENDS
CODIGO SEGMENT
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
PRINCIPAL PROC
MOV AX,DATOS
MOV DS,AX
MOV AH,9
MOV DX,OFFSET MENSAJE
INT 21H
MOV AH,4CH
INT 21H
PRINCIPAL ENDP
CODIGO
ENDS
END PRINCIPAL
.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

;Programa SUMA DE 3 NUMEROS

pila segment para stack "stack"
dw 32 dup (0)
pila ends
datos segment para "datos"
num1 dw 20
num2 dw 30
num3 dw ?
datos ends
codigo segment para "codigo"
empieza proc far
assume cs: codigo, ds: datos, ss:pila
mov ax,datos
mov ds,ax
mov ax,num1
add ax,num2
mov num3,ax
mov dx,num3
mov ax, 4C00H
int 21H
empieza endp
codigo ends
end empieza

.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

;PROGRAMA OBTIENE EL COMPLEMENTO A 2 DE UN NUMERO

pila segment para stack "stack"
db 200 dup (o)
pila ends
datos segment para "data"
var db 40H
datos ends
codigo segment para "code"
empieza proc far
assume cs: codigo, ds: datos, ss: pila
mov ax,datos
mov ds,ax
mov al,var
mov dl,al
mov ah,2
int 21
not al
inc al
mov dl,al
mov ah,2
int 21
empieza endp
codigo ends
end empieza
.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

;PROGRAMA CICLO LOOP, SUMAR 15D A 8 NUMEROS

PILA SEGMENT PARA STACK "STACK"
DB 200 DUP (0)
PIALA ENDS
DATOS SEGMENT PARA "DATA"
TABLA DB 20,26,15,28,19,27,16,29
DATOS ENDS
CODIGO SEGMENT PARA "CODE"
ASSUME CS:CODIGO,DS:DATOS.SS:PILA
EMPIEZA PROC FAR
MOV AX,DATOS
MOV DS,AX
MOV BX,OFFSET TABLA
MOV CX,8
ETA: ADD AL,15

INC BX
LOOP ETA
MOV AX,4C00H
INT 21H
EMPIEZA ENDP
CODIGO ENDS
END EMPIEZA
.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

Saber si un numero es mayor:

name "mayor"

mov AX, 5
mov BX, 5
;mov DX, AX

;CX el valor ms 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

Emulador EMU8086
10:21 Programacion 2 Comentarios

El Emulador EMU8086 es el primer programa que se utiliza en el curso de

Microprocesadores que imparte la Universidad Don Bosco; se ha elegido este
emulador porque posee una interfaz deusuario muy amistosa que permite
familiarizarse con los fundamentos de la programacin en lenguaje ensamblador de
forma muy intuitiva, aparte de eso brinda una serie de recursos para ejecutar y depurar
los programas. Tambin tiene algunas desventajas como el de no soportar algunas de
las interrupciones ms interesantes que posee el sistema operativo y tampoco puede
acceder a los puertos fsicos (reales), sino que los emula usando otros programas que
ya estn incluidos en su respectiva carpeta.
Para iniciar se debe ejecutar el archivos EMU886.exe, que se encuentra en la carpeta
del mismo nombre, en el directorio raz; seguramente en la computadora donde corra
el programa tendr otras alternativas para activar el programa, como un acceso directo
en el escritorio o en el men de programas del sistema operativo.
Si est ejecutando la versin 4.05 del EMU8086 observar primero la pantalla de
Bienvenida (welcome), similar a la que se muestra en la Figura 1

Figura 1. Pantalla de bienvenida del emulador EMU8086.

Se presentan cuatro diferentes opciones para elegir:

New : Le permite escribir un nuevo cdigo en lenguaje ensamblador (al que

Llamaremos Cdigo Fuente y tendr extensin .ASM)

Code examples: Le permite acceder a una serie de programas ejemplos que

pueden ayudarle a comprender funciones ms complejas.

Quick star tutor : activa un conjunto de documentos de ayuda, se recomienda

revisarlos frecuentemente en caso de dudas.

Recent file : Le muestra los ltimos archivos que se trabajaron en la mquina.

Para continuar este primer contacto con el emulador, seleccioneNew. Observar una
nueva caja de dialogo choose code template, como se muestra en la Figura 2

Figura 2. Caja de dialogo para seleccionar el tipo plantilla (template).

En ella se le presentan seis opciones, cuatro que le permiten usar plantillas
predefinidas con algunos de los tipo de archivo que se pueden crear en lenguaje
ensamblador: COM template, EXE template, BIN template y BOOT template (cada uno
le permite diferentes caractersticas que se abordaran a su debido tiempo en el curso).
Dos que le permiten usar un espacio vaco empty workspace (sin una plantilla) o
activar el emulador mismo. Selecciones la opcin del espacio vaco. Observar la
ventana de edicin o mejor dicho el Entorno de Desarrollo Integrado (Integrated
Development Environme IDE), como se muestra en la Figura 3, donde escribir sus
archivos fuentes en lenguaje ensamblador, por favor lo confunda con el lenguaje de
mquina.
Podr ver una barra de men de Windows con sus opciones file, edit, etc. pero
tambin vera unas opciones poco usuales como assembler, emulator, etc. propias del
emulador. Tambin vera una serie de botones que le permitirn crear un nuevo archivo
(new), abrir un archivo que ya existe (open), abrir un ejemplo (examples), compilar un
archivo fuente (compile), emular un archivo ejecutable (emulate) y otras opciones que
ira descubriendo a medida que se familiarice con el programa.

Figura 3. Ventana de edicin o Entorno de Desarrollo Integrado IDE del EMU8086.

Bueno, es el momento de estudiar nuestro primer programa en lenguaje ensamblador,
el cual imprime en pantalla algunas cadenas de texto. Para comprender mejor como
funciona revise primero la Figura 4, donde se presenta un diagrama de flujo.

Figura 4. Diagrama de Flujo del ejemplo.

Ahora observe la Tabla 1 donde aparece el cdigo fuente escrito en lenguaje

Ensamblador. Por favor note que el programa est compuesto de diferentes bloques

Tabla 1. Programa en lenguaje ensamblador.

Directivas de pre proceso: Le indican al compilador que debe realizar una serie de
acciones particulares en el momento de convertir el archivo fuente (ASM) en archivo
objeto (OBJ).

Segmento de Datos: Donde se declaran las variables y constantes que el programa va

a utilizar.

Segmento de Cdigo: Donde especifica lo que deseamos que el programa haga. Para
especificarlo se pueden usar: instrucciones (propias del microprocsador), Macroinstrucciones (similar a los comandos de los lenguajes de alto nivel) y procedimientos
(similar a las funciones definidas por el usuario de los lenguajes de alto nivel).

Segmento de PILA o STACK: bloque de memoria donde almacenan datos intermedios

que se generan durante la ejecucin de un programa. En este no se declaran variables
o constantes como en el segmento de datos, sino que se administra como una
memoria LIFO, el ltimo en entrar es el primero en salir.

Directiva que indica el fin del archivo, cualquier instruccin posterior a esta lnea Ser
ignorada.

Digite el cdigo en el IDE, note como se le asignan diferentes colores a las lneas,
dependiendo si son instrucciones, macro-instrucciones, comentarios, cadenas de texto
(formato ASCII), directivas, etc.

Al terminar de digitar el cdigo salve el archivo usando como nombre su nmero de

carnet (8 caracteres) y con extensin ASM (ensamblador).

Presione el botn compile para convertir el archivo fuente (ASM) en ejecutable

(lenguaje de mquina), debe aclararse que al compilar solo se crea un archivo objeto
que no es ejecutable, se necesita de otro proceso, el enlazado (LINK), para lograr que
el archivo objeto se convierta en ejecutable (EXE), pero por facilidad el emulador
realiza los dos procesos de forma secuencial al presionar el botn compile.

Mientras se realiza la compilacin y enlazado se abre un ventana llamada assembler

status que le informa sobre los resultados del proceso. Si el resultado es exitoso
observar un mensaje como el de la Figura 5.

Figura 5. Estado del proceso de compilacin.

Luego se le pedir que salve el archivo EXE, por defecto se le asigna el mismo
nombre del archivo fuente, pero usted puede elegir otro, siempre de 8 caracteres
mximo, use el nombre por defecto, Si existe algn problema (error de sintaxis u otros)
en la ventana assembler status se le indican las lneas donde estn los errores, para
hacer las correcciones cierre la ventana assembler status y corrija el archivo fuente,
que se encuentra en el IDE e intente compilar nuevamente.

Volviendo al caso de no tener errores, la ventana assembler status le muestra

diferentes opciones como revisar algunos de los archivos complementarios que se
crearon en el proceso de compilacin y enlazado (opcin view), puede ejecutar el
archivo usando el programa DEBUG (opcin external). Esta es otra herramienta que se
estudiar ms adelante en el curso, puede ejecutar directamente el archive EXE (RUN)
o puede cerrar la ventana (close). Seleccione esta opcin.

Emule el archivo EXE presionando el botn emulate. Notar que se abren dos
ventanas: Una llamada emulator en la que podr monitorear la mayora de procesos
al ejecutar el programa y otra llamada original sourse code que muestra el cdigo
fuente del archivo, esta ventana es diferente de la que observa en el IDE porque en
sta podr observar cual instruccin esta a punto de ejecutarse, es ideal al corre
programas pasos a paso.

Ahora observe con ms detenimiento la ventana llamada emulator Figura 6, sta ser
la que ms utilice a la hora de ejecutar las prcticas de laboratorio, por lo que es
importante que la conozca y maneje de forma efectiva.

Figura 6. Ventana del Emulador.

En la parte superior tiene una barra de herramientas con las siguientes opciones:

File, permite administrar (cargar o salvar) los archivos que va creando o ejecutando
Math, da acceso a una calculadora y un convertidor de basas de numeracin.
Debug, provee herramientas para depurar programas.

View, permite abrir otras ventanas que pueden ser de mucha ayuda al ejecutar o
depurar programas.
External, permite ejecutar el programa con otras herramientas diferentes del
EMU8086.

Virtual devices, activa los dispositivos virtuales con que cuenta el programa, dado que
se trata de un emulador no se tiene acceso a los puertos fsicos de la computadora,
por lo que estos son simulados.

Virtual drive, da opciones para administrar las unidades virtuales de almacenamiento

(HDD y FDD virtuales).

Help, activa la herramienta de ayuda.

Bajo la barra de herramientas hay cinco botones que le permiten:

Load, carga un archivo ejecutable EXE, COM, etc. que ya existe.

Reload, recarga (inicializa los registros) para ejecutar nuevamente un programa que
acaba de ser corrido.

Single step, ejecuta solamente una instruccin o macroinstruccin (paso a paso).

Step back, retrocede una instruccin que ya fue ejecutada (funcin muy til al depurar
un programa)

Run, ejecuta un programa en su totalidad o hasta presionar el botn STOP.

Vale la pena hacer notar que tambin es posible, en la opcin DEBUG, insertar un
break point cuando se est depurando programas.

La parte media est dividida en tres partes:

Parte izquierda denominada registers, donde se puede monitorear el contenido de los

registros del microprocesador.

Parte central, donde se puede observar el contenido de la memoria desde donde se

est ejecutando el programa. Primero se notan las direcciones del bloque de memoria
que se visualiza, estas direcciones de dan en un formato llamado fsico o absoluto
(existe otro formato para las direcciones) dado por cinco cifras hexadecimales (20 bits)
lo que indica que en este bus de direcciones se puede direccional desde la
direccin00000h (direccin 0) hasta la direccinFFFFFh (direccin 148575). Luego se
indica el contenido de cada palabra (cada una de 1 byte), por facilidad el contenido se
presenta en hexadecimal, decimal e
interpretado como un carcter ASCII.

Parte derecha, donde puede observar el contenido de la memoria, pero esta vez no se
detalla con direcciones especficas, sino que cada bloque de datos es interpretado
como un conjunto de instrucciones (lo que llamaremos programa DESENSAMBLADO)
que el microprocesador deber ejecutar. Es importante mencionar que algunas
instrucciones se expresan solo con un byte, pero otras necesitan varios bytes para ser
expresadas

Parte inferior, contiene una serie de botones que permiten un acceso rpido a una
serie de ventanas auxiliares, algunas de las cuales se puede activar tambin en la
barra de herramientas con la opcin view
Regresando a la estructura del programa estudiemos el Segmento de Datos: Puede
observar que se hab declarado tres cadenas de datos llamadas frase, frase_2 y lnea;
note que luego del nombre de la cadena de ha incluido la directiva db (definir byte) que
indica al compilador que ese es el tipo de datos que contendr la cadena. A parte de
eso en las primeras dos cadenas se han usado comillas simples para definir el
contenido, eso indica al compilador que el texto debe ser interpretado como caracteres
ASCII. En el caso de la ltima cadena los datos no estn entre comillas, lo que indica
que sern interpretados como datos hexadecimales.
Para ejecutar el programa presione el botn RUN: note que automticamente se activo
la ventana emulator screen en la que se pueden observar dos textos impresos, que
corresponden la frase y frase_2. Vamos a estudiar ms detenidamente la ejecucin del
programa.
Cierre la ventana emulator screen

Prepare el programa para ser ejecutado nuevamente presionando el botn reload.

Observe la ventana original sourse code, parece que es una copia fiel del cdigo
fuente que digito en el IDE (en la Figura 7 puede ver una comparacin entre las dos
ventanas), pero la primera lnea de cdigo est marcada de color amarillo, esto indica
que es la primera que se ejecutar al correr el programa.

Figura 7. Comparacin entre las ventanas de edicin y cdigo fuente.

Si observe la ventana emulator (Figura 6), se ha marcado un bloque de bytes

almacenados en memoria, precisamente los de las direcciones fsicas 07120h, 07121h
y 07122h que contiene los datos B8h (que equivalea 184d y al carcter ASCII ), los
otros datos son 10h y 07h.
Los tres juntos equivalen, en lenguaje de mquina, a la MOV AX, @DATA, que ya
desensamblada se transforma en mov AX, 0710h, Aparece marcada porque ser la
primera en ejecutarse.
Un detalle importante es la sustitucin de la expresin @DATA por un valor numrico,
esta sustitucin es producto de la compilacin del cdigo fuente que sustituye las
etiquetas y nombres de variables por direcciones fsicas de memoria.

Presione el botn single step note que se ha avanzado una sola lnea, dado que se
ejecuta una nica instruccin, Tambin se han dado cambios en los registros del
microprocesador, pero stos se analizarn en la primera gua de laboratorio. Ejecute la
siguiente instruccin, de igual manera se avanz solo un paso.
Ahora la lnea marcada no es de color azul, sino negra, en este caso indica que se
trata de una Macroinstruccin, que contiene un conjunto completo de instrucciones que
se ejecutan en bloque.
La lgica de esta estructura tiene varias formas de utilizacin, en este caso se
asemejan a formas que ya aplic programando en alto nivel, invoca a una funcin
predefinida en una librera o biblioteca (printf o putchar) y para hacerlo, al inicio tiene
que colocar una sentencia #include.
Como su nombre lo indica la macroinstruccin imprime una cadena de texto en la pantalla.
Esta cadena se especifica pasndole un parmetro a la funcin, la palabra frase.
Presione nuevamente single step observe que en la ventana emulator si se ha
avanzado en original sourse code y no se avanzar hasta ejecutar todas las
instrucciones que conforman la macroinstruccin.
Presione tres veces single step se activar de forma automtica la ventana emulator
screen e imprimiendo el texto de la cadena frase, note que el signo de dlar $ final
no se ha impreso.
Presione nuevamente single step y se marca la siguiente macroinstruccin, que
imprimir la cadena lnea.
Esta cadena no se declarado de la misma forma que las otras, pero aun as se
imprime, un detalle importante es que al final de esta cadena se encuentra el dato 24h
que corresponde al cdigo ASCII del signo de dlar.
Presione cinco veces single step con esto ha bajado el cursor a la siguiente lnea,
como si hubiera presionado ENTER en un editor de texto.
Presione cinco veces single step para imprimir la cadena frase_2
Ahora aparece marcada una lnea de instruccin (recuerde el color azul). Analicemos
su estructura, La estructura sintctica de las lneas de instruccin est formada por
elementos llamados campos, dependiendo la instruccin especfica se puede tener
uno o varios campos.
Primer campo se le llama cdigo de operacin e indica que es lo deseamos que
realice el microprocesador, bsicamente nos referimos a la instruccin en misma.

Este no puede faltar en una lnea de instruccin

Segundo y tercer campo se les llama 1 operando y 2 operando campo. Si solo existe
el 1 operando indica que la instruccin se ejecutar ese dato (el dato en cuestin
puede declararse de forma explcita o estar almacenado en un registro del micro o en
alguna localidad de memoria). En caso de existir los dos operandos implica que el 2
operando es la fuente donde est el dato que se procesar y el 1 operando es el
destino donde se almacenar el resultado de ejecutar la instruccin.
Tomando como ejemplo la instruccin que en este momento est marcada:
MOV AX, 4C00h
Se entiende que MOV es el cdigo de operacin e indica que un dato se mover (en
realidad se copiar porque la fuente conservar el dato). Por tener tres campos en
esta lnea de instruccin el 1 operando es el destino donde se copiar el dato (en este
caso el registro Acumulador AX del microprocesador) y el 2 operando es el dato que
ser movido (en este caso el nmero hexadecimal 4C00h)
Ejecute la instruccin, note que efectivamente el dato se copi en el registro, lo que
puede verificar en la ventana emulator
La ltima lnea del cdigo usa la instruccin INT (de interrupcin) que es otra forma
particular de invocar una funcin definida previamente, en este caso para terminar el
programa y regresar el control del microprocesador al sistema operativo, de forma
similar a la sentencia return(0) que se usa en lenguaje C.
Para visualizar de forma ms clara el proceso para imprimir la cadena lnea edite en
el IDE el cdigo fuente, eliminando de el dato 0Dh. Luego de esto realice las acciones
listadas anteriormente para crear un nuevo archivo ejecutable.
Ejecute el programa paso a paso y note coma cambian los mensajes en la pantalla.
Cambie la cadena, pero ahora solo elimine el 0Ah verifique como afectan los cambios
en la ejecucin.
Cul es la funcin individual de los datos 0Ah y 0Dh en el programa?
Cul es la relacin de estos y el cdigo ASCII?
Para terminar este primer acercamiento con el EMU8086 es importante mostrarle una
de las ventanas ms tiles del emulador la ventana de variables, es muy similar a la
herramienta match del lenguaje C en la que usted poda monitorear el estado de las
variables declaradas a medida que el programa se va desarrollando.
Recargue el programa y cierre la venta emulator screen. Usando los botones de la
parte inferior del emulator active la ventana denominada var. Observar que estn

listadas las tres variables declaradas al inicio del archivo fuente como se muestra en la
Figura 8a.
Note que aparece marcada la variable frase e indica que su contenido es 48
hexadecimal (indicado por la casilla llamada show as), pero sabemos que esta
variable contiene ms datos, para poder verlos todos juntos, cambien el datos en la
casilla elements de 1 a 7, observar una serie de datos hexadecimales. Puede
cambiar la representacin a datos ASCII cambiando la opcin en la casilla show as y
verificar que efectivamente es el contenido de la cadena frase, Figura 8b. Si durante
la ejecucin del programa el contenido de la cadena cambia en esta ventana podr
observarlo.
Marque la segunda variable llamada frase_2 observe la informacin, se le indica que
el contiene el dato 53h, cambie la representacin de datos a ASCII y la cantidad de
elementos de 1 a 8, debera observas la misma informacin que ve en la Figura 8c.
Ahora marque la tercera variable lnea, el contenido es 0Ah, cambie a representacin
ASCII y 3 elementos, debera observas la misma informacin que ve en la Figura 8d.
Bueno con estas ideas bsicas podr iniciar el estudio de la programacin en lenguaje
ensamblador apoyndose en los recursos que le brinda el EMU8086, adelante

Figura 8. Ventana auxiliar para monitorear el contenido de las variables declaradas

1. Escribir un programa en ensamblador que muestre un

mensaje por pantalla mediante interrupciones:

2.
3. ;----------------------------------------------------------------------------4. ;Definicion del segmento de datos
5. ;----------------------------------------------------------------------------6. DATOS SEGMENT
7.
8.
saludo db "Hola mundo!!!","$"
9.
10. DATOS ENDS
11.
12. ;----------------------------------------------------------------------------13. ;Definicion del segmento de codigo
14. ;----------------------------------------------------------------------------15. CODE SEGMENT
16.
assume cs:code,ds:datos
17.
18. START PROC
19.
mov ax,datos
;
20.
mov ds,ax
;Inicializar
21.
22.
mov dx,offset saludo
;Cargar la direccion del saludo
23.
mov
ah,9
;Opcion que va a servir a la
interrupcion 21h para
24.
;indicar que debe mostrar por
pantalla el offset
25.
;que hay en DX hasta que encuentre el
caracter '$'
26.
int 21h
;Interrupcion que lo mostrara por
pantalla
27.
28.
mov ax,4C00h
;
29.
int 21h
;Terminar el programa
30.
31. START ENDP
32.
33. CODE ENDS
34.
END START

35.

36.
Escribir un programa en ensamblador que muestre
un mensaje por pantalla accediendo a la memoria de
video (0B800h):
37.
38. ;----------------------------------------------------------------------------39. ;Definicion del segmento de datos
40. ;----------------------------------------------------------------------------41. DATOS SEGMENT
42.
saludo db "Hola mundo!!!"
43. DATOS ENDS
44.
45. ;----------------------------------------------------------------------------46. ;Definicion del segmento de pila
47. ;----------------------------------------------------------------------------48. PILA SEGMENT STACK "STACK"
49.
DB 40 DUP(0)
50. PILA ENDS

51.
52. ;----------------------------------------------------------------------------53. ;Definicion del segmento extra
54. ;----------------------------------------------------------------------------55. EXTRA SEGMENT
56.
RESULT DW 0,0
57. EXTRA ENDS
58.
59. ;----------------------------------------------------------------------------60. ;Definicion del segmento de codigo
61. ;----------------------------------------------------------------------------62. CODE SEGMENT
63.
assume cs:code,ds:datos,es:extra,ss:pila
64.
65. START PROC
66.
;Inicializamos los registros de segmento
67.
mov ax,datos
68.
mov ds,ax
69.
mov ax,pila
70.
mov ss,ax
71.
mov ax,extra
72.
mov es,ax
73.
;Fin de las inicializaciones
74.
75.
;Limpiamos la pantalla
76.
mov ax,0B800h
;En esta direccion comienza la memoria de
video
77.
mov es,ax
;Lo cargamos en el segmento extra
78.
xor di,di
;Ponemos DI=0. Esto equivale a mov di,0,
pero
79.
;xor di,di consume 3 ciclos de reloj y con
mov 4
80.
mov cx,80*25
;El tamao total es 2000 (80 lineas x 25
columnas)
81.
82. b_clear:
;Bucle que se encargara de recorrer los
2000
83.
;caracteres de la pantalla para limpiarla
84.
mov
al,20h
;20h=" "
Rellenar la pantalla con
espacios
85.
mov ah,1bh
;Fondo azul, letras blancas
86.
mov es:[di],ax
87.
inc di
88.
inc di
89.
loop b_clear
90.
91.
mov ax,0B800h
92.
mov es,ax
93.
mov si,offset saludo
94.
mov di,(80*7+17)*2 ;Linea 7, caracter 18
95.
mov cx,13
96.
97. b_saludo:
;Bucle que se encargara de recorrer los
2000
98.
;caracteres de la pantalla para limpiarla
99.
mov al,[si]
100.
mov ah,1bh
;Fondo azul, letras blancas
101.
mov es:[di],ax
102.
inc si
;Pasamos a apuntar a la siguiente
letra del saludo
103.
inc di
104.
inc di
105.
loop b_saludo
106.

107.
108.
109.
110.
111.
112.
113.
114.

mov
int

ax,4C00h
21h

;
;Terminar el programa

START ENDP
CODE ENDS
END START

115.

116.
Programa que calcula el factorial de 3 y lo muestra
por pantalla:
117.
118.
;----------------------------------------------------------------------------119.
;Definicion del segmento de datos
120.
;----------------------------------------------------------------------------121.
DATOS SEGMENT
122.
123.
dato
db 3 ;Numero del que calcularemos su factorial
124.
125.
DATOS ENDS
126.
127.
;----------------------------------------------------------------------------128.
;Definicion del segmento de pila
129.
;----------------------------------------------------------------------------130.
PILA SEGMENT STACK "STACK"
131.
db 40h dup(0)
132.
PILA ENDS
133.
134.
;----------------------------------------------------------------------------135.
;Definicion del segmento extra
136.
;----------------------------------------------------------------------------137.
EXTRA SEGMENT
138.
result
dw 0,0
;2 palabras (4 bytes)
139.
EXTRA ENDS
140.
141.
;----------------------------------------------------------------------------142.
;Definicion del segmento de codigo
143.
;----------------------------------------------------------------------------144.
CODE SEGMENT
145.
assume CS:code,DS:datos,ES:extra,SS:pila
146.
147.
factorial db 0
;Variable para guardar el
factorial
148.
149.
START PROC
150.
151.
call inicializar
;Inicializa los registros de
segmento
152.
mov sp,64
;Carga el puntero de pila con
el valor mas alto
153.
154.
mov cl,dato
155.
call calcula_factorial
;Calcula el faltorial de dato
156.
mov
factorial,al
;Almacenar el resultado en
factorial
157.
call muestra_factorial
;Muestra el valor del factorial

158.
159.
mov ax,4C00h
;
160.
int 21h
;Terminar el programa
161.
162.
163.
START ENDP
164.
165.
;----------------------------------------------------------------------------166.
; inicializar
167.
;
168.
; in:
169.
; out:
Los registros de segmento quedan inicializados
170.
; machaca: AX, DS, SS, ES
171.
; make:
Inicializa los registros de segmento
172.
;
173.
;----------------------------------------------------------------------------174.
inicializar proc near
175.
176.
mov ax,datos
177.
mov ds,ax
178.
mov ax,pila
179.
mov ss,ax
180.
mov ax,extra
181.
mov es,ax
182.
183.
ret
184.
185.
inicializar endp
186.
187.
;----------------------------------------------------------------------------188.
; calcula_factorial
189.
;
190.
; in:
CL contiene el dato
191.
; out:
Devuelve en AX el resultado de calcular el
factorial
192.
; machaca: AX, CX
193.
; make:
Inicializa los registros de segmento y el puntero
de pila
194.
;
195.
;----------------------------------------------------------------------------196.
calcula_factorial proc near
197.
198.
mov ax,1
199.
xor ch,ch
200.
cmp cx,0
;Si el numero es 0
201.
je
fin
;terminamos
202.
203.
factor:
204.
mul cx
205.
dec cx
206.
jne factor
207.
208.
fin:
209.
ret
210.
211.
calcula_factorial endp
212.
213.
;----------------------------------------------------------------------------214.
; muestra_nombre
215.
;
216.
; in: nombre contiene el nombre de usuario que se ha
introducido
217.
; out:

218.
; machaca: DI, SI
219.
; make:
Muestra el valor del factorial por pantalla
220.
;
221.
;----------------------------------------------------------------------------222.
muestra_factorial proc near
223.
224.
push ax
225.
push cx
226.
push es
227.
228.
mov ax,0B800h
229.
mov es,ax
;Apuntar a la memoria de video
230.
mov dl,factorial
231.
mov di,(80*12+31)*2
;Linea 12, columna 31
232.
add dl,30h
;Obtener el valor en ASCII
('0'=30h)
233.
mov dh,1bh
234.
mov es:[di],dx
235.
236.
pop es
237.
pop cx
238.
pop ax
239.
240.
ret
241.
242.
muestra_factorial endp
243.
244.
CODE ENDS
END START
;----------------------------------------------------------------------------;Definicion del segmento de pila
;----------------------------------------------------------------------------PILA SEGMENT STACK "STACK"
db
40h dup(0)
PILA ENDS
;----------------------------------------------------------------------------;Definicion del segmento de codigo
;----------------------------------------------------------------------------CODE SEGMENT
assume CS:code, SS:pila
START:
mov
neg

al,8
al

mov
int

ax,4C00h
21h

CODE ENDS
END START

;Convertir a su complemento a 2

1. Otra forma de convertir a complemento a 2 mediante las

instrucciones NOT e INC:
2.
3. ;----------------------------------------------------------------------------4. ;Definicion del segmento de pila
5. ;----------------------------------------------------------------------------6. PILA SEGMENT STACK "STACK"
7.
db
40h dup(0)
8. PILA ENDS
9.
10. ;----------------------------------------------------------------------------11. ;Definicion del segmento de codigo
12. ;----------------------------------------------------------------------------13. CODE SEGMENT
14.
assume CS:code, SS:pila
15.
16. START:
17.
18.
mov al,8
19.
not al
;
20.
inc al
;Convertir a su complemento a 2
21.
22.
mov ax,4C00h
23.
int 21h
24.
25. CODE ENDS
END START

Ejemplos en assembler

Ejemplos introductorios assembler(Download PDF):En este archivo se

encontrara la suma de nmeros mediante asignacin de datos a los
registros, tambin nos ensea como mostrar por pantalla un carcter ASCII y hacer
un bucle repetitivo todo esto se realiza en el DEBUG de windows.
Realizado en EMU8086 v4.08

Ejemplo 1: Mostrar su nombre en pantalla mediante interrupciones

org 100h ;Todo lo escrito despues de " ; " son comentarios
;escribir su nombre en pantalla
jmp inicio ;salto incondicional a una etiqueta
nombre db "Jorge Arce$";Para este caso el nombre tiene que terminar con $
inicio: ;etiqueta
mov ah,9 ;con esto le digo a la interrupcion que escriba en pantalla
mov dx,offset nombre ;con esto le indico la direccion del texto
int 21h ;invoco a la interrupcion para escribir en pantalla
int 20h ;invoco interrupcion para termina el programa
ret
Ejemplo 2: Mostrar su nombre en pantalla mediante el acceso a la memoria del video en modo texto
org 100h
;escribir su nombre en pantalla accediendo a la memoria del video
jmp inicio
nombre db "Jorge Arce";Guardo en una variable mi nombre
inicio: ;etiqueta para saltos de memoria
mov dx,0b800h ;guardo la direccion del video en dx
mov es,dx ;direcciono el video al segmento extra
mov cx,10 ;guardo en cx la cantidad de caracteres de la variable nombre
mov si,0 ;inicializo la posicion del primer caracter
mov di,offset nombre ;direcciono en "di" la direccion inicial de nombre
bucle: ;etiqueta para el bucle o ciclo repetitivo
mov al,[di] ;direcciono en "al" el siguiente caracter de nombre
es:mov byte ptr[si],al ;muestro en pantalla el caracter en posicion "si"
add si,2 ;desplazo la posicion de puntero para seguir escribiendo
inc di ;incremento en 1 a "di" y paso al siguiente caracter
loop bucle ;regresa a bucle y resta cx en 1 hasta que cx sea igual a 0
int 20h ;invoco interrupcion para termina el programa
ret
Ejecucin de los dos programas anteriores