Problemas Resueltos Parte III

Profesor: David Velasco

Ayudante: Francisco Pizarro

Primera prueba de microprocesadores octubre 2002
Disee un programa en assembler 8088 que concierta 4 bytes de memoria que
tienen como contenido una direccin en formato offset segmento(32 bits) a una
notacin lineal de 32 bits
-Entrada ES:BX puntero a los 4 bytes de memoria
Ejemplo
ENTRADA
ES= 2000
BX= 0700
ol oh-sl sh
2000:0700 34 12 78 56 00 00 00 00 00 00 00 00 00 00 00 00
2000:0710 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

-Vector inicial = 5678:1234 56780+1234=579B4

-Salida
2000:0700 B4 79 05 00 00 00 00 00 00 00 00 00 00 00 00 00
2000:0710 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

MOV AX, ES
MOV DS, AX
MOV AX, [BX] ; AX=1234
MOV DX. [BX+02] ; DX=5678
XOR CX,CX
MOV [BX], CX ; DEJAMOS EN 0 EL CONTENIDO DE LA MEMORIA
MOV [BX+02], CX
PUSH AX
MOV CL, 04
SHR AX, CL
ADD DX, AX ; VER COMENTARIO AL FINAL
JNC @CONTINUAR
MOV [BX], DL
SHR DX, CL
ADD DX, 1000
JMP @CONTINUAR_2
@CONTINUAR: MOV [BX], DL ;SI NO HAY CARRY QUEDA DS:BX= 9B
SHR DX, CL ;DX=0597
@CONTINUAR_2: POP AX ; AX= 1234 NUEVAMENTE
MOV [BX+1], DX ; DS:BX= 9B 79 05 00
XOR DX, DX
MOV DL, [BX]
AND DX, F
SHL DX, CL
AND AX, F
ADD AL, DL
MOV [BX], AL ; DS:BX= B4 79 05 00
Ya, el asunto es el siguiente, tenemos que mandar los bits de la forma que nos piden,
entonces, vamos a dividir la famosa suma segment:offset en dos partes.
Primero guardamos el valor de AX en la pila, para as no perderlo. Despus
desplazamos ese registro hacia la derecha para perder el bit del extremo derecho y
proceder con al suma, o sea nos quedara la suma
DX=5678
AX=123
Si sumamos da como resultado DX=579B
Ahora, supongamos que al hacer la suma, no hay carry, entonces saltamos a
@continuar. En caso de haber carry, hay que hacer un arreglo, pero eso estar
comentado al final. No hay que perder de vista que nuestro objetivo es que la salida de
memoria quede DS:BX= B4 79 05 00 que es el resultado de la suma famosa.
Entonces, en continuar tenemos el comando MOV [BX], DL lo que nos dara como
resultado DS:BX= 9B. Despus el comando de desplazamiento de bits nos dara como
resultado DX= 0579. Queda bastante poco ya para terminar el programa, solo basta
recuperar el valor que tenamos de AX para realizar las ultimas operaciones.
Ahora MOV [BX+1], DX nos dara como resultado DS:BX= 9B 79 05 00. Estamos a
4 bits de realizar nuestro cometido. Cmo obtenemos esos bits?. Si se dan cuenta el
nico numero que nos falta es el 4 que corresponde a los ltimos 4 bits del registro
AX (RECUERDEN QUE HICIMOS UN POP). Entonces, despus de los comandos
de desplazamiento de bits y comparacin lgica, nos da como resultado
DS:BX= B4 79 05 00.
Ahora basta arreglar el nico problema que podra tener este programa. Supongan que
AX despus del desplazamiento quede AX=0FFF y DX=FFFF. La suma quedara
DX=0FFE (suma en 8088) pero nosotros queremos obtener la suma real que es
FFFF+FFF=10FFE.
Este overflow se arregla de la siguiente manera
MOV [BX], DL ; DS:BX=FE
SHR DX, CL ; DX=00FF
ADD DX, 1000 ; DX=10FF
Eso seria todo para este problema.


















2.-Disee un programa en assembler 8088 que muestre en pantalla el contenido de
1024 bytes apuntados por ES:BX
Entrada: ES: Segmento de bloque de memoria a mostrar
BX : Offset de bloque a mostrar

Salida 01 20 55 44 45 45 44 8A C5 2D F7 C9 12 45 BF D5
Pantalla C4 F6 94 52 A8 67 23 DF 23 78 45 DF C0 A2 F2 54

Este cdigo quedo bastante laaaaaaaaaargo, pero es entendible, prefer hacerlo as en
vez de acortar ciertos procedimientos, pues podria llevar a alguna confusin
Obviamente hay varios saltos que pueden remplazar por call, pero como vamos a hacer
harto manejo de pila, prefer usar jumps para que nos e enreden


MOV AX, ES
MOV DS, AX
MOV CX, 0400
XOR DX, DX
PUSH CX
PUSH BX
MOV CX,F
@imprimir: MOV AL, [BX]
CALL @TRANSFORMAR_ASCII
PUSH AX
MOV AH,0A
PUSH CX
MOV CX,1
MOV BH,0F
INT 10
POP AX
MOV AL,AH
MOV AH,0A
INT 10
INC DL
MOV AL, 20
INT 10 ;HAY UN ESPACIO ENTRE BYTE Y BYTE MOSTRADO
INC DL
POP CX
DEC CX
CMP CX, 0 ;SOLO SE IMPRIMEN 16 CARACTERES POR LINEA
JE @ENTER
JMP @ACTUALIZAR_MEM
@ENTER: MOV AL, 0D
MOV BH, 0F
MOV AH,0A
INT 10
JMP @ACUALIZAR_MEM



@ACTUALIZAR_MEM: POP BX
POP CX
ADD BX,1
JNC @CONTINUAR
MOV AX,DS
ADD AX,1000
MOV DS,AX
LOOP @IMPRIMIR
JMP @FIN

@CONTINUAR: LOOP @IMPRIMIR
JMP @FIN
@FIN:

@TRANSFORMAR_ASCII: PUSH CX
MOV CL, 04
MOV CH,AL
SHR AL, CL
CMP AL,9
JBE @NUMERO
JMP @LETRA

@VOLVER: POP DX
POP CX
RET

@LETRA: CMP AL, 0F
JBE @TRANS_LETRA

@NUMERO:ADD AL, 30H
JMP@SEGUIR

@SEGUIR: MOV AH, AL
XOR AL, AL
PUSH DX
MOV DL, CH
AND AL,F
CMP AL, 0F
JBE @NUMERO_2
JB @NUMERO

@NUMERO_2: ADD AL, 30
JMP @VOLVER

@TRANS_LETRA: ADD AL, 37
JMP @SEGUIR_2






@SEGUIR2: MOV AH, AL
XOR AL,AL
PUSH DX
MOV DL, CH
AND DL, F
MOV AL, DL
CMP AL, 0F
JBE @LETRA_2
JB @VOLVER

@LETRA_2: ADD AL, 37
JMP @VOLVER