Assembler exercises

Ingeniería en Sistemas Computacionales Lenguajes de Interfaz

M.C. María Yolanda Huerta Castillo 1

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). 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 programa en una región distinta. El segmento extra en un 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 mov ax, 4C00h int 21h cseg ends dseg segment byte

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



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 Función Entrada Salida AH=0 Inicia el modo AL=0 40x25 B/W de visualizar AL=1 40x25 Color AL=2 80x25 B/W AL=3 80x25 Color AL=4 320x200 G. Color AL=5 320x200 G. B/W AL=6 640x200 G. B/W AL=10 640x350 E.G.A. AH=1 Inicia el tipo CH= Bits 4-0 de cursor Principio de línea cursor CL= Bits 4-0 Fin de línea para cursor AH=2 Inicia posición DH= Renglón del cursor DL= Columna BH= Página de pantalla AH=3 Lee posición DH= Renglón del cursor DL= Columna CH= Modo Cursor CL= Modo Cursor BH= Página de pantalla AH=6 Limpiar Pantalla AL= Número de líneas 0 = completa CH= Renglón inicial CL= Columna inicial DH= Renglón Final DL= Columna Final BH= Atributo BFFFTTTT AH=8 Lee caracter BH= Página de pantalla con atributo AL= Caracter leído AH= Atributo leído AH=9 Escribe caracter BH= Página de pantalla con atributo CX= Cantidad AL= Caracter BL= Atributo AH=12 Dibuja pixel DX= Renglón CX= Columna AL= Color del pixel AH=13 Lee pixel DX= Renglón CX= Columna AL= 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 Función Entrada Salida AH=01 Lee caracter AL=caracter leído AH=02 Escribe caracter DL= Carácter AH=07 Lee caracter AL=caracter leído (no visualiza) AH=09 Despliega cadena DS:DX= Dirección (offset) termina con '$' AH=2A Lee fecha CX= Año DH= Mes (1 - 12) DL= Día (1 - 31) AH=2B Escribe fecha CX= Año DH= Mes (1 - 12) DL= Día (1 - 31) AH=2C Lee hora CH= Horas (0 - 23) CL= Minutos (0 - 59) AH=2D Escribe hora CH= Horas (0 - 23) CL= Minutos (0 - 59) Tabla de Colores. Valor Color Fondo / Texto 0 Negro si si 1 Azul si si 2 Verde si si 3 Cyan si si 4 Rojo si si 5 Magenta si si 6 Café si si 7 Gris Claro si si 8 Gris Oscuro no si 9 Azul Claro no si 10 Verde Claro no si 11 Cyan Claro no si 12 Rojo Claro no si 13 Magenta Claro no si 14 Amarillo no si 15 Blanco 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 cseg segment start:

mov ax, dseg mov ds, ax ;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h mov ax, 4C00h int 21h cseg ends dseg segment byte msg db 'Hola mundo!$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #2 ; Limpiar la pantalla ; Desplegar una cadena 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 ;Desplegar una cadena mov dx, offset msg mov ah, 09h



int 21h mov ax, 4C00h int 21h cseg ends dseg segment byte msg db 'Hola mundo!$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #3 ; Limpiar la pantalla ; Posición del cursor ; Desplegar una cadena 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 mov ax, 4C00h int 21h cseg ends



dseg segment byte msg db 'Hola mundo!$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #4 ; Limpiar la pantalla ; Posición del cursor ; Modificar el color ; Desplegar una cadena 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,12 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 mov ax, 4C00h int 21h cseg ends dseg segment byte msg db 'Hola mundo!$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; 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 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 mov ax, 4C00h int 21h cseg ends dseg segment byte msg1 db 'Programa de Ejemplo$' msg2 db 'Lenguaje Ensamblador$' msg3 db 'Light Assembler$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #6 ; Visualizar un caracter assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax ; Visualizar un caracter mov ah,2 mov dl,'A' int 21h mov ax, 4C00h int 21h cseg ends dseg segment byte msg1 db 'Programa de Ejemplo$' msg2 db 'Lenguaje Ensamblador$' msg3 db 'Light Assembler$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start



; Programa #7 ; Leer un caracter con eco ; Visualizar el caracter leido assume cs:cseg,ds:dseg,ss:sseg 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 mov ax, 4C00h int 21h cseg ends dseg segment byte msg1 db 'Programa de Ejemplo$' msg2 db 'Lenguaje Ensamblador$' msg3 db 'Light Assembler$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #8 ; Leer un caracter sin eco ; Visualizar el caracter leido assume cs:cseg,ds:dseg,ss:sseg 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 mov ax, 4C00h int 21h cseg ends dseg segment byte msg1 db 'Programa de Ejemplo$' msg2 db 'Lenguaje Ensamblador$' msg3 db 'Light Assembler$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #9 ; Visualizar ABCDEFGHIJ manejando un ciclo assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov cx,15 mov dl,'A' ciclo: mov ah,2 int 21h inc dl loop ciclo mov ax, 4C00h int 21h cseg ends dseg segment byte msg1 db 'Programa de Ejemplo$' msg2 db 'Lenguaje Ensamblador$' msg3 db 'Light Assembler$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start



; Programa #10 ; Comparar mayúsculas y minúsculas assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov ah,1 int 21h ; al=caracter leido cmp al,94 jb may mov ah,9 mov dx,offset lmin int 21h jmp fin may: mov ah,9 mov dx,offset lmay int 21h fin: mov ax, 4C00h int 21h cseg ends dseg segment byte lmay db ' May£scula$' lmin db ' Min£scula$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #11 ; Visualizar un arreglo de caracteres assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov cx,20 mov si,0 ciclo:



mov ah,2 mov dl,msg[si] int 21h inc si loop ciclo mov ax, 4C00h int 21h cseg ends dseg segment byte msg db 'Instituto Tecnologico de Hermosillo$' dseg ends sseg segment stack db 100h dup(?) sseg ends end 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 cx,10 mov si,0 ciclo: mov ah,1 int 21h mov msg[si],al inc si loop ciclo mov msg[si],'$' mov ah,2 mov dl,0Ah int 21h mov ah,2 mov dl,0Dh int 21h ;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h mov ax, 4C00h int 21h



cseg ends dseg segment byte msg db 20 dup(?) dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; 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 cx,10 mov si,0 ciclo: mov ah,1 int 21h ; al=caracter leido cmp al,94 jb may sub al,32 may: mov msg[si],al inc si loop ciclo mov msg[si],'$' mov ah,2 mov dl,0Ah int 21h mov ah,2 mov dl,0Dh int 21h ;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h mov ax, 4C00h int 21h cseg ends dseg segment byte msg db 20 dup(?)



dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; 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 cx,10 mov si,0 ciclo: mov ah,1 int 21h ; al=caracter leido cmp al,94 ja min add al,32 min: mov msg[si],al inc si loop ciclo mov msg[si],'$' mov ah,2 mov dl,0Ah int 21h mov ah,2 mov dl,0Dh int 21h ;Desplegar una cadena mov dx, offset msg mov ah, 09h int 21h mov ax, 4C00h int 21h cseg ends dseg segment byte msg db 20 dup(?) dseg ends sseg segment stack



db 100h dup(?) sseg ends end start ; Programa #15 ; ORDENAMIENTO BURBUJA assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov dx, offset dato mov ah, 09h int 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 dx, offset dato mov ah, 09h int 21h mov ax, 4C00h int 21h cseg ends dseg segment byte dato db '8140936275',0Dh,0Ah,'$'



dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; 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 cx,16 mov bx,8000h ;máscara CICLO: mov ax,bx and ax,dato jnz UNO 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 mov ax, 4C00h int 21h cseg ends dseg segment byte dato dw 1842h dseg ends sseg segment stack db 100h dup(?) sseg ends end start



; 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 cx,16 ;Leer 16 bits mov bx,8000h ;m scara REPITE: mov ah,1 int 21h cmp al,'1' jne IGUAL or dato,bx jmp SIG IGUAL: cmp al,'0' je SIG mov dx,offset error mov ah,9 int 21h mov cx,1 SIG: ror bx,1 loop REPITE mov dx,offset linea ;Nueva linea mov ah,9 int 21h mov cx,16 ;Desp numero leido mov bx,8000h ;m scara CICLO: mov ax,bx and ax,dato jnz UNO 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



mov ax, 4C00h int 21h cseg ends dseg segment byte dato dw 0000h error db 'Error de Lectura!$' linea db 0Ah, 0Dh, '$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #18 ; Verificar la paridad assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax mov cx,16 mov bx,8000h ;m scara mov dl,48 CICLO: mov ax,bx and ax,dato jz SIG cmp dl,48 jz OK mov dl,48 jmp SIG OK: mov dl,49 SIG: mov ah,2 int 21h ror bx,1 loop CICLO cmp dl,48 je ESPAR mov dx,offset msg2 jmp NEXT ESPAR: mov dx,offset msg1 NEXT: mov ah,9 int 21h



mov ax, 4C00h int 21h cseg ends dseg segment byte dato dw 0421h msg1 db 0Ah, 0Dh, 'Es par$' msg2 db 0Ah, 0Dh, 'Es impar$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start ; Programa #19 ; Determina la hora del sistema assume cs:cseg,ds:dseg,ss:sseg cseg segment start: mov ax, dseg mov ds, ax ;Leer hora del sistema mov ah,02h int 1Ah mov ah, 0 mov al, ch mov bh, 0 mov bl, 16 div bl mov bl, ah mov ah, 0 mov si, ax mov di, bx mov ah, hexa[si] mov al, hexa[di] mov hora[0], ah mov hora[1], al mov ah, 0 mov al, cl mov bh, 0 mov bl, 16 div bl mov bl, ah mov ah, 0 mov si, ax mov di, bx



mov ah, hexa[si] mov al, hexa[di] mov hora[3], ah mov hora[4], al mov ah, 0 mov al, dh mov bh, 0 mov bl, 16 div bl mov bl, ah mov ah, 0 mov si, ax mov di, bx mov ah, hexa[si] mov al, hexa[di] mov hora[6], ah mov hora[7], al ;Desplegar hora como cadena mov dx, offset hora mov ah, 09h int 21h mov ax, 4C00h int 21h cseg ends dseg segment byte hexa db '0123456789ABCDEF' hora db '00:00:00$' dseg ends sseg segment stack db 100h dup(?) sseg 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 mov ah,04h ;Leer hora del sistema int 1Ah mov ah, 0

mov al, ch mov bh, 0 mov bl, 16 div bl mov bl, ah mov ah, 0 mov si, ax mov di, bx mov ah, hexa[si] mov al, hexa[di] mov fecha[0], ah mov fecha[1], al mov ah, 0 mov al, cl mov bh, 0 mov bl, 16 div bl mov bl, ah mov ah, 0 mov si, ax mov di, bx mov ah, hexa[si] mov al, hexa[di] mov fecha[2], ah mov fecha[3], al mov ah, 0 mov al, dh mov bh, 0 mov bl, 16 div bl mov bl, ah mov ah, 0 mov si, ax mov di, bx mov ah, hexa[si] mov al, hexa[di] mov fecha[5], ah mov fecha[6], al mov ah, 0 mov al, dl mov bh, 0 mov bl, 16 div bl



mov bl, ah mov ah, 0 mov si, ax mov di, bx mov ah, hexa[si] mov al, hexa[di] mov fecha[8], ah mov fecha[9], al mov dx, offset fecha mov ah, 09h ;Desplegar fecha como cadena int 21h mov ax, 4C00h int 21h cseg ends 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 dseg segment byte dato dw 65535 cadena db 10 dup(?), '$' dseg ends sseg segment stack db 100h dup(?) sseg ends end start

Documents

Assembler exercises