Está en la página 1de 10

Contenido

Objetivo.............................................................................................................. 2
Desarrollo del Programa...................................................................................... 2
Antes de Programar......................................................................................... 2
Programacin................................................................................................... 3
Compilacin..................................................................................................... 5
Ejemplo............................................................................................................... 7
Conclusiones....................................................................................................... 9
Recomendaciones............................................................................................... 9
Anexos................................................................................................................ 9
Objetivo
Realizar un programa en lenguaje ensamblador que permita operar el
factorial de 4 utilizando el IDE Zilog Z80.

Desarrollo del Programa


Antes de Programar
Primero se abre el software y se debe ir a la barra de herramientas, dar click en
la opcin Tools. Y escoger la opcin Assembler, en esta opcin es donde se
programara en lenguaje ensamblador.

Figura 1 IDE Zilog Z80

Se abrir una ventana (Figura 2) en donde se debe programar.


Figura 2 Editor de Cdigo de Lenguaje Ensamblador

Programacin
Para explicar el programa se presentara primeramente el diagrama de bloques
general (Figura 3) y se explicara cada bloque, este diagrama de bloques esta
realizado en base a la programacin realizada para dicho programa.

Figura 3 Diagrama de Bloques General

Bloque Inicializar SP
En el primer bloque nicamente se inicia la direccin a la que apunta el
puntero de pila (SP) con el siguiente cdigo.
LD SP, 1500H
Luego de esto estn las llamadas a subrutinas.

Bloque Factorial
El presente bloque se dividir en dos partes el bloque donde se realiza la
factorial y el bloque de la multiplicacin, cada uno de estos sub-bloques es una
subrutina, llamadas FACT y OPER respectivamente.
Figura 4 Sub-Bloques del Bloque Factorial

a) Sub-Bloque FACT
En el presente bloque bsicamente se escoger a que numero se va a
multiplicar para realizar el factorial esto se realizara de acuerdo al cdigo que
ser explicado a continuacin.
Primero guardaremos en el registro D el valor que este en el registro A, esto
debido a que entre A y D se realizara las sumas sucesivas que dar como
resultado la multiplicacin, esto se realiza con la siguiente instruccin:
LD D, A
Despus se guardara en el registro B lo que este guardado en el registro C ya
que este ser el contador de cuantas veces se realizara las sumas sucesivas.
Debido a que el primer valor ya est en el acumulador se despus de cargar el
valor al registro B se le restara uno. Esto con las siguientes instrucciones:
LD B, C
DEC B
Luego de esto ser realizara un salto relativo el cual trabajara con la bandera de
resultado cero. Compara si al decrementar B es igual a cero, si B es diferente
de cero entonces salta al siguiente sub-bloque llamado OPER sino es as
continua con la siguiente instruccin. Esto ser realiza con el siguiente cdigo:
JR NZ, OPER
Luego de esto se utiliza otro salto relativo de igual forma trabaja con la
bandera de resultado igual cero, en este caso si ya salto no salto con la
anterior comparacin, revisara la comparacin actual y si el resultado es igual
a cero entonces salta al siguiente bloque y por tanto siguiente subrutina
llamada SALIDA. Esto se realiza con la siguiente instruccin:
JR Z, SALIDA
b) Sub-Bloque OPER
En el presente bloque se explica cmo se va a ejecutando la multiplicacin con
sumas sucesivas para realizar el factorial. Primero sumaremos el calor que se
encuentre en el registro acumulador con lo que est guardado en el registro D
que ser el mismo valor. Esto se realiza con la instruccin:
ADD A, D
Luego de esto utilizaremos el registro B como contador con el salto DJNZ esta
instruccin decrementara en uno el registro B. Si B no es cero entonces saltara
a la subrutina FACT para escoger el siguiente nmero para multiplicar, pero si
B=0 continua con la siguiente instruccin. El cdigo que realiza esto es:
DJNZ OPER
Una vez que se termine la multiplicacin enviaremos el resultado al puerto de
salida 01H ya que aqu es donde ser vera como se ejecuta el factorial. Esto se
realiza con la siguiente instruccin:
OUT (01H), A
Lo siguiente ser decrementar en uno el registro C ya que escoger el
siguiente nmero a multiplicar. Por lo que se ejecuta la siguiente instruccin
para esto:
DEC C
Para finalizar es sub-bloque realizaremos un salto a la subrutina FACT para que
se selecciones el siguiente nmero a multiplicarse.

Bloque Salida de Datos


Este es el bloque final del programa en el cual se mostrar el ltimo resultado
de la operacin del factorial. Por lo que la siguiente instruccin enviar el valor
del acumulador al puerto de salida 01H con la siguiente instruccin:
OUT (01H), A
Por ltimo para finalizar y que se quede mostrando el valor final del factorial
del nmero cuatro haremos una pausa con la instruccin HALT.

Compilacin
Una vez finalizado el programa se debe guardar y luego compilar el mismo
para ver que no exista ningn error en el cdigo. Para esto en la ventana donde
se programa se debe dar click en Tools y escoger la opcin Assembler.

Figura 5 Compilacin de Programa

Una vez el programa sea compilado en la parte inferior aparecer el nmero de


errores, si el nmero de errores es 0, entonces el programa est listo para ser
cargado y ejecutado en el IDE.
Figura 6 Errores de Compilacin

Una vez que se tiene cero errores al compilar se debe cargar el programa al
IDE para esto se debe dar click en la barra de herramientas en la opcin File y
escoger Load Program. Aqu se cargar un archivo con el nombre que se haya
guardado el cdigo pero tendr la extensin .obj.

Figura 7 Cargar Programa al IDE

Luego de esto dar click en la barra de herramientas en la opcin Simulation


para correr el programa, aqu hay dos opciones correr el programa
normalmente o correrlo paso a paso, se escoge una de las dos opciones.

Figura 8 Iniciar Simulacin

En los programas que utilicen puertos, se podr ver lo ingresado o la salida de


los puertos usando una herramienta incorporada en el IDE. Se da click en Tools
y se escoge I/O Ports Editor.
Figura 9 Editor de Puertos

Aqu es donde se vern los datos que se enven a los puertos de salida.
Por ltimo para finalizar la compilacin presionamos F3.

Ejemplo
Primero en el puerto de salida veremos el nmero 4 ya que es el primer factor
a multiplicarse.

Figura 10 Primer Factor del Factorial

En los registros se podr ver los nmeros a multiplicarse.

Figura 11 Nmeros a Multiplicarse

El resultado de esa operacin ser OC en hexadecimal y es lo que aparece en el


puerto de salida 01H.
Figura 12 Resultado de Primera Multiplicacin

La siguiente multiplicacin a realizarse es:

Figura 13 Segundo factores a multiplicarse

El resultado de la multiplicacin anterior se muestra en el puerto

Figura 14 Resultado segunda multiplicacin

Ultima multiplicacin a realizarse

Figura 15 ltima Multiplicacin

Y el resultado ya que se multiplica por 1 es el mismo anterior


Figura 16 Resultado ltima Multiplicacin

Conclusiones
Se concluye que en la mayora de operaciones que se realiza, el un
operando es el acumulador.
Los programas puede ejecutarse continuamente o pararse despus de
una ejecucin como en este caso con la instruccin HALT.
Todos los registros que no son el acumulador son muy necesarios para
guardar los datos que se necesitaran posteriormente.
El registro B tiene un uso beneficioso como contador.
Se puede combinar una rutina de multiplicacin con una de seleccin de
nmero para calcular el factorial.

Recomendaciones
Se recomienda usar banderas para realizar los saltos a otras funciones.
Si se desea realizar un programa en un orden especfico se recomienda
retornar al final de las subrutinas y realizar las llamadas al inicio del
programa.
Se recomienda tener en cuenta la estructura de programacin por
ejemplo, las instrucciones no van desde el inicio de la lnea, sino
despus de un espacio, mientras que los nombres de las subrutinas si se
debe escribir desde el inicio de la lnea donde se escriba.
Se recomienda ejecutar paso a paso antes de ejecutar continuamente a
fin de que se pueda detectar errores en el cdigo.

Anexos
LD SP, 1500H ;Inicializa Direccion del Puntero de Pila
;LLAMADAS A SUBRUTINAS
CALL INICIO ;Llama a la subrutina INICIO
CALL FACT ;Llama a la subrutina FACT
INICIO:

LD A,04H ;Carga el 4 en el registro A


OUT (01H),A ;Envia al puerto de salida 01H el valor del acumulador
LD C,03H ;Carga el 3 en el registro B
RET ;Retorna a la llamada a subrutinas para continuar
;con la siguiente subrutina
FACT:
LD D,A ;Carga en la direccion de memoria 1000 el valor del
;registro A, (HL) apunta a la direccion del valor
;que tiene el registro HL
LD B,C ;Carga al registro B el valor del registro C
DEC B ;Decrementa en 1 el registro B
JR NZ,OPER ;Compara si al decrementar B no es cero (Flag z=0)
;Si z=0 entonces salta a subrutina OPER
;caso contrario continua con la siguiente instruccion
JR Z,SALIDA ;Compara si al decrementar B es cero (Flag z=1)
;Si z=1 entonces salta a salida

OPER:
ADD A,D ;Suma el valor de la direccion de memoria a la que
;apunta el registr HL con el valor del registro A
DJNZ OPER ;Decrementa el valor de registro B en 1 mientras
;B no sea cero salta a la subrutina OPER formando
;un bucle, si B=0 continua la siguiete instruccion
OUT (01H),A ;Envia al puerto de salida 01H el valor del acumulador
DEC C ;Decrementa el registro C en 1
JP FACT ;Realiza un salto relativo, compara si al decrementar
;el registro C es diferente de cero entonces salta
;a la subrutina Fact caso contrario continua la
;siguiente instruccion
SALIDA:

OUT (01H),A ;Envia al puerto de salida 01H el valor del acumulador


HALT ;Para el programa
.END ;Finaliza el programa