¡Descarga practica ic 3 y más Ejercicios en PDF de Introducción a los Ordenadores solo en Docsity!
PRÁCTICA 3
Implementación de un multiplicador secuencial de
números naturales.
Objetivos que se deben haber alcanzado antes de realizar la práctica
Antes de preparar esta práctica se deben haber alcanzado los objetivos específicos que se indican en la siguiente tabla. Para ello, es recomendable haber estudiado las secciones de la documentación que se indican en la primera columna de la tabla.
Secciones de la documentación a estudiar Objetivos específicos a alcanzar
Capítulo 7: Secciones de la 7.1 a la 7.3. Del 7.1 al 7.8.
Estos objetivos serán evaluados en parte del informe previo que debéis entregar al inicio de la sesión de laboratorio y en la prueba previa individual que se hará al inicio de la sesión.
Objetivos que se deben alcanzar al realizar la práctica
Después de realizar esta práctica, el estudiante será capaz de:
- Multiplicar dos números naturales codificados en binario siguiendo los pasos del algoritmo de multiplicación secuencial basado en desplazamientos y sumas.
- Dibujar el esquema a bloques de la unidad de proceso del multiplicador secuencial y el esquema interno de todos los bloques que la componen.
- Dibujar el grafo de estados de la unidad de control del multiplicador y el esquema de su implementación con el número mínimo de biestables y dos memorias ROM.
- Obtener el tiempo de ciclo mínimo del multiplicador secuencial y el tiempo de cálculo de una multiplicación.
Directorio de la práctica Aularios en módulo A5 y C6: Mi PC\I:\ic\Prac Aularios en el módulo D6: Mi PC\R:\Logic\Ver_4.1\Ic\Prac
3.1 Introducción
En esta práctica vamos a implementar un multiplicador secuencial de dos números naturales codificados en binario con 16 bits. Pero vamos a hacer el diseño poco a poco, como cuando aprendimos a multiplicar en la escuela. ¿Cómo aprendimos a multiplicar? Si recordáis, comenzamos a multiplicar números de n dígitos por números de un solo dígito y solamente cuando dominábamos esto, pasamos al caso general de multiplicar dos números de n dígitos cada uno. ¡Aquí vamos a proceder de la misma forma!
3.2 Multiplicación de un número por un dígito
Vamos a repasar lo que hacemos en decimal cuando multiplicamos un número natural por un dígito. Por ejemplo, para n = 4, X = 9381 e Y = 8:
x 8 7 5 0 4 8
¿Sabemos de memoria el resultado de la multiplicación de cualquier número de 4 dígitos por cualquier número de 1 dígito? La respuesta es ¡NO! Sólo aprendimos de memoria en la escuela la multiplicación de dos números de un dígito cada uno, o lo que es lo mismo, aprendimos la tabla de multiplicar dos dígitos decimales:
X 0 1 2 3 … 8 9
La multiplicación la realizamos aplicando un algoritmo, que avanza dígito a dígito, comenzando por el de menor peso. En cada paso efectuamos la multiplicación de un dígito del multiplicando por el único dígito del multiplicador. Dado que al multiplicar dos dígitos decimales el resultado puede requerir dos dígitos para ser representado, para obtener un dígito decimal del resultado en cada paso del algoritmo debemos pasar (o llevar) el acarreo al dígito siguiente, si es distinto de cero. En la multiplicación por un dígito en decimal, a diferencia de lo que ocurre en la suma, el acarreo puede tomar valores en el rango de 0 a 8.
Podríamos obtener el algoritmo de la multiplicación de un número por un dígito, en general para el sistema de numeración convencional en base b , manipulando las expresiones de la representación de un número en función de sus dígitos, como hicimos en el caso de la suma. Pero no lo vamos a hacer así porque este algoritmo es trivial para el caso particular de la representación en binario, base 2. De hecho lo vais a encontrar vosotros respondiendo a las siguientes preguntas.
Ø Informe previo
Pregunta 1
a) Al igual que al principio de esta sección hemos dibujado la tabla de multiplicación de dos dígitos en decimal, rellenad, ahora, la tabla de multiplicación de dos dígitos binarios:
X 0 1
b) Dibujad la tabla de verdad de un circuito combinacional que multiplica dos dígitos binarios. ¿Cuántos bits de entrada y de salida tiene el circuito? Dibujad el esquema lógico del circuito en suma de minterms. A este circuito lo denominaremos “BitBit”.
c) Si entendéis por qué aparece el acarreo al multiplicar un número por un dígito decimal, a la vista la tabla de la multiplicación de dos dígitos binarios y comparándola con la equivalente para decimal, podréis responder con éxito a la siguiente cuestión: ¿existe acarreo en el algoritmo de multiplicación de un número por un dígito en el caso binario? Razonad la respuesta.
d) Dado el vector de 16 bits, X = x 15 x 14 L x 1 x 0 y el vector de 1 bit Y = y 0 , con
xi , y 0 Î { 0 , 1 }" i , que representan en binario a los números naturales X (^) u e Yu ¿cuántos
bits son necesarios para representar en binario el resultado de la multiplicación X (^) u ´ Y u (o
lo que es lo mismo, Xu ´ y 0 , ya que Y es un vector de 1 bit y el valor que representa en binario es igual al valor de su único dígito, y 0 )?
e) Dibujad el esquema lógico de un circuito combinacional para multiplicar un número natural representado en binario con 16 bits por un dígito binario. Este circuito, que denominaremos MULBIT, tiene 16 bits de entrada para el vector X , que es la representación binaria de Xu , una entrada de un bit para el dígito y 0 y 16 bits de salida para W , que representa el resultado W^ u =^ Xu ´ y 0.
f) ¿Cuál es la pareja entrada-salida del circuito MULBIT que has diseñado en la pregunta anterior, con un tiempo de propagación mayor? ¿Cuál es ese tiempo de propagación en función del tiempo de propagación de las puertas?
b) Realizad, en binario, la multiplicación de los números naturales Xu = 23 e Yu = 17 y comprobad, pasando el resultado a decimal, que habéis realizado la multiplicación correctamente.
Aunque ya sabemos multiplicar en binario, ahora vamos a obtener el algoritmo de la multiplicación a partir de las fórmulas que nos dan el valor representado por un vector de bits y demostraremos que el algoritmo que acabamos de usar es correcto. Además, a partir de las expresiones matemáticas, o del algoritmo expresado formalmente, nos resulta relativamente fácil diseñar el circuito que lo implementa. Para ello partimos de la expresión del resultado Wu y sustituimos el multiplicador por su valor en función de los dígitos que lo representan:
÷
÷
ø
ö
ç
ç
è
æ
= ´ = ´ å ´
=
1
0
n
j
j
Wu Xu Yu Xu yj
Manipulando esta expresión obtenemos:
1
0
1
0
j
n
j
j u
n
j
j
Wu Xu yj ÷= X ´ ´ y
÷
ø
ö
ç
ç
è
æ
= ´ å ´ å
=
=
De la última igualdad de esta ecuación obtenemos el siguiente algoritmo secuencial, donde Wu ( j ) va
acumulando en cada iteración j del algoritmo el resultado de multiplicar el multiplicando por un dígito del
multiplicador. Hemos utilizado las variables intermedias Du y M u para separar las tres operaciones
que requiere cada iteración del bucle:
Wu ( 0 )= 0 ;
for ( j = 0; j < n ; j = j + 1) { j
Du = Xu ´ 2 ;
M u = Du ´ y j ;
Wu ( j + 1 )= Wu ( j )+ M u ;
Wu = Wu ( n );
Por último, transformamos el algoritmo para ahorrarnos multiplicar en cada iteración X u por
j
(ahorrarnos multiplicar por una potencia distinta de 2, dependiendo de la iteración en la que nos
encontremos). En vez de esto calcularemos j
Du = Xu ´ 2 mediante la recurrencia:
Du ( 0 )= X u ;
for ( k = 0; k < j; k = k + 1) {
D u ( k + 1 )= Du ( k )´ 2 ;
D u = Du ( j );
Insertando el cálculo de esta recurrencia en el mismo bucle del algoritmo de multiplicación, tenemos que ahora en todas las iteraciones multiplicamos por el valor 2 independientemente de la iteración en la que estemos: Algoritmo MUL
Du ( 0 )= X u ;
Wu ( 0 )= 0 ;
for ( j = 0; j < n ; j = j + 1) {
M u = Du ( j )´ y j ;
Wu ( j + 1 )= Wu ( j )+ M u ;
D u ( j + 1 )= Du ( j )´ 2 ;
Wu = Wu ( n );
Este algoritmo es parecido al que usamos en decimal con lápiz y pape l (y al que hemos usado en binario al principio de esta sección). La diferencia consiste en que con lápiz y papel efectuamos los cálculos en dos fases. La primera fase tiene n (n es el número de dígitos) iteraciones o pasos y en cada iteración calculamos la multiplicación del multiplicando por un dígito del multiplicador y desplazamos el resultado adecuadamente para prepararlo para la suma de la segunda fase (desplazar una posición a la izquierda un vector de dígitos que representa un número natural en el sistema convencional en base b es multiplicar el número por b, como ya sabemos ). En la segunda fase efectuamos la suma de los n resultados parciales de la primera fase.
Sin embargo, en el algoritmo que acabamos de encontrar las dos fases se efectúan entremezcladas en una única fase. El algoritmo completo consiste en n iteraciones o pasos. En cada iteración se calcula un resultado parcial sumando al resultado parcial de la iteración anterior el resultado de multiplicar el multiplicando por un dígito del multiplicador y desplazarlo adecuadamente.
Vamos a hacer un seguimiento del algoritmo en una sola fase para dos números concretos X (^) u = 18 e
Yu = 13. Representamos el multiplicador con, por ejemplo, n = 8 bits, por lo que el algoritmo tendrá 8
iteraciones o pasos. El vector de bits que representa Y en binario es Y = 00001101. El resultado de la
multiplicación debe ser Wu = 234. La siguiente tabla muestra los valores numéricos y el bit de Y
involucrados en cada iteración del algoritmo. Vemos que el resultado final es correcto, Wu = 234.
Estado inicial
Wu(0) = 0
Du(0) = 18 Iteración j M (^) u = Du ( j )´ y j u u u
W ( j + 1 )= W ( j )+ M D u ( j + 1 )= Du ( j )´ 2
y j
0 18 18 36 1 1 0 18 72 0 2 72 90 144 1 3 144 234 288 1 4 0 234 576 0 5 0 234 1152 0 6 0 234 2304 0 7 0 234 4608 0 Resul. Final Wu
3.3.2 Implementación secuencial del multiplicador binario
Vamos a implementar el algoritmo anterior para el caso de n = 16. Como vimos al principio, si X (^) u e
Y u están representados en binario con n bits, necesitamos 2 n bits para que el resultado de la
multiplicación sea siempre representable. Dado que en un computador las instrucciones operan con datos de n bits y los registros donde se guardan los resultados son de n bits, tiene sentido estar interesados únicamente en los n bits de menor peso del resultado de la multiplicación. Sabemos, claro está, que con esos n bits no siempre tendremos el resultado correcto de la multiplicación. Así, cuando
X (^) u y/o Yu sean números grandes, se puede producir un resultado incorrecto. Vamos a implementar un
multiplicador que sólo calcula los n bits de menor peso del resultado. Además, para simplificar, no vamos a implementar la detección de resultado no representable con n bits, aunque os haremos una pregunta al respecto.
Como sólo queremos los n bits de menor peso de la representación de Wu = Xu ´ Yu , podemos usar
únicamente n bits para codificar en binario cada uno de los resultados de las operaciones del algoritmo
en cada iteración: M (^) u , Wu ( j + 1 )y Du ( j + 1 ).
Conocemos algoritmos y sabemos implementar circuitos lógicos combinacionales para las tres
operaciones que hay que realizar en cada iteración del algoritmo. La operación M (^) u = Du ( j )´ yj la
realizaremos con el circuito MULBIT que habéis diseñado en la pregunta 1 del informe previo y la
· El dispositivo secuencial SRL_REG (Shift Right Logic Register) es un registro con carga paralela (cuando Ini vale 1) y desplazamiento lógico a la derecha (cuando Ini vale 0). La salida es el bit de menos peso del dato almacenado en el registro. Como a cada ciclo se desplaza una posición a la derecha el dato almacenado, k ciclos después de que Ini valga 1, el bit de menor peso del dato almacenado es el bit k del dato original que se cargo cuando Ini valía 1. Esta parte del circuito se usa para obtener el bit yj en cada ciclo, desde j = 0 hasta n-1. El circuito combinacional SRL-1 (que forma parte del circuito SRL_REG) y el circuito a bloques que implementa el SRL_REG son los siguientes: X
W
b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2^ b
b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b
0
SRL_REG
Y
yj
Ini
B(j)<0>
Y
Clk
MUX
10
REG
b
Ini
SRL-
yj
B(j)
· El dispositivo combinacional MULBIT, cuyo símbolo esta etiquetado con el mnemotécnico X·y,
calcula M (^) u = Du ( j )´ y j. El bloque que lo implementa y su circuito interno son los siguientes (podéis comprobar ahora que respondisteis bien a la pregunta 1 del informe previo):
D(j)
yj
M
X · y
X
W
b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1^ b
b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b
y
· El dispositivo ADD_REG es un registro acumulador que se inicializa a cero (al final del ciclo en el que Ini vale 1) y que suma el contenido del registro con el valor de la entrada M y deja el resultado en el registro (cuando Ini vale 0). Este dispositivo calcula Wu ( j + 1 )= Wu ( j )+ Mu
para cada iteración. El bloque que lo implementa y su circuito interno se muestran a continuación. Los 16 bits de salida del símbolo etiquetado con el mnemotécnico 0 valen siempre todos 0; está construido con un breakout de 16 bits, con cada uno de los 16 bits fijados al valor 0 y es necesario para inicializar el registro acumulador al valor 0.
ADD_REG
M
W
Ini
Clk
W
REG
MUX 10
ADD
Ini
0
M
M
W(j+1)
W(j)
W(0)
La siguiente figura muestra la interconexión de estos cuatro bloques para formar la unidad de proceso del multiplicador.
ADD_REG
M
W
Ini
X · y
SL_REG
X
D(j)
Ini
IniUP X Y
Clk
W
SRL_REG
Y
yj
Ini
La unidad de control, que definimos más adelante, es la encargada de activar la señal IniUP, que sirve para cargar los registros de los bloques SL_REG, SRL_REG y ADD_REG con los valores iniciales, antes de comenzar las n iteraciones del algoritmo.
Una vez entendido lo que hace cada bloque secuencial y cómo lo hace internamente, es más útil para lo que sigue de la práctica ver la unidad de proceso en un solo nivel, viendo a la vez el contenido de los tres bloques secuenciales que acabamos de diseñar. Esto se muestra en la siguiente figura.
Los nombres que etiquetan los buses del circuito hacen referencia a los vectores de 16 bits que representan en binario a las variables del algoritmo (sólo las representan correctamente cuando con 16 bits se puede representar el valor correcto de la variable).
Aunque en esta práctica n vale 16, para simplificar, vamos a hacer un seguimiento del algoritmo aritmético para un par de vectores concretos con n = 8 bits: X = 00010010 e Y = 00001101. Estos
vectores representan en binario a los números naturales X (^) u = 18 e Yu = 13 , por lo que el resultado
de su multiplicación debe ser Wu = 234. Como 234 se puede representar en 8 bits, el resultado que
obtendremos será correcto. La siguiente tabla muestra los vectores de bits involucrados en el algoritmo para cada una de las iteraciones (ciclos de reloj en la implementación que estamos realizando).
Estado inicial
W(0) =
D(0) =
B(0) =
Iteración / ciclo j
M =
MULBit (D(j), B(j)<0>)
W(j+1) = ADD(W(j), M)
D(j+1) = SL-1(D(j))
B(j+1) = SRL-1(B(j))
Resul. Final W
El resultado final W codifica en binario el resultado correcto de la multiplicación, Wu = 234.
Ø Informe previo
Pregunta 3 Efectuad el seguimiento del algoritmo aritmético de multiplicación que obtiene los 8 bits de menor peso del resultado para los valores numéricos X (^) u = 22 e Yu = 77. Para ello, rellenad la siguiente tabla, tal como se ha hecho en el ejemplo anterior.
Estado inicial
W(0) = D(0) = B(0) =
Iteración / ciclo j
M =
MULBit (D(j), B(j)<0>)
W(j+1) = ADD(W(j), M)
D(j+1) = SL-1(D(j))
B(j+1) = SRL-1(B(j))
Resul. Final W
¿Cuál es el resultado correcto de la multiplicación, Wu = Xu ´ Yu? ¿Los 8 bits que se obtienen como resultado del algoritmo anterior, representan el resultado correcto de la multiplicación? ¿Por qué?
Ahora continuamos con el diseño del multiplicador. Para que el multiplicador funcione correctamente hay que generar la entrada de control IniUP correctamente. De esto se encarga la Unidad de Control.
Este multiplicador es un Procesador de Propósito Específico, que estará inmerso en un sistema más complejo que le dará los datos a multiplicar de manera síncrona (sincronizados con su mismo reloj) y recogerá el resultado para usarlo en otra parte del sistema, también de manera síncrona.
Especificación del multiplicador como caja negra
Vamos a especificar el funcionamiento del multiplicador (unidad de proceso más unidad de control) como caja negra (desde el punto de vista de sus entradas y salidas y sin hacer mención de la implementación interna). Al multiplicador entran dos buses de entrada de datos de 16 bits X e Y que codifican en binario
X (^) u e Y u y sale un bus de 16 bits W que codifica en binario el resultado de la multiplicación
Wu = Xu ´ Y u cuando este se puede representar con n bits (es decir, cuando 2 1 16 Xu ´ Yu£ - ).
Hay dos señales de control de un bit, una de entrada, IniMul , y otra de salida, FinMul. Además, como todo circuito secuencial, tiene una entrada de reloj. El dispositivo que implementa este multiplicador se muestra a continuación.
El funcionamiento del multiplicador como caja negra debe ser el siguiente: · En el ciclo en el que la señal IniMul vale 1, los datos de los buses de entrada X e Y son válidos y se debe comenzar su multiplicación. · Los datos sólo están un ciclo en la entrada, el mismo ciclo en el que IniMul vale 1. · Cuando el multiplicador muestra el resultado correcto en el bus de salida, lo indicará poniendo a 1 durante un ciclo la señal de control FinMul. · El resultado estará presente en el bus de salida del multiplicador durante ese ciclo, así que el sistema exterior debe estar esperando este ciclo, para no perder el resultado. · Si mientras se está multiplicando un par de números (después del ciclo en el que IniMul vale 1 y antes de que FinMul valga 1), se recibe por la entrada IniMul un 1, el multiplicador hará caso omiso de esta petición y continuará sin inmutarse hasta que ponga a 1 FinMul. · En el ciclo en el que FinMul vale 1, ya puede comenzar otra multiplicación, si IniMul vale 1 en ese mismo ciclo.
Unidad de Proceso y Unidad de Control
En la siguiente figura se muestra el circuito interno del dispositivo MUL formado por dos dispositivos: la Unidad de Control (UCMUL) y la Unidad de Proceso (UPMUL).
El circuito interno de la unidad de proceso es el que ya hemos diseñado anteriormente. Ahora vamos a diseñar la unidad de control del multiplicador. Observad que de la UPMUL que acabamos de diseñar no se genera ninguna señal que indique que la multiplicación ha terminado. Esto no lo sabe la UPMUL. Así pues, tenemos que diseñar la UCMUL para que mientras está esperando que IniMul valga 1, active la señal IniUP para inicializar el sistema y cargar los operandos de la multiplicación, después cuente los 16 ciclos (iteraciones) del algoritmo y como pasados esos 16 ciclos sabe que el resultado ya está disponible en el bus W, genere la señal FinMul y se disponga a esperar los operandos de una nueva multiplicación.
antes de que la simulación del ciclo actual haya terminado. Mientras LogicWorks simula el funcionamiento del circuito, el contador de pasos de simulación que se encuentra en la barra de herramientas de simulación se va incrementando. Cuando se para este contador ya podéis provocar el siguiente flanco ascendente de reloj.
q Informe final
Pregunta 1: Indicad para cada multiplicación de los dos apartados siguientes cuál es el resultado que se visualiza en los displays hexadecimales de la salida en el ciclo en que FinMul vale 1. Indicad también si el resultado de la multiplicación es incorrecto (resultado no representable en 16 bits), y en caso de no ser correcto, cuál sería el resultado correcto de la multiplicación. Para ello debéis realizar los cálculos vosotros con lápiz y papel y comprobar el resultado que genera el circuito. Las letras 0x antes del vector de dígitos indican que los dígitos son hexadecimales.
a) X=0x0003, Y=0x
b) X=0x6752, Y=0x
Implementad ahora en LogicWorks el grafo que habéis diseñado sobre papel en la pregunta 4 del informe previo usando el número mínimo de biestables (5, ya que el grafo tiene 18 estados) y dos memorias ROM, una para obtener el estado siguiente, Q+, en función de la entrada, IniMul, y del estado actual, Q, y otra para obtener las salidas, IniUP y FinMul, a partir del estado actual, Q. El esquema lógico resultante que tenéis que crear tiene que tener el aspecto que se muestra en la siguiente figura.
REG
IniMul FinMul In0In1 IniUP In In In In
Out Out Out Out Out Out Out Out ROM_Q+MUL
In In In In In
Out Out Out Out
ROM_OutMUL
b
b
b
b
b
b
b
b
b
b b
b
b
b
b
Clk
Encontraréis el registro de estado, REG, en la LibPrac3. Ponemos un registro de 16 bits, porque es el tamaño que tenemos en la librería, pero sólo usamos los 5 bits de menor peso para codificar el estado de la unidad de control. También encontraréis el dispositivo de la unidad de control (UCMUL) donde debéis encapsular el circuito, ya que el circuito interno del dispositivo UCMUL de la librería sólo dispone de los conectores. Cómo implementar las ROMs en LogicWorks lo explicamos de la siguiente pregunta del informe previo.
Observad que de los 4 bits (un dígito hexadecimal) de menor peso de la salida de la ROM_OutMUL, solamente usamos los dos bits de menor peso, para codificar las señales IniUP y FinMul. Hemos usado un dígito hexadecimal en vez de dos bits, para que sea más fácil escribir el contenido de la ROM en hexadecimal, aunque se necesite una ROM con 2 bits más por palabra. Lo mismo hemos hecho en la ROM que obtiene el estado siguiente, ROM_Q+MUL, que sólo necesita 5 bits de salida y hemos usado palabras de 8 bits (dos dígitos hexadecimales), de los que los 3 de más peso quedan sin utilizar.
Ø Informe previo
Pregunta 5 Indicad el contenido de cada una de las dos memorias ROM, para que el multiplicador funcione como se ha especificado (y de acuerdo con el grafo de 18 estados que habéis diseñado en la pregunta 4 del informe previo). Codificad el estado inicial con el 0, cinco bits a cero, ya que así no hace falta hacer nada especial para inicializar el registro de estado, que por defecto se inicializa a 0). Codificad el resto de estados del 1 al 17 ya que así sólo tenéis que especificar las 36 primeras palabras de la ROM del estado siguiente y las 18 primeras de la ROM de las salidas. A las otras posiciones de las ROMs no hace falta especificarlas ya que el circuito nunca leerá esas posiciones (su contenido puede ser cualquiera). Los bits que no se usan de cada palabra de las ROM haced que sean siempre 0 (bits 5, 6 y 7 de la ROM del estado siguiente y bits 2 y 3 de la ROM de las salidas). Expresad el contenido de cada una de las dos ROM en hexadecimal, separando cada palabra por un espacio o un cambio de línea acordando que la primera palabra
corresponde a la palabra con dirección 0, la siguiente a la de dirección 1, etc. Usad el espacio siguiente.
ROM_Q+MUL
ROM_OutMUL
Implementad en el laboratorio, usando el LogicWorks, cada una de las dos ROM cuyo contenido habéis indicado en la pregunta 5 del informe previo. Para construir un dispositivo de tipo ROM tenéis que seguir
los pasos que os indica el PROM/RAM/PLA Wizard que se encuentra en la barra de herramientas del LogicWorks. Después de hacer clic en el icono tenéis que seleccionar PROM (ya que la ROM que usamos es realmente una Programmable ROM, PROM), en la siguiente ventana poner el número de líneas (número de bits) de dirección de la ROM ( Address Lines ) y de datos ( Bits per Word ), seleccionar Enter hex data manually y por último entrar los datos del contenido de la ROM en hexadecimal, separando cada palabra con un espacio o con un return. Podéis hacer clic en Format Help para saber otras formas de separar cada palabra del contenido de la ROM. Como las ROM son bastante grandes para entrar los datos manualmente es fácil cometer errores. Hay un problema, que una vez creada una ROM en LogicWorks no se puede ver su contenido ni modificarlo, a no ser que se construya un circuito para ello. Si se quiere cambiar el contenido hay que crear otra ROM. Así si se produce un error al entrar los datos es muy difícil detectarlo y corregirlo. Podéis escribir el contenido de la ROM en un fichero tipo texto (con el bloc de notas, por ejemplo) y recortar y pegar su contenido en la ventana de entrada de datos manual. Sólo hace falta que peguéis el contenido de las 36 primeras palabras de la ROM del estado siguiente y las 18 de la ROM de las salidas, ya que las posiciones que no se especifican al crear una PROM en LogicWorks se cargan con valores x (no importa). Por último decir que para poder salvar cada ROM tenéis que tener abierta una librería de dispositivos en el escritorio, ya que en el disco donde está LibPrac5 no podéis escribir.
Una vez creadas vuestras dos ROM, copiar el dispositivo UCMUL de la LibPrac3 en una hoja de circuitos en blanco, abridlo (veréis que solo contiene los conectores de entrada salida) y dibujad en su interior el circuito de la unidad de control con las dos ROMs y el registro de estado. Cerradlo y salvad el dispositivo en vuestra copia de la LibPrac3, como ya habéis hecho en prácticas anteriores (Schematics -> Save Part to Library …).
q Informe final
Pregunta 2: Sustituid la Unidad de Control del multiplicador del circuito ProbeMUL por la que vosotros habéis implementado. Comprobad que funciona correctamente con los mismos datos que para la pregunta 1 del informe final. Comprobad que el multiplicador funciona correctamente (no olvidéis hacer clic en el botón de reset del simulador, para inicializar los registros de la unidad de proceso y de la de control). Cuando estéis seguros del correcto funcionamiento del circuito, avisad al profesor de laboratorio y pedidle que revise vuestro trabajo y firme en el informe final.
Tiempo de ciclo
Dada la importancia del tiempo de ciclo mínimo adecuado para que un circuito secuencial funcione correctamente, es importante que repaséis el tema 5.
Para responder a la pregunta siguiente del informe final es necesario saber el tiempo de propagación del sumador ADD que está inmerso en el circuito. Aunque ya calculamos el tiempo de propagación del ADD en la práctica anterior, se hizo suponiendo el caso peor de cambio en los datos y que el acarreo de entrada podía valer 1. Sin embargo, en este sumador el acarreo de entrada es siempre 0 y además · el operando de la entrada de la derecha del sumador vale 0 la primera vez que se suma, cuando en el operando de la izquierda está Y; · en la segunda suma el bit de menor del operando de la izquierda del sumador vale 0, pués el vector X se ha desplazado una posición a la izquierda, · en la tercera suma los dos bits de menos peso del operando de la izquierda valen 0 y así sucesivamente.
Informe previo Práctica-
Apellidos y nombre: ................................................................................................................ Grupo: .......
Apellidos y nombre: ................................................................................................................ Grupo: .......
(por orden alfabético)
Pregunta 1
a) X 0 1 0 1
b)
c)
d)
e)
f)
Pregunta 4
Pregunta 5
ROM_Q+MUL
ROM_OutMUL
Pregunta 6
a)
b)
