Ensamblador[1] USAR UNIDAD 2

Ingeniería en Sistemas Computacionales

Lenguaje Ensamblador

Arquitectura básica del microprocesador. Los microprocesadores 80286 y compatibles integran un conjunto de registros de 16 bits que les permiten realizar todas sus operaciones: registros básicos, señalizadores (banderas) y registros de segmento.

Cada registro básico de 16 bits (AX, BX, CX, DX, SP, BP, SI y DI) tiene un propósito específico. Pero además, los registros AX, BX, CX y DX pueden trabajar con ocho bits para conservar la compatibilidad con arquitecturas anteriores. En el caso del registro AX de 16 bits, se divide en dos bloques de 8 bits cada uno: AL ( Acumulator Low) con los bits del 0 al 7 y AH ( Acumulator High) con los bits del 8 al 15. Acumulador ( Acumulator ). Acumulator Register Register ). El Registro Acumulador AX tiene el propósito de almacenar los resultados de las operaciones del procesador. Se le llama Acumulador por que sirve de enlace cuando el resultado de una primera operación es un operando de la segunda. Base Register Register ). Base ( Base ). El Registro Base BX permite almacenar las direcciones de las variables que se encuentran en la memoria principal (RAM Random Access Access Memory). También se utiliza como un registro auxiliar en las operaciones del microprocesador que requieren de un registro adicional al Acumulador.

Contador (Counter Register ). ). El Registro Contador CX se utiliza para contar las iteraciones de los ciclos, esto quiere decir que le permite a los programas ejecutar instrucciones como while y for . Datos ( Data ). Data Register Register ). El Registro de Datos DX se utiliza para almacenar las direcciones de las variables del programa. En realidad, esta dirección es un desplazamiento a partir del inicio del segmento de datos. Puntero de Pila ( Stack Pointer ). ). El puntero de Pila SP se utiliza para trabajar conjuntos de instrucciones o datos apilados en la memoria, bajo el criterio LIFO ( Last ), menos conocido en español como UEPS (El Último en Entrar es el Primero en Salir). Input First Output ), Puntero Base ( Base Pointer ). ). El Puntero Base BP se utiliza para almacenar la dirección inicial en estructuras de datos complejas, tales como arreglos de enteros y cadenas de caracteres. Registro Indice ( Source Index).



El Registro Indice SI permite realizar operaciones complejas que tomarían más de una instrucción en lenguaje máquina, tales como desplazamientos desplazamientos dentro de un arreglo de datos. Registro Destino ( Destin Index). El Registro Destino DI permite realizar operaciones aún más complejas, tales como asignar el valor de una casilla a otra dentro de un mismo arreglo de datos. Register ). Registro de Banderas ( Flags Register ). El Registro de Banderas FR tiene una longitud de 16 bits, donde cada bit es un sañalizador del resultado de la última operación del microprocesador. microprocesador. A continuación describimos las cuatro banderas más utilizadas.

Bandera de Arrastre CF ( Carry Flag ). ). Su valor será 1 si una operación aritmética realizada en el Acumulador AX genera una valor mayor a 16 bits y será 0 si el resultado en AX no se desborda. Bandera de Paridad PF ( Parity Flag ). ). Su valor será 1 si la cantidad de bits encendidos en el Acumulador es un número par y será 0 si es impar. Se utiliza generalmente en aplicaciones para comunicación. Bandera de Cero ZF ( Zero Flag ). ). Su valor será 1 si el resultado en el Acumulador AX es 0 y será 0 si el resultado es diferente de 0. Permite saber si el valor de AX es 0 sin comparar los 16 bits del Acumulador. Bandera de Signo SF ( Sign Flag ). ). Su valor será 1 si el resultado en el Acumulador es un número negativo y será 0 si no es negativo. Le ahorra al programador el hecho de preguntar si los 16 bits del Acumulador es un número menor que 0. Pointer ). Puntero de Instrucción IP ( Instruction Pointer ). Es un registro donde se almacena la dirección en la memoria RAM de la siguiente instrucción del programa a ejecutar. Es un contador relativo al registro CS ( Code Regisgter ), ), esto es, indica el desplazamiento en bytes dentro del código.

Estructura de un Programa en Ensamblador. Un programa en Lenguaje Ensamblador se compone de cuatro segmentos: Código, Datos, Pila y Extra. El procesador cuenta con cuatro registros de propósito específico para almacenar las direcciones en memoria de estos cuatro segmentos: Registro de Segmento de Código CS ( Code Segment ). ). Este registro permite almacenar una dirección de 16 bits que indica la primera casilla en la memoria RAM donde se encuentran todas las instrucciones ejecutables del programa. Registro de Segmento de Datos DS ( Data Segment ). ). Almacena la dirección del segmento de datos del programa, es decir, indica la primera casilla en la memoria RAM donde se encuentran las variables del programa. Registro de Segmento de Pila SS ( Stack Segment ). ). Contiene la dirección inicial de la región de memoria que se reserva previamente para trabajar las llamadas a rutinas del programa ejecutable. Registro de Segmento Extra ES ( Extra Segment ). Segment ). Contiene la dirección de una región de memoria que se reserva para operaciones especiales, tales como transferir el control del programa a otro otro programa en una región región distinta. distinta. El segmento extra extra en un programa programa es opcional. En el siguiente código se define la estructura de un programa en Ensamblador sin instrucciones y ni datos, sólo el esqueleto. assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax ;instrucciones


cseg dseg dseg sseg sseg

mov int ends


ax, 4C00h 21h

segment byte ;datos ends segment stack db 100h dup(?) ends end start

Comandos del Lenguaje Ensamblador. A continuación se listan los comandos (mnemónicos) más comúnmente utilizados en Lenguaje Ensamblador, su sintaxis, señalizadores (banderas) afectados y ejemplos. La estructura de una instrucción en Ensamblador consiste de tres elementos: mnemónico, destino y fuente. El mnemónico indica la operación a realizar. El destino indica el registro o variable que actuará como primer operando y donde se guardará el resultado. Por último, fuente es el segundo operando y no sufre ningún cambio. Algunas instrucciones no requieren de un segundo operando. ADD Suma dos operandos, almacena el resultado en destino. Sintaxis: ADD destino, fuente Banderas: CF, PF, SF, ZF Ejemplos: ADD AX, BX ADD TOT, AX ADD DX, VAR ADD AL, 24 ADD VAR, 3245h ADD SUMA, 10101010b ADD CH, TABLA[BX][SI]

AND Calcula la operación AND Lógica de dos operandos, almacena el resultado en destino. Sintaxis: AND destino, fuente Banderas: CF, PF, SF, ZF Ejemplos: AND AX, BX AND TOT, 0101001010110110b AND DX, VAR AND AL, 0D4h AND VAR, 4DA7h AND SUMA, 11010010b CMP Compara dos operandos. En realidad, resta el operando fuente del destino, afectando las banderas sin alterar los operandos. Sintaxis: CMP destino, fuente Banderas: CF, PF, SF, ZF Ejemplos: CMP AX, BX CMP TOT, 1 CMP DX, VAR CMP AL, 0D4h CMP AH, TABLA[BX][SI] CMP RES, 00110100b DEC Decrementa el operando destino en 1. Utiliza un único operando donde guarda el resultado. Sintaxis: DEC destino Banderas: PF, SF, ZF Ejemplos: DEC AX


DEC DEC DEC


TOT TABLA[BX][SI] AL

DIV Realiza la división de AX entre fuente y almacena el cociente del resultado en AL y el residuo en AH cuando el operando fuente es de 8 bits. Si es de 16 bits, el dividendo de 32 bits se almacena en DX:AX y el cociente queda almacenado en AX y el residuo en DX. Se debe cargar previamente el dividendo en AX o DX:AX. Sintaxis: DIV fuente Banderas: CF, PF, SF Ejemplos: DIV AX DIV TOT DIV AL DIV 45h DIV TABLA[BX][SI] INC Incrementa el operando destino en 1. Utiliza un único operando donde guarda el resultado. No altera la bandera CF. destino Sintaxis: INC Banderas: PF, SF, ZF Ejemplos: INC AX INC TOT INC TABLA[BX][SI] INC AL INT Realiza la llamada a la tabla de interrupciones del procesador, donde el operando fuente es el número de interrupción. Sintaxis: INT fuente Banderas: Todas o ninguna, depende de la tarea Ejemplos: INT 10h INT 21h INT 1Ah JMP Realiza un salto incondicional desde una dirección de instrucción hasta otra, modificando el registro IP ( Instruction Pointer ) sin almacenar ningún resultado. etiqueta Sintaxis: JMP Banderas: Todas o ninguna, depende de la tarea Ejemplos: JMP siguiente JMP fin J(condición) Realiza un salto condicional desde una dirección de instrucción hasta otra, modificando el registro IP ( Instruction Pointer ) sin almacenar ningún resultado. Para usar esta instrucción, previamente se debe realizar la comparación de los operandos. La condición soporta las siguientes condiciones: J(cond ) JA JAE JB JBE JC JCXZ JE JNA JNAE JNB JNBE JNC JNE JNP JNS JNZ

JUMP IF ABOVE ABOVE OR EQUAL BELOW BELOW OR EQUAL CARRY CX IS ZERO EQUAL NOT ABOVE NOT ABOVE OR EQUAL NOT BELOW NOT BELOW OR EQUAL NOT CARRY NOT EQUAL NO PARITY FLAG NO SIGN FLAG NO ZERO FLAG

SALTA SI MAYOR QUE MAYOR O IGUAL QUE MENOR QUE MENOR O IGUAL QUE ACARREO CX ES IGUAL A CERO IGUAL NO ES MAYOR QUE NO ES MAYOR O IGUAL QUE NO ES MENOR QUE NO ES MENOR O IGUAL QUE NO HAY ACARREO NO ES IGUAL BANDERA DE PARIDAD ES 0 BANDERA DE SIGNO ES 0 BANDERA DE CERO ES 0


JP JS JZ

PARITY FLAG SIGN FLAG ZERO FLAG

Sintaxis: Banderas: Ejemplos:


BANDERA DE PARIDAD ES 1 BANDERA DE SIGNO ES 1 BANDERA DE CERO ES 1

J(cond ) etiqueta Ninguna JE INICIO JNAE CALCULA JNC MENOR JNZ MAYOR JB REPITE

LOOP Permite hacer ciclos usando a CX como contador. La instrucción LOOP decrementa el registro CX y realiza el salto hasta la dirección señalada por etiqueta. El ciclo termina cuando el valor de CX es cero. La instrucción LOOP soporta las siguientes condiciones: INSTRUCCIÓN LOOP LOOPE LOOPNE LOOPNZ LOOPZ

REALIZA EL SALTO A ETIQUETA SI CX es diferente de CERO CX es diferente de CERO y ZF = 1 CX es diferente de CERO y ZF = 0 CX es diferente de CERO y ZF = 0 CX es diferente de CERO y ZF = 1

Sintaxis: Banderas: Ejemplos:

LOOP etiqueta Ninguna LOOP CICLO LOOPE REPITE

MOV Copia el contenido del operando fuente al operando destino. Sintaxis: MOV destino, fuente Banderas: Ninguna Ejemplos: MOV AX, BX MOV TOT, 1 MOV DX, VAR MOV SUMA, CX MOV AL, 0D4h MOV CX, TABLA[BX][SI] MOV BX, 0D3A5h MOV AH, 01101000b MUL Permite realizar una multiplicación, el contenido del registro AL por el operando fuente y almacena el resultado en AX cuando el operando fuente es de 8 bits. Si es de 16 bits, se almacena en AX y el resultado se guarda en DX:AX. Se debe cargar previamente el primer operando en AL o en AX. Sintaxis: MUL fuente Banderas: CF Ejemplos: MUL AX MUL TOT MUL AL NOT Realiza la negación lógica del operando, invierte cada bit de la palabra, dejando el resultado en el mismo operando. Sintaxis: NOT destino Banderas: Ninguna Ejemplos: NOT AX NOT BL OR



Realiza la disyunción lógica de dos operandos y almacena el resultado en el operando destino. Sintaxis: OR destino, fuente Banderas: CF, PF, SF, ZF Ejemplos: OR AX, CX OR BL, DH OR SI, 0E5B4h OR CL, 64 POP Recupera el valor almacenado en la pila con el comando PUSH y lo pasa al operando destino. Este valor está apuntado en la pila por el registro SP ( Stack Pointer ). destino Sintaxis: POP Banderas: Ninguna Ejemplos: POP AX POP BL

PUSH Almacena el valor del operando fuente en la pila, el cual quedará apuntado por el registro SP ( Stack Pointer ). Sintaxis: PUSH fuente Banderas: Ninguna Ejemplos: PUSH AX PUSH BL RC(L/R) Realiza un desplazamiento circular usando el bit de arrastre CF ( Carry Flag ) hacia la izquierda L ( left ) o derecha R ( right ). Sintaxis: RCL/RCR destino, cuenta Banderas: CF Ejemplos: RCL AX, 1 RCR BL, CL RCL CL, 5 RCR DX, BL

RO(L/R) Realiza un desplazamiento circular hacia la izquierda L ( left ) o derecha R ( right ). Sintaxis: ROL/ROR fuente, cuenta Banderas: Ninguna Ejemplos: ROL AX, 1 ROR BL, CL SUB Resta dos operandos, almacena el resultado en destino. Sintaxis: SUB destino, fuente Banderas: CF, PF, SF, ZF Ejemplos: SUB AX, BX SUB TOT, AX SUB DX, VAR SUB AL, 24 SUB VAR, 3245h XOR Realiza la disyunción exclusiva de dos operandos y almacena el resultado en el operando destino. Sintaxis: XOR destino, fuente Banderas: CF, PF, SF, ZF Ejemplos: XOR AX, CX XOR BL, DH XOR SI, 0E5B4h XOR CL, 64



Tabla de Valores de la Interrupción 10H. Las operaciones realizadas con la interrupción 10H están orientadas básicamente al manejo del monitor. AH AH=0

Función Inicia el modo de visualizar

AH=1

Inicia el tipo de cursor

Entrada AL=0 AL=1 AL=2 AL=3 AL=4 AL=5 AL=6 AL=10 CH=

CL=

AH=2

Inicia posición del cursor

AH=3

Lee posición del cursor

AH=6

Limpiar Pantalla

AH=8

Lee caracter con atributo

AH=9

Escribe caracter con atributo

AH=12

Dibuja pixel

AH=13

Lee pixel

DH= DL= BH= DH= DL= CH= CL= BH= AL= CH= CL= DH= DL= BH= BH= AL= AH= BH= CX= AL= BL= DX= CX= AL= DX= CX= AL=

Salida 40x25 B/W 40x25 Color 80x25 B/W 80x25 Color 320x200 G. Color 320x200 G. B/W 640x200 G. B/W 640x350 E.G.A. Bits 4-0 Principio de línea cursor Bits 4-0 Fin de línea para cursor Renglón Columna Página de pantalla Renglón Columna Modo Cursor Modo Cursor Página de pantalla Número de líneas 0 = completa Renglón inicial Columna inicial Renglón Final Columna Final Atributo BFFFTTTT Página de pantalla Caracter leído Atributo leído Página de pantalla Cantidad Caracter Atributo Renglón Columna Color del pixel Renglón Columna Color del pixel

Tabla de Valores de la Interrupción 21H. Las operaciones realizadas con la interrupción 10H están orientadas básicamente al manejo del teclado. AH AH=01 AH=02 AH=07

Entrada

AH=09

Función Lee caracter Escribe caracter Lee caracter (no visualiza) Despliega cadena

AH=2A

Lee fecha

AH=2B

Escribe fecha

AH=2C

Lee hora

AH=2D

Escribe hora

CX= DH= DL= CX= DH= DL= CH= CL= CH=

DL=

DS:DX=

Salida AL=caracter leído Carácter AL=caracter leído Dirección (offset) termina con '$' Año Mes (1 - 12) Día (1 - 31) Año Mes (1 - 12) Día (1 - 31) Horas (0 - 23) Minutos (0 - 59) Horas (0 - 23)

Ingeniería en Sistemas Computacionales CL=

Lenguaje Ensamblador Minutos (0 - 59)

Tabla de Colores. Valor 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Color Negro Azul Verde Cyan Rojo Magenta Café Gris Claro Gris Oscuro Azul Claro Verde Claro Cyan Claro Rojo Claro Magenta Claro Amarillo Blanco

Fondo / Texto si si si si si si si si si si si si si si si si no si no si no si no si no si no si no si no si

Light Assembler .

El Lenguaje Ensamblador Ligero es un shareware disponible en internet para aplicaciones académicas, ocupa muy poco espacio en disco y pueden compilar programas de 150 líneas de código o menos. Consta de cinco programas ejecutables que funcionan bajo MS-DOS: LASM.EXE Permite compilar programas escritos en lenguaje ensamblador. Recibe como parámetro un archivo de texto con extensión ".ASM". Verifica que no tenga errores sintácticos y si los tiene, despliega un mensaje de error señalando el número de línea. Genera como resultado un archivo del mismo nombre pero con extensión ".OBJ". LASM = Light AsseMbler. Ejemplo: LASM hello LASM32.EXE Permite compilar programas usando los registros de 32 bits de los procesadores 80386 en adelante. Ejemplo: LASM32 hello LIL.EXE Toma el archivo ".OBJ" generado con LASM.EXE y lo convierte a programa ejecutable. LIL = Light Linker. Ejemplo: LIL hello LIL32.EXE Toma el archivo ".OBJ" generado con LASM.EXE y lo convierte a programa ejecutable usando los registros de 32 bits de los procesadores 80386 en adelante. LID.EXE Toma el archivo ejecutable generado con LIL.EXE y lo ejecuta línea por línea, mostrando los valores de todos los registros del procesador en cada paso. LID = Light Debuger. Ejemplo: LID hello

; Programa #1 ; Desplegar una cadena assume

cs:cseg,ds:dseg,ss:sseg

Ingeniería en Sistemas Computacionales cseg segment start: mov ax, dseg mov ds, ax ;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h

cseg

mov int ends

dseg msg dseg

segment byte db 'Hola mundo!$' ends

sseg

segment stack db 100h dup(?) ends

sseg

end

ax, 4C00h 21h

start

; Programa #2 ; Limpiar la pantalla ; Desplegar una cadena assume


cseg segment start: mov ax, dseg mov ds, ax ;Limpiar la pantalla mov ah,6 mov al,0 mov ch,0 mov cl,0 mov dh,24 mov dl,79 mov bh,07h ; BFFF TTTT int 10h ;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h

cseg

mov int ends

dseg msg dseg


sseg


sseg

end

; ; ; ;

ax, 4C00h 21h

start

Programa #3 Limpiar la pantalla Posición del cursor Desplegar una cadena


Ingeniería en Sistemas Computacionales assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax ;Limpiar la pantalla mov ah,6 mov al,0 mov ch,0 mov cl,0 mov dh,24 mov dl,79 mov bh,07h ; BFFF TTTT int 10h ;Posición del cursor mov ah,2 mov dh,5 mov dl,30 mov bh,0 int 10h ;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h

cseg

mov int ends

dseg msg dseg


sseg

segment stack db 100h dup(?) ends end start

sseg

; ; ; ; ;

ax, 4C00h 21h

Programa #4 Limpiar la pantalla Posición del cursor Modificar el color Desplegar una cadena assume


cseg segment start: mov ax, dseg mov ds, ax ;Limpiar la pantalla mov ah,6 mov al,0 mov ch,0 mov cl,0 mov dh,24 mov dl,79 mov bh,07h ; BFFF TTTT int 10h ;Posici¢n del cursor mov ah,2 mov dh,5 mov dl,30 mov bh,0 int 10h ;Cambiar el color mov ah,9 mov bh,0 mov cx,12


Ingeniería en Sistemas Computacionales mov al,' ' mov bl,1Eh int 10h ;Posici¢n del cursor mov ah,2 mov dh,5 mov dl,30 mov bh,0 int 10h ;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h

cseg

mov int ends

dseg msg dseg


sseg


sseg

ax, 4C00h 21h

; Programa #5 ; Desplegar la portada UNO assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax ;Limpiar la pantalla mov ah,6 mov al,0 mov ch,0 mov cl,0 mov dh,24 mov dl,79 mov bh,07h ; BFFF TTTT int 10h ;Posición del cursor mov ah,2 mov dh,5 mov dl,30 mov bh,0 int 10h ;Cambiar el color mov ah,9 mov bh,0 mov cx,24 mov al,' ' mov bl,71h int 10h ;Posici¢n del cursor mov ah,2 mov dh,5 mov dl,30 mov bh,0 int 10h ;Desplegar una cadena mov dx, offset msg1 mov ah, 09h


Ingeniería en Sistemas Computacionales int 21h ;Posici¢n del cursor mov ah,2 mov dh,6 mov dl,30 mov bh,0 int 10h ;Cambiar el color mov ah,9 mov bh,0 mov cx,24 mov al,' ' mov bl,72h int 10h ;Posici¢n del cursor mov ah,2 mov dh,6 mov dl,30 mov bh,0 int 10h ;Desplegar una cadena mov dx, offset msg2 mov ah, 09h int 21h ;Posición del cursor mov ah,2 mov dh,7 mov dl,30 mov bh,0 int 10h ;Cambiar el color mov ah,9 mov bh,0 mov cx,24 mov al,' ' mov bl,74h int 10h ;Posición del cursor mov ah,2 mov dh,7 mov dl,30 mov bh,0 int 10h ;Desplegar una cadena mov dx, offset msg3 mov ah, 09h int 21h

cseg dseg msg1 msg2 msg3 dseg sseg sseg

mov int ends

ax, 4C00h 21h

segment byte db 'Programa de Ejemplo$' db 'Lenguaje Ensamblador$' db 'Light Assembler$' ends segment stack db 100h dup(?) ends end start

; Programa #6 ; Visualizar un caracter


Ingeniería en Sistemas Computacionales assume


cseg segment start: mov ax, dseg mov ds, ax ; Visualizar un caracter mov ah,2 mov dl,'A' int 21h

cseg

mov int ends

dseg msg1 msg2 msg3 dseg

segment byte db 'Programa de Ejemplo$' db 'Lenguaje Ensamblador$' db 'Light Assembler$' ends

sseg


sseg

end

ax, 4C00h 21h

start

; Programa #7 ; Leer un caracter con eco ; Visualizar el caracter leido assume


cseg segment start: mov ax, dseg mov ds, ax ; Leer un caracter con eco mov ah,1 int 21h ; Visualizar el caracter leido mov ah,2 mov dl,al int 21h

cseg

mov int ends



sseg


sseg

; Programa #8

ax, 4C00h 21h


Ingeniería en Sistemas Computacionales ; Leer un caracter sin eco ; Visualizar el caracter leido assume


cseg segment start: mov ax, dseg mov ds, ax ; Leer un caracter con eco mov ah,8 int 21h ; Visualizar el caracter leido mov ah,2 mov dl,al int 21h

cseg

mov int ends



sseg


sseg

end

ax, 4C00h 21h

start

; Programa #9 ; Visualizar ABCDEFGHIJ manejando un ciclo assume


cseg segment start: mov ax, dseg mov ds, ax mov mov ciclo: mov int inc loop

cx,15 dl,'A'

ax, 4C00h 21h

cseg

mov int ends



sseg


sseg

end

ah,2 21h dl ciclo

start


Ingeniería en Sistemas Computacionales ; Programa #10 ; Comparar mayúsculas y minúsculas assume


cseg segment start: mov ax, dseg mov ds, ax mov int

ah,1 21h

cmp jb mov mov int jmp may: mov mov int fin:

al,94 may ah,9 dx,offset lmin 21h fin

ax, 4C00h 21h

cseg

mov int ends

dseg lmay lmin dseg

segment byte db ' May£scula$' db ' Min£scula$' ends

sseg


sseg

end

; al=caracter leido

ah,9 dx,offset lmay 21h

start

; Programa #11 ; Visualizar un arreglo de caracteres assume


cseg segment start: mov ax, dseg mov ds, ax mov mov ciclo: mov mov int inc loop

cx,20 si,0

ax, 4C00h 21h

cseg

mov int ends

dseg msg dseg

segment byte db 'Universidad del Noroeste$' ends

sseg


sseg

end

ah,2 dl,msg[si] 21h si ciclo

start



; Programa #12 ; Leer un arreglo de caracteres ; Desplegar el arreglo como una cadena assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov mov ciclo: mov int mov inc loop mov mov mov int mov mov int

cx,10 si,0 ah,1 21h msg[si],al si ciclo msg[si],'$' ah,2 dl,0Ah 21h ah,2 dl,0Dh 21h

;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h

cseg

mov int ends

dseg msg dseg

segment byte db 20 dup(?) ends

sseg


sseg

ax, 4C00h 21h

; Programa #13 ; Leer una cadena y convertirla a mayúsculas assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov mov ciclo: mov int cmp jb sub may: mov inc loop

cx,10 si,0

ah,1 21h ; al=caracter leido al,94 may al,32 msg[si],al si ciclo

mov

msg[si],'$'

mov mov int mov

ah,2 dl,0Ah 21h ah,2


Ingeniería en Sistemas Computacionales mov dl,0Dh int 21h ;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h

cseg

mov int ends

dseg msg dseg


sseg


sseg

ax, 4C00h 21h

; Programa #14 ; Leer una cadena y convertirla a minúsculas assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov mov ciclo: mov int cmp ja add min: mov inc loop

cx,10 si,0

ah,1 21h ; al=caracter leido al,94 min al,32 msg[si],al si ciclo

mov

msg[si],'$'

mov mov int mov mov int

ah,2 dl,0Ah 21h ah,2 dl,0Dh 21h

;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h

cseg

mov int ends

dseg msg dseg


sseg


sseg

ax, 4C00h 21h



; Programa #15 ; ORDENAMIENTO BURBUJA assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov mov int

dx, offset dato ah, 09h 21h

mov cx,9 mov bx,0 ciclo1: push cx mov SI,9 ciclo2: mov DI,SI dec DI mov al, dato[DI] mov ah, dato[SI] cmp al, ah jb nomov ;si es menor, no intercambia mov al, dato[SI] mov ah, dato[DI] mov dato[DI],al mov dato[SI],ah nomov: dec SI loop ciclo2 mov dx, offset dato; imprime en cada ciclo mov ah, 09h int 21h inc bx pop cx loop ciclo1 mov mov int

dx, offset dato ah, 09h 21h ax, 4C00h 21h

cseg

mov int ends

dseg dato dseg

segment byte db '8140936275',0Dh,0Ah,'$' ends

sseg

segment s tack db 100h dup(?) ends end start

sseg

; Programa #16 ; Convertir un número de 16 bits a binario assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov mov CICLO: mov and jnz

cx,16 bx,8000h ax,bx ax,dato UNO

;máscara


Ingeniería en Sistemas Computacionales mov ah,2 mov dl,48 int 21h ;Desp 0 jmp CERO UNO: mov ah,2 mov dl,49 int 21h ;Desp 1 CERO: ror bx,1 loop CICLO

cseg

mov int ends

dseg dato dseg

segment byte dw 1842h ends

sseg


sseg


ax, 4C00h 21h

; Programa #17 ; Leer un número de 16 bits en binario assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov mov

cx,16 ;Leer 16 bits bx,8000h ; m scara

REPITE: mov ah,1 int 21h cmp al,'1' jne IGUAL or dato,bx jmp SIG IGUAL: cmp je mov mov int mov SIG: ror loop

al,'0' SIG dx,offset error ah,9 21h cx,1 bx,1 REPITE

mov mov int

dx,offset linea ah,9 21h

mov mov

cx,16 ;Desp numero leido bx,8000h ; m scara

CICLO: mov and jnz mov mov int jmp UNO: mov mov

ax,bx ax,dato UNO ah,2 dl,48 21h ;Desp 0 CERO ah,2 dl,49

;Nueva linea

Ingeniería en Sistemas Computacionales int 21h ;Desp 1 CERO: ror bx,1 loop CICLO

cseg

mov int ends

dseg dato error linea dseg

segment byte dw 0000h db 'Error de Lectura!$' db 0Ah, 0Dh, '$' ends

sseg


sseg

ax, 4C00h 21h

; Programa #18 ; Verificar la paridad assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov mov mov CICLO: mov and jz cmp jz mov jmp OK: mov SIG: mov int ror loop

cx,16 bx,8000h dl,48

; m scara

ax,bx ax,dato SIG dl,48 OK dl,48 SIG dl,49 ah,2 21h bx,1 CICLO

cmp je mov jmp ESPAR: mov NEXT: mov int

dl,48 ESPAR dx,offset msg2 NEXT

ax, 4C00h 21h

cseg

mov int ends

dseg dato msg1 msg2 dseg

segment byte dw 0421h db 0Ah, 0Dh, 'Es par$' db 0Ah, 0Dh, 'Es impar$' ends

sseg


sseg

dx,offset msg1 ah,9 21h



; Programa #19 ; Determina la hora del sistema assume


cseg segment start: mov ax, dseg mov ds, ax ;Leer hora del sistema mov ah,02h int 1Ah mov mov mov mov div mov mov mov mov mov mov mov mov

ah, 0 al, ch bh, 0 bl, 16 bl bl, ah ah, 0 si, ax di, bx ah, hexa[si] al, hexa[di] hora[0], ah hora[1], al

mov mov mov mov div mov mov mov mov mov mov mov mov

ah, 0 al, cl bh, 0 bl, 16 bl bl, ah ah, 0 si, ax di, bx ah, hexa[si] al, hexa[di] hora[3], ah hora[4], al

mov mov mov mov div mov mov mov mov mov mov mov mov

ah, 0 al, dh bh, 0 bl, 16 bl bl, ah ah, 0 si, ax di, bx ah, hexa[si] al, hexa[di] hora[6], ah hora[7], al

;Desplegar hora como cadena mov dx, offset hora mov ah, 09h int 21h

cseg

mov int ends

ax, 4C00h 21h

dseg hexa hora dseg

segment byte db '0123456789ABCDEF' db '00:00:00$' ends


Ingeniería en Sistemas Computacionales sseg sseg

segment stack db 100h dup(?) ends end

start

; Programa #20 ; Determina la fecha del sistema assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax

cseg

mov int mov mov mov mov div mov mov mov mov mov mov mov mov mov mov mov mov div mov mov mov mov mov mov mov mov mov mov mov mov div mov mov mov mov mov mov mov mov mov mov mov mov div mov mov mov mov mov mov mov mov mov mov int mov int ends

ah,04h ;Leer hora del sistema 1Ah ah, 0 al, ch bh, 0 bl, 16 bl bl, ah ah, 0 si, ax di, bx ah, hexa[si] al, hexa[di] fecha[0], ah fecha[1], al ah, 0 al, cl bh, 0 bl, 16 bl bl, ah ah, 0 si, ax di, bx ah, hexa[si] al, hexa[di] fecha[2], ah fecha[3], al ah, 0 al, dh bh, 0 bl, 16 bl bl, ah ah, 0 si, ax di, bx ah, hexa[si] al, hexa[di] fecha[5], ah fecha[6], al ah, 0 al, dl bh, 0 bl, 16 bl bl, ah ah, 0 si, ax di, bx ah, hexa[si] al, hexa[di] fecha[8], ah fecha[9], al dx, offset fecha ah, 09h ;Desplegar fecha como cadena 21h ax, 4C00h 21h


Ingeniería en Sistemas Computacionales dseg segment byte hexa db '0123456789ABCDEF' fecha db '0000:00:00$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #21 ; Convertir binario 16 bits a decimal de 5 digitos assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov dx,0 mov ax,dato mov bx,10 div bx add dl,48 mov cadena[4], dl mov dx,0 div bx add dl,48 mov cadena[3], dl mov dx,0 div bx add dl,48 mov cadena[2], dl mov dx,0 div bx add dl,48 mov cadena[1], dl add al,48 mov cadena[0], al mov dx,offset cadena mov ah,9 int 21h mov ax, 4C00h int 21h cseg ends dseg segment byte dato dw 65536 cadena db 10 dup(?), '$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start

; ; ; ;

Programa #22 Convertir un numero binario de 16 bits a un numero decimal ascii de 5 digitos (65535) utilizando un ciclo para compactar el codigo

assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov ax,dato mov bx,10 mov cx,5 CICLO: mov dx,0 div bx add dl,48 mov si,cx dec si mov cadena[si], dl loop CICLO mov dx,offset cadena mov ah,9 int 21h mov ax, 4C00h int 21h cseg ends


Ingeniería en Sistemas Computacionales dseg segment byte dato dw 65535 cadena db 10 dup(?), '$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start


Ensamblador[1] USAR UNIDAD 2

Recommend Documents