ELECTRNICA DIGITAL

Trabajo Prctico Especial Procesador con instrucciones monociclo

Fernndez Cocirio, Mariano Babbicola, Paula Florencia

08/11/2013

Informe realizado para la ctedra de Electrnica Digital, ao 2013, con el objetivo de explicar los componentes agregados al procesador como funcionan y el programa de prueba aadido.

ndice ndice ....................................................................................................................................... 2

Introduccin ............................................................................................................................. 3

Instrucciones aadidas ............................................................................................................. 4

Instruccin CALL .............................................................................................................................. 4

Instruccin RET ................................................................................................................................ 4

Repercusin en la DU ............................................................................................................... 5

Componentes Agregadas .......................................................................................................... 6

Pila de Ejecuciones .......................................................................................................................... 6

Alpha DU y BetaDU ......................................................................................................................... 6

Programa con CALL y RET .......................................................................................................... 7

Cambios en el diseo ................................................................................................................ 8

Introduccin

El objetivo del trabajo era lograr hacer en Logisim un procesador con instrucciones monociclo. El

mismo deba contar con componentes realizados en clase que al final se los hace trabajar en

conjunto para poder realizar un programa dado por la ctedra.

Este informe est destinado a explicar los componentes aadidos a consideracin del grupo, es

decir, los componentes extras, y el programa realizado por el grupo para comprobar el

funcionamiento de los mismos.

Junto a este documento se adjunta en el mail los siguientes archivos:

TP Electro.circ, el cual contiene al procesador finalizado.

ROM_prog1, el programa suministrado por la ctedra.

ROM_prog2, el programa realizado para demostrar el funcionamiento de los componentes

adicionales.

Instrucciones aadidas

Se decidi aadir las instrucciones CALL y RET, el cdigo de operacin de cada una es 0x07 y 0x08

respectivamente. Al agregar estas instrucciones, se modifica la tabla de la Decoding Unit (DU),

agregando las salidas: PUSH, POP, STACK_DIR, IMM_DIR y JUMP.

Instruccin CALL Esta instruccin lo que hace es saltar incondicionalmente a la direccin enviada en el Immediate,

la forma de esta instruccin es:

Cdigo de Instruccin Direccin a la que se desea saltar

8bits 8bits

Es decir, para saltar a la instruccin 0x20, la instruccin quedara: 0x0720.

A su vez tambin activa desde la DU el Jump, el Imm_dir, para poder saltar a la direccin que viene

por Immediate, y el Push de una pila de ejecuciones, para guardar la direccin de memoria en la

que estaba, para luego poder hacer un RET.

Instruccin RET La instruccin RET provoca que se vuelva a la ultima direccin apilada en la Pila de Ejecuciones, su

formato es:

Cdigo de Instruccin Sin Importancia

8bits 8bits

Esta instruccin se llama siempre como: 0x0800.

Dentro de la DU activa el Jump, el Stack_dir, para poder saltar a la ultima direccin de la pila, y el

Pop, para sacar de la pila el tope actual, al popear un elemento, el ultimo valor se convierte en

un 0x00 automticamente.

Repercusin en la DU

Los cambios realizados tuvieron una repercusin directa en la DU, teniendo que modificarla al

agregar nuevas salidas a la misma, por lo que la tabla de la DU quedo de la siguiente forma:

Instruccin in_en reg_en alu_op regA_we out_we reg_we imm_en push pop imm_dir stack_dir

IN (0x01) 1 0 000 0 0 1 0 0 0 0 0

OUT (0x02) 0 1 000 0 1 0 0 0 0 0 0

MOV(0x03) 0 1 000 0 0 1 0 0 0 0 0

LDA (0x04) 0 1 000 1 0 0 0 0 0 0 0

LDI (0x05) 0 0 000 1 0 0 1 0 0 0 0

CALL(0x07) 0 0 000 0 0 0 0 1 0 1 0

RET(0x08) 0 0 000 0 0 0 0 0 1 0 1

SHL(0x20) 0 1 001 0 0 1 0 0 0 0 0

SHR(0x21) 0 1 111 0 0 1 0 0 0 0 0

ADD(0x10) 0 1 010 0 0 1 0 0 0 0 0

SUB (0x11) 0 1 011 0 0 1 0 0 0 0 0

AND(0x12) 0 1 100 0 0 1 0 0 0 0 0

OR (0x13) 0 1 101 0 0 1 0 0 0 0 0

XOR (0x14) 0 1 110 0 0 1 0 0 0 0 0

Las salidas agregadas son solo utilizadas en CALL y RET, se puede apreciar lo que hace cada una al

leer el funcionamiento de dichas instrucciones.

Componentes Agregadas

Pila de Ejecuciones La pila de ejecuciones funciona como una Stack normal, tiene una capacidad mxima de 3, es

decir, se pueden apilar hasta tres elementos, posee las funciones push y pop, y siempre tiene el

tope visible al exterior.

Se utiliza para ir guardando las direcciones en las que se utiliza un CALL, por las caractersticas de

la estructura se pueden hacer tantos CALL como la capacidad de la pila, y cada vez que se haga un

RET vuelva al ltimo CALL, es decir, si hago dos CALL seguidos y luego doy un RET, volver a la

instruccin siguiente al ltimo CALL.

Alpha DU y BetaDU Ests componentes existen por el hecho que la DU es generada utilizando la funcin de cargar una

tabla en Logisim y que te genere el circuito automticamente. Por tener demasiadas salidas se

tuvo que dividir en 2 partes la DU.

Programa con CALL y RET El programa realizado para demostrar el funcionamiento de los CALL y RET fue el siguiente:

0x00 IN r0

0x01 IN r1

0x02 CALL 0x20

0x03 OUT r3

0x20 LDA r1

0x21 ADD r3, r0

0x22 CALL 0x30

0x23 OUT r5

0x24 RET

0x30 IN r5

0x31 RET

El mismo, lo que hace es cargar por Input a r0 y r1, luego carga a Reg_A con el valor en r1, le da a

r3 el valor de la suma entre Reg_A y r0, le carga a r5 lo que hay en Input, muestra en Reg_OUT el

calor de r5 y por ltimo muestra en Reg_Out el valor en r3. Entre medio de estas acciones invoca

sucesivos CALL en cadena, llamando primero a una subrutina que suma a los r0 y r1 colocando el

resultado en r3, y luego a otra subrutina que simplemente carga r5.

Este es un programa simple pero demuestra el funcionamiento del CALL y el RET, incluyendo un

anidamiento del mismo, ya que se realiza la suma y se carga r5 en subrutinas distintas que en las

que se los muestra en el Reg_OUT.

Cambios en el diseo Se opt por hacer una caja que se llame Procesador y ponerla en el main, con la ROM fuera de la

misma, ya que el procesador propiamente dicho no tendra a la ROM en su interior.

Tambin se le hizo una Output que muestra lo contenido en Reg_OUT, esto se realiz para poder

visualizar de forma ms simple los resultados, por esta misma razn, tambin se dejo fuera al

Clock y al Clear.