r. hinojosa - arquitectura de microprocesadores i

Arquitectura de Procesadores I Ing. Ral Hinojosa

Descripcin del Lenguaje Ensamblador

Los programas fuente escritos utilizan un formato para su escritura.

El formato que utiliza INTEL, divide cada lnea del lenguaje ensamblador en los siguientes

campos:

ETIQUETA COD. DE OP. OPERANDO COMENTARIOS

El campo de etiqueta es opcional y representa el nombre de la lnea.

Generalmente las lneas que son el destino de salto o bifurcaciones tendrn entradas

en el campo de etiqueta.

El campo de cdigo de Operacin, contiene el nemotcnico del cdigo de operacin

de la instruccin que se va a ejecutar.

El campo de operando, da el dato con el que se va a operar el cdigo de operacin

especificado. El campo de operando, a veces se denomina argumento.

El campo de comentarios puede contener informacin til para explicar la funcin de

la instruccin . Los comentarios son opcionales, pero su uso documenta el programa.

Ejemplo:

DATA MOV A, M ; ENTRAR DATO AL ACUMULADOR

1. Etiqueta: Contiene la entrada DATA. Este es el de esta lnea.

Probablemente es el destino de una instruccin de bifurcacin posterior o anterior.

2. Cdigo de operacin. Contiene la entrada MOV, esta dice a la CPU que es una

instruccin de transferencia de datos. La CPU entonces busca el siguiente campo de

operando para encontrar la fuente y destino de la transferencia del dato.

3. Campo de operando. Contiene la entrada A, es (acumulador) el destino del dato

mientras que la memoria M es la fuente. La posicin esta indicada por el registro par

HL de esta instruccin de registro directo.

1


4. Campo comentario. Contiene la entrada , este

campo describe que ocurre cuando se ejecuta la instruccin. En este caso, el dato es

introducido en el acumulador desde una posicin de MEM sealada por el registro

par HL. El punto y coma (;) se utiliza como delimitador para separar el campo del

operando del campo de comentario.

Escritura de un Programa en Assembler

Los puntos para desarrollar un programa pueden resumirse como sigue:

1. Definir y analizar el problema.

2. Dibujar el diagrama de flujo de la solucin del problema.

3. Escribir el programa en lenguaje ensamblador

4. Generar la versin en lenguaje maquina del programa

5. Depurar el programa

6. Documentar el programa.

Procedimientos para crear un programa en ensamblador

Son varios los procedimientos que pueden seguir en la creacin de un programa en

ensamblador, uno de ellos puede ser como se indica.

1. Se elige un editor de textos sin formato ( Edit del D.O.S. por ejemplo, con el Word

pero se graba como TEXTO modo D.O.S.)

2. Se crea un archivo con con una extensin ASM.

Ejem1.asm

3. Se escribe en el archivo todo el programa en formato ensamblador y posteriormente

se graba con el mismo nombre.

4. Se copia el archivo creado (ejem1.asm) en la carpeta BIN del programa MASM.

2


5. Se ensambla el programa de la siguiente manera.

C:\MASM

C:\MASM ejem1.asm

Al ejecutarse el MASM, esta va a ensamblar el cdigo fuente y generar el cdigo

objeto.

6. Si la compilacin fue realizada sin problemas, se tendr un mensaje como el

siguiente:

Mircrosoft Compatibility Driver

Copyright Microsoft Corp 1984 1992. All rights reserved

Invoking: ML.exe /I. /Zm /c /Ta ejem1.asm

Microsoft macro Assembler Versin 6.10

Invoking: ML.exe /I. /Zm /c /Ta ejemplo.asm


Assembling: ejem1.asm

7. En el siguiente paso, se hace el enlace con las libreras internas y se crea el archivo

ejecutable, de la siguiente manera:

C:\MASM\BIN> LINK ejem1

El linker se encarga de asignar localidades de memoria absolutas para relocalizar al

cdigo objeto. Tambin permite el desarrollo de cdigos modulares ya que con l es

posible cambiar mdulos individuales y para producir un programa completo.

8. Si al crear el enlace no hubo problemas, se tendr un mensaje como el siguiente:

3


Mircrosoft Segmented Executable Linker Versin 5.31.009 Jul 13 1992


Run File [ejem1.exe]:

List File [nul.map]:

Libraries [.lib]:

Definitions Files [nul.def]:

9. De esta manera se ha creado un archivo ejecutable con extensin EXE, el cual

ejecutar el programa que se escribio.

10. Despus que se tiene el programa se puede emplear el DEBUG.

Este programa es til durante la fase de desarrollo de programas. Tiene caractersticas

que permiten al usuario ejecutar, por ejemplo un programa paso a paso y examinar

dinmicamente como cambia la memoria, tambin permite observar las banderas y la

ejecucin del programa desde un punto determinado (break point) monitorenado los

registros.

Emplee DEBUG /? Para ver los comandos adicionales que se pueden escribir

11. El MASM, tiene incorporado un programa PWB.exe que permite tambien hacer el

seguimiento de un programa al igual que el DEBUG. Ejecute el programa PWB y abra un

archivo, y emplee la barra del menu para ejecutar el programa seleccionado (ejem1.asm)

El siguiente es el programa ejem1.asm, escrito en forma de texto sin formato: ;************************************************************************ ; Objetivo : Desplegar una cadena ;************************************************************************

4


; COMANDO DE ENSAMBLE : MASM EJEM1; ; COMANDO DE ENLACE : LINK EJEM1; ; COMANDO DE EJECUCION : EJEM1 [Enter] ;************************************************************************ ; ; Define el modelo de memoria ; CODE SEGMENT PUBLIC 'CODE' ORG 100H ASSUME CS:CODE, ES:CODE, DS:CODE, SS:CODE Empieza: ; Etiqueta de comienzo de programa Jmp Codigo Mensaje Db 'BIENVENIDOS AL LENGUAJE ENSAMBLADOR !!!!!.$' Codigo: mov Dx, offset Mensaje ; Direccion de Mensaje mov Ah, 9 ; en Dx para poder desplegarlo Int 21h ; a traves de la Int 21 de MS-DOS. mov ax,4c00h ; Regresa a MS-DOS por medio de la int 21h ; funcion 4c. CODE ENDS END Empieza ; Fin del programa Al compilarlo y enlazarlo dar un mensaje en la pantalla de: BIENVENIDOS AL LENGUAJE ENSAMBLADOR !!!!!. ............................. Escribir cada uno de los ejemplos proporcionados y estudiarlos para ver su funcionamiento. Ejem2.asm Ejem3.asm Ejem4.asm Ejem5.asm Ejemplo 2 ;************************************************************************* ; Objetivo : Programa sin DIRECTIVAS SIMPLIFICADAS ;*************************************************************************

5


; COMANDO DE ENSAMBLE : MASM EJEM2.ASM; ; COMANDO DE ENLACE : LINK EJEM2; ; COMANDO DE EJECUCION : EJEM2 [Enter] ;************************************************************************* ;-------------------------------------------------------------------------- ; La siguiente linea especifica el segmento que contendra ; el bloque codigo. ;-------------------------------------------------------------------------- CODE SEGMENT PUBLIC 'CODE' ; Segmento de codigo ;-------------------------------------------------------------------------- ; La siguiente linea le indica al ensamblador el nombre del ; segmento que cada registro de segmentos debe direccionar. ;-------------------------------------------------------------------------- ASSUME CS:CODE, DS:CODE, ES:CODE, SS:STACK ; Empieza el codigo. Empieza: Mov Ax, 4C00h Int 21h ;-------------------------------------------------------------------------- ; La siguiente linea le indica al ensamblador que termina ; el segmento de codigo 'CODE'. ;-------------------------------------------------------------------------- CODE ENDS ;-------------------------------------------------------------------------- ; El segmento STACK es el rea que usar la pila . ;-------------------------------------------------------------------------- STACK SEGMENT PARA STACK 'STACK' Dw 64 DUP (?) STACK ENDS ;-------------------------------------------------------------------------- ; Se cierra el bloque de codigo. Es decir, termina el programa. ;-------------------------------------------------------------------------- END Empieza

6


Ejemplo 03 ;************************************************************************* ; Objetivo : Despliega el titulo del programa y los numeros ; hexadecimales correspondientes del 15 al 1 en ; forma de escalera. ;************************************************************************* ; COMANDO DE ENSAMBLE : Masm EJEM3; ; COMANDO DE ENLACE : Link EJEM3; ; COMANDO DE EJECUCION : EJEM3 [Enter] ;************************************************************************* ; -------------------------------------------------------------------- ; INICIA EL PROGRAMA. SE DEFINE EL MODELO DE MEMORIA A USAR Y EL ; SEGMENTO DE CODIGO ; -------------------------------------------------------------------- .MODEL SMALL ; Modelo de memoria .CODE ; Area de codigo Empieza: ; Etiqueta de comienzo de programa Mov Ax, @Data ; Permite el acceso a los datos inicializando Mov Ds, Ax ; el registro DS con la direccion adecuada. Mov Dx, OFFSET Mensaje ; Carga la direccion de mensaje a DX para Mov Ah, 9 ; poder desplegarlo con la funcion 9 de la Int 21h ; Int 21h (DS:DX contiene la direccion de ; la cadena que se desplegar ). Mov Cx, 15 ; Contador de los numeros (van a ser 15). Mov Bx, OFFSET Tabla ; Permite el acceso a la tabla de equivalencias ; hexadecimales inicializando su direccion

; y apuntando al primer elemento. Itera: ; Etiqueta controladora de las iteraciones Mov Al, Cl ; Pone en Al el numero a traducir Xlat ; (empezando desde 15) y lo traduce. Mov Dl, Al ; Prepara para desplegar el numero usando la Mov Ah, 2 ; funcion 2 de la Int 21h. Dl debe de tener Int 21h ; el caracter a ser desplegado. Mov Dl, 10 ; Salta una linea dando un efecto de Int 21h ; escalera. De nuevo se usa la funcion 2. Loop Itera ; Itera hasta llegar a 0 (de 15 a 0). El

; registro CX mantiene una cuenta activa de ; las veces que se ha iterado, y al completar ; un ciclo se decrementa en uno hasta llegar ; a cero. Mov ax,4c00h ; Regresa a MS-DOS por medio de la funcion

7


; 4c de la interrupcion 21h. int 21h ; El codigo de regreso es 0 porque no hubo ; error. En caso de existir se podria pasar

; un codigo diferente a 0 (ej. 4c01h). ; -------------------------------------------------------------------- ; INICIA SEGMENTO DE DATOS ; -------------------------------------------------------------------- .DATA ; Segmento de datos Mensaje DB 13,10,13,10 DB 'Desplegando los numeros hexadecimales del 15 al 1' DB 13,10,13,10,'$' ; Cadena a desplegar Tabla DB '0123456789ABCDEF'; Tabla de traduccion ; -------------------------------------------------------------------- ; INICIA SEGMENTO DE PILA ; -------------------------------------------------------------------- .STACK ; Se necesita una PILA. END Empieza ; Fin del programa Ejemplo 04 ;************************************************************************* ; Objetivo : Captura dos cadenas y las compara, reportando si ; son iguales o no. La cantidad de caracteres a ; comparar esta dada por los caracteres realmente ; leidos de la cadena 1. Es decir, para que se ; consideren iguales, las dos cadenas deben ser de ; la misma longitud. El programa distingue entre ; mayusculas y minusculas. La "A" es diferente de "a". ; Con un poco m s de creatividad, este programa se ; puede ampliar para que busque una cadena dentro de ; otra y reporte si existe o no. ;************************************************************************* ; COMANDO DE ENSAMBLE : Masm EJEM4; ; COMANDO DE ENLACE : Link EJEM4; ; COMANDO DE EJECUCION : EJEM4 [Enter] ;************************************************************************* ; ; NOTA : procure usar SOLO las instrucciones que se han visto o explicado. ; El procedimiento (objetivo) es con fines educativos y NO de ; optimizacin o eficiencia. Por favor, NO SE DESESPERE y estdielo. ;*************************************************************************

8


; Define el modelo de memoria .MODEL SMALL .Data Cadena1 DB 15,0,15 DUP(?) ; Variable que almacena cadena 1 Cadena2 DB 15,0,15 DUP(?) ; Variable que almacena cadena 2 Mensaje DB 'Bienvenidos al EJEM4.' DB ' Programa ejemplo que compara' DB ' dos cadenas y reporta si son iguales o no.' DB ' Para terminar digite FIN en maysculas.' DB 13,10,'$' Error DB 7,7,7,13,10,'ERROR : cadenas son DIFERENTES !!!.' DB 13,10,13,10,'$' Error1 DB 7,7,7,13,10,'ERROR : cadena no puede ser NULA !!!.' DB 13,10,13,10,'$' Final DB 'FIN' TodoBIEN DB 7,7,7,13,10,'Cadenas son IGUALES.' DB 13,10,13,10,'$' CadUnoM DB 13,10,13,10,'Digite primera CADENA: $' CadDosM DB 13,10,13,10,'Digite Segunda CADENA: $' .CODE ; Area de cdigo Empieza: ; Etiqueta de comienzo de programa ;------------------------------------------------------------------------------ ; BORRA LA PANTALLA CAMBIANDO LA MODALIDAD DE VIDEO. ESTA FORMA DE BORRAR ; LA PANTALLA ES MUY PECULIAR Y ES CONSIDERADA COMO UN "TRUCO". SE BASA EN ; EL HECHO DE QUE AL CAMBIAR LA MODALIDAD DE VIDEO, EL PROPIO BIOS ; (HARDWARE) BORRA LA PANTALLA POR NOSOTROS. ES UN METODO BURDO PERO MUY ; EFICIENTE. ;------------------------------------------------------------------------------ Mov Ah, 0Fh ; Obtiene modalidad de video actual Int 10h Mov Ah, 0 ; Cambia a la modalidad de video que se obtuvo Int 10h mov Ax,@Data ; Inicializa DS con la direccin de @Data mov Ds, Ax

9


mov Dx, Offset Mensaje ; Despliega el mensaje de bienvenida Mov Ah, 9 Int 21h Push Ds Pop Es ; ES = DS ;------------------------------------------------------------------------------ ; SE CAPTURAN LAS CADENAS Y SE GUARDAN EN SUS RESPECTIVAS VARIABLES PARA ; PODER TRABAJAR CON ELLAS MAS ADELANTE. LA CAPTURA SE BASA EN LA FUNCION ; 09 DE LA INT 21H. DICHA FUNCION ESTABLECE QUE EL REGISTRO AH CONTENGA 09 ; Y EL REGISTRO PAR DS:DX APUNTE A LA DIRECCION DE LA VARIABLE QUE ; ALMACENARA LA ESTRUCTURA DEL BUFFER. ESTE DEBE DE ESTAR CONSTRUIDO DE LA ; SIGUIENTE MANERA: ; ; BYTE 1 = CANTIDAD DE BYTES A LEER ; BYTE 2 = (LLENADO POR MS-DOS) ES LA CANTIDAD DE BYTES REALMENTE ; LEIDOS. ; BYTE 3 = BUFFER DONDE SE ALMACENA EL RESULTADO. DEBE ENCONTRARSE ; INICIALIZADO CON LA MISMA CANTIDAD DE BYTES ESPECIFICADOS ; POR EL BYTE 1. ; ; LAS CANTIDADES CAPTURADAS REPRESENTAN UNA CADENA QUE ES NECESARIO ; CONVERTIR A BINARIO ANTES DE PODER OPERAR SOBRE ELLA. MAS ADELANTE ; QUEDARA CLARO LO ANTERIOR. ;------------------------------------------------------------------------------ ;------------------------------------------------------------------------------ ; CAPTURA PRIMER CADENA ;------------------------------------------------------------------------------ CAPCAD01: Mov Dx, Offset CadUnoM ; Mensaje de captura de cadena 1 Mov Ah, 9 Int 21h Mov Ah, 0Ah ; Captura la cantidad (hasta 15 bytes) Mov Dx, Offset Cadena1 Push Dx ; Guarda direccion de variable Int 21h Pop Dx

10


Inc Dx ; Obtiene cantidad de bytes realmente leidos ; que se encuentra en el byte 1 del buffer Mov Si, Dx Cmp Byte ptr [Si], 0 ; Es 0? Jnz CAPCAD02 ; No, asi que prosigue Mov Dx, Offset Error1 ; Despliega mensaje de error y captura la Mov Ah, 9 ; cadena de nuevo Int 21h Jmp CAPCAD01 ;------------------------------------------------------------------------------ ; PRIMERO COMPRUEBA SI LA CADENA 1 TIENE LA CADENA "FIN" QUE ESPECIFICA ; TERMINAR ESTE PROGRAMA. SI LO ANTERIOR ES VERDADERO EL PROGRAMA TERMINA, ; DE LO CONTRARIO CAPTURA LA SEGUNDA CADENA Y PROSIGUE. "FIN" DEBE DE ESTAR ; EN MAYUSCULAS. ;------------------------------------------------------------------------------ CAPCAD02: Inc Dx ; Primer byte del buffer de CADENA 1 Mov Cx, 3 ; Vamos a revisar 3 bytes. Mov Si, Dx ; Cadena capturada Mov Di, Offset Final ; Mensaje de final Repe Cmpsb ; Digitaron "FIN"? Jcxz TERMINA ; Si; asi que termina este programa CAPCAD03: Mov Dx, Offset CadDosM ; Mensaje de captura de cadena 2 Mov Ah, 9 Int 21h Mov Ah, 0Ah ; Captura la segunda cadena Mov Dx, Offset Cadena2 Push Dx ; Guarda direccion de variable Int 21h Pop Dx Inc Dx ; Obtiene cantidad de bytes realmente leidos ; que se encuentra en el byte 1 del buffer Mov Si, Dx Cmp Byte ptr [Si], 0 ; Es 0? Jnz CAPCAD04 ; No, as que prosigue Mov Dx, Offset Error1 ; Despliega mensaje de error y captura la Mov Ah, 9 ; cadena de nuevo Int 21h Jmp CAPCAD03

11


;------------------------------------------------------------------------------ ; YA SE TIENEN LAS DOS CADENAS CAPTURADAS, AHORA PROCEDEMOS A COMPARARLAS Y ; DESPLEGAR EL MENSAJE ADECUADO. ;------------------------------------------------------------------------------ CAPCAD04: Xor Ch, Ch ; CH = 0 por si acaso. Mov Si, Offset Cadena1 + 1 ; Bytes realmente ledos de cadena 1 Mov Cl, byte ptr [Si] ; Cx tiene bytes ledos de cadena 1 Inc Cl ; Ajusta CL debido a la naturaleza de ; la instruccin de comparacin, y a ; manera en que se comporta ; la funcin 9 de la INT 21H. Inc Si ; Regresa a direccin de cadena 1 Mov Di, Offset Cadena2 + 2 ; Direccin de cadena 2 Cld Repe Cmpsb ; Compara cadenas Jcxz CAPCAD05 ; Son iguales? Mov Dx, Offset Error ; No, despliega mensaje Mov Ah, 9 Int 21h Jmp CAPCAD01 CAPCAD05: Mov Dx, Offset TodoBIEN ; Cadenas son iguales Mov Ah, 9 Int 21h Jmp CAPCAD01 ;------------------------------------------------------------------------------ ; TERMINA EL PROGRAMA ;------------------------------------------------------------------------------ TERMINA: Mov Ax, 4C00h ; Termina el programa sin errores. Int 21h .STACK End Empieza Ejemplo 05 ;************************************************************************* ; Objetivo : Realizar operaciones de suma, resta, ; multiplicacion y division sobre dos cantidades ; enteras sin signo y no mayores de 65535.

12


;************************************************************************* ; COMANDO DE ENSAMBLE : Masm EJEM5; ; COMANDO DE ENLACE : Link EJEM5; ; COMANDO DE EJECUCION : EJEM5 [Enter] ;************************************************************************* ; NOTA : se procura usar SOLO las instrucciones que se han visto o explicado. ; El objetivo es educativo y NO de optimizacin o ; eficientar. Por favor, NO SE DESESPERE y estdielo. ;************************************************************************* ; Define el modelo de memoria .MODEL SMALL .Data ErrorCAP DB 0 ; Bandera de error en la captura de las cantidades Cantidad DB 0 ; La cantidad sobre la que se opera. Si es 0 se opera ; sobre la cantidad 1, si es 1 se opera sobre la ; cantidad 2. CantUnoR DW 0 ; Variable que guarda la cantidad 1 convertida a binario. CantDosR DW 0 ; Variable que guarda la cantidad 2 convertida a binario. CantUnoN DB 6,0,6 DUP(?) ; Variable que almacena la cantidad 1 CantDosN DB 6,0,6 DUP(?) ; Variable que almacena la cantidad 2 Funcion DB 0 ; Variable que guarda la funcin a realizar Resulta DB 13,10,13,10,'El resultado es: $' ResultaR DB 11 DUP('?') Mensaje DB 'Bienvenidos a EJEM5, que le permite realizar las' DB 13,10 DB 'operaciones BASICAS de MULTIPLICACION, DIVISION, SUMA' DB 13,10,'y RESTA sobre dos cantidades enteras.' DB 13,10,13,10,'$' Pregunta DB 13,10,13,10,'DIGITE:',13,10,13,10 DB ' (1) para MULTIPLICAR.',13,10 DB ' (2) para DIVIDIR.',13,10 DB ' (3) para SUMAR.',13,10 DB ' (4) para RESTAR.',13,10 DB ' (5) para TERMINAR.',13,10,'$' Error DB 7,7,7,13,10,'ERROR : en la seleccin de las opciones.' DB 13,10,13,10,'$' Error1 DB 7,7,7,13,10,'ERROR : dgito INVALIDO en CANTIDAD 1.' DB 13,10,13,10,'$' Error2 DB 7,7,7,13,10,'ERROR : dgito INVALIDO en CANTIDAD 2.' DB 13,10,13,10,'$' Error3 DB 7,7,7,13,10,'ERROR : cantidad fuera de RANGO ( 65535).' DB ' !!!.' DB 13,10,13,10,'$'

13


Error4 DB 7,7,7,13,10,'ERROR : intento de DIVISION por CERO.' DB 13,10,13,10,'$' CantunoM DB 13,10,13,10,'Digite primer CANTIDAD (debe ser < a 65535)' DB ' : $' CantDosM DB 13,10,13,10,'Digite Segunda CANTIDAD (debe ser < a 65535)' DB ' : $' ;------------------------------------------------------------------------------ ; TABLA DE POTENCIAS USADA PARA CONVERTIR EL RESULTADO BINARIO DE LA ; OPERACION EN FORMATO ASCII. SE USAN LAS POTENCIAS DE 10 (1, 10, 100, 1000 ; y 10000), PORQUE EL NUMERO MAS GRANDE ES 65535. EN CASO DE QUE QUIERA ; OPERAR SOBRE NUMEROS MAS GRANDES AMPLIE LA TABLA. ;------------------------------------------------------------------------------ Potencia DW 0001h, 000ah, 0064h, 03E8h, 2710h PotenciaF DW $ .CODE ; Area de cdigo Empieza: ; Etiqueta de comienzo de programa ;------------------------------------------------------------------------------ ; BORRA LA PANTALLA CAMBIANDO LA MODALIDAD DE VIDEO. ESTA FORMA DE BORRAR ; LA PANTALLA ES MUY PECULIAR Y SE CONSIDERA COMO "TRUCO". SE BASA EN EL ; HECHO DE QUE AL CAMBIAR LA MODALIDAD DE VIDEO, EL PROPIO BIOS (HARDWARE) ; BORRA LA PANTALLA POR NOSOTROS. ES UN METODO BURDO PERO MUY EFICIENTE. ;------------------------------------------------------------------------------ Mov Ah, 0Fh ; Obtiene la modalidad de video actual Int 10h Mov Ah, 0 ; Cambia la modalidad de video que se obtuvo Int 10h Mov Ax,@Data ; Inicializa DS con la direccin de @Data Mov Ds, Ax Mov Dx, Offset Mensaje ; Despliega el mensaje de bienvenida Call Imprime Mov Si, Offset ResultaR ; Inicializa la variable ResultaR Add Si, 11

14


Mov Al, '$' Mov [Si], Al ;------------------------------------------------------------------------------ ; SE DESPLIEGA EL MENU DE OPCIONES A ELEGIR. LA OPCION ELEGIDA DEBE DE ESTAR ; COMPRENDIDA ENTRE 1 Y 5. ESTO ES VERIFICADO POR LAS INSTRUCCIONES CMP Y ; JAE (SALTA SI MAYOR O IGUAL A) Y JBE (SALTA SI MENOR O IGUAL A). ; NOTE QUE LA SELECCION "NO ES DEPLEGADA A LA PANTALLA", ESO SE DEJA A SU ; CREATIVIDAD. SI EXISTE ALGUN ERROR, SE DESPLEGARA EL MENSAJE APROPIADO. ;------------------------------------------------------------------------------ OTRA: Mov Dx, Offset Pregunta ; Despliega men de opciones Call Imprime Call ObtenTecla ; Espera a que el usuario seleccione la ; funcin a realizar (1 a 5) Cmp Al, 49 ; La seleccin del usuario es mayor o igual Jae SIGUE ; a 1 ?. Mov Dx, Offset Error ; NO, despliega mensaje de error Call Imprime Jmp OTRA SIGUE: Cmp Al, 53 ; La seleccin del usuario es menor o igual Jbe TODOBIEN ; a 5?. Mov Dx, Offset Error ; NO, despliega mensaje de error Call Imprime Jmp OTRA TODOBIEN: Cmp Al, 53 Jnz CHECATODO Jmp FUNCION5 CHECATODO: Mov Funcion, Al ; Guarda la funcin a realizar ;------------------------------------------------------------------------------ ; SE CAPTURAN LAS CANTIDADES Y SE GUARDAN EN SUS RESPECTIVAS VARIABLES PARA ; PODER TRABAJAR SOBRE ELLAS MAS ADELANTE. LA CAPTURA SE BASA EN LA FUNCION

15


; 09 DE LA INT 21H. DICHA FUNCION ESTABLECE QUE EL REGISTRO AH CONTENGA 09 ; Y EL REGISTRO PAR DS:DX APUNTE A LA DIRECCION DE LA VARIABLE QUE ; ALMACENARA LA ESTRUCTURA DEL BUFFER, EL CUAL DEBE ESTAR CONSTRUIDO DE LA ; SIGUIENTE MANERA: ; ; BYTE 1 = CANTIDAD DE BYTES POR LEER ; BYTE 2 = (LLENADO POR MS-DOS) ES LA CANTIDAD DE BYTES REALMENTE LEIDOS. ; BYTE 3 = BUFFER DON DE SE ALMACENA EL RESULTADO; DEBE ENCONTRARSE ; INICIALIZADO CON LA MISMA CANTIDAD DE BYTES ESPECIFICADOS ; POR EL BYTE 1. ; ; LAS CANTIDADES CAPTURADAS REPRESENTAN UNA CADENA QUE ES NECESARIO ; CONVERTIR EN BINARIO ANTES DE QUE SE PUEDA OPERAR SOBRE ELLA. MAS ; ADELANTE SERA EVIDENTE LO ANTERIOR. ;------------------------------------------------------------------------------ ;------------------------------------------------------------------------------ ; CAPTURA PRIMER CANTIDAD. ;------------------------------------------------------------------------------ CAPCANT01: Mov Dx, Offset CantUnoM ; Mensaje de captura de cantidad 1 Call Imprime Mov Ah, 0Ah ; Captura la cantidad (hasta 8 dgitos) Mov Dx, Offset CantUnoN Int 21h Mov ErrorCAP, 0 ; Supone que no hay errores y que se est Mov Cantidad, 0 ; operando sobre la cantidad 1. Call ConvNUM ; Convierte cantidad 1 a binario Cmp ErrorCAP, 1 ; Hubo error? Jz CAPCANT01 ; S, regresa a la captura Mov CantUnoR, Bx ; Guarda resultado de conversin ;------------------------------------------------------------------------------ ; CAPTURA SEGUNDA CANTIDAD. ;------------------------------------------------------------------------------ CAPCANT02: Mov ErrorCAP, 0 ; Supone que no hay error Mov Cantidad, 1 ; Indica a ConvNUM que es la segunda cantidad Mov Dx, Offset CantDosM ; Mensaje de captura de cantidad 2

16


Call Imprime Mov Ah, 0Ah ; Captura la segunda cantidad Mov Dx, Offset CantDosN Int 21h Call ConvNUM ; Convierte cantidad 2 a binario Cmp ErrorCAP, 1 ; Hay error? Jz CAPCANT02 ; S, regresa a capturar la cantidad Mov CantDosR, Bx ; Guarda conversin de cantidad 2 ;------------------------------------------------------------------------------ ; DESPUES DE CAPTURAR LAS DOS CANTIDADES SOBRE LAS CUALES SE VA A OPERAR, ; SE DEFINE CUAL ES LA FUNCION POR REALIZAR (MULTIPLICACION, DIVISION, SUMA ; O RESTA). ;------------------------------------------------------------------------------ Mov Al, Funcion ; Funcin que seleccion el usuario Cmp Al, 31h ; Es 1? Jne FUNCION2 ; No. Call Multiplica ; Multiplica las dos cantidades Jmp OTRA FUNCION2: Cmp Al, 32h ; Es 2? Jne FUNCION3 ; No. Call Divide ; Divide las dos cantidades Jmp OTRA FUNCION3: Cmp Al, 33h ; Es 3? Jne FUNCION4 ; No. Call Suma ; Suma las dos cantidades Jmp OTRA FUNCION4: Cmp Al, 34h ; Es 4? Jne FUNCION5 ; No. Call Resta ; Resta las dos cantidades Jmp OTRA FUNCION5: ;------------------------------------------------------------------------------ ; TERMINA EL PROGRAMA ;------------------------------------------------------------------------------ Mov Ax, 4C00h ; Termina el programa sin errores.

17


Int 21h ;************************************************************************* ; R U T I N A S D E S O P O R T E ;************************************************************************* ;------------------------------------------------------------------------------ ; Rutina : Multiplica ; Propsito : Multiplica dos nmeros enteros sin signo ; Par metros : En el registro AX el multiplicando y en BX el multiplicador ; Regresa : El resultado en el registro par DX:AX, que es desplegado en ; la pantalla. ;------------------------------------------------------------------------------ Multiplica Proc Near Xor Dx, Dx ; Dx = 0 por si acaso Mov Ax, CantUnoR ; Primera cantidad (multiplicando) Mov Bx, CantDosR ; Segunda cantidad (multiplicador) Mul Bx ; Multiplica Call ConvASCII ; Convierte en ASCII Mov Dx, Offset Resulta ; Prepara para desplegar la cadena del Call Imprime ; resultado Mov Dx, Offset ResultaR ; Despliega el resultado. Call Imprime Ret Multiplica Endp ;------------------------------------------------------------------------------ ; Rutina : Divide ; Propsito : Divide dos nmeros enteros sin signo ; Par metros : En el registro AX el dividendo y en BX el divisor ; Regresa : El resultado en el registro par DX:AX, que es desplegado en ; la pantalla. ;------------------------------------------------------------------------------ Divide Proc Near Mov Ax, CantUnoR ; Carga la cantidad 1 (dividendo) Mov Bx, CantDosR ; Carga la cantidad 2 (divisor) Cmp Bx, 0 ; Revisa si el divisor es 0 para evitar un ; error de divisin por cero. Jnz DIVIDE01 Mov Cantidad, 3 ; Hubo error, as que despliega el mensaje y ; salta Call HuboERROR Ret DIVIDE01:

18


Div Bx ; Divide Xor Dx, Dx ; Dx = 0. No se usa el residuo para simplificar ; las operaciones Call ConvASCII ; Convierte en ASCII Mov Dx, Offset Resulta ; Despliega la cadena del resultado Call Imprime Mov Dx, Offset ResultaR ; Despliega el resultado Call Imprime Ret Divide Endp ;------------------------------------------------------------------------------ ; Rutina : Suma ; Propsito : Suma dos nmeros enteros sin signo ; Par metros : En el registro AX el primer nmero y en BX el segundo ; Regresa : El resultado en el registro par DX:AX, que es desplegado en ; la pantalla. ;------------------------------------------------------------------------------ Suma Proc Near Xor Dx, Dx ; Dx = 0 por si acaso existe acarreo Mov Ax, CantUnoR ; Primera cantidad Mov Bx, CantDosR ; Segunda cantidad Add Ax, Bx ; suma Jnc SUMACONV ; Hubo acarreo? Adc Dx, 0 ; S. SUMACONV: Call ConvASCII ; Convierte resultado en ASCII Mov Dx, Offset Resulta ; Despliega cadena del resultado Call Imprime Mov Dx, Offset ResultaR ; Despliega el resultado Call Imprime Ret Suma Endp ;------------------------------------------------------------------------------ ; Rutina : Resta ; Propsito : Resta dos nmeros enteros sin signo ; Par metros : En el registro AX el primer nmero y en BX el segundo ; Regresa : El resultado en el registro par DX:AX, que es desplegado en ; la pantalla. ;------------------------------------------------------------------------------ Resta Proc Near Xor Dx, Dx ; Dx = 0 por si acaso existe acarreo Mov Ax, CantUnoR ; Primera cantidad Mov Bx, CantDosR ; Segunda cantidad

19


Sub Ax, Bx ; Resta cantidades Jnc RESTACONV ; Hubo acarreo? Sbb Dx, 0 ; S. RESTACONV: Call ConvASCII ; Convierte en ASCII Mov Dx, Offset Resulta ; Despliega cadena del resultado Call Imprime Mov Dx, Offset ResultaR ; Despliega el resultado Call Imprime Ret Resta Endp ;------------------------------------------------------------------------------ ; Rutina : Imprime ; Propsito : Despliega una cadena ; Par metros : El registro DX contiene el desplazamiento de la cadena ; Regresa : Nada ;------------------------------------------------------------------------------ Imprime Proc Near Mov Ah, 9 ; Prepara para desplegar la cadena a travs de la Int 21h ; INT 21h. Ret Imprime Endp ;------------------------------------------------------------------------------ ; Rutina : ObtnTecla ; Propsito : Espera a que el usuario digite una tecla ; Par metros : Ninguno ; Regresa : En el registro AL el cdigo ASCII de la tecla ;------------------------------------------------------------------------------ ObtenTecla Proc Near Mov Ah, 0 ; Lee una tecla del teclado a travs de la INT 16h Int 16h Ret ObtenTecla Endp ;------------------------------------------------------------------------------ ; Rutina : ConvNUM ; Propsito : Convertir una cadena a un entero largo ; Par metros : La longitud de la cadena y la direccin de la misma, y se ; pasan a la pila. ; Regresa : En el registro BX la cadena convertida en un entero ;------------------------------------------------------------------------------ ConvNUM Proc Near

20


Mov Dx, 0Ah ; Multiplicador es 10 Cmp Cantidad, 0 ; Es la cantidad 1? Jnz CONVNUM01 ; NO, as que es la cantidad 2 Mov Di, Offset CantUnoN + 1 ; Bytes ledos de la cantidad 1 Mov Cx, [Di] Mov Si, Offset CantUnoN + 2 ; La cantidad 1 Jmp CONVNUM02 CONVNUM01: Mov Di, Offset CantDosN + 1 ; Bytes ledos de la cantidad 2 Mov Cx, [Di] Mov Si, Offset CantDosN + 2 ; La cantidad 2 CONVNUM02: Xor Ch, Ch ; CH = 0 Mov Di, Offset Potencia ; Direccin de la tabla de potencias Dec Si ; Posiciona Si en el primer byte de la Add Si, Cx ; cadena capturada y le suma el Xor Bx, Bx ; desplazamiento de bytes ledos Std ; para que podamos posicionarnos en el ; final de la misma (apunta al ltimo ; dgito capturado). BX = 0 y lee la ; cadena en forma inversa; es decir, de ; atr s hacia adelante. CONVNUM03: Lodsb ; Levanta un byte del nmero (esta instruccin indica ; que el registro AL ser cargado con el contenido ; de la direccin apuntada por DS:SI. Cmp AL,"0" ; Es menor a 0? (entonces NO es un dgito v lido) Jb CONVNUM04 ; S, despliega el mensaje de error y termina Cmp AL,"9" ; Es mayor a 9? (entonces NO es un dgito v lido) Ja CONVNUM04 ; S, despliega el error y salta Sub Al, 30h ; Convierte el dgito de ASCII a binario Cbw ; Convierte a palabra Mov Dx, [Di] ; Obtiene la potencia de 10 que ser usada para Mul Dx ; multiplicar, multiplica nmero y lo suma Jc CONVNUM05 ; a BX. Revisa si hubo acarreo, y si lo hubo, sto Add Bx, Ax ; significa que la cantidad es > 65535. Jc CONVNUM05 ; Si hay acarreo la cantidad es > 65535 Add Di, 2 ; Va a la siguiente potencia de 10 Loop CONVNUM03 ; Itera hasta que CX sea = 0 Jmp CONVNUM06 CONVNUM04: Call HuboERROR ; Algo ocurri, despliega mensaje y salta Jmp CONVNUM06

21


CONVNUM05: Mov Cantidad, 2 ; Hubo acarreo en la conversin, por lo tanto la Call HuboERROR ; cantidad capturada es mayor a 65535. CONVNUM06: Cld ; Regresa la bandera de direccin a su estado normal Ret ; y REGRESA. ConvNum Endp ;------------------------------------------------------------------------------ ; Rutina : ConvASCII ; Propsito : Convertir un valor binario en ASCII ; Par metros : El registro par DX:AX ; Regresa : Nada, pero almacena el resultado en el buffer ResultaR ;------------------------------------------------------------------------------ ConvASCII Proc Near ;------------------------------------------------------------------------------ ; Lo primero que se hace es inicializar la variable que contendr el ; resultado de la conversin. ;------------------------------------------------------------------------------ Push Dx Push Ax ; Guarda el resultado Mov Si, Offset ResultaR ; Inicializa la variable ResultaR llen ndola Mov Cx, 10 ; con asteriscos Mov Al, '*' ConvASCII01: Mov [Si], Al Inc Si Loop ConvASCII01 Pop Ax Pop Dx Mov Bx, Ax ; Palabra baja de la cantidad Mov Ax, Dx ; Palabra alta de la cantidad Mov Si,Offset ResultaR ; Cadena donde se guardar el resultado Add Si, 11 Mov CX, 10 ; Divisor = 10 OBTENDIGITO: Dec Si Xor Dx, Dx ; DX contendr el residuo Div Cx ; Divide la palabra alta (AX)

22


Mov Di, Ax ; Guarda cociente (AX) Mov Ax, Bx ; AX = palabra baja (BX) Div Cx ; DX tena un residuo de la divisin anterior Mov Bx, Ax ; Guarda el cociente Mov Ax, Di ; Regresa la palabra alta Add Dl,30h ; Convierte residuo en ASCII Mov [Si], Dl ; Lo almacena Or Ax, Ax ; Palabra alta es 0? Jnz OBTENDIGITO ; No, sigue procesando Or Bx, Bx ; Palabra baja es 0? Jnz OBTENDIGITO ; No, sigue procesando Ret ConvASCII Endp ;------------------------------------------------------------------------------ ; Rutina : HuboERROR ; Propsito : Desplegar el mensaje de error adecuado. ; Par metros : Nada ; Regresa : Nada ;------------------------------------------------------------------------------ HuboERROR Proc Near Cmp Cantidad, 0 ; Es la cantidad 1? Jnz HUBOERROR02 ; No. Mov Dx, Offset Error1 Call Imprime Mov ErrorCAP, 1 ; Enciende la bandera de error Jmp HUBOERROR05 HUBOERROR02: Cmp Cantidad, 1 ; Es la cantidad 2? Jnz HUBOERROR03 ; No. Mov Dx, Offset Error2 Call Imprime Mov ErrorCAP, 1 Jmp HUBOERROR05 HUBOERROR03: Cmp Cantidad, 2 ; Cantidad capturada est fuera de rango ? Jnz HUBOERROR04 ; No. Mov Dx, Offset Error3 Call Imprime Mov ErrorCAP, 1 Jmp HUBOERROR05

23


HUBOERROR04: Mov Dx, Offset Error4 ; Error de intento de divisin por cero Call Imprime Mov ErrorCAP, 1 HUBOERROR05: Ret HuboERROR Endp .STACK End Empieza

24

Arquitectura de Microprocesadores I Ing. Ral Hinojosa

INSTRUCCIONES DEL MICROPROCESADOR

El grupo de instrucciones que un microprocesador

especfico que puede ejecutar se denomina su repertorio

de instrucciones.

Los repertorios de instrucciones de los

microprocesadores pueden variar desde ocho hasta 200

instrucciones bsicas. Los repertorios de

instrucciones no estn estandarizados, debido al

individualismo de cada fabricante y a la diferencia de

arquitectura y uso de los microprocesadores.

Las instrucciones de un repertorio pueden

clasificarse en diversas categoras:

OPERACIONES ARITMETICAS

Las instrucciones aritmticas son las primeras

operaciones del microprocesador genrico que se van a

considerar. Estas se resumen en la fig. 1. Incluye las

operaciones de sumar, restar, incrementar, decrementar

y comparar. Observar en la figura que hay cuatro

instrucciones de sumar. El acumulador, identificado

como el registro A en la fig. 1, contiene uno de los

nmeros que se va a sumar. Cada instruccin de suma

1


especifica una fuente diferente para el otro nmero que

va a ser sumado.

Considerar la primera instruccin listada en la

tabla de la fig. 1; La instruccin "sumar A inmediato"

es una instruccin de 2 bytes cuyo formato se muestra

cerca de la parte derecha de la tabla. Como siempre,

el cdigo de op(C6H en este caso) aparece en el primer

byte de la memoria de programa, y el dato a ser sumado

al acumulador en el segundo byte. La instruccin ADI

se muestra en forma de diagrama en la fig. 1.a. El dato

inmediato de la memoria de programa (00010000) se suma

al contenido del acumulador (00001111). La suma

(00011111) es devuelta al acumulador despus de la

operacin.

2


Descripcin de la

operacin

Modo de direccionam

iento

Nemotcnico Cd. de

oper.

Bytes Formato de la instruccin

Simblico Sealizadores afectados

Suma A al dato

Inmediato ADI C6 2 Cdigo de op. / datos

(A)


OPERACIONES LOGICAS

Las instrucciones lgicas son las segundas

operaciones del microprocesador genrico que se van a

considerar. Estas estn resumidas en la fig. 2.

Incluyen las instrucciones AND, OR, OR exclusiva,

complementacin (NOT) e instrucciones de

desplazamiento circular.

La organizacin de la tabla de la fig. 2 es la

misma que la utilizada para las operaciones aritmticas

anteriores. De nuevo, el foco de la mayor parte de las

operaciones est en el contenido del acumulador. Como

con las instrucciones aritmticas, el modo de

direccionamiento indica cmo y dnde se encuentra el

otro dato en el sistema basado en microprocesador.

4


Descripcin de la

operacin

Modo de direccionam

iento

Nemotcnico Cd. de

oper.



AND de A con dato

Inmediato ANI E6 2 Cdigo de op. / datos

(A)


OPERACIONES DE TRANSFERENCIA DE DATOS

Las instrucciones de transferencia de datos son la

tercera categora de operaciones, del microprocesador

en la fig. 3.

Entre ellas se incluyen las instrucciones de

transferencia de registro a registro, de carga de

memoria, de almacenamiento en memoria, de entrada y

salida y de poner a 1 el sealizador de arrastre.

La mayora de los programas contiene ms

instrucciones de transferencia de datos que otros tipos

de operaciones. Casi ningunas instruccin de

transferencia de datos pueden ser transferidos de

cualquier posicin de memoria u otro registro. Los

microprocesadores con ms registros de CPU tienen ms

instrucciones de transferencia de datos. Tener en

cuenta que cada instruccin de transferencia tendr una

fuente y un destino para el dato. El modo de

direccionamiento determina cmo y dnde se encuentra

el dato fuente.

Considerar la primera operacin de transferencia

listada en la tabla de la fig. 3; el dato se va a

transferir del registro L registro A, o acumulador. El

nemotcnico del lenguaje ensamblador (MOV A, L) sugiere

6


primero la accin, que es transferir (MOV); la

siguiente letra del nemotcnico (A en este ejemplo) es

el destino del dato, mientras que la ltima letra (L

en este ejemplo) es la fuente del dato. Esto parece un

poco al revs, pero es el convenio utilizado por Intel

Corporation con las instrucciones del 8086/80486.

Algunos microprocesadores identifican la fuente y

destino de forma diferente y en el orden opuesto.

Ver Tabla #3

OPERACIONES DE BIFURCACION

Las instrucciones de bifurcaciones son la cuarta

categora de las operaciones del microprocesador

genrico que se van a considerar y estn resumidas en

la fig. 4. Observar que las operaciones se definen como

instrucciones de salto, aunque los trminos salto y

bifurcacin se considerarn sinnimos.

Algunos fabricantes hacen distinciones entre

instrucciones de bifurcacin y de salto. Las

operaciones de bifurcacin o de salto que a veces se

denominan instrucciones de transferencia de control.

Como las operaciones de la fig. 4 son un

subconjunto del repertorio de instrucciones del

8080/8085, el convenio de Intel fue de llamar a estas

7


instrucciones de salto que se utilizar ms tarde en

este captulo.

La microcomputadora normalmente ejecuta

instrucciones en orden secuencial. El contador de

programa de 16 bits del microprocesador genrico

siempre sigue la pista de la direccin de la siguiente

instruccin que se va a buscar en memoria y ejecutar.

El contador de programa normalmente sigue una

secuencia ascendente aumentando de uno en uno. Las

instrucciones de salto o bifurcacin proporcionan un

mtodo par cambiar el valor del contador de programa,

alternando as la secuencia normal de ejecucin del

programa.

Las instrucciones de salto o bifurcacin se

subdividen normalmente en operaciones de salto

incondicional y de salto condicional. La primera

instruccin listada en la fig. 4 es una instruccin de

salto incondicional.

La instruccin "saltar inmediato" es una

instruccin de 3 bytes, utilizada para cargar una

direccin especfica en el contador del programa de la

CPU.

8


Un problema ejemplo que utiliza esta instruccin,

de salto incondicional, se muestra en la fig. 4.1,

donde la direccin sigue inmediatamente al cdigo de

op, y por tanto, se denomina direccionamiento

inmediato.

OPERACIONES DE LLAMADA Y VUELTA DE SUBRUTINA

Las instrucciones de llamada y vuelta de subrutina

son la quinta categora de operaciones del

microprocesador genrico que se van a considerar. Estas

estn resumidas en la fig. 5. Observar que el

microprocesador genrico tiene solamente dos

instrucciones en este grupo. Las instrucciones de

llamada y vuelta son utilizadas siempre en parejas.

Descripcin

de la operacin

Modo de direccionam

iento

Nemotcnico Cd. de

oper.



Llama a la subrutina en LOC con aa

Inmediato/indirecto de

registro

CALL CD 3 Cdigo de op. Direc. De orden

inferior Direc. De orden

superior

((SP)-1) (PCH ((SP)-2) (PLC) (SP) (SP)-2 (PC) (Direccin)

Vuelta de subrutina

Indirecto de registro

RET C9 1 Cdigo de op. (PCL) ((SP)) (PCH) ((SP)+1 (SP) (SP)+2

( ) = CONTENIDO DE

(( )) = DIRECCIONAMIENTO INDIRECTO DE REGISTRO

PC = CONTADOR DEL PROGRAMA

SP = PUNTERO DE PILA

9


La instruccin de llamada de 3 bytes se utiliza en

el programa principal para hacer que el microprocesador

salte a una subrutina. En el ejemplo mostrado en la

fig. 5.1, la subrutina es un pequeo grupo de

instrucciones que consiguen un retardo de 1 segundo.

10


INTERRUPCIONES DEL UP

Son instrucciones avanzadas y de alta prioridad que detienen la ejecucin de un programa

y hace que el apuntador de instrucciones se detenga en una localidad de memoria

especfica donde despus se reanudara el procesamiento.

El formato de las interrupciones es :

INT ( Tipo de interrupcin)

Existen 3 tipos de interrupciones:

Tipo Intel

Tipo Bios

Tipo Dos

Las interrupciones disponibles para el programador estn clasificadas en :

INT, INT0 e INT3

En modo real cada una de estas instrucciones busca y carga un valor de la tabla de

vectores y luego llama al procedimiento almacenado en la localidad direccionado por el

vector.

En el modo protegido cada de estas instrucciones busca un descriptor de interrupciones

de la tabla de descriptores de interrupcin. El descriptor especfica la direccin del

procedimiento de servicio de interrupcin.

La llamada de interrupcin es similar a la instruccin CALL FAR por que coloca la

direccin de retorno ( IP: CS) en la pila.

1


Siempre que ejecuta una INT, se realiza las siguientes acciones:

1. Salva el registro de banderas en el stack

2. Desactiva las banderas TF e IF

3. Salva CS en el stack

4. Recupera el valor de CS del vector

5. Salva el valor de IP/EIP del vector

6. Recupera el nuevo valor de IP/EIP del vector

7. Salta a la direccin CS: IP/EIP

Los tipos de Interrupcin:

INT Hay 256 diferentes instrucciones para interrupcin por software, disponibles

para el programador. Cada instruccin INT tiene un operando numrico cuyo intervalo

es OOH a FFh .

Por ejm , la INT 100 utiliza el vector de interrupcin que se encuentra en las direcciones

190h-193h en la memoria, para calcular la direccin del vector de interrupcin, se

multiplica el nmero de tipo de interrupcin por 4 por ejm, la instruccin INT 10h llama

al procedimiento de interrupcin cuya direccin esta almacenada a partir de la direccin

40h (10*4) de la memoria, el modo real.

En el modo protegido para ubicar el descriptor de interrupcin se multiplica por 8, por

que cada descriptor tiene 8 bytes de longitud.

Cada instruccin INT tiene una longitud de 2 bytes. El primer byte contiene el cdigo de

operacin y el segundo , el nmero de tipo de vector.

La nica excepcin es INT 3, una interrupcin de software especial de un byte, utilizada

para los puntos de interrupcin.

2


Siempre que se ejecuta una interrupcin por software se realizan las siguientes acciones:

Las instrucciones INT acta como una llamada FAR excepto que no solo salva a CS e IP

en el stack, sino que tambin salva los registros de banderas en el stack.

Se debe de tener en cuenta que cuando se ejecuta las instruccin, se desactiva la bandera

IF la que controla al terminal de entrada de interrupciones externa por hardware INTR.

Cuando IF=0, el microprocesador deshabilita la terminal INTR y cuando IF =1

habilita el terminal INTR.

IRET/ IRETD La instruccin para retorno de interrupcin ( IRET) slo se emplea con

procedimientos de servicio de interrupcin en el software o hardware . Al contrario de

una instruccin sencilla (RET) para retorno.

La instruccin IRET har lo sgte:

1. Restaura el registro I P desde el stack.

2. Restaura el registro CS desde el stack.

3. Restaura los registros de banderas.

Siempre que se ejecuta una instruccin IRET se recupera el contenido original de las

banderas TF e IF.

Esto es importante porque se conserva el estado de estos bits de bandera. Si se habilitan

las interrupciones antes de un procedimiento de servicio de interrupcin, se les vuelve a

habilitar automticamente con la instruccin IRET, porque recupera el contenido

original de los registros de bandera.

3


INT 0 La instruccin de interrupcin por sobre flujo (INT 0), es una interrupcin

condicional de software que prueba la bandera OF. si OF= 0, la instruccin INT 0 , no

se ejecuta pero si OF= 1, se ejecuta una interrupcin de vector 4.

INT 3 Es una interrupcin especial de software destinada como punto de ruptura.

La diferencia entre esta y las otras interrupciones en software es que INT3 es una

instruccin de 1 byte mientras que las otras son de 2 byte.

Se acostumbran introducir una instruccin INT3 en un programa para interrumpir o

romper el flujo.

Dentro del ordenador, el DOS, y el BIOS ( Basic Input Output System), continen un nmero

de rutinas para efectuar operaciones de entrada y salida a un nivel muy bajo tales como

leer desde el teclado, enviar caracteres a la pantalla; leer y escribir en un disco etc. Todas

estas rutinas nos facilitan hacer uso de estos recursos del hardware .

Toda llamada a una funcin del DOS se efecta a travs de la interrupcin 21h. Las

funciones individuales se seleccionan poniendo el nmero apropiado de la funcin en el

registro AH.

A continuacin se alistan algunas funciones invocadas a travs de INT 21h.

FUNCIONES DE INT 21

AH Descripcin

00H Terminar

01H Entrada de carcter eco

02H Salida de carcter

03H Entrada auxiliar

04H Salida auxiliar

05H Salida por impresora

06H Entrada /Salida directa por teclado / consola

07H Entada directa por teclado

4


08H Entrada por teclado

09H Salida de una cadena

0AH Entrada por teclado

FUNCIN 00h (AH=00)

Su funcin es la terminar un programa y devolver e l control al DOS. Funcionalmente es

idntica a la INT 20h del DOS.

MOV AH, 00H

INT 21H

FUNCIN 01h (AH= 01) Entrada con un carcter con eco

Esta funcin espera una entrada de carcter desde el teclado y carga el cdigo ASCII

del mismo y lo muestra en la pantalla..

MOV AH, 01

INT 21H

FUNCIN 02h ( AH= 02) Salida de carcter

Esta funcin muestra en la pantalla , el carcter cuyo cdigo ASCII se encuentra en el

registro DL. Para esta funcin , hay varios caracteres que tienen un significado especial:

7 Beep: Enva un tono de un segundo de duracin al altavoz.

8 Retroceso: Mueve el cursor de una posicin haca la izquierda

9 Tabulador: Va hasta la sgte parada del tabulador

Las paradas del tabulador estn establecidas cada 8 caracteres.

0AH Salto de lnea : Salta a la lnea sgte.

0DH Retorno de carro: Va hasta el principio de la lnea en curso.

EJM:

5


MOV AH 02H: Define la funcin de escribir

MOV DL,0AH: Salta a la sgte lnea

INT 21H

MOV DL,0DH: Pasa al inicio de la lnea en curso.

INT 21h : Solicita se ejecute la funcin

MOV DL, 07H : Emite sonido

INT 21h : Solicita se ejecute la funcin

FUNCIN 03h (AH= 04) Salida auxiliar

La funcin 03h lee un carcter desde la entrada AUX, y lo carga al registro AL.

El dispositivo auxiliar estndar, es COM1, el primer puerto de comunicaciones RS-232.

Ejm:

MOV AH,03

INT 21H

FUNCIN 04h ( AH=04) Salida auxiliar

La funcin 04h escribe un carcter desde el registro DL al dispositivo auxiliar estndar.

Ejm:

MOV DL, carcter

MOV AH, 04

INT 21h

FUNCIN 05h (AH=05) Salida por impresoras

6


Escribe un byte desde DL, al dispositivo impresora estndar , el cual se conoce

normalmente por PRN o LPT1. La impresora estndar por defecto es siempre la primera

impresora paralela , incluso si se utiliza un puerto serie para la salida de impresora .

Ejm:

MOV DL, carcter

MOV AH, 05

INT 21H

FUNCIN 06Hh (AH=06) Entrada /Salida por teclado/Consola

La funcin 06 es una funcin que combina el funcionamiento de entrada del teclado y la

salida del monitor en un solo paquete. Al registro AL se le utiliza como entrada y a DL

como salida. Si se llama a la funcin 06 cuando DL=FFh , la funcin ejecuta una entrada.

Si se pulso una tecla , la funcin 06 carga el cdigo ASCII al registro AL y desactiva el

indicador de cero.

Si no se pulso ninguna tecla la funcin 06 activa al indicador de cero.

Si se le llama a la funcin 06 con cualquier otro valor en DL, la funcin ejecuta una salida

, el carcter en DL se escribe en el dispositivo de salida.

Ejm:

MOV DL, FFH ;Si carcter es a igual FF, lee desde.

MOV AH, 06 ;el teclado de lo contrario.

INT 21H ;Imprime.

FUNCIN 07h ( AH=07) Entrada directa por teclado sin eco

Esta funcin espera por una entrada de carcter en el dispositivo de entrada estndar y

lo carga en le registro AL. No muestra el carcter en la pantalla.

7


Ejm:

MOV AH, 07

INT 21

FUNCIN 08h (AH=08) Entrada por teclado

Esta funcin espera por una entrada de carcter desde el teclado y lo carga en el registro

AL. No muestra el carcter en la pantalla.

Ejm:

MOV AH, 08

INT 21

FUNCIN 09 (AH=09) Salida de una cadena

Escribe una cadena de caracteres en la pantalla. El registro DX debe de contener el

desplazamiento dentro del segmento de datos del inicio de la cadena. La cadena de

caracteres debe terminar en $.

Ejm: Cadena de DB Este es un ejm de cadena$

LEA,DX, Cadena ; Mueve a DX el desplazamiento de

MOVAH,09 ; Cadena

INT 21

FUNCIN OAH (AH=0A) Entrada por teclado con buffer de cadena

La funcin obtiene una cadena de entrada completa , la cual es presentada al programa

como un todo en vez de carcter. Para utilizar esta funcin , se debe de proporcionar un

8


rea de buffer donde se pueda almacenar la cadena . El par de registros DS: DX apunta

al inicio del buffer.

Los tres primeros bytes de esta rea tienen propsitos especficos :

El primer byte indica el espacio de buffer ( mximo 255)

EL segundo byte es actualizado por el dos para indicar el nmero real de bytes de

entradas.

El tercer byte es el comienzo de la cadena de entrada, la cual consta nicamente de

caracteres ASCII.

El final de la cadena esta sealado por el carcter de retorno de carro, cuando pulsamos

ENTER.

Ejm:

Programa que escribe una cadena desde el teclado y luego lo muestra en el monitor ,

combina las funciones 0A y 09.

MOV AH, 0AH ; Define la funcin 0A

MOV DX, 200h ; Define el inicio del buffer.

INT 21h ; Se ejecuta la funcin 0A.

MOV DX, 202h ; Apunta al inicio de la cadena a leer.

MOV AH, 09h ; Define la funcin 09.

INT 21h ; Se ejecuta a la funcin.

FUNCIN 4C ( AH=4C) Devuelve el control a DOS

9


Esta funcin termina un programa y devuelve el cdigo de retorno que se especifica en AL.

Si el programa fue llamado como programa secundario , el programa principal puede

obtener el cdigo de retorno a travs de la funcin 4Dh.

FUNCIN 4D (AH=4D) Obtener el cdigo de retorno

La funcin 4Dh obtiene el cdigo de entorno de un programa secundario llamado con la

funcin 4Bh y finalizado con las funciones 31H o 4Ch . La informacin se devuelve en

dos partes :

AL devuelve el cdigo de retorno emitido por el programa secundario ,

AH Informa sobre como termino el programa secundario.

FUNCIONES DE BIOS INT 10

FUNCIN 01 (AH=01H) Selecciona el tipo de cursor

Entrada CH= Nmero de la lnea para iniciar.

CL= Nmero de la ultima lnea

Salida tamao del cursor modificado

FUNCIN 02 ( AH = 02H ) Seleccin posicin del cursor

Entrada BH = Nmero de pagina

DH= Nmero de fila

DL. Nmero de columna

Salida cambia el cursor a una nueva posicin .

FUNCIN 03 (AH=03H) Leer posicin del cursor

Entrada BH =Nmero de pgina

Salida CH= lnea inicial

CL= Lnea final

10


DH= Fila actual

DL= Columna Actual.

FUNCIN 05 (Ah=5H) Selecciona una pagina activa

Entrada AL =Nmero de pgina

FUNCIN 06 (AH=06H) Pantalla arriba

Entrada AL =Nmero de lneas en la parte inferior de la pantalla

(CH, CL)= Fila, columna de la esquina superior izquierda.

(DH,DL)= Fila, columna de la esquina inferior derecha de la pantalla.

BH = Atributo de la pantalla para usar en las lneas en blanco.

FUNCIN 07 (AH=07) Pantalla abajo

(Esta funcin es igual a la funcin 6)

FUNCIN 08 (AH=08) Lee atributo y carcter sobre el que se encuentra el cursor

Entrada BH = Nmero de pagina.

Salida AL =Carcter ledo

AH= Atributo de carcter ledo

( Esta funcin no avanza el cursor)

11

Descripcin del lenguaje EnsambladorETIQUETA COD. DE OP. OPERANDO COMENTARIOSEscritura de un Programa en AssemblerProcedimientos para crear un programa en ensamblador

Instrucciones del microprocesadorInterrupciones del MicroprocesadorINTERRUPCIONES DEL UP

r. hinojosa - arquitectura de microprocesadores i

Documents