Guía Trabajo Práctico Número 4

Página 1 de 7
Guía Trabajo Práctico Número 4
Sistemas con Microprocesadores
01/10/2014
Ejercicio Propuesto
7) Escriba una subrutina transparente Volcado, la cual debe escribir en una cadena ascii el contenido
hexadecimal de un bloque de memoria. Esta subrutina recibe como parámetros la dirección del bloque en
el registro H:X, el tamaño del bloque en SP+3 y la dirección de la cadena en SP+4 (parte alta) y SP+5 (parte
baja). Para completar la traducción de cada nibble en el carácter ascii correspondiente deberá utilizar una
tabla de conversión.
Recomendaciones

Para ubicar las variables en la memoria RAM debe utilizar la directiva ORG $0080.

Para ubicar el código en la memoria ROM debe utilizar la directiva ORG $EE00.

Comience sus programas a partir de un rótulo genérico Main. Coloque los datos en los lugares más
convenientes.

El procesador requiere que la dirección de la primera instrucción del programa debe ser
almacenada a partir de la dirección $FFFE. Para ello se debe utilizar la directiva ORG $FFFE
seguida de DC.W Main.

Para probar sus programas puede definir los parámetros de entrada como constantes (en ROM) o
como variables inicializadas (en RAM) usando las directivas DC.B y DC.W.

No suponga nunca valores iniciales para las variables, use una instrucción para fijar el valor inicial
en caso de ser necesario.

Emplee notación hexadecimal para las direcciones. Emplee la notación más clara posible para los
datos.
Solución Propuesta
Para desarrollar la solución plantearemos un primer diagrama de flujo de nivel de C, considerando el
bloque de memoria y la cadena de caracteres como arreglos. En Tabla un arreglo de 16 caracteres
constantes que contienen los códigos ascii del 0 al 9 en las diez primeras posiciones y de la A a la F en las
seis restantes. En el diagrama adjunto puede verse el algoritmo utilizado, el cual consiste en convertir cada
uno de los nibbles del dato de memoria utilizándolo como índice en la tabla de conversión para recuperar
el código ascii correspondiente. En este diagrama se utilizan los siguientes vectores



Bloque: Bloque de memoria que queremos convertir.
Tabla: Tabla de traducción descripta mas arriba.
Cadena: Cadena de caracteres destino de la conversión.
Guía Trabajo Práctico Número 4
Página 2 de 7
Guía Trabajo Práctico Número 4
Página 3 de 7
Si ahora convertimos los vectores en punteros a memoria y hacemos que el contador sea descendente para
mayo facilidad en la comparación obtenemos el siguiente diagrama de flujo. En el mismo se utilizan los
siguientes punteros o direcciones de memoria:




Memoria: Apunta al byte de memoria que estamos convirtiendo.
Tabla: Apunta al primer elemento de la tabla de conversión.
Entrada: Apunta al elemento de la tabla correpondiente al nibble a convertir.
Caracter: Apunta al carácter actual en la cadena de destino.
Guía Trabajo Práctico Número 4
Página 4 de 7
En el diagrama de flujo anterior identificamos tres operaciones que se repiten dos veces:
Entrada  Tabla + Valor
M(Cadena)  M(Entrada)
Cadena  Cadena + 1
Dado que estas operaciones, además de repetirse, se realizan sobre direcciones de 16 bits vamos a
necesitar varios pasos de ensamblador para completar las mismas. Por esta razón vamos a separar esos
pasos en una subrutina Convertir que reciba como parámetros por memoria el valor a convertir en el
acumulador y el puntero a la cadena en memoria. Agregaremos en la subrutina el filtrado del nibble
superior del valor, con lo cual los nuevos diagramas de flujo quedarían de la siguiente forma:
Volcado
Memoria
Contador
Caracter
H:X
M(SP+3)
M(SP+4):M(SP+5)
Contador = 0
No
A
(M(Memoria) >> 4)
Convertir
A
M(Memoria)
Convertir
M(Caracter) = ‘ ‘
Caracter
Caracter + 1
Memoria
Memoria + 1
Contador
Contador - 1
M(Caracter) = 0
Fin
Si
Guía Trabajo Práctico Número 4
Memoria
Entrada
Caracter
Cadena
Página 5 de 7
ORG $0080
DS 2
DS 2
DS 2
DS 24
;
;
;
;
;
Defino las variables globales del programa
Puntero al byte de memoria a convertir
Puntero a la tabla de conversion
Puntero al caracter actual de la cadena
Cadena de caracteres para el volcado
ORG $EE00
; Comienzo a definir el codigo del programa
*******************************************************************
*
* Funcion que convierte el nibble inferior del acumulado en la
* correspondiente representacion ASCII del digito hexadecimal
* al finalizar incrementa el puntero de la cadena de caracteres
* NO CONSERVA LOS VALORES EN LOS REGISTROS, NO ES TRANSPARENTE
*
* Parametros
* Acumulador : Valor a convertir, solo se toma el nibble inferior
* Caracter
: Puntero en memoria al lugar a escribir
*
Tabla
DC.B "01234567"
DC.B "89ABCDEF"
Convert LDHX #Tabla
STHX Entrada
Salto
; Defino la tabla de conversión como una
; constante de 16 entradas de un byte
; Cargo el valor de la tabla
; lo almaceno en el puntero
AND #$0F
ADD Entrada+1
; Elimino el nibble superior del valor
; Lo sumo a la parte baja del puntero
BCC Salto
INC Entrada
; Si hay acarreo
; Incremento la parte alta del puntero
STA Entrada+1
; Almaceno la parte baja del puntero
; Ahora Entrada apunta al elemento
; de la tabla correspondiente a Valor
LDHX Entrada
LDA 0,X
LDHX Caracter
STA 0,X
AIX #1
STHX Caracter
;
;
;
;
;
;
Cargo el puntero al elemento de la tabla
Cargo el caracter correspondiente a Valor
Cargo el puntero al caracter a escribir
Escribo el caracter en la cadena
Incremento en un el indice
Actualizo el puntero al caracter actual
RTS
*******************************************************************
*
* Funcion que realiza el volcado de un bloque de memoria como una
* cadena de caracteres con los dos digitos hexadecimales de cada
* byte separados por un espacio. La cadena es terminada con un NULL
*
* Parametros
* H:X
: Puntero al bloque de memoria a leer
* SP+3
: Cantidad de bytes a leer del bloque de memoria
* SP+4:SP+5 : Puntero a la cadena de caracteres a escribir
*
Contador EQU 1
; Defino una constante contador
Volcado PSHA
; Conservo el estado del procesador
Guía Trabajo Práctico Número 4
Lazo
Final
Página 6 de 7
PSHX
PSHH
;
;
AIS #-1
; Reservo un lugar en la pila para la
; variable local Contador
STHX Memoria
; Inicializo el puntero al bloque con H:X
LDA 7,SP
STA Contador,SP
; Inicializado el contador de bytes
; con el valor de tamaño del bloque
LDA
STA
LDA
STA
; Inicializo el puntero a la cadena
; con los valores recibidos en la pila
;
;
8,SP
Caracter
9,SP
Caracter +1
TST Contador,SP
BEQ Final
; Repito mientras el contador sea
; distinto de cero
LDHX Memoria
LDA 0,X
NSA
BSR Convert
;
;
;
;
Cargo el puntro al byte a convertir
Cargo el byte en el acumulador
Invierto los nibbles
Convierto Valor en un caracter de Cadena
LDHX Memoria
LDA 0,X
AND #$0F
BSR Convert
;
;
;
;
Cargo el puntro al byte a convertir
Cargo el byte en el acumulador
Elimino el nibble superior
Convierto Valor en un caracter de Cadena
LDA #' '
LDHX Caracter
STA 0,X
AIX #1
STHX Caracter
;
;
;
;
;
Cargo el codigo ASCII del espacio
Cargo el puntero al caracter a escribir
Escribo el espacio en la cadena
Incremento en un el indice
Actualizo el puntero al caracter actual
LDHX Memoria
AIX #1
STHX Memoria
; Cargo el puntero al bloque de memoria
; Incremento el indice
; Actualizo el puntero al bloque
DEC Contador,SP
BRA Lazo
; Decremento la cantidad
; Repito el control del lazo
CLRA
LDHX Caracter
AIX #-1
CLR ,X
;
;
;
;
AIS #1
; Elimino la variable local Contador
PULH
PULX
PULA
RTS
; Recupero el estado inicial del procesador
;
;
; Retorno al programa principal
Borro el acumulador para generar el NULL
Cargo el puntero al siguiente caracter
Muevo el puntero al carácter a escribir
Escribo el terminado de la cadena
Guía Trabajo Práctico Número 4
Página 7 de 7
*******************************************************************
*
* Programa princiapal destinado a probar la rutina de volcado
* carga los parametros y llama a la misma
*
Main
LDHX #Cadena
; Cargo la dirección de la variable global
PSHX
; La paso como primer parametro en la pila
PSHH
;
LDA #8
; Cargo el tamaño del bloque a volcar
PSHA
; Lo paso como segundo parametro en la pila
LDHX #$EE00
; Defino el bloque a como el inicio de ROM
BSR Volcado
; Llamo a la función de volcado
STOP
; Detengo la ejecución del procesador
ORG $FFFE
DC.W Main
;
; Indico el punto de comienzo del programa