Soluciones Electrónicas Integradas BYM S.R.

GUIA PRACTICA Nº 2

1. Título: LENGUAJE ASSEMBLER

2. Objetivos
§ Conocer los requerimientos básicos para codificar un programa en lenguaje ensamblador y
definir sus elementos de datos.
§ Conocer y familiarizarse con el entorno de desarrollo de programas en Lenguaje Assembler
mediante el uso y manejo de un Ensamblador (Turbo Assembler) y un depurador (Turbo
Debugger).
§ Entender el funcionamiento básico de los Procedimientos o Subrutinas y las Macros.
§ Desarrollar programas (.EXE y .COM) empleando llamadas a funciones del DOS y BIOS.

3. Materiales
§ Computadora personal.
§ Set de instrucciones del Microprocesador INTEL 8086.

4. Fundamento teórico

4.1 Estructura de un programa ensamblador

Un programa fuente en ensamblador contiene dos tipos de sentencias : las instrucciones y las
directivas. Las instrucciones se aplican en tiempo de ejecución, pero las directivas sólo son
utilizadas durante el ensamblaje.

a) Formato de una sentencia de instrucción:

[etiqueta] nombre_instrucción [operandos] ;[comentarios]

Los corchetes, como es normal al explicar instrucciones en informática, indican que lo

especificado entre ellos es opcional, dependiendo de la situación que se trate.
Campo de etiqueta: Es el nombre simbólico de la primera posición de una instrucción,
puntero o dato. Consta de hasta 31 caracteres que pueden ser las letras de la A a la Z, los
números del 0 al 9 y algunos caracteres especiales como “@”, “_”, “.” y “$”. Reglas:

Ø Si se utiliza el punto “.”, éste no debe colocarse como primer carácter de la etiqueta. El
primer carácter tampoco puede ser un dígito.
Ø No se pueden utilizar los nombres de instrucciones o registros como nombres de
etiquetas.
Ø Las etiquetas son de tipo NEAR cuando el campo de etiqueta finaliza con dos puntos (:),
quiere esto decir que la llamada está dentro del mismo segmento de código (llamadas
intrasegmento) y el procesador sólo carga el puntero de instrucciones IP.
Ø Las etiquetas son de tipo FAR si el campo de etiqueta no termina con los dos puntos (:).
En estas etiquetas la instrucción a la que apunta no se encuentra en el mismo segmento
de código sino en otro. Cuando es referenciada en una transferencia de control se carga el
puntero de instrucciones IP y el segmento de código CS (llamadas intersegmento).

Ing. Javier Barriga Hoyle 1

 Soluciones Electrónicas Integradas BYM S.R.L

Campo de nombre: Contiene el mnemónico de las instrucciones (Ej. MOV, ADD, etc) o
bien una directiva (Ej. EQU, DB, DW, etc) de las que veremos más adelante.
Campo de operandos: Indica cuales son los datos implicados en la operación. Puede haber
0, 1 ó 2; en el caso de que sean dos al 1º se le llama destino y al 2º (separado por una coma)
fuente.
MOV AX, [DI] ; AX à destino y [DI] à origen o fuente

Campo de comentarios: Cuando en una línea hay un punto y coma (;) todo lo que sigue en
la línea es un comentario, resulta de gran utilidad para realizar futuras modificaciones al
mismo. Ejemplo:
; Programa que calcula el promedio aritmético de 20 datos de un Byte
ADD AH, [BX] ; Suma al registro AH el contenido de BX

b) Formato de las DIRECTIVAS.

La sintaxis de una sentencia directiva es muy similar a la de una sentencia de instrucción:
[nombre] nombre_directiva [operandos] ; [comentario]

Sólo es obligatorio el campo «nombre_directiva»; los campos han de estar separados por al
menos un espacio en blanco. La sintaxis de «nombre» es análoga a la de la «etiqueta» de las
líneas de instrucciones. El campo de comentario cumple también las mismas normas.

Directivas de definición de datos:

Ø DB (define byte), DW (define palabra), DD (define doble palabra), DQ (define cuádruple

palabra), DT (define 10 bytes): Sirven para declarar las variables, asignándolas un valor
inicial. Ejemplo:
dato DW 2000
mes DB 08
numero DD 12345678h

Con el operando DUP pueden definirse estructuras repetitivas. Por ejemplo, para asignar
100 bytes a cero y 25 palabras de contenido indefinido (no importa lo que el ensamblador
asigne):
ceros DB 100 DUP (0)
matriz DW 25 DUP (?)

Se admiten también los anidamientos. El siguiente ejemplo crea una tabla de bytes donde
se repite 50 veces la secuencia 1,2,3,7,7:
tabla DB 50 DUP (1, 2, 3, 2 DUP (7))

Directivas de definición de símbolos:

Ø EQU (EQUivalence): Asigna el valor de una expresión a un nombre simbólico fijo:

olimpiadas EQU 1992

Donde olimpiadas ya no podrá cambiar de valor en todo el programa.

Ø = (signo '='): Asigna el valor de la expresión a un nombre simbólico variable: Análogo al

anterior pero con posibilidad de cambiar en el futuro. Muy usada en macros (sobre todo
con REPT).
num = 19

Ing. Javier Barriga Hoyle 2

 Soluciones Electrónicas Integradas BYM S.R.L

Directivas de control del ensamblador:

Ø ORG (ORiGin): Puede usarse esta directiva para cambiar el contenido del contador de
localidades de un segmento de datos o código. En los programas COM (que se cargan en
memoria con un OFFSET 100h) es necesario colocar al principio un ORG 100h, y un
ORG 0 en los controladores de dispositivo (aunque si se omite se asume de hecho un
ORG 0).

Ø END [expresión]: indica el final del fichero fuente. Si se incluye, expresión indica el
punto donde arranca el programa. Puede omitirse en los programas EXE si éstos constan
de un sólo módulo. En los COM es preciso indicarla y, además, la expresión (realmente
una etiqueta) debe estar inmediatamente después del ORG 100h.

4.2 Procedimientos o Subrutinas

Un procedimiento o subrutina es una sección de código que realiza una tarea definida y clara (tal
como posicionar cursor o leer un carácter del teclado). Estos procedimientos usados dentro de los
programas proporcionan los siguientes beneficios:
§ Reduce la cantidad de código, ya que un procedimiento común puede ser llamado desde
cualquier lugar dentro del segmento de código.
§ Facilita la depuración del programa, ya que los errores pueden ser aislados con mayor
claridad.
§ Ayuda en el mantenimiento progresivo de programas, ya que los procedimientos son
identificados de forma rápida para su modificación.
Los procedimientos pueden ser considerados como NEAR (llamada intrasegmento) o FAR
(llamada intersegmento), guardando en la pila el valor de IP en el primer caso, o CS e IP en el
segundo caso (ver figuras 1 y 2).

Segmento de código

Al saltar, el uP sólo
CALL DELAY guarda IP en la pila
Continua el
programa

Inicio del
DELAY PROC NEAR procedimiento

Retorna y recupera
IP de la pila RET
DELAY ENDP
Figura 1. Procedimiento NEAR

Segmento de código Segmento de código

Guarda en la
piila CS e IP
DELAY PROC FAR
CALL DELAY
Retorna y RET
recupera CS DELAY ENDP
e IP de la pila

Figura 2. Procedimiento FAR

Ing. Javier Barriga Hoyle 3

 Soluciones Electrónicas Integradas BYM S.R.L

Formato de un Procedimiento

Para escribir un procedimiento o subrutina se sigue los siguientes pasos, considerando que los
nombres no deben ser de las instrucciones ni de las directivas del ensamblador.
Su formato sería:
Nombre PROC [atributo] ; Comienza procedimiento
PUSH AX ; Atributo puede ser NEAR o FAR
PUSH BX ; Se salvan los registros a usarse
......
;-------------------------------------------------------------------------------------------
; programa a ejecutar
;-------------------------------------------------------------------------------------------
......
POP BX
POP AX ; Se recuperan los registros
RET
Nombre ENDP

Ejemplo 1: Escribir un procedimiento de retardo DELAY de “t” segundos.

Delay PROC NEAR ; Comienza procedimiento

PUSH CX ; Se salva el valor de CX0

MOV CX, 0FFFFh

L2: PUSH CX ; Se salva el valor de CX1
MOV CX, 1000h
L1: LOOP L1
POP CX ; Se recupera el valor de CX1
LOOP L2

POP CX ; Se recupera el valor de CX0

RET
Delay ENDP

Ejemplo 2: Escribir un procedimiento de borrar pantalla.

Clrscr PROC NEAR ; Comienza procedimiento

PUSH AX ; Se salva los registros
PUSH BX
PUSH CX
PUSH DX
MOV CX, 0 ; Inicio esquina superior de pantalla
MOV DX, 2479h ; Inicio esquina inferior de pantalla
MOV BH, 7 ; Atributo de pantalla (normal)
MOV AX, 0600h ; Parámetros de interrupción
INT 10h ; Llamada interrupción
POP DX ; Se recuperan los registros
POP CX
POP BX
POP AX
RET
Clrscr ENDP

Ing. Javier Barriga Hoyle 4

 Soluciones Electrónicas Integradas BYM S.R.L

4.3 Macros
Una “macro” es un conjunto de instrucciones en ensamblador que pueden aparecer varias veces
en un programa con algunas modificaciones cada vez que se usan. Las macros son útiles para los
siguientes propósitos:
§ Simplificar y reducir la cantidad de codificación repetitiva.
§ Reducir errores causados por la codificación repetitiva.
§ Linealizar un programa en lenguaje ensamblador para hacerlo más legible.
La macro se define por medio de la directiva MACRO. Es necesario definir la macro antes de
utilizarla. Una macro puede llamar a otra macro. Con frecuencia, las macros se colocan juntas en
un fichero independiente y luego se mezclan en el programa principal con la directiva INCLUDE:

INCLUDE LIB_MAC.MAC ; Librería de Macros

Formato de una Macro

Conviene hacer hincapié en que la definición de la macro no consume memoria, por lo que en la
práctica es indiferente declarar cientos que ninguna macro.
Su formato es:

nombre_simbólico MACRO [parámetros] ; Inicio de la Macro

----- ; Instrucciones de la Macro
-----
-----
ENDM ; Fin de la Macro

El nombre_simbólico es el que permitirá en adelante hacer referencia a la macro, y se construye

casi con las mismas reglas que los nombres de las variables y demás símbolos. La macro puede
contener parámetros de manera opcional. A continuación vienen las instrucciones que engloba y,
finalmente, la directiva ENDM señala el final de la macro.

Ejemplo 1: Escribir una Macro que sume 2 cantidades y retorne un resultado.

SUMAR MACRO a,b,total ; Inicio de la macro

PUSH AX
MOV AX, a ; AX ß a
ADD AX, b ; AX ß AX + b
MOV total, AX ; total ß AX
POP AX
ENDM ; Fin de la Macro

Ejemplo 2: Escribir una Macro que compare 2 números y retorne como resultado el menor

MINIMO MACRO p, q, menor ; Inicio de la Macro

LOCAL salto ; Etiqueta local para la Macro
MOV AX, p ; AX ß p
CMP AX, q ; ¿Es p el menor?
JB salto ; Sí
MOV AX, q ; No, es q
salto: MOV menor, AX ; menor ß AX
ENDM ; Fin de la Macro

La directiva LOCAL dentro de la Macro, permite definir etiquetas propias de la macro y que
pueden tener inclusive el mismo nombre que las etiquetas dentro del programa principal.

Ing. Javier Barriga Hoyle 5

 Soluciones Electrónicas Integradas BYM S.R.L

Directiva útil para macros

Esta directiva pueden ser empleada también sin las macros, aumentando la comodidad de la
programación, aunque abundan especialmente dentro de las macros.

Ø REPT veces ... ENDM (Repeat)

Permite repetir cierto número de veces una secuencia de instrucciones. El bloque de
instrucciones se delimita con ENDM (no confundirlo con el final de una macro).
Ejemplo 3: Escriba una macro que imprima en pantalla el valor obtenido de la siguiente
ecuación: y = (X * 5 / 255) con una aproximación a 4 decimales (X tamaño de un Byte).

Ecuacion Macro X ; Inicio la Macro con parámetro X

PUSH BX ; Salvo registros útiles en la pila
PUSH DX
MOV AL, X ; AL ß X
MOV AH, 0 ; AX = dato a imprimir.
MOV BX, 5 ; BX ß 5
MUL BX ; DX:AX ß AX * BX
MOV DX, 0 ; DX ß 0 (solo nos quedamos con AX)
MOV BX, 255 ; BX ß 255
DIV BX ; DX(residuo):AX(cociente) ß AX / BX
WRITEINT ; Macro que imprime en pantalla el
; valor de AX (valor entero)
PRINT "." ; Macro que imprime en pantalla el “.”
; Número de cifras decimales a imprimir
REPT 4 ; Repite 4 veces estas instrucciones
MOV AX, DX ; AX ß DX (asigna a AX el residuo DX)
MOV DX, 10 ; DX ß 10
MUL DX ; DX:AX ß AX * DX ,(residuo por 10)
DIV BX ; DX:AX ß AX / BX ,(AX / 255)
WRITEINT ; Imprime en pantalla el valor de AX
ENDM ; Retorna a rept hasta 4 veces
POP DX ; Recupera registros de la pila
POP BX
ENDM ; Fin de la Macro

4.4 Formatos de programas en ensamblador tipo .EXE y .COM

Antes de que el COMMAND.COM pase el control al programa que se pretende ejecutar, se crea
un bloque de 256 bytes llamado PSP (Program Segment Prefix). La dirección del PSP en los
programas COM viene determinada por la de cualquier registro de segmento (CS=DS=ES=SS)
nada más al comenzar la ejecución del mismo. Sin embargo, en los programas de tipo EXE el
cargador del DOS inicializa los registros CS:IP y SS:SP, pero no los registros DS y ES; en
consecuencia se tiene que inicializar el DS con la direc ción del segmento de datos. Cuando el
programa toma el control, DS y ES apuntan al PSP. Tipos de programas:
En los de tipo EXE:
Ø CS e IP toman los valores del punto de arranque del programa (directiva END etiqueta).
Ø SS apunta al segmento de pila y SP = tamaño de la pila definida.
En los de tipo COM:
Ø CS apunta al PSP e IP = 100h (el programa empieza tras el PSP).
Ø SS apunta al PSP y SP toma la dirección más alta dentro del segmento del PSP.

Ing. Javier Barriga Hoyle 6

 Soluciones Electrónicas Integradas BYM S.R.L

Programa tipo EXE:

JUMPS ; Para saltos largos 16 bits (opcional)

INCLUDE Lib_Gen.MAC ; Incluye librería de Macros (opcional)
;---------------------------------------------------------------------
.MODEL SMALL
.STACK 64h ; Se define la pila de 100 bytes
.DATA ; Se define el segmento de datos
;---------------------------------------------------------------------
...... ; Area de definición de datos
......
......
;---------------------------------------------------------------------
.CODE ; Se define el segmento de código
MAIN PROC FAR ; Inicio del procedimiento MAIN
MOV AX, @data ; AX ß dirección del segmento de datos
MOV DS, AX ; Almacena dirección en DS
;---------------------------------------------------------------------
...... ; Instrucciones del programa (inicio)
......
...... ; Instrucciones del programa (fin)

MOV AH, 4Ch ; Petición de salida al DOS

INT 21h ; Llama a la interrupción
MAIN ENDP ; Fin del procedimiento MAIN
END MAIN ; Fin del programa

Programa tipo COM:

JUMPS ; Para saltos largos 16 bits (opcional)

INCLUDE Lib_Gen.MAC ; Incluye librería de Macros (opcional)
;---------------------------------------------------------------------
.MODEL TINY
.CODE ; Se define segmento de código
ORG 100H ; Inicio al final de PSP
BEGIN: JMP MAIN ; Salto pasando los datos si lo hubiera
;---------------------------------------------------------------------
...... ; Area de definición de datos
......
......
;---------------------------------------------------------------------
MAIN PROC NEAR
;---------------------------------------------------------------------
...... ; Instrucciones del programa (inicio)
......
...... ; Instrucciones del programa (fin)

INT 20h ; Interrupción de salida al DOS

MAIN ENDP ; Fin del procedimiento
END BEGIN ; Fin del programa

4.5 Creación de un Archivo Ejecutable

Para crear un archivo ejecutable, a partir de un código en lenguaje de ensamblaje, deberá seguir
los siguientes pasos:

Ø Utilice un editor de textos (por ejemplo EDIT del DOS o NOTEPAD de Windows) para
escribir el programa y grábelo con extensión “.ASM”.

Ing. Javier Barriga Hoyle 7

 Soluciones Electrónicas Integradas BYM S.R.L

Ø Luego deberá ensamblar su programa de la siguiente manera:

TASM Nombre_Archivo,,,

Si hubo error en la compilación, edite y corrija su código fuente y repita el paso anterior.
De los contrario se habrá creado un archivo con extensión “.OBJ”, el cual deberá enlazar
para generar el ejecutable:
TLINK Nombre_Archivo ; Para un programa .EXE
TLINK /t Nombre_Archivo ; Para un programa .COM

Ø Si no hubo error en este comando se habrá creado un archivo ejecutable (extensión

“.EXE” o “.COM”). Luego ejecute su programa y compruebe su correcto
funcionamiento.

Editor: Crea Crea un programa fuente

Prog.ASM en ensamblador (.ASM)
Editor

Prog.ASM

Teclado Ensambla el programa

Ensamble fuente, crea un programa
objeto (.OBJ)

Ensamblador
Prog.OBJ

Opcional
Prog.LST Enlaza el programa
Enlace objeto, crea un programa
Prog.CRT ejecutable (.EXE)

Enlazador Prog.EXE

Carga y ejecuta el
Ejecuta programa .EXE

Creación de un archivo BATCH:

Un archivo BATCH (extensión “.BAT”) es un archivo de texto que contiene un conjunto de

comandos del DOS, que se ejecutan al llamar el archivo creado desde el prompt del DOS.
Son muy útiles de usar porque pueden realizar todos los pasos anteriores con un solo
comando y de esta manera crear su ejecutable más rápidamente. Para ello utilice el editor de
textos y escriba las siguientes líneas y guárdelo con un nombre con extensión .BAT (Por ejemplo,
COMPI.BAT)

Ing. Javier Barriga Hoyle 8

 Soluciones Electrónicas Integradas BYM S.R.L

COMPI.BAT

ECHO OFF
CLS
ECHO ENSAMBLANDO %1
TASM –zi %1,,,
IF ERRORLEVEL 1 GOTO ERROR
ECHO ENLAZANDO %1 ...
TLINK –v %1 %2
ECHO ...
GOTO FIN
:ERROR
ECHO ERROR NO ENSAMBLADO - ABORTADO
:FIN

Uso del Turbo Debugger

Una herramienta útil para el desarrollo de programas es el Turbo Debugger (TD.EXE) pues
permite hacer un seguimiento a la ejecución del programa.
TD Nombre_Archivo (enter)

Al ejecutar el Turbo Debugger aparecerá una ventana con el listado del programa cargado, luego
presione ALT-V y seleccione las ventanas que UD desea observar durante la ejecución del
programa. Por ejemplo:

Ø ALT-V-R: Puede ver los registros y los flags del CPU.

Ø ALT-V-D: Puede ver la memoria de datos con su dirección, contenido en hexadecimal y
código ASCII.

Con estas opciones UD puede ejecutar el programa paso a paso y hacer el seguimiento respectivo .
Si su programa incluye MACROS y/o PROCEDIMIENTOS, éstas se ejecutarán como si tratara
de una instrucción más del microprocesador.
Ahora si UD desea analizar internamente cada una de ellas ejecutándolo paso a paso, haga lo
siguiente:
Ø ALT-V-C: Obtiene una ventana con cinco secciones (Usar TAB para moverse entre cada
sección y las flechas dentro de cada sección).
4 Segmento de código: Mostrando las direcciones, códigos hexadecimales e instrucciones del
programa cargado.
4 Registros: Los cuales se pueden ver y modificar directamente.
4 CPU flags: Para modificarlos utilizar CTRL-T para cambiar de 1 a 0 o viceversa.
4 Segmento de pila: Mostrando la dirección, contenido de la pila y la posición actual del stack
pointer.
4 Segmento de datos: mostrando la dirección, contenido y código ASCII del segmento de
datos.
Para iniciar la ejecución y/o depuración del programa utilizar:

Ø RUN (F9): Ejecuta el programa completo.

Ø TRACE (F7): Ejecuta el programa instrucción por instrucción.
Ø STEP (F8): Igual que trace, pero no entra a las subrutinas (las ejecuta completamente).
Ø PROGRAM RESET (CTRL-F2): Posiciona el cursor de ejecución del programa al inicio
de éste.
Ø USER SCREEN (ALT-F5): Visualiza la pantalla del usuario (del DOS en este caso).
Herramientas adicionales:

Ing. Javier Barriga Hoyle 9

 Soluciones Electrónicas Integradas BYM S.R.L

Ø BREAKPOINTS: Para programas extensos, no es práctico correr el programa paso a

paso, lo que se suele hacer es añadir un breakpoint, es decir, un punto donde el Debugger
se detendrá y permitirá entre otras cosas ver el estado de los registros, continuar con la
ejecución (paso a paso o rápida), etc. Para la inserción de un breakpoint, colocar el cursor
(barra azul) sobre la instrucción donde se quiere que el Debugger se detenga y presionar
F2 (pulsando F2 nuevamente se quita el breakpoint); apareciendo una barra roja sobre la
instrucción. Se pueden añadir la cantidad de breakpoints que se deseen.
Ø WATCHES: Permite ver el estado de una variable durante la ejecución de un programa
pudiendo ser ésta una etiqueta, posición de memoria e inclusive un registro. Para añadir
un watch presionar CTRL-F7 y escribir el nombre de la variable a visualizar.

Para obtener mayor información sobre el uso de esta herramienta puede hacer uso del Help que viene
dentro del entorno integrado.

5. Procedimiento
Cargue el edit del DOS o el bloc de notas de Windows y escriba los siguientes ejemplos.

5.1 Programa 1:
Escriba un programa que imprima los siguientes mensajes en pantalla: “Hola, bienvenido al
Lenguaje Ensamblador” y “Qué fácil es este lenguaje!!!”.

Modelo .EXE

; **********************************************************************
; G2_E1A.ASM (Tipo EXE)
; Este programa muestra algunas características de un programa en
; Lenguaje Assembler imprimiendo en pantalla 2 mensajes de texto.
; **********************************************************************
CR EQU 13 ; Retorno de carro
LF EQU 10 ; Fin de línea

.Model Small
.Stack 64h ; reserva 100 bytes en la pila
.Data ; inicia segmento de datos
;-----------------------------------------------------------------------
texto1 DB ‘Hola, bienvenidos al Lenguaje Assembler’,LF,CR,‘$’
texto2 DB ‘Que facil es este Lenguaje!!!’,LF,CR,’$’
;-----------------------------------------------------------------------
.Code
MAIN PROC FAR
MOV AX, @Data ; Inicializa segmento de datos
MOV DS, AX ; para que apunte a mi segmento “Data”

LEA DX, texto1 ; DX ß dirección de texto1 (offset)

MOV AH, 09H ; AH ß 09h (función de imprimir)
INT 21H ; Llama a la interrupción

LEA DX, texto2 ; DX ß dirección de texto1 (offset)

MOV AH, 09H ; AH ß 09h (función de imprimir)
INT 21H ; Llama a la interrupción

MOV AH, 4CH ; Función para salir al DOS

INT 21H ; Llama a la interrupción
MAIN ENDP ; Fin del procedimiento
END MAIN ; Fin del programa

Ing. Javier Barriga Hoyle 10

 Soluciones Electrónicas Integradas BYM S.R.L

Modelo .COM

; **********************************************************************
; G2_E1B.ASM (Tipo COM)
; Este programa muestra algunas características de un programa en
; Lenguaje Assembler imprimiendo en pantalla 2 mensajes de texto.
; **********************************************************************
CR EQU 13 ; Retorno de carro
LF EQU 10 ; Fin de línea

.Model Tiny
.Code ; Inicia segmento de código
ORG 100H ; Inicio al final de PSP
BEGIN: JMP MAIN ; Salto pasando los datos si lo hubiera
;-----------------------------------------------------------------------
texto1 DB ‘Hola, bienvenidos al Lenguaje Assembler’,LF,CR,‘$’
texto2 DB ‘Que facil es este Lenguaje!!!’,LF,CR,’$’
;-----------------------------------------------------------------------

MAIN PROC NEAR

LEA DX, texto1 ; DX ß dirección de texto1 (offset)

MOV AH, 09H ; AH ß 09h (función de imprimir)
INT 21H ; Llama a la interrupción

LEA DX, texto2 ; DX ß dirección de texto1 (offset)

MOV AH, 09H ; AH ß 09h (función de imprimir)
INT 21H ; Llama a la interrupción

INT 20H ; Llama a la interrupción para salir al DOS

MAIN ENDP ; Fin del procedimiento
END BEGIN ; Fin del programa

Para convertirlo a ejecutable siga los siguientes pasos:

C:\Asembler\tasm G2_E1B,,, ; Si no hay errores se crea el archivo OBJ
C:\Asembler\tlink /t G2_E1B ; Se crea el archivo G2_E1B.COM
C:\Asembler\G2_E1B ; Se ejecuta

Compare ahora el tamaño de ambos ejecutables (.EXE y .COM), deberá salir como sigue:
G2_E1A EXE 1.226 ; Ocupa 1226 bytes en memoria
G2_E1B COM 93 ; Ocupa 93 bytes en memoria

5.2 Programa 2: (De aquí en adelante todos los programas serán tipo EXE)
Escriba el mismo programa anterior (G2_E1A.ASM), pero ahora usando la librería de macros.

; *********************************************************************************
; G2_E2A.ASM
; Este programa muestra algunas características de un programa en Lenguaje
; Assembler imprimiendo en pantalla 2 mensajes de texto. USO DE MACROS
; *********************************************************************************
JUMPS
INCLUDE LIB_GEN.MAC ; Incluye librería de Macros

.Model Small
.Stack 64h ; reserva 100 bytes en la pila
.Data ; Segmento de datos (no hay datos)
.Code
MAIN PROC FAR

Ing. Javier Barriga Hoyle 11

 Soluciones Electrónicas Integradas BYM S.R.L

MOV AX, @Data ; Inicializa segmento de datos

MOV DS, AX ; para que apunte a mi segmento “Data”

PRINT ‘Hola, bienvenidos al Lenguaje Assembler’

NL ; Salto de línea
PRINT ‘Que facil es este Lenguaje!!!’

MOV AH, 4CH ; Función para salir al DOS

INT 21H ; Llama a la interrupción
MAIN ENDP ; Fin del procedimiento
END MAIN ; Fin de programa

5.3 Programa 3: Programa que emplea Macros y Procedimientos tipo NEAR

; *********************************************************************************
; G2_E3A.ASM
; Este programa muestra como usar los Macros y procedimientos tipo NEAR
; realizando diversas acciones como borrar pantalla, etc.
; *********************************************************************************
JUMPS
INCLUDE LIB_GEN.MAC

.Model Small
.Stack 64h ; reserva 100 bytes en la pila
.Data ; Segmento de datos (no hay datos)
.Code
MAIN PROC FAR
MOV AX, @Data ; Inicializa segmento de datos
MOV DS, AX ; Para que apunte a mi segmento "Data"

CALL borra ; Procedimiento que borra pantalla

PCURSOR 0,0 ; Macro que posiciona cursor (fila,columna)
CALL parpachar ; Imprime carácter parpadeante
PCURSOR 3,25 ; Fila=3, Columna=25
PRINT 'ARQUITECTURA DE COMPUTADORAS' ; Macro
PCURSOR 6,0 ; Fila=6, Columna=0
CALL parpachar ; Imprime carácter parpadeante

MOV AH, 4CH ; Función para salir al DOS

INT 21H ; Llama a la interrupción
MAIN ENDP ; Fin del procedimiento

;----------------------------------------------------------------------------------
borra PROC NEAR ; Procedimiento que borra pantalla
MOV AX, 0600H ; Recorrer toda la pantalla
MOV BH, 07H ; Atributo fondo blanco, letra blanca
MOV CX, 0000 ; Posición superior izquierda
MOV DX, 184FH ; Posición inferior derecha
INT 10H
RET
borra ENDP

parpachar PROC NEAR ; Procedimiento parpadeante

MOV AH, 09H ; Petición de despliegue
MOV AL, '*' ; Carácter a imprimir
MOV BH, 0 ; Página 0
MOV BL, 8EH ; Fondo negro, letra amarilla
MOV CX, 79 ; Número de caracteres
INT 10H
RET
parpachar ENDP
;----------------------------------------------------------------------------------
END MAIN ; Fin de programa

Ing. Javier Barriga Hoyle 12

 Soluciones Electrónicas Integradas BYM S.R.L

5.4 Programa 4: Programa que emplea Macros y Procedimientos tipo NEAR y FAR.

; *********************************************************************************
; G2_E4A.ASM
; Este programa muestra como usar los Macros y procedimientos tipo NEAR y FAR
; realizando diversas acciones como borrar pantalla, etc.
; Los procedimientos están en una librería de procedimientos LIBPROC.ASM
; *********************************************************************************
JUMPS
INCLUDE LIB_GEN.MAC

extrn borra:far, delay_1:far ; Procedimientos externos

LF EQU 10
CR EQU 13

.Model Small
.Stack 64h ; reserva 100 bytes en la pila
.Data ; Segmento de datos (no hay datos)
;----------------------------------------------------------------------------------
texto DB ‘PROGRAMA QUE ILUSTRA LOS PROCEDIMIENTOS FAR’,LF,CR,’$’
;---------------------------------------------------------------------------------
.Code
MAIN PROC FAR
MOV AX, @Data ; Inicializa segmento de datos
MOV DS, AX ; Para que apunte a mi segmento "Data"

CALL borra ; Procedimiento que borra pantalla

PCURSOR 0,0 ; Macro que posiciona cursor (fila,columna)
CALL parpachar ; Imprime carácter parpadeante
PCURSOR 13,0 ; Fila=20, Columna=0
CALL parpachar ; Imprime carácter parpadeante
PCURSOR 3,18 ; Fila=3, Columna=18
LEA DX, texto ; Imprime texto
MOV AH, 9
INT 21H

PCURSOR 6,25 ; Fila=6, Columna=25

PRINT 'ARQUITECTURA DE COMPUTADORAS' ; Macro

MOV AX, 0 ; Inicializa cuenta a cero

repite: PCURSOR 10,38
WRITEINT ; Macro que imprime número de AX en pantalla
CALL DELAY_1 ; Espera 1 segundo aproximado
ADD AX, 01 ; Suma 1 a registro AX
CMP AX, 50 ; ¿es 50?, salir
JE fin ; SI, salta a salir
JMP repite ; NO, regresa a repite

fin: PCURSOR 16,0

MOV AH, 4CH ; Función para salir al DOS
INT 21H ; Llama a la interrupción
MAIN ENDP ; Fin del procedimiento

;----------------------------------------------------------------------------------
parpachar PROC NEAR ; Procedimiento parpadeante
MOV AH, 09H ; Petición de despliegue
MOV AL, '*' ; Carácter a imprimir
MOV BH, 0 ; Página 0
MOV BL, 8EH ; Fondo negro, letra amarilla
MOV CX, 79 ; Número de caracteres
INT 10H
RET
parpachar ENDP
;----------------------------------------------------------------------------------
END MAIN ; Fin de programa

Ing. Javier Barriga Hoyle 13

 Soluciones Electrónicas Integradas BYM S.R.L

Librería de procedimientos: LIBPROC.ASM

;************************************************************************
; Librería de procedimientos
;************************************************************************
.MODEL SMALL
.STACK 64H
.CODE
MAIN PROC FAR
PUBLIC BORRA, DELAY_1 ;Se declaran públicos todos los procedimientos

BORRA PROC FAR ; Procedimiento que borra pantalla

MOV AX, 0600H ; Recorrer toda la pantalla
MOV BH, 07H ; Atributo fondo blanco, letra blanca
MOV CX, 0000 ; Posición superior izquierda
MOV DX, 184FH ; Posición inferior derecha
INT 10H
RET
BORRA ENDP

DELAY_1 PROC FAR ; Retardo de tiempo 1 seg aproximado

PUSH CX ; Guarda registro CX (CX0)
MOV CX, 250
p1: PUSH CX ; Guarda nuevamente CX (CX1)
MOV CX, 0FFFFH ; CX = 65535 (CX2)
p2: LOOP p2 ; Decrementa CX2 hasta llegar a cero
POP CX ; Recupera CX (CX1)
LOOP p1 ; Decrementa CX1 hasta llegar a cero DEC
DX ; Si cero, decrementa DX
POP CX ; Recupera CX (CX0)
RET ; Retorna
DELAY_1 ENDP

MAIN ENDP ; Fin del procedimiento MAIN

END MAIN ; Fin de programa

;**********************************************************************************

Para convertirlo a ejecutable siga los siguientes pasos:

C:\Asembler\tasm G2_E4A,,, ; Si no hay errores se crea el archivo OBJ
C:\Asembler\tasm LIBPROC ; Se crea el archivo Libproc.OBJ
C:\Asembler\tlink G2_E4A + LIBPROC ; Se enlazan ambos archivos OBJ y crea
; el archivo ejecutable G2_E4A.EXE

5.5 Programa 5: Aplicación diversa

;**********************************************************************************
; G2_E5A.ASM
; Este programa encuentra y muestra en pantalla todos los números primos menores a
; un número ingresado por el teclado.
;**********************************************************************************
JUMPS
INCLUDE LIB_GEN.MAC ; Librería de MACROS

.Model small
.Stack 64H
.Data ; Segmento de datos
EsPrimo DB 0
Nmax DW 0
.Code
MAIN PROC FAR
MOV AX, @Data
MOV DS, AX ; Inicializo DS

Ing. Javier Barriga Hoyle 14

 Soluciones Electrónicas Integradas BYM S.R.L

PRINT "PROGRAMA EN LENGUAJE ASSEMBLER" ; Macro

NL ; Macro
PRINT "LISTADO DE NUMEROS PRIMOS MENORES O IGUALES A :" ; Macro
READINT ; Macro
NL ; Macro
PRINT "Primos :" ; Macro
MOV NMax, AX ; Guarda el valor ingresado
MOV AX,1
Otro: CMP AX, NMax
JBE Llama ; Verifica los números (< o =) que NMax
JMP FinProc
Llama: CALL TestPrimo ; Rutina que verifica si AX es primo
CMP EsPrimo, 1
JNE NoImpre
PRINT " " ; Muestra al numero primo
WRITEINT ; Imprime en pantalla el valor de AX
NoImpre:
INC AX
JMP Otro
FinProc:
MOV AH, 4CH
INT 21H
MIAN ENDP

;**********************************************************************************
; Procedimiento que verifica si un numero es primo o no.
; Entrada : AX -> Numero a Verificar
; Salida : EsPrimo : 0 -> No es primo ; 1 -> Si es primo
;**********************************************************************************

TestPrimo PROC NEAR

PUSH BX
PUSH DX
MOV EsPrimo, 0 ; Se asume que no es primo hasta probar lo
; contrario
MOV BX, 2 ; Primer divisor
Sigue: CMP AX, BX
JBE EsPr ; Si el residuo nunca fue cero -> Es Primo
PUSH AX
MOV DX, 0
DIV BX ; Divide DX:AX / BX ( 1 < BX < AX )
POP AX
CMP DX, 0 ; Compara el Residuo con Cero
JE NoEs ; Si el residuo es cero -> No Es Primo
INC BX
JMP Sigue
EsPr: MOV EsPrimo, 1 ; Se asigna valor adecuado
NoEs: POP DX
POP BX
RET
TestPrimo ENDP ; Finaliza la subrutina “TestPrimo”
END MAIN

6. Bibliografía
BREY, Barry (Capítulos 7)
2001 Los Microprocesadores Intel: 8086/8088, 80186, 80286, 80386 y 80486.
Arquitectura, programación e interfaces. 5ta Edición. Ed. Prentice may
(621.3981 BREY)

ABEL, Peter (Capítulos 4, 5, 7 , 22 y 23)

1996 Lenguaje ensamblador y programación para IBM PC. 3ra Edición. Prentice Hall
(005.136 ABEL)

Ing. Javier Barriga Hoyle 15