;Programa HOLA MUNDODATOSSEGMENT MENSAJE DB "HOLA MUNDO$"DATOSENDS

PILASEGMENT STACK "STACK" DB 200 DUP(0)PILAENDS

CODIGOSEGMENT ASSUME CS:CODIGO,DS:DATOS,SS:PILAPRINCIPALPROCMOV AX,DATOSMOV DS,AXMOV AH,9MOV DX,OFFSET MENSAJEINT 21HMOV AH,4CHINT 21HPRINCIPALENDPCODIGO ENDSEND 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,datosmov ds,ax mov ax,num1 add ax,num2 mov num3,ax mov dx,num3 mov ax, 4C00H int 21Hempieza endpcodigo endsend 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 40Hdatos ends

codigo segment para "code"empieza proc farassume cs: codigo, ds: datos, ss: pilamov ax,datosmov ds,ax

mov al,varmov dl,almov ah,2int 21not alinc al

mov dl,almov ah,2int 21empieza endpcodigo endsend 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,29DATOS ENDS

CODIGO SEGMENT PARA "CODE"

ASSUME CS:CODIGO,DS:DATOS.SS:PILA

EMPIEZA PROC FAR

MOV AX,DATOSMOV DS,AXMOV BX,OFFSET TABLAMOV CX,8ETA:ADD AL,15INC BXLOOP ETAMOV AX,4C00HINT 21H

EMPIEZA ENDPCODIGO ENDSEND EMPIEZA

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

Saber si un numero es mayor:name "mayor"

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

;CX el valor ms grande entre AX Y BX ;AX-BX mayor a 0sub AX,BXjs A_MENOR_Bmov CX,AXjmp FINA_MENOR_B:mov CX,BXFIN:

;mov AX,DXret

Emulador EMU808610:21Programacion2 ComentariosEl 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 deusuariomuy amistosa que permite familiarizarse con los fundamentos de la programacin en lenguaje ensamblador de forma muy intuitiva, aparte de eso brinda unaseriede 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 elarchivosEMU886.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 lapantalladeBienvenida (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 queLlamaremos Cdigo Fuente y tendr extensin .ASM)

Code examples: Le permite acceder a una serie de programas ejemplos quepueden ayudarle a comprender funciones ms complejas.

Quick star tutor : activa un conjunto de documentos de ayuda, se recomiendarevisarlos 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 unanueva 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 dearchivoque 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 IntegradoIDEdel 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 lenguajeEnsamblador. 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), Macro-instrucciones (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 dememoriadonde 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 ejecutandoMath, 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 delEMU8086.

Virtual devices, activa losdispositivosvirtuales 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 einterpretado 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 viewRegresando 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 screenPrepare 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_2Ahora 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 instruccinSegundo 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, 4C00hSe 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 emulatorLa 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 cambiosen 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 datos5. ;------------------------------------------------------------------------------6. DATOS SEGMENT7. 8. saludo db "Hola mundo!!!","$"9. 10. DATOS ENDS11. 12. ;------------------------------------------------------------------------------13. ;Definicion del segmento de codigo14. ;------------------------------------------------------------------------------15. CODE SEGMENT16. assume cs:code,ds:datos17. 18. START PROC19. mov ax,datos ;20. mov ds,ax ;Inicializar21. 22. mov dx,offset saludo ;Cargar la direccion del saludo23. mov ah,9 ;Opcion que va a servir a la interrupcion 21h para24. ;indicar que debe mostrar por pantalla el offset25. ;que hay en DX hasta que encuentre el caracter '$'26. int 21h ;Interrupcion que lo mostrara por pantalla27. 28. mov ax,4C00h ;29. int 21h ;Terminar el programa30. 31. START ENDP32. 33. CODE ENDS34. END START35. 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 datos40. ;------------------------------------------------------------------------------41. DATOS SEGMENT42. saludo db "Hola mundo!!!"43. DATOS ENDS44. 45. ;------------------------------------------------------------------------------46. ;Definicion del segmento de pila47. ;------------------------------------------------------------------------------48. PILA SEGMENT STACK "STACK"49. DB 40 DUP(0)50. PILA ENDS51. 52. ;------------------------------------------------------------------------------53. ;Definicion del segmento extra54. ;------------------------------------------------------------------------------55. EXTRA SEGMENT56. RESULT DW 0,057. EXTRA ENDS58. 59. ;------------------------------------------------------------------------------60. ;Definicion del segmento de codigo61. ;------------------------------------------------------------------------------62. CODE SEGMENT63. assume cs:code,ds:datos,es:extra,ss:pila64. 65. START PROC66. ;Inicializamos los registros de segmento67. mov ax,datos68. mov ds,ax69. mov ax,pila70. mov ss,ax71. mov ax,extra72. mov es,ax73. ;Fin de las inicializaciones74. 75. ;Limpiamos la pantalla76. mov ax,0B800h ;En esta direccion comienza la memoria de video77. mov es,ax ;Lo cargamos en el segmento extra78. xor di,di ;Ponemos DI=0. Esto equivale a mov di,0, pero79. ;xor di,di consume 3 ciclos de reloj y con mov 480. 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 200083. ;caracteres de la pantalla para limpiarla84. mov al,20h ;20h=" " Rellenar la pantalla con espacios85. mov ah,1bh ;Fondo azul, letras blancas86. mov es:[di],ax87. inc di88. inc di89. loop b_clear90. 91. mov ax,0B800h92. mov es,ax93. mov si,offset saludo94. mov di,(80*7+17)*2 ;Linea 7, caracter 1895. mov cx,1396. 97. b_saludo: ;Bucle que se encargara de recorrer los 200098. ;caracteres de la pantalla para limpiarla99. mov al,[si]100. mov ah,1bh ;Fondo azul, letras blancas101. mov es:[di],ax102. inc si ;Pasamos a apuntar a la siguiente letra del saludo103. inc di104. inc di105. loop b_saludo106. 107. 108. mov ax,4C00h ;109. int 21h ;Terminar el programa110. 111. START ENDP112. 113. CODE ENDS114. END START115. 116. Programa que calcula el factorial de 3 y lo muestra por pantalla:117. 118. ;------------------------------------------------------------------------------119. ;Definicion del segmento de datos120. ;------------------------------------------------------------------------------121. DATOS SEGMENT122. 123. dato db 3 ;Numero del que calcularemos su factorial124. 125. DATOS ENDS126. 127. ;------------------------------------------------------------------------------128. ;Definicion del segmento de pila129. ;------------------------------------------------------------------------------130. PILA SEGMENT STACK "STACK"131. db 40h dup(0)132. PILA ENDS133. 134. ;------------------------------------------------------------------------------135. ;Definicion del segmento extra136. ;------------------------------------------------------------------------------137. EXTRA SEGMENT138. result dw 0,0 ;2 palabras (4 bytes)139. EXTRA ENDS140. 141. ;------------------------------------------------------------------------------142. ;Definicion del segmento de codigo143. ;------------------------------------------------------------------------------144. CODE SEGMENT145. assume CS:code,DS:datos,ES:extra,SS:pila146. 147. factorial db 0 ;Variable para guardar el factorial148. 149. START PROC150. 151. call inicializar ;Inicializa los registros de segmento152. mov sp,64 ;Carga el puntero de pila con el valor mas alto153. 154. mov cl,dato155. call calcula_factorial ;Calcula el faltorial de dato156. mov factorial,al ;Almacenar el resultado en factorial157. call muestra_factorial ;Muestra el valor del factorial158. 159. mov ax,4C00h ;160. int 21h ;Terminar el programa161. 162. 163. START ENDP164. 165. ;------------------------------------------------------------------------------166. ; inicializar167. ;168. ; in:169. ; out: Los registros de segmento quedan inicializados170. ; machaca: AX, DS, SS, ES171. ; make: Inicializa los registros de segmento172. ;173. ;------------------------------------------------------------------------------174. inicializar proc near175. 176. mov ax,datos177. mov ds,ax178. mov ax,pila179. mov ss,ax180. mov ax,extra181. mov es,ax182. 183. ret184. 185. inicializar endp186. 187. ;------------------------------------------------------------------------------188. ; calcula_factorial189. ;190. ; in: CL contiene el dato191. ; out: Devuelve en AX el resultado de calcular el factorial192. ; machaca: AX, CX193. ; make: Inicializa los registros de segmento y el puntero de pila194. ;195. ;------------------------------------------------------------------------------196. calcula_factorial proc near197. 198. mov ax,1199. xor ch,ch200. cmp cx,0 ;Si el numero es 0201. je fin ;terminamos202. 203. factor:204. mul cx205. dec cx206. jne factor207. 208. fin:209. ret210. 211. calcula_factorial endp212. 213. ;------------------------------------------------------------------------------214. ; muestra_nombre215. ;216. ; in: nombre contiene el nombre de usuario que se ha introducido217. ; out:218. ; machaca: DI, SI219. ; make: Muestra el valor del factorial por pantalla220. ;221. ;------------------------------------------------------------------------------222. muestra_factorial proc near223. 224. push ax225. push cx226. push es227. 228. mov ax,0B800h229. mov es,ax ;Apuntar a la memoria de video230. mov dl,factorial231. mov di,(80*12+31)*2 ;Linea 12, columna 31232. add dl,30h ;Obtener el valor en ASCII ('0'=30h)233. mov dh,1bh 234. mov es:[di],dx235. 236. pop es237. pop cx238. pop ax239. 240. ret241. 242. muestra_factorial endp243. 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 al,8 neg al ;Convertir a su complemento a 2

mov ax,4C00h int 21h

CODE ENDS END START

1. Otra forma de convertir a complemento a 2 mediante las instrucciones NOT e INC:2. 3. ;------------------------------------------------------------------------------4. ;Definicion del segmento de pila5. ;------------------------------------------------------------------------------6. PILA SEGMENT STACK "STACK"7. db 40h dup(0)8. PILA ENDS9. 10. ;------------------------------------------------------------------------------11. ;Definicion del segmento de codigo12. ;------------------------------------------------------------------------------13. CODE SEGMENT14. assume CS:code, SS:pila15. 16. START:17. 18. mov al,8 19. not al ;20. inc al ;Convertir a su complemento a 221. 22. mov ax,4C00h23. int 21h24. 25. CODE ENDS END START

Ejemplos en assembler Ejemplos introductorios assembler(Download PDF):En este archivo se encontrara la suma denmerosmedianteasignacinde datos a los registros,tambinnos ensea como mostrar por pantalla uncarcterASCII y hacer un bucle repetitivo todo esto se realiza en el DEBUG de windows.Realizado en EMU8086 v4.08Ejemplo 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