Prácticas de Fundamentos de los...

Prácticas de Fundamentos de los Computadores

Grado en Ingeniería Informática Escuela de Ingeniería Informática

Autores: Cuenca Hernández, Carmelo

Quintana Domínguez, Francisca Título: Prácticas de Fundamentos de los Computadores

Dirección: Edificio de Informática y Matemáticas

Campus Universitario de Tafira 35017 Las Palmas de Gran Canaria

Reservados todos los derechos. La reproducción total o parcial de esta obra por cualquier medio o procedimiento

comprendidos la reprografía y el tratamiento informático, y la distribución de ejemplares de ella mediante alquiler o préstamos públicos, queda rigurosamente prohibida sin la autorización escrita de los titulares del

copyright, bajo las sanciones establecidas por las leyes.

Sin perjuicio de lo anterior, queda expresamente autorizada la reproducción reprográfica total o parcial de esta

obra por miembros de la comunidad universitaria de la Universidad de Las Palmas de Gran Canaria para uso

docente en el ámbito de la misma.

© Universidad de Las Palmas de Gran Canaria, 2013

i

Contenido

Práctica 1: Introducción a las herramientas de diseño .......................................... 1

Introducción ............................................................................................................. 1

Objetivos .................................................................................................................. 2

Desarrollo de la práctica ......................................................................................... 2

XILINX´s Foundation Series Software................................................................ 2

Puertas lógicas ..................................................................................................... 2

Realización práctica ............................................................................................. 3

Autocuestionario (a rellenar ANTES de la sesión de laboratorio) ........................ 15

Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) .......... 15

Práctica 2: Circuitos combinacionales ................................................................... 17

Introducción ........................................................................................................... 17

Objetivos ................................................................................................................ 17

Desarrollo de la práctica ....................................................................................... 18

Sumador binario de un bit .................................................................................. 18

Realización práctica ........................................................................................... 19



Práctica 3: Retardo de puertas ............................................................................... 33

Introducción ........................................................................................................... 33

Objetivos ................................................................................................................ 36


Ampliador aritmético ......................................................................................... 36




Práctica 4: Captura y simulación de elementos biestables ................................... 49

Introducción ........................................................................................................... 49

Objetivos ................................................................................................................ 54





ii

Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control

asociada ..................................................................................................................... 65

Introducción ........................................................................................................... 65

Objetivos ................................................................................................................ 65


Multiplicador binario ......................................................................................... 66


Anexo ...................................................................................................................... 76



Práctica 6: Procesador multiciclo: Simulación y modificación del diseño del

procesador para añadir nuevas instrucciones ....................................................... 79

Introducción ........................................................................................................... 79

Objetivos ................................................................................................................ 83

Realización práctica parte 1: Simulación del procesador multiciclo.................... 84

Preparación del proyecto .................................................................................... 84

Estudio del camino de datos .............................................................................. 84

Estudio de la especificación del control mediante un diagrama de estados finitos

............................................................................................................................ 85

Estudio de la fase de iniciación del procesador ................................................. 86

Estudio del secuenciamiento de las instrucciones.............................................. 87

Realización práctica parte 2: Añadir nuevas instrucciones con números de ciclos

de ejecución fijos .................................................................................................... 89

Descripción de la instrucción jal ........................................................................ 89

Añadir la instrucción jal ..................................................................................... 90

Descripción de la instrucción jr ......................................................................... 92

Añadir la instrucción jr ...................................................................................... 92

Descripción de la instrucción addi ..................................................................... 92

Añadir la instrucción addi .................................................................................. 93

Preguntas frecuentes .............................................................................................. 93

Esquemas y diagramas .......................................................................................... 95

Errores más frecuentes .......................................................................................... 101

Errores generales ................................................................................................. 101

Errores en el editor esquemático ......................................................................... 101

Errores en el simulador ....................................................................................... 102

1

Práctica 1: Introducción a las herramientas de diseño

Índice

Introducción 1

Objetivos 2

Desarrollo de la práctica 2

XILINX´s Foundation Series Software 2

Puertas lógicas 2

Realización práctica 3

Paso 1. Iniciar Xilinx 4

Paso 2. Inicio de un nuevo proyecto 4

Paso 3. Captura del diseño utilizando el editor de esquemas 6

Paso 4. Simulación funcional del diseño 10

Autocuestionario (a rellenar ANTES de la sesión de laboratorio) 15

Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) 15

Introducción

En términos muy generales, el proceso de diseño de un sistema digital puede

definirse como la secuencia de pasos que llevan desde el concepto de un producto

digital hasta los esquemas de fabricación que describen cómo hacer dicho producto.

Con pequeñas variaciones inherentes a las empresas, a los productos y a las personas,

los pasos en este proceso de diseño son la especificación del diseño, el desarrollo de

una biblioteca de componentes básicos, la síntesis del diseño, el análisis del diseño,

la documentación y la fabricación del circuito.

Los diseñadores utilizan normalmente herramientas CAD (Computer Aided Design)

para facilitar algunas de las etapas anteriores. Estas herramientas CAD pueden

dividirse en cinco categorías diferentes según la forma de usarlas en el proceso de

diseño, herramientas para captura y modelado, para síntesis, para verificación y

simulación, para ubicación e interconexionado y para generación de pruebas.

Las herramientas de captura y modelado permiten al diseñador seleccionar un

componente de un menú, situarlo en la pantalla y conectarlo a otros componentes

mediante líneas que representan cables. Este tipo de representación estructural recibe

el nombre de esquemática y las herramientas que ayudan a esta tarea se denominan

herramientas de captura de esquemas. Como alternativa puede utilizarse un lenguaje

para la descripción del hardware.

Las herramientas de síntesis permiten convertir una descripción de un

comportamiento en una descripción estructural que contenga componentes de una

biblioteca concreta, tales como FPGA o CPLD.

Las herramientas de verificación y simulación permiten probar el diseño. A partir de

un conjunto de valores de entrada obtenemos un conjunto de valores de salida. Estos

valores sirven al diseñador para compararlos con los valores teóricos de salida

indicando si existe alguna discrepancia o error en el proceso de diseño.


2

Las herramientas de ubicación e interconexionado permiten optimizar la situación de

los componentes y la posición de cada cable que conecta los componentes.

Las herramientas de prueba ayudan a generar el conjunto de patrones de prueba que

comprueba tantas combinaciones de entrada como sea posible.

En las prácticas de esta asignatura usaremos el paquete software “Xilinx´s

Foundation Series Software” que nos permitirá realizar muchas de las funciones que

acabamos de comentar.

Objetivos

De manera general, los objetivos de esta primera práctica son los siguientes:

1. Iniciación en el uso de un computador.

2. Estudio de las puertas lógicas.

3. Familiarización con las herramientas de captura de esquemas y simulación

funcional.

Como puede observarse, los objetivos son de diferente naturaleza. Por una parte,

objetivos ajenos a la propia materia, como son la iniciación en el uso del computador

y del sistema operativo. Por otra parte, los objetivos relacionados con la materia son

el estudio de las puertas lógicas elementales y la familiarización con dos de las

herramientas que posteriormente van a utilizarse en las prácticas de la asignatura: la

herramienta para la captura de esquemas y la herramienta para la simulación

funcional.

Desarrollo de la práctica

Una vez conocidos los objetivos de la práctica, veamos cómo actuamos para

conseguirlos. En primer lugar hemos de proporcionar toda la información teórica

necesaria para conocer el tema en el que se va a desarrollar la práctica. A

continuación veremos cuáles son los pasos a seguir para realizar la práctica.

Como conocimientos teóricos, hemos de saber en primer lugar con qué software

vamos a trabajar. Como hemos mencionado anteriormente, las prácticas de esta

asignatura las realizaremos con el paquete de desarrollo denominado "Xilinx´s

Foundation Series Software", y lo describiremos a continuación. También hemos de

conocer un poco mejor lo que son las “puertas lógicas” puesto que trabajaremos con

ellas en esta práctica.

XILINX´s Foundation Series Software

"Xilinx´s Foundation Series Software" es un conjunto de herramientas que constituye

un sistema de desarrollo integrado de software y hardware para crear, simular e

implementar diseños digitales. Todas las herramientas en este entorno tienen una

interfaz gráfica de usuario que facilita el uso de las mismas.

Este entorno proporciona herramientas para la captura y modelado tanto esquemática

como mediante lenguaje de descripción del hardware, para síntesis combinacional y

secuencial, y para la simulación de circuitos digitales.

Puertas lógicas

Las puertas lógicas son circuitos elementales que realizan operaciones booleanas.

Estas operaciones son similares a las conjunciones “o” e “y” (en inglés “or” y “and”)


3

que usamos en el lenguaje natural, y constituyen el componente básico en el diseño

con puertas lógicas.

Existen siete puertas lógicas básicas, que son NOT, AND, OR, NAND, NOR, XOR,

y XNOR. La razón de que sean exactamente estas puertas está fundamentada en

criterios de frecuencia de uso, ampliación a más de dos entradas y sencillez de

construcción física. Cada una de estas puertas puede describirse funcionalmente bien

con una ecuación booleana o bien con una tabla de verdad que relaciona los valores

de las señales de entrada y el valor que toma la salida en función de las entradas.

En el capítulo 3 de [Floy97] o en la sección 3.8 de [Gajs97] se puede encontrar una

descripción exhaustiva acerca de las puertas lógicas.

Realización práctica

Esta primera práctica es muy simple, así que la especificación del diseño también lo

es. La práctica consiste en utilizar las herramientas de captura de esquemas y

simulación funcional que ofrece Xilinx para construir un circuito elemental con una

puerta lógica y comprobar el funcionamiento del mismo cuando le aplicamos unos

ciertos valores de entrada.

El circuito que proponemos consta de una única puerta NAND de dos entradas. Una

puerta lógica de tipo NAND tiene la representación esquemática de la Figura 1-1.

Figura 1-1 Símbolo de una puerta nand.

Dadas dos entradas X e Y, la puerta produce una salida cuyo comportamiento es

justamente el contrario a la conjunción “y” que usamos en el lenguaje natural. Por

ejemplo, si decimos en lenguaje natural que “el perro es negro y cariñoso”, queremos

decir que posee a la vez ambas cualidades. Una puerta AND daría salida Z cierta

solamente cuando se presentasen ambas cualidades a la vez. Una puerta NAND daría

el resultado contrario, es decir, daría salida cierta cuando alguna de las dos

cualidades fuese falsa, o cuando lo fuesen ambas a la vez. Esta misma descripción

funcional de la puerta NAND se puede especificar mediante la Tabla 1-1, también

podría hacerse con una ecuación.

Y X Z

0 0 1

0 1 1

1 0 1

1 1 0

Tabla 1-1 Tabla de verdad de una puerta nand.

Introduciremos el esquema de este circuito utilizando Xilinx y luego simularemos el

funcionamiento del circuito conforme van cambiando las entradas. En los próximos

apartados de este guión de prácticas describimos los pasos que hay que seguir para

realizar la práctica.


4

Paso 1. Iniciar Xilinx

Para iniciar la herramienta de desarrollo seleccionamos Inicio Programas

Xilinx Foundation Series Xilinx Foundation Project Manager. Una alternativa

para esta secuencia de selecciones es abrir el icono Xilinx Foundation Project

Manager, si el icono está accesible en el escritorio.

Aparecerá la ventana principal del manejador de proyectos, la apariencia de esta

ventana será similar a la mostrada en la Figura 1-2. La apariencia exacta de la

ventana principal del gestor de proyectos depende de cual haya sido el último

proyecto en el que se ha estado trabajando o de si es la primera vez que el programa

es utilizado.

Figura 1-2 Ventana del gestor de proyectos.

Dos de los botones que aparecen en la sección de la derecha, los etiquetados con los

nombres “Design Entry” y “Simulation” son los que más utilizaremos en esta

práctica y en las sucesivas. El primero nos permite acceder a la herramienta gráfica

de captura de diseños y el segundo a la herramienta de simulación lógica.

Paso 2. Inicio de un nuevo proyecto

Para empezar a trabajar por primera vez en un diseño es necesario indicar que

queremos comenzar un proyecto nuevo. Para ello seleccionamos File New

Project, y entonces se abrirá la ventana de inicio de un proyecto nuevo (ver Figura

1-3). Esta ventana sirve para especificar en ella el nombre del proyecto, el

directorio donde guardaremos la información sobre este proyecto, el tipo de

proyecto y el tipo de captura de esquemas que va a utilizarse. El significado de los

otros campos va más allá de los objetivos de esta primera práctica.


5

Figura 1-3 Ventana de inicio de un proyecto nuevo.

Así que rellenamos los campos referentes al proyecto que vamos a comenzar, tal

como se muestra en la Figura 1-4. Hemos de elegir un nombre para el nuevo

proyecto que comienza. El nombre que le demos es elección personal de cada uno,

aunque es aconsejable que sea un nombre significativo de lo que estamos diseñando.

En este caso, y puesto que el circuito consta de una única puerta lógica NAND, le

daremos el nombre “NAND”. El directorio de trabajo también hemos de

especificarlo. En nuestro caso el directorio de trabajo especificado es el

C:\XCPROJ\, pero este campo debe ajustarse al directorio de trabajo personal. En

cuanto a los otros campos, hemos de elegir la familia XC9500, para esta familia los

chips 95108PC84 y entre estos el integrado con velocidad 20 MHz.

Figura 1-4 Inicialización del proyecto NAND.

Finalmente validamos el inicio del proyecto con el botón de OK, con lo que

volvemos a la ventana anterior, la del gestor de proyectos. La apariencia de la

ventana del gestor de proyectos para el proyecto NAND una vez hemos creado el

proyecto debe ser similar a la que se muestra en la Figura 1-5.


6

Figura 1-5 Ventana del gestor de proyectos una vez inicializada.

Paso 3. Captura del diseño utilizando el editor de esquemas

Una vez que hemos creado el proyecto, el siguiente paso es capturar el esquema del

diseño. Esto significa introducir en la herramienta el circuito que hemos diseñado.

Tenemos dos formas de hacerlo, utilizando una herramienta gráfica o utilizando un

lenguaje de descripción del hardware. Esta vez utilizaremos la herramienta gráfica

para captura de esquemas. Para iniciar la herramienta de edición de esquemas

seleccionamos Tool Design Entry Schematic Editor o directamente picamos

en el botón . Entonces se ejecuta el editor de esquemas que tiene una apariencia

como la que se muestra en la Figura 1-6.

Figura 1-6 Ventana del editor gráfico de esquemas.

La ventana de edición de esquemas permite la colocación de los símbolos gráficos

que representan a las puertas lógicas y de los símbolos que identifican las entradas y

las salidas del circuito.


7

El editor tiene distintos modos de funcionamiento. En cada uno de ellos permite

realizar un tipo de acción diferente: seleccionar componentes, situar puertas, situar

entradas o salidas, situar cables para unir terminales, etc.

En primer lugar situaremos la puerta NAND, para ello pondremos al editor de

esquemas en el modo de situar símbolos, seleccionando Mode Simbols. Otra

manera de hacerlo es usando el botón . De cualquiera de las dos formas aparecerá

la ventana de símbolos lógicos, que tiene el aspecto que se muestra en la Figura 1-7.

Figura 1-7 Ventana de símbolos lógicos.

Para situar la puerta NAND, movemos la barra de desplazamiento en la ventana de

selección de símbolos lógicos hasta encontrar la palabra NAND; la lista está

ordenada alfabéticamente. Picamos sobre la palabra NAND2 para seleccionarla y

entonces situamos el cursor sobre el área de dibujo. Veremos el símbolo de la puerta

NAND moverse junto con el cursor. Simplemente pulsamos sobre el área de dibujo

para situar la puerta NAND. Para cambiar desde cualquier modo al modo selección

pulsa la tecla “Esc” (normalmente está situada en la parte superior izquierda del

teclado).

Es necesario añadir ahora entradas y salidas al circuito. Para hacer esto tenemos dos

formas, o bien vamos a la parte izquierda de la ventana de edición de esquemas y

pulsamos el botón de la barra de herramientas o bien vamos a la parte superior

de la ventana de símbolos lógicos y pulsamos el botón de la barra de

herramientas. Aparecerá una ventana de diálogo en la cual hemos de escribir el

nombre y el tipo de cada terminal. De forma general se denomina terminal a una

entrada o a una salida de una puerta lógica.

En primer lugar situaremos una entrada que llamaremos “X”. Tal como se muestra

en la Figura 1-8, seleccionamos INPUT para el tipo de terminal, indicándole así que

es una entrada, y rellenamos el campo del nombre del terminal con una “X”. Para

situar el terminal de entrada pulsa en el área de dibujo. Repetiremos este proceso

para situar otro terminal de entrada de nombre “Y”.


8

Figura 1-8 Ventana para la entrada X.

A continuación situaremos el terminal de salida, tal como se muestra en la Figura

1-9. Para ello seleccionamos nuevamente el botón , pero en este caso rellenamos

el campo del nombre del terminal con “Z” y seleccionamos un terminal de tipo

OUTPUT. El proceso para situar las salidas en el esquema es similar al proceso para

situar las entradas. La única diferencia es el tipo de terminal.

Figura 1-9 Ventana para la salida Z.

El aspecto del área de dibujo de la ventana de edición de esquemas después de añadir

las señales de entrada y salida será similar al de la Figura 1-10.

Figura 1-10 Esquema del circuito tras añadir la puerta NAND y los terminales

de entrada y salida.

El siguiente paso es conectar los símbolos entre sí. El editor de esquemas está en el

modo de dibujar símbolos, y antes que nada es necesario cambiarlo al modo de

trazado de conexiones. Para cambiar el editor a este modo de funcionamiento

seleccionamos Mode Draw Wires, o bien pulsamos el botón . A continuación

pulsamos en el símbolo de la entrada “X” y luego en el terminal de entrada superior

de la puerta NAND. Esta acción unirá ambos terminales. Haremos exactamente lo

mismo con el terminal de entrada “Y” y el terminal inferior de la puerta NAND.


9

Finalmente conectaremos el terminal de salida “Z” a la salida de la puerta NAND. El

esquema está ahora terminado y el aspecto final del diseño será equivalente al de la

Figura 1-11.

Figura 1-11 Esquema completo del circuito.

Como hemos terminado la captura del esquema lo más prudente es que lo guardemos

seleccionando File Save antes de seguir adelante. La siguiente operación a

realizar consiste en comprobar si existen errores de conexión. Este es un proceso que

consta de dos pasos, el primer paso crea una representación intermedia del circuito

llamada “netlist” que describe los tipos de puertas y las conexiones, y el segundo

paso comprueba los errores usando esta “netlist”. Para hacerlo seleccionamos

primero Options Create Netlist para crear la “netlist” y luego seleccionamos

Options Integrity Test para iniciar la comprobación de errores. La comprobación

debe indicar que no hay errores en el esquema.

Ahora que hemos terminado el esquema podemos pasar a la siguiente parte de la

práctica que consiste en simular el funcionamiento del circuito diseñado. Para ello

hemos de usar una parte diferente del Xilinx, así que tenemos que exportar el diseño.

Esto es necesario porque las distintas parte del Xilinx se comunican a través de las

netlist, que son la forma interna de especificar el diseño. La netlist se genera a partir

del esquema y contiene información que otros programas son capaces de entender.

Para exportar la netlist primero seleccionamos Options Export Netlist. Con esto

aparecerá la ventana para la exportación de netlist que se muestra en la Figura 1-12.

En esta ventana seleccionamos el formato en que vamos a especificar la netlist, de

entre la lista de formatos existentes. En este caso seleccionamos Edif 200[*.EDN]

de la lista de formatos, y pulsamos el botón Abrir. Con ello se creará un fichero con

nombre nand.alb que es una representación de la netlist en el formato EDIF 200.

Este archivo es el que utilizaremos como entrada a otros módulos.


10

Figura 1-12 Ventana para exportar una netlist en formato EDIF 200.

Ya hemos terminado todo el trabajo a realizar en el editor de esquemas, por lo que

regresaremos al gestor de proyectos seleccionando File Exit. Hasta ahora hemos

creado un esquema de un circuito, pero no hemos especificado todavía que ese

esquema forma parte del proyecto actual. Para especificarlo seleccionamos

Document Add, con lo que aparece la ventana de la Figura 1-13. Pulsamos

entonces sobre el fichero nand.sch y luego en el botón Abrir.

Figura 1-13 Ventana para añadir un fichero de esquema al gestor de proyectos.

Paso 4. Simulación funcional del diseño

Una vez finalizada la captura del esquemático pasamos al proceso de simulación. La

simulación del circuito sirve para comprobar el funcionamiento del mismo.

Para iniciar el simulador picamos directamente en el botón simulation en la

ventana del gestor de proyectos. Aparece entonces la ventana de simulación lógica

funcional y una ventana vacía de visualización de señales, tal como se muestra en la

Figura 1-14.


11

Simular un circuito consiste en aplicar valores a las entradas del circuito y visualizar

qué valor toma la salida. Para ellos tenemos que poder “ver” de alguna manera las

entradas del circuito (y poder cambiarles su valor) y también la salida.

Lo primero que hacemos es añadir las entradas y salidas de nuestro circuito a la

ventana de visualización de señales para poder ver qué va ocurriendo en el circuito.

Para hacer esto seleccionamos Signal Add Signals. Entonces aparecerá la ventana

que permite elegir las entradas a visualizar, tal como muestra la Figura 1-15.

Pinchamos la entrada X y luego pulsamos el botón Add, y repetimos estos dos pasos

para la entrada Y y la salida Z. Las señales que ya han sido puestas en la ventana de

visualización de señales aparecen marcadas en la ventana para añadir señales. Hemos

terminado de añadir terminales así que pulsamos en el botón Close para cerrar esta

ventana.

Figura 1-15 Añadiendo señales a la ventana de visualización.

Ahora las tres señales X, Y y Z pueden verse en la ventana de visualización de

señales, aunque todavía no ocurre nada con ellas.

Para realizar la simulación aplicamos estímulos a las señales de entrada. Para añadir

un estímulo seleccionamos Signal Add Stimulators y aparecerá la ventana de

selección de estímulos de la Figura 1-16. En esta ventana existen varios botones.

Nosotros sólo usaremos por ahora el contador binario de 16 bits etiquetado BC.

Durante una simulación, los 2 bits menos significativos (los que están situados más a

la derecha) de este contador siguen de manera cíclica la secuencia 00, 01, 10 y 11.

Estas son todas las combinaciones que se pueden producir en las entradas de la

puerta NAND: que las dos entradas estén a 0, que las dos estén a 1, o que sólo una de

Figura 1-14 Ventanas del simulador lógico funcional y visualización de señal.


12

las dos esté a 1. Bastará entonces con asignar cada uno de estos bits a cada una de las

entradas del circuito.

Figura 1-16 Ventana de selección de estímulos.

Asociaremos a la entrada X de nuestro circuito el estímulo correspondiente al bit 0

del contador binario, para ello pulsamos en la entrada X para seleccionarla y luego en

el botón circular de color amarillo correspondiente al bit 0. Repetimos este paso con

la entrada Y y el bit 1 del contador. El nombre del estímulo asociado a cada entrada

aparece a la derecha del nombre de la entrada. Una vez hecho esto, cerramos la

ventana de selección de estímulos pulsando el botón Close.

Antes de comenzar la simulación tenemos que fijar los parámetros de simulación.

Existen varios parámetros. De entre todos ellos los más significativos son el período

del contador (que fija la velocidad a la que van cambiando las señales de entrada) y

la precisión de la simulación. Seleccionamos Options Preferences y fijamos los

valores de los campos de acuerdo con los valores mostrados en la Figura 1-17. Los

valores diferentes a los mostrados por defecto son el período del contador, “B0

Period”, que lo pondremos a 20 ns, y la desactivación de la opción “Transport

Delay”. Esto último se hace para indicar al simulador que estamos realizando una

simulación lógica y que no tenga en cuenta los detalles de implementación física del

circuito. Pulsamos entonces en el botón de OK para hacer efectivos estos parámetros

de simulación.

Figura 1-17 Ventana para fijar los parámetros de simulación.

El siguiente paso para poder realizar la simulación es calcular el tiempo de

simulación, que debe ser suficiente grande como para que se prueben todos los

valores posibles de las señales de entrada a nuestro circuito. El tiempo de simulación

que permite probar todas las combinaciones de la tabla de verdad del circuito se

calcula como:

𝑻𝒊𝒆𝒎𝒑𝒐 𝑺𝒊𝒎𝒖𝒍𝒂𝒄𝒊ó𝒏 = 𝟐𝑵ú𝒎𝒆𝒓𝒐 𝒅𝒆 𝒆𝒏𝒕𝒓𝒂𝒅𝒂𝒔 ·𝑷𝒆𝒓í𝒐𝒅𝒐 𝑩𝟎

𝟐


13

En nuestro caso, el circuito tiene 2 entradas que son X e Y. Hemos fijado el período

de B0 (B0 Period) a 20ns. Por lo tanto, el tiempo de simulación es de 40ns.

𝑇𝑖𝑒𝑚𝑝𝑜 𝑆𝑖𝑚𝑢𝑙𝑎𝑐𝑖ó𝑛 = 22 ·20

2= 40𝑛𝑠

El valor calculado para el tiempo de simulación lo colocamos en el desplegable que

se encuentra a la derecha del botón . Para comenzar la simulación pulsamos en el

botón y después de varios segundos, el resultado de la simulación aparece en la

ventana de visualización de señales, tal como se muestra en la Figura 1-18. Es

posible que el resultado no se vea correctamente y que se tenga que aumentar o

disminuir el factor de escala de visualización, usando los botones y . A pesar

de que se vea bien, usen estos botones y vean qué efecto producen en la ventana de

visualización de señales.

Figura 1-18 Resultado de la simulación

En esta ventana vemos las señales de entrada del circuito dibujadas en negro, y la

señal de salida dibujada en azul. Vemos la entrada X asociada al bit 0 (B0) del

contador y la entrada Y asociada al bit 1 (B1) del contador. El valor 0 en la entrada

se representa con la línea de entrada por debajo de la línea punteada. El valor 1 se

representa con la línea de entrada por encima de la línea punteada. Esto se muestra

de esta manera porque es así como ocurre en la implementación física del circuito.

Los circuitos digitales funcionan con tensión eléctrica en las entradas, de forma que

los valores 0 y 1 indican la ausencia o presencia de tensión eléctrica en la entrada. Un

0 indica que no hay voltaje (por ejemplo, 0 voltios), y un 1 indica que hay voltaje

(por ejemplo, 5 voltios).

La simulación comienza en tiempo 0 ns. En ese instante las dos entradas tienen valor

0, y la salida tiene valor 1. Luego cambia la entrada X a valor 1 y la salida sigue

siendo 1. A continuación cambian ambas entradas y la salida sigue siendo 1. Por

último, cuando ambas entradas valen 1 la salida pasa a ser 0. Esto define un ciclo

completo. Si vuelves a pulsar el botón verás cómo se genera otro ciclo completo

de simulación, y apreciarás cómo vuelven a repetirse cíclicamente los valores de las

entradas, con lo cual la salida vuelve a tomar también cíclicamente los mismos

valores.


14

En este circuito tan sencillo encontrar en qué instante de tiempo se están probando

las diferentes combinaciones de la tabla de verdad es muy sencillo. Sin embargo, en

circuitos con muchas más entradas esta tarea no es tan simple. Para posicionarse

directamente en el instante de tiempo donde se está realizando la simulación de una

combinación concreta de la tabla de verdad no hay más que fijarse en que la

combinación 0 (Y=0, X=0) comienza en t=0, la combinación 1 (Y=0, X=1) comienza

en t=10ns (PeríodoB0/2), la combinación 2 (Y=1, X=0) comienza en t=20ns

(2*PeríodoB0/2) y la combinación 3 (Y=1,X=1) comienza en t=30ns

(3*PeríodoB0/2). En general, en la simulación la combinación N comienza en el

instante de tiempo t= N*PeríodoB0/2. Esto es válido para cualquier simulación que

realicemos y es un necesario recordarlo pues será de primordial utilidad en las

prácticas venideras.

Finalmente guardamos el resultado de la simulación seleccionando File Save

Simulation State y tras guardar la simulación en el archivo nand.des, hemos

terminado la práctica por lo que abandonamos el programa de simulación

seleccionando File Exit, y salimos también del gestor de proyectos seleccionando

File Exit.

IMPORTANTE:

El tiempo total de simulación se calcula como:


𝟐

La combinación N de la tabla de verdad comienza en la simulación en el instante:

𝒕(𝑵) = 𝑵 · 𝑷𝒆𝒓í𝒐𝒅𝒐 𝑩𝟎

𝟐


15

Autocuestionario (a rellenar ANTES de la sesión de laboratorio)

1. ¿Qué objetivo te parece el más importante de la práctica?

2. ¿Qué es una puerta lógica?

3. Dibuja el símbolo gráfico correspondiente a la puerta lógica NAND

suponiendo que tiene dos entradas.

4. ¿Qué circuito vamos a diseñar en esta práctica? ¿Cuál es su tabla de verdad?

5. ¿Qué significa capturar el esquema del diseño?

6. ¿Para qué sirve simular el comportamiento del circuito?

Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio)

1. ¿Cómo se comprueba si un diseño esquemático tiene errores?

2. ¿Qué es una “netlist”?

3. ¿Cuál es el resultado final del diseño esquemático?

4. ¿Cómo se añaden las terminales de entrada y salida a la simulación?

5. ¿Cómo se conectan estímulos a los terminales de entrada?

6. ¿Tiene sentido conectar un estímulo a un terminal de salida? ¿Por qué?

7. ¿Cuáles son los parámetros más significativos en la simulación y para qué se

utilizan?

17

Práctica 2: Circuitos combinacionales

Índice

Introducción 17

Objetivos 17


Sumador binario de un bit 18


Realización de un sumador binario de un bit 19

Realización de un sumador binario de 2 bits 22

Realización de un sumador binario de 8 bits 28



Introducción

Los circuitos combinacionales son aquellos circuitos digitales en los cuales los

valores de la salida en un instante cualquiera únicamente dependen de los valores de

las entradas en ese instante, sin importar cuales han sido las entradas en los instantes

de tiempos anteriores.

En esta segunda práctica capturaremos mediante el editor de esquemas la estructura

de un circuito digital combinacional sencillo y simularemos su comportamiento. A

posteriori, lo extenderemos aumentando su complejidad.

Objetivos

De manera general, los objetivos de esta segunda práctica son los siguientes:

1. Estudio de los circuitos combinacionales.

2. Adquisición de destreza en la captura de diseños esquemáticos complejos.

3. Profundización en las posibilidades avanzadas de las herramientas de diseño.

4. Manejo de vectores de prueba complejos.

5. Ilustrar la necesidad del diseño jerárquico y de otras técnicas de captura de

esquemas.

En esta práctica comenzaremos realizando la captura y simulación de un circuito

combinacional correspondiente a un sumador binario de 1 bit. Este esquema lo

verificaremos mediante la herramienta de simulación. En un segundo paso

extenderemos el sumador binario de un único bit para que sea posible la suma de

números de dos bits, y finalmente extenderemos el sumador a 8 bits. Este circuito

final usará aproximadamente 100 puertas lógicas y 150 conexiones, requiriendo del

alumno destreza a la hora de la captura del esquema.


18

Por otra parte un sumador binario de 8 bits tiene 16 entradas y 9 salidas, dando un

total de 25 señales a visualizar. Para facilitar su visualización es necesario ahondar

en las posibilidades de representación que ofrece la herramienta.

También puesto que para la suma de dos números binarios de 8 bits existen en total

65536 posibilidades diferentes en las entradas, también notaremos la necesidad de

utilizar estrategias para asignar los estímulos a las señales de entrada, más allá de la

simple asignación de entradas a estímulos mostrada en la práctica anterior.

Finalmente veremos lo inadecuado de utilizar este método de diseño si queremos

escalar el sumador hasta 64 bits. A pesar de que el escalado del circuito es muy fácil

de manera conceptual, usar la simple replicación nos lleva a una forma de trabajar

muy engorrosa por el tedio que supone trabajar con circuitos muy voluminosos. Con

ello introduciremos la necesidad del diseño jerárquico y de otras herramientas de

captura.


Sumador binario de un bit

El diseño a realizar en esta práctica es el circuito combinacional correspondiente a un

sumador completo de un bit y su expansión a 2 y 8 bits.

Un sumador binario de un bit es un circuito combinacional con tres entradas y dos

salidas. Los nombres de las tres entradas son: INPUT0 e INPUT1, que corresponden

a los bits a sumar, y CARRY_INPUT, que es el bit de acarreo. Los nombres de las

salidas son SUM y CARRY_OUTPUT, siendo SUM el resultado de la suma binaria

y CARRY_OUPUT el acarreo de salida.

Entradas del circuito Salidas del circuito

INPUT0 INPUT1 CARRY_INPUT SUM CARRY_OUTPUT

0 0 0 0 0

0 0 1 1 0

0 1 0 1 0

0 1 1 0 1

1 0 0 1 0

1 0 1 0 1

1 1 0 0 1

1 1 1 1 1

Tabla 2-1 Tabla de verdad correspondiente a un sumador binario de un 1 bit.

El funcionamiento de este circuito puede describirse usando una tabla de verdad. Una

tabla de verdad es una representación tabular de las entradas y las salidas del circuito,

en la cual cada fila de la tabla posee una de las posibles combinaciones de entrada

del circuito y el valor de las salidas correspondiente a esas entradas. La Tabla 2-1 es

la tabla de verdad para el circuito sumador binario. En ella se ve, por ejemplo, que

para la combinación de entrada correspondiente a INPUT0 = 1, INPUT1 = 0,

CARRY_INPUT = 1, la combinación de salida es SUM = 0 y CARRY_OUPUT = 1.

Mediante técnicas basadas en el álgebra de Boole es posible obtener una

representación equivalente del comportamiento del circuito mediante ecuaciones

algebraicas que relacionan las salidas del circuito con sus entradas. En el caso de un

sumador binario de un bit estas ecuaciones son las siguientes:

INPUTCARRYINPUTINPUTSUM _10


19

)10(*_10_ INPUTINPUTINPUTCARRYINPUTINPUTOUTPUTCARRY

En las ecuaciones anteriores los símbolos matemáticos , * y + corresponden

respectivamente a las operaciones lógicas de XOR, AND y OR, que como vimos en

la primera práctica son algunas de las funciones lógicas básicas (puertas lógicas), y

que tienen asociadas unos símbolos gráficos que posibilitan la representación

esquemática de las ecuaciones anteriores. Así, a las ecuaciones anteriores les

corresponde el esquema de la Figura 2-1.

Figura 2-1 Representación esquemática de un sumador binario de 1 bit.


Llegados a este punto es de vital importancia recordar lo aprendido en la práctica

anterior, ya que los primeros pasos a realizar (para iniciar la herramienta, crear el

proyecto, capturar el esquema,…) son los que vimos allí. Dado que no es preciso

memorizar cada detalle, es un buen consejo tener a mano el guión de la primera

práctica.

La realización práctica consta de tres pasos, en el primero realizaremos un sumador

binario de un bit y simularemos su comportamiento. En el segundo realizaremos un

sumador binario de dos bits y en el tercero un sumador binario de ocho bits.

Realización de un sumador binario de un bit

Primero, creamos un proyecto cuyo nombre sea ADD1_95, rellenando los campos

para la creación de un nuevo proyecto tal y como se muestra en la Figura 2-2. En el

campo directorio debes hacer referencia a tu directorio personal de trabajo.


20

Figura 2-2 Iniciación del proyecto de un sumador binario de 1 bit.

A continuación iniciamos la herramienta gráfica para la captura de esquemáticos y

capturamos el diseño de la Figura 2-3. Este esquema no es igual que el esquema de la

Figura 2-1, pero la funcionalidad es exactamente la misma.

Figura 2-3 Esquema para el sumador binario de un bit.

Cabe resaltar que en este esquema hay dos símbolos que no corresponden a puertas

lógicas, cuyos nombres son IBUF y OBUF, y que están situados a continuación de

los terminales de entrada y antes de los terminales de salida. Estos símbolos

corresponden a buffers de entrada y salida e indican a la herramienta que las señales

conectados a ellos corresponderán con entradas y salidas de un chip FPGA.

Guardamos el esquema con el nombre ADD1.SCH. Para ello utilizamos la opción

FileSave As y rellenamos los campos de la ventana con los valores indicados en la

Figura 2-4. Finalmente picamos en el botón Aceptar.


21

Figura 2-4 Ventana para guardar el esquema con otro nombre.

Una vez que hemos finalizado el esquema generamos una netlist usando la opción

OptionsCreate Netlist... y la exportamos en el formato EDIF 200 usando la

opción del menú principal OptionsExport Netlist... Antes de exportar la netlist

podemos comprobar que todo es correcto seleccionando OptionsIntegrity Test.

Finalmente abandonamos el editor de esquemas con FileExit.

Ahora debemos comprobar que el sumador funciona correctamente. Picamos en el

botón , en la ventana del gestor de proyectos para iniciar el simulador. Una vez

en él, usamos SignalAdd Signals... para añadir las entradas y salidas en la ventana

de visualización de señales. Luego, seleccionando SignalAdd Stimulators...

conectamos las entradas a los tres bits inferiores del contador binario (Bc0, Bc1,

Bc2). Finalmente, picamos en el botón en la barra de herramientas del simulador

lógico y aparecerán las señales de entrada y salida de una manera similar a la

mostrada en la Figura 2-5. Usamos los botones y así como los

desplazadores horizontales y verticales en la ventana de visualización de señales para

obtener una buena imagen de las señales.

Figura 2-5 Simulación del sumador binario de un bit.


22

Ahora hemos de comprobar que el resultado de la simulación coincide con el del

sumador binario de un bit, usando para ello la tabla de verdad de la Tabla 2-1. Si no

es así, revisamos el diseño esquemático en busca del error y volvemos a realizar la

simulación. Cuando el resultado de la simulación sea correcto guardamos el estado

de la simulación seleccionando FileSave Simulation State y cerramos la

herramienta de simulación con FileExit.

Realización de un sumador binario de 2 bits

Llegados a este punto vamos a construir un sumador binario de dos bits.

Teóricamente a partir de un sumador binario de un bit es posible construir un

sumador binario de dos bits únicamente encadenando dos de ellos. Encadenar

significa conectar la salida CARRY_OUPUT del sumador binario del bit menos

significativo a la entrada CARRY_INPUT del segundo sumador.

Comenzamos este segundo paso creando un proyecto de las misma características

que el ADD1_95, pero con nombre ADD2_95. Una vez creado vamos a aprovechar

el diseño esquemático anterior y así evitaremos una nueva captura desde el principio

del diseño. Seleccionamos DocumentAdd... y buscamos el fichero esquemático

anterior en el proyecto ADD1_95, tal como se muestra en la Figura 2-6.

Figura 2-6 Ventana para añadir el esquema add1.SCH del proyecto Add1_95 al

proyecto Add2_95.

Iniciamos el editor de esquemas, usando el botón , o bien en la ventana

principal del gestor de proyectos, seleccionando ToolsDesign Entry

Schematic Editor. Para mayor claridad guardamos el esquema con el nombre

ADD2.SCH indicando con este nombre que el esquema corresponde a un sumador de

dos bits. Para ello seleccionamos File->Save As... y en el campo del nombre del

archivo escribimos ADD2.SCH.

Un sumador binario de dos bits tiene la misma estructura que un sumador binario de

un bit, replicada dos veces.

Para copiar esta estructura colocamos primero el editor de esquemáticos en el modo

de selección, con la opción del menú principal ModeSelect and Drag.

Seleccionamos entonces todo el diseño. Marcamos un recuadro con el ratón

alrededor del esquema, picando primero con el botón izquierdo en la esquina

superior izquierda de un área imaginaria que vaya a contener todo el dibujo y


23

moviendo el ratón hasta la esquina inferior derecha de esa área. Si lo hemos hecho

bien tendremos que ver todos los componentes del esquema seleccionados en color

rojo. A continuación copiamos en el portapapeles el esquema usando en la barra del

menú principal la opción EditCopy y luego lo recuperamos del portapapeles con

la opción EditPaste. Aparecerá entonces un recuadro que contiene todo el diseño

en su interior, tal y como se muestra en la Figura 2-7. Movemos el recuadro debajo

de los componentes que ya tenemos situados, de manera que no se solapen entre sí, y

lo situamos definitivamente picando con el botón izquierdo. Si lo hemos hecho mal,

todavía tenemos una oportunidad de deshacer los cambios seleccionando en el menú

EditUndo.

Figura 2-7 Editor de esquemas tras la operación de pegado.

Hemos de fijarnos en que los dos bloques de diseño son exactamente iguales. Tanto

es así que hasta los nombres de las entradas y las salidas son iguales. Obviamente,

los nombres de las salidas no deben coincidir si corresponden a diferentes salidas.

Por ello procederemos a renombrar todas las entradas y las salidas. Para el bloque

sumador del bit menos significativo utilizaremos para las entradas los nombres X0,

Y0 y CI0, y para las salidas los nombres S0, CO0. La manera de cambiar el nombre

asociado a un terminal es picar dos veces rápidamente sobre el terminal. Entonces la

herramienta abrirá el cuadro de diálogo correspondiente al terminal, según muestra la

Figura 2-8, y en el campo correspondiente al nombre del terminal escribiremos el

nuevo nombre del terminal.


24

Figura 2-8 Ventana para cambiar el nombre a los terminales de entrada y

salida.

Cambiamos el nombre de los terminales para el bloque sumador correspondiente al

segundo bit, pasando a llamarse ahora X1, Y1, CI1, S1 y CO1. El resultado final de

todo este cambio de nombres es un esquema equivalente al de la Figura 2-9.

Figura 2-9 Esquema tras haber cambiado los nombres de los terminales


25

Algunos terminales en el esquema del sumador binario de dos bits son diferentes a

los terminales en el sumador binario de un bit. En concreto tenemos que realizar un

encadenamiento de los acarreos entre las etapas, es decir, tenemos que unir la señal

CO0 con CI1, y estas señales quedarán como señales internas al diseño. Esto quiere

decir que desde un punto de vista externo carecen de significado. Por ello, hemos de

eliminarlos. Para borrar cualquier componente primero lo seleccionamos con el ratón

picando con el botón izquierdo y luego pulsamos la tecla Suprimir. Hacemos este

proceso para borrar el OBUF asociado al terminal CO0, el propio terminal CO0, el

IBUF asociado al terminal CI1 y el terminal CI1.

Conectamos entonces la salida y la entrada de las puertas lógicas donde antes estaban

conectados los terminales CO0 y CI1. El esquema final debe ser equivalente al de la

Figura 2-10.

Figura 2-10 Esquema final del sumador binario de dos bits.

Creamos ahora una netlist usando OptionsCreate Netlist... y la exportamos en el

formato EDIF 200 usando la opción del menú principal OptionsExport Netlist...

Antes de exportar la netlist comprobamos que todo es correcto con


26

OptionsIntegrity Test. Finalmente abandonamos el editor de esquemas con

FileExit.

Ahora debemos comprobar que el sumador funciona correctamente. Picamos en el

botón de la ventana del gestor de proyectos para iniciar el simulador. Una vez

en él, usamos SignalAdd Signals... para añadir las entradas y salidas en la ventana

de visualización de señales. Añadimos las señales a visualizar en el siguiente orden:

en primer lugar CI0, después las correspondientes al número X (el número formado

al concatenar las señales X1 y X0), luego las correspondientes al número Y (el

número formado al concatenar las señales Y1 e Y0), a continuación la salida S (el

número formado al concatenar S1 y S0) y finalmente el acarreo de salida CO1.

Luego, con SignalAdd Stimulators... conectamos CI0 al estímulo 0. Sólo

tenemos que pulsar el botón cero en la ventana para añadir estímulos. Asociamos X0,

X1, Y0 e Y1 respectivamente con las entradas a los cuatro bits inferiores del

contador binario (Bc0, Bc1, Bc2 y Bc3). Finalmente, calculamos el tiempo de

simulación, lo introducimos en el recuadro que está a la derecha del botón de la

barra de herramientas del simulador lógico y picamos en dicho botón. Entonces

aparecerán las señales de entrada y salida de una manera similar a la Figura 2-11.

Usando los botones y , así como los desplazadores horizontales y verticales

en la ventana de visualización de señales obtendremos una buena imagen de las

señales.

Figura 2-11 Resultado de la simulación del sumador binario de dos bits.

La comprobación de que la captura del esquemático ha sido correcta en este caso no

es sencilla, ya que no tenemos una tabla de verdad para él que nos permita hacerlo de

forma fácil. Tendríamos que obtener una tabla de verdad con cuatro entradas, y para

cada una de esas posibles 16 combinaciones de entrada comprobar si sus salidas son

las adecuadas. Por supuesto que este forma de verificación es inviable si los

sumadores son de ocho bits, ya que implicaría 256x256 combinaciones de entrada

diferentes. Para resolver estas dificultades la herramienta permite agrupar las señales.

Una agrupación de señales recibe el nombre de BUS.

Vamos a organizar las señales en buses, uno para la señal de entrada X, otro para la

entrada Y y un tercero para la salida S. Seleccionamos X0, y después, picando con el

ratón sobre el nombre de la señal X1, a la vez que mantienes pulsada la tecla shift (la

tecla para escribir con letras mayúsculas) ambas señales, la X0 y X1, deben aparecer

seleccionadas con una franja azul. En el menú principal de la herramienta de


27

simulación seleccionamos la opción SignalBusCombine y ya hemos agrupado

las señales X0 y X1 en un bus. Repetimos este proceso para formar otros buses con

las otras entradas Y0 e Y1 y con las señales de salida S0, S1 y CO1, ver la Figura

2-12.

Figura 2-12 Ventana de visualización de las señales tras definir los buses para

las entradas y las salidas.

Es posible cambiar el nombre de los buses simplemente seleccionando el nombre del

bus al cual queremos cambiar el nombre. Luego seleccionamos SignalBusBus

Name... y escribimos el nuevo nombre. También es posible cambiar el formato de

representación de los valores en los buses a binario, octal, decimal o hexadecimal.

Para cambiar un valor, por ejemplo a binario, primero seleccionamos el bus y luego

usamos la opción SignalBusBinary. En la Figura 2-13 se muestra el resultado

de cambiar los nombres a los buses y mostrar el valor en cada instante de simulación

en binario.

Figura 2-13 Visualización de las señales organizadas en buses y representadas

en binario.

Cuando agrupamos las señales en un bus se sigue un orden determinado en la

asignación de qué línea del bus es la más significativa y cuál es la menos

significativa. Si en algún momento nos interesa invertir el orden, podemos hacerlo

seleccionando SignalBusChange Direction.


28

Una vez hemos llegado hasta aquí comprobamos que el resultado de la simulación

coincide con lo esperado de un sumador binario de 2 bits. Si no es así, revisamos el

diseño esquemático en busca del error y volvemos a realizar la simulación. Cuando

el resultado de la simulación sea el correcto guardamos el estado de la simulación

con FileSave Simulation State y cerramos la herramienta de simulación con

FileExit.

Realización de un sumador binario de 8 bits

Ahora vamos a capturar el esquema de un sumador binario de ocho bits y

posteriormente lo vamos a simular. Los pasos son similares a los dados en los

diseños de los sumadores de un bit y de dos bits.

Creamos un proyecto con nombre ADD8_95 con las mismas características de los

anteriores. Añadimos el esquema ADD2.SCH al proyecto. Iniciamos el editor de

esquemático y en primer lugar guardamos el nuevo diseño con el nombre

ADD8.SCH. Seleccionamos todos los componentes del esquema y los copiamos en

el portapapeles, los recuperamos y los situamos para obtener los bloques necesarios

para un sumador binario de 4 bits. Repetimos estos pasos para conseguir los bloques

de 6 y 8 bits, tal como muestra la Figura 2-14.

Figura 2-14 Ejemplo de situación de los sumadores de 2 bits para diseñar un

sumador de 8 bits.


29

Renombramos cada uno de los terminales de entrada con los nombres X0..X7,

Y0..Y7, el terminal de salida también lo renombramos con S0..S7 y al acarreo de la

última etapa CO7. Borramos los terminales y los buffers asociados con los acarreos

intermedios y propagamos el acarreo entre los diferentes bloques. El esquema será

similar al mostrado en la Figura 2-15. En este esquema el orden entre los bloques

viene dado por la numeración de arriba abajo y luego de izquierda a derecha.

Creamos la netlist y la exportamos con formato EDIF200.

Figura 2-15 Esquema final del sumador binario de 8 bits.

A continuación iniciamos el simulador. Añadimos las señales por este orden, CI0,

X0...X7, Y0...Y7, S0..S7 y CO7. Asociamos el estímulo 0 con CI0, X0 con Bc0, X1

con Bc1, y así sucesivamente hasta X7 con Bc7. También asociamos Y0 con Bc8,

Y1 con Bc9,…, y finalmente Y7 con BcF. Agrupamos las señales X0...X7 para

formar el bus X, las señales Y0...Y7 para formar el bus Y, y las señales S0...S7 y

CO7 para formar el bus SUM. Cambiamos el modo de visualización de los buses a

decimal.

Para visualizar los resultados de esta simulación tenemos que realizar una simulación

de bastante tiempo, pues hemos de dar tiempo a que se presenten todas las


30

combinaciones en las entradas. Para ello calculamos el tiempo de simulación de

acuerdo a la fórmula ya vista en la práctica anterior:


𝟐

Es importante tener en cuenta que aunque en el circuito existen 17 entradas, sólo 16

de ellas producen todas las combinaciones posibles del cicuito. La entrada CI0 está

conectada siempre al valor 0, por lo que no va a variar y no va a generar

combinaciones diferentes. Por ese motivo no hay que tenerla en cuenta para hacer el

cálculo del tiempo de simulación.

El resultado de la simulación debe ser similar al mostrado en la Figura 2-16. Si el

resultado es correcto, guardamos los resultados, pero si no es así habrá que

comprobar el diseño y volver a realizar la simulación.

Figura 2-16 Resultado de la simulación del sumador binario de 8 bits.

En esta simulación, si queremos ir al instante donde se esté realizando la suma de

unos valores determinados de Y y X hemos de aplicar también lo aprendido en la

práctica anterior. Por lo tanto, para ir a ese instante de tiempo hemos de aplicar la

fórmula siguiente:

𝒕(𝑵) = 𝑵 · 𝑷𝒆𝒓í𝒐𝒅𝒐 𝑩𝟎

𝟐

Siendo N el valor decimal de la correspondiente combinación de Y y X. Para dos

valores cualesquiera de Y y X, calculamos N como:

𝑵 = 𝒀 · 𝟐𝟓𝟔 + 𝑿

Por lo tanto, para cualquier combinación de los valores de entrada (Y,X), el instante

de tiempo donde se está realizando dicha simulación se calcula como:

𝒕(𝒀, 𝑿) = (𝒀 · 𝟐𝟓𝟔 + 𝑿) · 𝑷𝒆𝒓í𝒐𝒅𝒐 𝑩𝟎

𝟐


31


1. ¿Cuál es la tabla de verdad de un sumador binario de dos bits?

2. ¿Qué significa “encadenar” los sumadores binarios de un bit para construir

sumadores de más bits?

3. ¿Por qué no es interesante desde el punto de vista de la simulación visualizar

los acarreos intermedios?

4. ¿Qué es el tiempo de simulación?

5. ¿Cómo influirá el periodo de la señal Bc0 del contador binario con el tiempo

de simulación?

6. ¿Qué es un bus?

7. ¿Por qué el valor de CI0 es 0 en todas las simulaciones excepto en la del

sumador binario de un bit?

8. ¿Por qué no hemos fijado el valor de CO7?

9. ¿Cuál es la técnica descrita en el guión de la práctica para reutilizar los

diseños?


1. ¿Cuántos periodos de la señal Bc0 son necesarios para comprobar todos los

posibles valores de las entradas en el sumador binario de 8 bits?

2. ¿Por qué incluimos el bit de acarreo de salida como un bit más en el bus de

salida? ¿Qué ocurriría si no lo incluyésemos?

3. ¿Cuál ha sido la característica de visualización que nos ha permitido trabajar

con las 18 señales del sumador binario de 8 bits?

4. ¿Crees que utilizando las mismas técnicas podríamos construir sumadores de

16, 32, 64 bits o incluso de más bits?

5. ¿Qué modificación deberíamos añadir al sumador binario de 8 bits para que

fuera un sumador en complemento a dos?

6. ¿Por qué ha sido necesario hacer simulaciones fijando el tiempo que el

simulador estará calculando valores?

33

Práctica 3: Retardo de puertas

Índice

Introducción 33

Objetivos 36


Ampliador aritmético 36


Simulación con retardos de puertas del ampliador aritmético de 1 bit 38

Eliminación de los riesgos estáticos 42

Retardo total del ampliador aritmético 43

Riesgos estáticos del circuito ampliador lógico 44



Introducción

En las prácticas anteriores hemos realizado simulaciones funcionales para comprobar

el funcionamiento del diseño lógico. En las simulaciones funcionales los retrasos de

las puertas lógicas son siempre cero. Esto significa que las salidas cambian

inmediatamente como respuesta a los cambios en los valores de las señales de

entrada, lo que no es más que una simplificación de la realidad.

A pesar de lo ideal que pueden ser las simulaciones funcionales no por ello dejan de

ser interesantes, ya que permiten visualizar claramente las relaciones de causa y

efecto, analizar fácilmente los cronogramas y verificar el comportamiento funcional

del circuito. Además, las simulaciones lógicas son la única manera de detectar

comportamientos oscilatorios en los diseños, que serían imposibles de comprobar

cuando las puertas tienen retardos.

A medida que vamos avanzando en el diseño se hacen necesarios otros modos de

simulación. Por ejemplo, si queremos conocer cuál es la frecuencia máxima a la que

puede operar el circuito diseñado, o saber si las señales de entrada están activas el

suficiente tiempo para que puedan funcionar correctamente los componentes que

utilizamos en los circuitos, es necesario que las simulaciones tengan en cuenta los

retardos.

Las causas de los retardos en los circuitos son variadas. Por una parte están los

retardos debidos a las conexiones entre puertas. En cada nodo de un circuito real hay

una capacidad parásita asociada. Estas capacidades actúan como almacenes

temporales de cargas que hay que vaciar o llenar antes de que las señales alcancen

los valores de tensión mínimos y máximos.

Supongamos que el valor de la capacidad parásita de una puerta lógica es de 10pF

(1pF = 1012

F) y que conectamos la salida de la puerta a un total de 20 entradas. La

capacidad parásita total en este caso es la suma de todas las capacidades individuales,


34

20x10pF = 200pF. Si la puerta de salida presenta una impedancia de salida de 100,

la constante de tiempo es 200pF x100 = 20ns y ya que el tiempo necesario para

realizar una transición entre estados es en torno a 2 ó 3 veces la constante de tiempo,

el tiempo que empleará está puerta para cambiar de estado oscilará entre 40 y 60ns.

Esto implica que, poniéndonos en el caso peor, el circuito no podrá funcionar a una

frecuencia mayor que 1/60ns = 16.7MHz, lo cual es una restricción bastante severa.

Además de los retrasos debidos a las conexiones entre dispositivos, están los retrasos

inherentes a cada puerta. Cuando la entrada a una puerta cambia, la salida de la

puerta no cambia inmediatamente. Este retraso también es debido a capacidades

parásitas dentro del circuito integrado. El tiempo entre el cambio en la entrada y el

cambio en la salida es llamado retardo de propagación o retardo de puerta. Hay

dos tipos de retardo de puerta, ver Figura 3-1:

Figura 3-1 Retardos de propagación en puertas.

tPHL: Este es el retardo entre el cambio en la entrada y el tiempo en que la señal

de salida cambia desde el nivel alto al nivel bajo.

tPLH: Este es el retardo entre el cambio en la entrada y el tiempo en que la señal

de salida cambia desde el nivel bajo al nivel alto.

Normalmente estos retardos no son muy diferentes, así que se suelen simplificar en

un único parámetro llamado tpd que simboliza el retardo de propagación en una

puerta, tanto para el caso de las transiciones hacia el nivel bajo o el nivel alto.

Otra consecuencia de los retardos son las condiciones de riesgo, que pueden originar

el mal funcionamiento del circuito. Los riesgos generan pequeños pulsos espurios

indeseables que aparecen en las salidas a causa de los diferentes retardos de

propagación en caminos diferentes, pero convergentes a lo largo del circuito.

Concretamente, un pulso espurio es un cambio de corta duración en el valor de la

salida cuando no debería aparecer cambio alguno.

El concepto de riesgo se muestra en el ejemplo a continuación. En la Tabla 3-1 se

expone la representación de mapa de Karnaugh de la función booleana F = xy’ + yz,

y en la Figura 3-2 el esquema lógico correspondiente.

yz

x

00 01 11 10

0 0

1 3

1 2

1 4

1 5

1 7

1 6

Tabla 3-1 Representación de mapa F = xy' + yz.

En la Figura 3-2 puede verse que hay dos caminos diferentes, etiquetados como a y

b, desde la entrada Y hasta la salida F, y estos dos caminos tienen retardos de

propagación diferentes. El retardo en el camino a, que va desde Y hasta F a través

del inversor, una puerta AND y una puerta OR, es de 3 ns, mientras que el retardo en


35

el camino b, que sólo atraviesa una puerta AND y una puerta OR, es de 2 ns. En el

caso en el que X=Z=1, Y=1, la salida F valdrá 1 debido al camino b. De igual modo,

cuando X=Z=1, Y=0, la salida F valdrá 1 debido al camino a. Por consiguiente, en

un diseño ideal donde el retardo de las puertas es 0, la salida F debería permanecer a

1 cuando Y cambia de 1 a 0, ya que la señal que viene por el camino a se hace igual

a 1 al tiempo que la señal que viene por el camino b se hace igual a 0. Sin embargo,

en realidad a necesita 2 ns para llegar a valer 1, mientras que b se iguala a 0 en 1 ns,

forzando F a 0 durante 1 ns. Esta situación se muestra en la Figura 3-3. En esta figura

$I3.0 es la salida del inversor, $I1.0 es a y $I2.0 es b. Se puede apreciar que Y

cambia a 0 en t0 = 20ns, seguida por un cambio de b a 0 en t0+1 ns y por un cambio

en a al valor 1 en t0+2 ns. Ya que F es igual al valor de (a OR b), F cambia a 0 en

t1=t0+2 ns y vuelve a valer 1 en t2=t0+3 ns.

Figura 3-2 Esquema lógico.

En general existe un riesgo estático 1 (riesgo estático 0) cuando dos minterms (o

maxterms) son adyacentes y no están cubiertos en la implementación de la función

lógica por ningún primo implicante (primo implicado) simultáneamente. La manera

de evitar los riesgos estáticos 1 (riesgo estático 0) es aumentar el coste del circuito y

añadir un nuevo primo implicante (primo implicado) que evite la situación anterior.

Figura 3-3 Diagrama de tiempos.

Este método garantiza la eliminación de los pulsos espurios producidos por

transiciones entre combinaciones de entrada a distancia 1, no así cuando las

transiciones ocurren entre combinaciones de entrada a distancia mayor que 1. Así por

ejemplo, las transiciones entre las combinaciones 3 y 5 también producen riesgos

estáticos 1, ver la Figura 3-4.

Figura 3-4 Riesgo estático producido por una transición a distancia 2.

En general la identificación explícita y, de ser posible, la eliminación de los riesgos y

de las señales espurias que ellos crean, es muy difícil. Esto se debe tanto a la

1

1

1

1

a

b


36

incertidumbre inherente en los retardos de propagación que hay que considerar como

al gran número de posibles combinaciones de estos retardos. Por lo tanto, sólo es

factible llevar a cabo un análisis explícito de riesgos para circuitos pequeños que

operan en condiciones restrictivas.

Objetivos

Los objetivos de esta práctica son:

1. Introducción de los conceptos de retardo de puerta y retardo de propagación.

2. Uso de los modos de simulación que tienen en cuenta los retardos de las

puertas.

3. Estudios de las consecuencias de los retardos en los diseños.

4. Determinación de la frecuencia máxima de operación de un circuito.


Esta práctica consta de dos partes. En la primera vamos a estudiar de manera guiada

el circuito ampliador aritmético con los objetivos principales de aprender los modos

de simulación que tienen en cuenta los retardos de propagación y de puerta, y además

comprobar y corregir las situaciones de riesgos estáticos.

En la segunda parte de la práctica, aplicaremos las técnicas anteriores otro circuito,

de forma no guiada.

Ampliador aritmético

Para el estudio inicial de los retardos y las consecuencias de los mismos en los

circuitos digitales vamos a utilizar el circuito ampliador aritmético de 1 bit. La tabla

de verdad y el esquema lógico están en la Tabla 3-2, y en la Figura 3-5.

M S1 S0 Bi Yi

1 0 0 0 1

1 0 0 1 1

1 0 1 0 0

1 0 1 1 1

1 1 0 0 1

1 1 0 1 0

1 1 1 0 0

1 1 1 1 0

0 x x x 0

Tabla 3-2 Tabla de verdad del ampliador aritmético.

Tal y como se ve en la Tabla 3-3, la cobertura de primos implicantes elegida

corresponde a los minterms {0, 2} y {4, 5}. Con esta elección de primos implicantes

ocurre que los minterms 0 y 4 que son adyacentes no están cubiertos

simultáneamente por ningún primo implicante en la implementación de la función

lógica. Por ello habrá una situación de riesgo estático cuando la señal Bi cambie de

estado lógico con S1=0 y S0=0. Para evitar este riesgo estático basta con añadir un

primo implicante que cubra los minterms 0 y 4.


37

Figura 3-5 Esquema lógico del ampliador aritmético.

Por otra parte, tal y como se ve en la Figura 3-5, el retardo máximo en el ampliador

aritmético corresponde al camino de las señales S0, S1 ó Bi cuando atraviesan el

inversor, la puerta AND y la puerta OR. Suponiendo un retardo de 1 ns en cada

puerta, resulta que el retraso total máximo es de 3ns, y por ello la máxima frecuencia

a la que pueden variar las señales de entrada, con la garantía de que el circuito tendrá

tiempo de operar correctamente, es F=1/(3ns)=333 MHz. Esta situación es peor en la

realidad puesto que los retrasos temporales serán mayores y variarán para cada

puerta.

S1 S0

bi

00 01 11 10

0

0

1 1 3

2

1

1 4

1 5

1 7 6

Tabla 3-3 Mapa del ampliador aritmético.


La realización práctica consta de varios apartados. En el primero realizaremos la

simulación del ampliador lógico de un bit con retardos. El objetivo es estudiar las

consecuencias de los mismos en los circuitos combinacionales y comprobar cómo

pueden evitarse los pulsos espurios en la salida. A continuación estudiaremos los

retardos de propagación a través de una cadena de puertas, para obtener el caso peor,

el cual define el tiempo de operación. Estos dos apartados estarán dirigidos por el

guión de prácticas, paso por paso. El apartado siguiente es similar a los anteriores

con la salvedad de que el alumno debe aplicar de forma autónoma los conocimientos

adquiridos en los apartados anteriores.


38

Simulación con retardos de puertas del ampliador aritmético de 1 bit

Inicia la herramienta de Xilinx. Luego crea un proyecto de nombre “delay” tal y

como indica la Figura 3-6. En el campo directorio debes hacer referencia a tu

directorio personal de trabajo.

Figura 3-6 Ventana de nuevo proyecto.

Luego, captura el esquema del ampliador aritmético utilizando el editor de esquemas.

No olvides añadir terminales de entrada y de salida para las señales M, S1, S0, Bi e

Yi que no están incluidas en el esquema de la Figura 3-5. Llámale AE.SCH. Pica dos

veces en el nombre del esquema, en la ventana del gestor de proyectos, para abrirlo.

Una vez que esté abierto el esquema generamos la netlist usando la opción

OptionsCreate Netlist... y la exportamos en el formato EDIF 200 usando la

opción del menú principal OptionsExport Netlist... Antes de exportar la netlist

podemos comprobar que todo es correcto seleccionando OptionsIntegrity Test.

Finalmente abandonamos el editor de esquemas con FileExit.

A continuación realizaremos la simulación con retardos del ampliador aritmético.

Picamos en el botón , en la ventana del gestor de proyectos, para iniciar el

simulador. Una vez en él, usamos SignalAdd Signals... para añadir a la ventana de

visualización las señales de entrada M, S0, S1 y Bi.

En este caso también estamos interesados en visualizar no sólo los terminales de

entrada y salida, sino también las señales intermedias, como son las tres señales de

entrada a cada puerta AND y las dos señales de entrada a la puerta OR

Para añadirlas existen dos métodos. En el primer método, selecciona en la

subventana del medio, llamada “Chip Selection”, la puerta AND3 y pica dos veces,

según se muestra en la Figura 3-7. Al hacerlo, en la subventana de la derecha

aparecerán enumerados los terminales de entrada y salida de la puerta, selecciona el

I0 y pulsa el botón Add. Repite lo mismo con los terminales intermedios I1 e I2.

Cuando hayas terminado, repite este proceso para la otra puerta AND3 y para la

puerta OR2.


39

Figura 3-7 Ventana para añadir señales intermedias a la simulación.

El otro método, quizás preferible por ser más directo, es el siguiente: la herramienta

permite visualizar en el simulador cualquier señal, aunque esta no esté asociada a un

terminal de entrada o salida del circuito y sea una señal intermedia sin nombrar.

Para añadir al simulador una señal, desde el editor de esquemas, pulsa en el botón

en la barra de herramientas principal. Aparecerá la ventana de herramientas de

simulación de la Figura 3-8. Pica en el botón para añadir señales. El editor

cambia de modo y el cursor es ahora una flecha con señales digitales. Pica en cada

terminal que quieras añadir, y asegúrate que seleccionas el terminal de entrada o

salida de un bloque o de una puerta lógica, no el cable que une un terminal a otro

elemento, pues en éste último caso la señal no aparecerá en la ventana principal del

simulador. Cuando un terminal es añadido a la ventana de simulación aparece una

marca de color gris junto al terminal. Para eliminar de la ventana de simulación una

señal añadida pica en el botón y luego en la señal, la marca al lado de la señal

debe desaparecer.

Figura 3-8 Ventana para añadir el esquema del ampliador aritmético.

Finalmente añade la señal de salida Yi. La ventana de visualización de señales con

las señales añadidas debe ser similar a la Figura 3-9.


40

Figura 3-9 Ventana de visualización con las señales intermedias añadidas.

Luego, seleccionando SignalAdd Stimulators... conectamos las entradas M, S1,

S0 y B a los estímulos 1, 0, 0 y Bc0 respectivamente. Esta asignación de estímulos se

realiza así para comprobar el riesgo cuando ocurre la transición entre las

configuraciones correspondientes a los minterms 0 y 4.

A diferencia de las simulaciones hasta ahora realizadas, vamos a especificar que la

simulación no es funcional, sino con retardos, y también vamos a especificar el valor

del retardo de puerta.

Figura 3-10 Cambio de simulación funcional a unitaria.

En la barra de herramientas del simulador, ver Figura 3-10, existe a la izquierda una

subventana desplegable con los modos de simulación: “Functional”, “Timing”,

“Glitch” y “Unit”. Seleccionaremos el modo “Unit” que significa retardo unitario en

todas las puertas lógicas.


41

Figura 3-11 Fijación del retardo unitario.

A continuación nos queda fijar el tiempo a que corresponde un retardo unitario. Para

ello seleccionamos OptionsPreferences... y fijamos el parámetro de precisión de

la simulación a 1 ns, según se muestra en la Figura 3-11. No debemos olvidar

desactivar la opción “Transport Delay”.

Finalmente, calculamos el tiempo de simulación, lo introducimos y picamos en el

botón en la barra de herramientas del simulador lógico y aparecerán las

simulaciones de las señales de entrada y salida. Para obtener una buena imagen de las

señales usamos los botones y , así como los desplazadores horizontales y

verticales en la ventana de visualización de señales. El resultado de la simulación se

muestra en la Figura 3-12.

Figura 3-12 Resultado de la simulación para riesgos estáticos.

En la Figura 3-12 vemos que el cambio desde la configuración M=1, S1=S0=0 y Bi=1

a la configuración M=1, S1=S0=0 y Bi=0 produce un resultado no deseado. La


42

transición contraria, de la configuración M=1, S1=S0=0 y Bi=0 a la configuración

M=1, S1=S0=0 y Bi=1, no produce ningún riesgo.

Eliminación de los riesgos estáticos

Para eliminar los riesgos estáticos es suficiente añadir primos implicantes que cubran

a la vez los minterms causantes del riesgo. Captura el nuevo esquema propuesto en la

Figura 3-13 y repite los pasos ya explicados para estudiar el comportamiento del

circuito con retardos. El resultado de la simulación se muestra en la Figura 3-14.

Figura 3-13 Esquema del ampliador aritmético modificado para evitar riesgos

estáticos.

En esta figura vemos cómo los pulsos espurios en la señal de salida han desaparecido

como consecuencia de añadir un nuevo primo implicante en la implementación de la

función lógica de salida.


43

Figura 3-14 Resultado de la simulación del ampliador aritmético modificado.

Retardo total del ampliador aritmético

Para calcular de manera aproximada el retardo máximo del circuito podemos realizar

una simulación donde cambien todas las señales de entrada.

Asigna a las señales de entrada M, S1, S0 y Bi los estímulos correspondientes a los 4

bits menos significativos del contador binario (Bc3, Bc2, Bc1 y Bc0).

Con 4 entradas existen un total de 24=16 combinaciones de entrada, y dado que el

período de la señal es de 10 ns, será suficiente un tiempo de simulación de 80 ns.

Puedes fijar este tiempo de simulación en la barra de herramientas del simulador

lógico, según se muestre en la Figura 3-15. Luego pica en el botón para simular.

Figura 3-15 Fijación del tiempo de simulación.

El resultado de la simulación aparece en la Figura 3-16.


44

Figura 3-16 Simulación con retardo del ampliador aritmético.

La peor situación que podría ocurrir según el diagrama lógico de la Figura 3-5 es un

retardo de 3 ns. Examinando el resultado de la simulación en la Figura 3-16 vemos

que esta situación se presenta cuando ocurre una transición desde la configuración

M=0, S1=1, S0=1 y Bi=1 a la configuración M=1, S1=0, S0=0 y Bi=0.

Podemos concluir que el retardo total para nuestro ampliador aritmético de 1 bit es

de 3 ns.

También vemos en la simulación de la Figura 3-16 que en el instante de simulación

correspondiente a t=62ns hay un espurio producido por una transición entre minterms

a distancia mayor que 1.

Riesgos estáticos del circuito ampliador lógico

En este apartado debes realizar el estudio de los riesgos estáticos del circuito

ampliador lógico que se muestra en la Figura 3-17, cuya tabla de verdad se encuentra

en la Tabla 3-4.


45

Figura 3-17 Esquema lógico del circuito ampliador lógico

El ampliador lógico, a diferencia del ampliador aritmético, no tiene transiciones entre

combinaciones adyacentes que produzcan pulsos espurios en la señal de salida del

circuito. De aquí no debe deducirse que en el ampliador lógico no haya transiciones

entre combinaciones que produzcan pulsos espurios, ocurre simplemente que estas

transiciones son entre configuraciones a distancia mayor que 1.

M S1 S0 Xi

0 0 0 Ai’

0 0 1 AiBi

0 1 0 Ai

0 1 1 Ai+Bi

1 x x Ai

Tabla 3-4 Tabla de verdad del ampliador lógico

Por ejemplo en la Figura 3-18 los estímulos a las señales de entrada han sido

asignados de manera que producen transiciones entre los minterms 4 y 7 de manera

cíclica provocando una secuencia de espurios.


46

Figura 3-18 Espurios por la transición entre los minterms 7 y 4.

La parte práctica de este apartado consiste en la realización de una simulación del

ampliador lógico que visualice algunas transiciones entre combinaciones a distancia

mayor que 1 que produzcan riesgos estáticos en el ampliador lógico. Al capturar el

esquema del ampliador lógico para su posterior simulación, no olvides añadir

terminales de entrada y salida para las señales M, S1, S0, Ai y Bi, que no están

incluidas en el esquema de la Figura 3-17.


47


1. ¿Qué significa que una puerta lógica tenga un retardo de 1 ns?

2. ¿Qué es un riesgo estático en un circuito combinacional?

3. ¿Por qué se producen los riesgos estáticos? ¿Cómo se evitan? ¿Pueden

evitarse todos?

4. ¿Cómo se realiza una simulación que tiene en cuenta los retardos de puerta?

5. ¿Cómo está relacionado el retardo de propagación con la frecuencia máxima

de operación de un circuito?

6. Justifica que el ampliador lógico no tiene riesgos estáticos 1 debido a

transiciones entre configuraciones adyacentes.


1. En la simulación presentada en la Figura 3-16 para el tiempo de simulación

de t = 62 ns hay un pulso espurio. Explica la existencia de dicho pulso

espurio mediante un cronograma.

2. ¿Qué transiciones has comprobado que producen pulsos espurios en el

ampliador lógico?

3. ¿Presentan los sumadores binarios riesgos estáticos?

49

Práctica 4: Captura y simulación de elementos biestables

Índice

Introducción 49

Objetivos 54



Latch SR 55

Simulación funcional del latch SR 57

Simulación con retardo unitario del latch SR 59

Latch D síncrono 60

Biestable D maestro esclavo 61

Biestable D disparado por flanco con entradas asíncronas de set y clear. 61



Introducción

Todas las prácticas realizadas hasta ahora han sido de circuitos combinacionales. La

característica principal de todos ellos es el hecho de que los valores de salida se

calculan exclusivamente a partir de los valores actuales en las entradas. En cambio

los circuitos secuenciales difieren debido a que contienen elementos de memoria,

mientras que los combinacionales no. Como resultado, los valores de salida de los

componentes se calculan utilizando tanto los valores de entrada actuales como los

valores de entrada anteriores.

El elemento estructural básico de los circuitos secuenciales es el “latch” SR, que

consta en una posible implementación de dos puertas NOR conectadas de forma

cruzada. Como puede verse en la Figura 4-1, el latch SR tiene dos señales de entrada:

la señal de puesta a 1, S (set) y la señal de puesta a 0, (reset); también tiene dos

señales de salida Q y Q’ (en la figura llamada AUX por razones tipográficas);

finalmente, tiene dos estados: un estado de puesta a uno (o set) cuando Q=1 (Q’=0) y

un estado de puesta a cero (o reset) cuando Q=0 (Q’=1).


50

Figura 4-1 Latch SR implementado con puertas NOR.

Mientras las señales S y R sean iguales a 0, el latch SR permanece en el mismo

estado. Si la entrada S (entrada R) se hace 1, el latch SR irá al estado de puesta a uno

(puesta a cero). Si las señales de entrada S y R valen ambas 1, las salidas Q y Q’

deben ser iguales a 0. Si una de las señales de entrada cambia antes que la otra, el

latch finaliza en un estado forzado por la señal que cambie en último lugar.

Un problema inherente al latch SR es el hecho de que si S y R cambian al mismo

tiempo, no se puede predecir la salida. En el caso de que las puertas tengan el mismo

retardo, ambas valdrán 1 al mismo tiempo y, después, valdrán 0 simultáneamente y

así sucesivamente, oscilando siempre.

Para eliminar este comportamiento indeterminista, se debe asegurar que las señales S

y R no se restablezcan al mismo tiempo o asegurarse de que las señales S y R nunca

cambien al mismo tiempo.

S R Q(actual) Q(siguiente) Q’(siguiente)

0 0 0 0 1

0 0 1 1 0

0 1 X 0 1

1 0 0 1 0

1 1 X 0 0

Tabla 4-1 Tabla de funcionamiento del latch SR implementado con puertas

NOR.

El funcionamiento del latch SR implementado con puertas NOR está descrito en la

Tabla 4-1.

Figura 4-2 Latch SR implementado con puertas NAND.

El latch SR puede implementarse también con puertas NAND, según se muestra en

la Figura 4-2. En este caso las entradas S y R están normalmente a 1. Activando S o

R a 0, el latch se establecerá a 1 o pondrá a 0, respectivamente, que es justamente lo


51

opuesto a la implementación NOR en la que activando S o R a 1 se causaba la puesta

a uno o a cero del latch, respectivamente.

S R Q(actual) Q(siguiente) Q’(siguiente)

0 0 X 1 1

0 1 X 1 0

1 0 X 0 1

1 1 0 0 1

1 1 1 1 0

Tabla 4-2 Tabla de funcionamiento del latch SR implementado con puertas

NAND.

El comportamiento funcional del latch SR implementado con puertas NAND está

descrito en la Tabla 4-2.

Figura 4-3 Latch SR síncrono.

A partir de un latch SR es posible construir fácilmente un latch SR síncrono. La

diferencia entre un latch SR y un latch SR síncrono está en la existencia de una

tercera entrada, C, que habilita o deshabilita el latch SR. Esto significa que cuando

C=1, el latch SR sincronizado funciona exactamente igual que el latch SR; mientras

que cuando C=0, el latch permanecerá siempre en el estado anterior. En la Figura 4-3

puede verse la implementación de un latch SR síncrono y en la Tabla 4-3 la

descripción del funcionamiento del mismo.

C S R Q(actual) Q(siguiente)

0 X X 0 0

0 X X 1 1

1 0 0 0 0

1 0 0 1 1

1 0 1 X 0

1 1 0 X 1

1 1 1 X indefinido

Tabla 4-3 Tabla de funcionamiento del latch SR síncrono.

Como se ha indicado anteriormente, en los latch SR debe garantizarse que las

entradas S y R no valgan 1 al mismo tiempo. Este inconveniente puede evitarse

modificando apropiadamente el latch SR para que esto no ocurra, dando lugar así al

latch D sincronizado, ver la Figura 4-4. Un latch D también tiene una entrada C que

lo habilita, del mismo modo que se hacía en el latch SR sincronizado. Cuando C es

igual a 1, la salida Q tomará el mismo valor que la entrada D. Por el contrario, si C es


52

igual a 0, la salida Q mantendrá el último valor de D establecido antes del flanco de

bajada del reloj. El funcionamiento del latch D queda recogido en la Tabla 4-4.

Figura 4-4 Latch D síncrono.

Como se ha expuesto anteriormente, los latches síncronos con puertas son elementos

sencillos de memoria que se habilitan durante todo el intervalo de tiempo en el que la

señal de control C es igual a 1. Estos latches se denominan latches sensibles al nivel

porque están habilitados siempre que la señal de control esté a 1. En cualquier

instante de ese tiempo los latches serán transparentes, en el sentido de que cualquier

cambio en las entradas se propagará a la salida. Estos latches funcionan como

elementos de memoria sólo después del flanco de bajada de la señal de control,

cuando mantienen el estado establecido por el último valor de la entrada anterior al

flanco de bajada de la señal de control.

C D Q(actual) Q(siguiente)

0 X 0 0

0 X 1 1

1 0 X 0

1 1 X 1

Tabla 4-4 Tabla de funcionamiento del latch D síncrono.

Como alternativa de diseño con latches sensibles al nivel están los biestables

maestro-esclavo y los biestables disparados por flanco. La diferencia funcional entre

los latches y los biestables radica en que los biestables maestro-esclavo y los

biestables disparados por flanco no son transparentes, esto es, sólo pueden cambiar

de estado durante las transiciones positivas (o negativas) del reloj.

La Figura 4-5 es el diagrama lógico de un biestable D maestro esclavo. Está

implementado utilizando dos latches, denominados maestro (latch de la izquierda) y

esclavo (latch de la derecha). La entrada al latch maestro es la entrada al biestable, la

salida del latch esclavo es la salida del biestable completo.


53

Figura 4-5 Biestable D maestro-esclavo.

La Figura 4-6 es el esquema de un biestable disparado por flanco implementado con

tres latches básicos de puesta a uno, de puesta a cero y de salida, interconectados.

Figura 4-6 Biestable D disparado por flanco con entradas asíncronas de clear y

preset.

Además de los biestables D existen otros. En total son cuatro las clases de biestables:

SR, JK, D y T. Se diferencian en el número de entradas y en la respuesta que

proporcionan a valores diferentes de las señales de entrada. Las cuatro clases de

biestables se indican en la Tabla 4-5. Cada uno de estos biestables puede

caracterizarse por su símbolo gráfico, por su tabla característica, su ecuación

característica y por su tabla de excitación.


54

Nombre

del

biestable

Símbolo del

biestable

Tabla

característica

Ecuación

característica

Tabla de

excitación

SR

Q(t+1) = S +

R’Q

S R Q(t+1) Q(t) Q(t+1) S R

0 0 Q(t) 0 0 0 X

0 1 0 0 1 1 0

1 0 1 1 0 0 1

1 1 X 1 1 X 0

JK

Q(t+1)=JQ’+K’Q

J K Q(t+1) Q(t) Q(t+1) J K

0 0 Q(t) 0 0 0 X

0 1 0 0 1 1 X

1 0 1 1 0 X 1

1 1 Q’(t) 1 1 X 0

D

Q(t+1) = D

D Q(t+1) Q(t) Q(t+1) D

0 0 0 0 0

1 1 0 1 1

1 0 0

1 1 1

T

Q(t+1) = TQ’

+T’Q

T Q(t+1) Q(t) Q(t+1) T

0 Q(t) 0 0 0

1 Q’(t) 0 1 1

1 0 1

1 1 0

Tabla 4-5 Tipos de biestables.

Los símbolos gráficos de los biestables de la Tabla 4-5 además de las entradas ya

mencionadas tienen entradas de “set” y “reset” asíncronas, esto es, cuando la entrada

de “set” (“reset”) asíncrona es activada el biestable cambia al estado de puesta a uno

(puesta a cero).

Objetivos


1. El estudio práctico tanto estructural como funcional de los latches y los

biestables.

2. Estudio de los comportamientos oscilatorios mediante la simulación.

3. Aprendizaje y explicación de relaciones causa-efecto con cronogramas

complejos.

4. Análisis de circuitos con múltiples realimentaciones.


55

5. Uso de nuevas características del programa de simulación.

6. Propuesta de patrones de test para la verificación del circuito.


El desarrollo de la práctica consiste en capturar múltiples esquemas correspondientes

a latches o biestables y confrontar que los resultados experimentales coinciden con

los teóricos.

En cada uno de los apartados vamos a realizar una o dos simulaciones que deben

comprender pues es lo que luego se les preguntará en los cuestionarios de

laboratorio.


La realización práctica es casi en su totalidad guiada. Comienza con el estudio de un

latch SR, continua con un latch D síncrono, sigue con un biestable D maestro-esclavo

y termina con un biestable D disparado por flanco con entradas asíncronas de preset

y clear. Para el último apartado el alumno deberá proponer además un vector de test

para comprobar el circuito.

Latch SR

Inicia la herramienta Xilinx. Luego crea un proyecto de nombre “flipflop”, tal y

como indica la Figura 4-7. En el campo directorio debes hacer referencia a tu

directorio personal de trabajo.

Figura 4-7 Ventana de nuevo proyecto.

Captura el esquema correspondiente a la implementación con puertas NOR de la

Figura 4-1. Para añadir el nombre de “AUX” a la conexión entre la salida de la

puerta NOR superior y la primera entrada de la otra puerta NOR selecciona en

primer lugar el cable de unión entre estos dos terminales, la herramienta indica que el

cable está seleccionado cambiando el color del mismo de azul a rojo. Luego pulsa el

botón derecho del ratón y selecciona la opción “Net Properties”. Aparece entonces la

ventana de la Figura 4-8, escribe el nombre “AUX” en el campo nombre y luego pica

en el botón OK.


56

Figura 4-8 Ventana para la asignación de un nombre a una conexión.

Cambia la posición de la etiqueta “AUX” seleccionándola, picando sobre la etiqueta

con el botón izquierdo del ratón y luego arrastrándola, manteniendo pulsado el botón

izquierdo a la vez que mueves el ratón.

A continuación generamos la netlist usando la opción OptionsCreate Netlist... y

la exportamos en el formato EDIF 200 usando la opción del menú principal

OptionsExport Netlist... Antes de exportar la netlist podemos comprobar que

todo es correcto seleccionando OptionsIntegrity Test. Finalmente abandonamos

el editor de esquemas con FileExit.

A continuación realizaremos la simulación del latch SR. Picamos en el botón ,

en la ventana del gestor de proyectos para iniciar el simulador. Una vez en él, usamos

SignalAdd Signals... para añadir a la ventana de visualización las señales de

entrada S, R, Q y AUX.

Figura 4-9 Ejemplo de estímulos para las señales de entrada S y R en el latch

SR.

A diferencia de las prácticas anteriores, esta vez no utilizaremos las señales del

contador para los estímulos de entrada. En lugar de ello modelaremos a nuestra

conveniencia las señales de entrada utilizando fórmulas. Las entradas S y R tendrán

una forma de onda que definiremos a nuestra conveniencia, como podría ser la forma

mostrada en la Figura 4-9.

Figura 4-10 Ventana de selección de estímulos.

Para modelar las señales S y R tenemos que editar fórmulas. Selecciona

SignalAdd Stimulators... para que aparezca la ventana de selección de estímulos,

ver la Figura 4-10. Pica en el botón Formula... aparecerá la ventana para definición

de fórmulas de la Figura 4-11.


57

Figura 4-11 Ventana para definir fórmulas.

En esta ventana pueden definirse fórmulas, en primer lugar definiremos la fórmula

“F0” que luego asignaremos a la señal S y en segundo lugar la fórmula “F1” que

asignaremos a la señal R.

Pica dos veces en la etiqueta de la fórmula F0 para que la herramienta te permita

editar la fórmula F0. Escribe en el campo “Edit Formula”

“L10H10L30H10L20H10L10”, esto indica que la señal de entrada estará a nivel bajo

10ns, luego otros 10ns a nivel alto, seguido de 30ns a nivel bajo, nuevamente 10ns a

nivel alto, seguirán 20ns a nivel bajo, otros 10 más a nivel alto y finalmente 10 a

nivel bajo. Para terminar pica en el botón Accept de la ventana para definir fórmulas.

Repite los mismos pasos para definir la fórmula F1. Escribe en el campo “Edit

Formula” “L30H10L15H10L10H15L10”. Pica en el botón Accept y finalmente en el

botón Close.

Ahora es posible asignar la fórmula F0 y F1 a las señales de entrada S y R. En la

ventana de selección de estímulos una fila de estímulos está etiquetada con el nombre

“Form:”, ver Figura 4-10. Pica en la señal de entrada S y luego en el cuadrado más a

la derecha de dicha fila, así se asigna el estímulo F0 a la señal de entrada S. Luego

pica en la señal de entrada R y posteriormente en el segundo cuadrado empezando

por la derecha, así se asigna el estímulo F1 a la señal de entrada R.

Ahora hemos de fijar el tiempo de simulación. Para ello NO necesitamos aplicar la

fórmula que calcula el tiempo de simulaicón que ya conocemos, sino darnos cuenta

de que los estímulos de entrada están fijados por las fórmulas que hemos introducido,

y que el tiempo total que están definiendo estas fórmulas es de 100ns, ya que

10+10+30+10+20+10+10=100. Para fijar el tiempo de simulación a 100ns escribe en

la subventana intermedia en la barra de herramientas principal el valor de “100ns”.

A continuación vamos a realizar la simulación del latch SR en los dos modos de

simulación: el funcional y el unitario.

Simulación funcional del latch SR

Pulsa el botón para comenzar la simulación funcional.


58

Figura 4-12 Mensaje de error por oscilaciones.

Después de esperar un tiempo aparece el mensaje de la Figura 4-12, el cual indica

que la herramienta de simulación ha detectado un comportamiento oscilatorio del

sistema. Pulsa el botón para detener la simulación. El resultado de la simulación

es la Figura 4-13.

Figura 4-13 Simulación funcional del latch SR.

En el modo funcional de simulación la herramienta presupone la situación ideal

donde todos los componentes lógicos tienen retardo de 0 ns. Ello ocasiona que

cuando las entradas S y R cambian simultáneamente del nivel lógico alto al nivel

lógico bajo, con retardo de 0 ns, sus salidas cambiarán del nivel lógico bajo al nivel

alto, lo cual provocará que con retardo 0 la salida cambie nuevamente de nivel, y así

sucesivamente. Por tanto ocurre una oscilación irresoluble para la herramienta de

simulación.

Puede ocurrir que para ver claramente el cronograma para la simulación del latch SR

que tengas que aumentar el factor de visualización .

Una vez aumentada la escala de visualización nos centraremos en los detalles en el

intervalo [0ns, 10ns]. En este intervalo observamos que el estado de las señales de

salida Q y AUX es desconocido. Esto es así ya que en un latch SR cuando las dos

entradas S y R toman el valor 0 las salidas permanecen inalteradas, pero inicialmente

el simulador desconoce el valor.


59

Simulación con retardo unitario del latch SR

Figura 4-14 Cambio a simulación unitaria.

Cambia el modo de simulación a “Unit” para que el simulador asigne un retardo

unitario a cada puerta y fija que el retardo sea de 1 ns. Aunque esto ya lo hemos

visto, reproducimos aquí las figuras que te recuerdan cómo hacerlo (ver la Figura

4-14 y la Figura 4-15).

Figura 4-15 Fijación de retardo unitario a 1 ns.

Cambia el tiempo de simulación para que este sea 100ns, para ello escribe en la

subventana intermedia el valor de “100ns”. Finalmente pulsa el botón para

comenzar la simulación. El resultado de la simulación es la Figura 4-16.


60

Figura 4-16 Simulación del latch SR implementado con puertas NOR.

Puede ocurrir que para ver claramente el cronograma para la simulación del latch SR

que tengas que aumentar el factor de visualización .

En el intervalo [90ns, 100ns] observamos que mientras las dos señales de entrada S y

R están a nivel alto, ambas salidas Q y AUX están a nivel bajo. En el instante de

simulación correspondiente a 90ns las entradas S y R cambian simultáneamente a

nivel bajo, produciendo un retardo de puerta después un cambio en las señales de

salida. A su vez un retardo de puerta después produce un nuevo cambio en la salida y

así sucesivamente.

Latch D síncrono

Con el objeto de evitar el comportamiento oscilatorio del latch SR es posible

construir otro tipo de latch a partir de él, llamado latch D que, sin disminuir la

funcionalidad del mismo, evita el problema de las oscilaciones. En la Figura 4-4 se

muestra la estructura de un latch D síncrono.

La parte práctica de este apartado consiste en realizar la simulación funcional y

unitaria del latch D síncrono. Los estímulos a aplicar a las señales C y D son las

mostradas en la Figura 4-17. Para ello deberás editar las fórmulas correspondientes.

Figura 4-17 Estímulos de prueba para el latch D síncrono.

El resultado de la simulación funcional es la Figura 4-18. En este caso puedes

comprobar que la herramienta de simulación no detecta ningún comportamiento

oscilatorio.


61

Figura 4-18 Resultado de la simulación del latch D síncrono.

Biestable D maestro esclavo

La parte práctica de este apartado consiste en capturar el esquema del biestable D

descrito en la Figura 4-5, y realizar la simulación con retardo unitario del mismo.

El latch D utilizado en el esquema viene ya implementado en la biblioteca para la

familia XC9500 con el nombre “LD”.

Las señales de entrada CLOCK y D para la simulación, así como el resultado de la

simulación, se muestra en la Figura 4-19.

Figura 4-19 Resultado de la simulación con retardo unitario del biestable D

maestro esclavo.

Nuevamente habrá que utilizar las entradas tipo “Fórmula” para luego asignarlas a

las señales de entrada CLOCK y D.

Biestable D disparado por flanco con entradas asíncronas de set y clear

La parte práctica en este apartado consiste en capturar el esquema de la Figura 4-6 y

realizar una simulación con retardo unitario del mismo.

Los valores para las señales de entrada y el resultado de la simulación aparecen en la

Figura 4-20. Observa que las señales de entrada PRS y CLR están puestas a 1.


62

Figura 4-20 Simulación con retardo unitario del biestable D disparado por

flanco.

En esta simulación las señales de entrada de PRS y CLR están fijas a valor alto.

Modifica estas señales asignándoles fórmulas, de manera que pueda observarse su

funcionalidad en el resultado de la simulación.


63


1. ¿Qué es una fórmula? ¿Cómo se edita su valor? ¿Cómo se asocia una fórmula

a una señal de entrada?

2. ¿Cómo se asigna un nombre a una conexión entre terminales?

3. ¿Cómo se detiene la simulación cuando la herramienta de simulación detecta

un comportamiento oscilatorio?

4. ¿Qué ventajas presenta la simulación funcional sobre la simulación con

retardo unitario?

5. ¿Cómo se fija el tiempo de simulación?

6. ¿Cómo se fija el retardo unitario de la simulación?

7. ¿Cómo se cambia entre simulación funcional y simulación con retardo

unitario?

8. ¿Para qué sirven las señales de PRS y CLR en el esquema de la Figura 4-6?


1. Explica el cronograma de la Figura 4-13.




5. Explica las similitudes y las diferencias entre la Figura 4-13 y la Figura 4-16.

65

Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control asociada

Índice

Introducción 65

Objetivos 65


Multiplicador binario 66

Diseño de la ruta de datos del multiplicador binario de 4 bits 66

Diseño de la unidad de control del multiplicador binario de 4 bits 69

Diseño del multiplicador binario de 4 bits 72


Implementación de la unidad de control 73

Implementación del camino de datos 74

Implementación del multiplicador de 4 bits 75

Anexo 76



Introducción

Los caminos datos se emplean en todas las implementaciones de procesadores

estándar y de ASIC (circuitos integrados de propósito específico) para realizar

cálculos numéricos complejos y manipular datos. Un camino de datos consta de

elementos de memoria temporal, además de unidades aritméticas, lógicas, y de

desplazamiento.

En estos caminos de datos tiene lugar la ejecución de algoritmos bajo la supervisión

de la unidad de control. Una unidad de control no es más que la implementación de

una máquina de estados finitos en la que, en cada estado, dependiendo de los valores

de las señales provenientes del camino de datos o externas, se produce la correcta

activación de las señales de control del camino de datos.

En esta práctica se diseñará una unidad de control para un camino de datos que

realizará la operación de multiplicación binaria.

Objetivos


1. Diseño, implementación y depuración de un circuito secuencial.

2. Aprendizaje de nuevas funcionalidades de la herramienta de simulación.

3. Utilización de las técnicas de modularización y jerarquización para el diseño

de sistemas complejos.


asociada

66


El desarrollo de esta práctica consta de dos pasos: en el primero, tras un trabajo

previo de diseño personal en papel, se implementa la unidad de control; en segundo

lugar, se captura el esquema del camino de datos propuesto en este guion y

posteriormente ambas partes se unen para construir el multiplicador.

Multiplicador binario

Resulta complejo realizar el diseño y posterior implementación de un circuito digital

que realice la operación de multiplicación binaria usando técnicas exclusivamente

combinacionales. En cambio, si se utilizan técnicas secuenciales el proceso se

simplifica bastante.

En general, aplicando técnicas de diseño de circuitos secuenciales es posible

trasladar, la mayoría de las veces, fácilmente una especificación algorítmica a un

circuito digital que la implemente.

La Figura 5-1 es un ejemplo de algoritmo de multiplicación mediante sumas

iterativas. Este algoritmo dista mucho de ser óptimo según criterios de coste y

velocidad, pero en cambio es muy sencillo de implementar en un circuito digital.

En primer lugar vamos a examinar el algoritmo para detectar qué componentes

estructurales harían falta para su implementación en un circuito digital. Este paso

recibe el nombre de diseño de la “ruta o camino de datos”.

En segundo lugar diseñaremos una “unidad de control” para esa ruta de datos. La

funcionalidad de la unidad de control es generar convenientemente las señales de

control para esa ruta de datos de manera que la multiplicación tenga lugar

correctamente. Esta unidad de control será en este caso simplemente una máquina de

estados finitos tipo Moore.

Diseño de la ruta de datos del multiplicador binario de 4 bits

Examinando el algoritmo de multiplicación binaria descrito en la Figura 5-1

detectamos que necesitamos tres “lugares” o registros de 4 bits para almacenar datos.

Un registro de 4 bit para la variable CX, otro para CY y uno más para P de 8 bits.


asociada

67

CX = X;

CY=Y;

P ='0';

¿CY='0'?

P = CX + P;

CY = CY -1;

Fin

Inicio

NO

SÍ

Un algoritmo de multiplicación: P = X x Y

Estado S0

Estado S1

Estado S2

Figura 5-1 Un algoritmo de multiplicación.

Las operaciones realizadas en el algoritmo de multiplicación son sumas y

decrementos. Debe ser posible realizar la suma entre el contenido del registro CX y

el contenido del registro P y guardar nuevamente el resultado en P. También debe ser

posible decrementar en una unidad el registro CY. Por tanto, necesitamos una ALU.

Esta ALU debe ser de 8 bits ya que en general el resultado de multiplicar dos

números binarios de tamaño N bits es un número binario de tamaño 2N bits.

Una posible ruta de datos implementada con componentes elementales de la

biblioteca de la herramienta de captura de esquemáticos con todas estas

funcionalidades puede verse en la Figura 5-2. Esta misma ruta de datos se muestra a

mayor escala en la Figura 5-13.

En esta figura podemos ver diversos elementos que pasamos a describir a

continuación. En primer lugar vemos que existen buses de entrada y salida, como son

X[3:0], Y[3:0] y P[7:0]. Un bus en una agrupación de señales con una función

común. En el caso de X[3:0] indica que es un bus de entrada de 4 bits. Las señales

que lo componen serán X3,X2,X1,X0. Lo mismo ocurre con Y[3:0]. Por otro lado

P[7:0] es un bus de salida de 8 bits. También existen buses intermedios, como

B[7:0], que no son ni entrada ni salida, si no que interconectan elementos dentro del

diseño.


asociada

68

Figura 5-2 Ruta de datos para la multiplicación binaria de números de 4 bits.

Ver la misma figura ampliada en la Figura 5-13.

El registro CX es el componente de la biblioteca “FD4RE”. Es un registro de 4 bits

integrado por un bloque con 4 biestables D disparados por flanco y con el terminal de

entrada síncrona R (reset) siempre inactivo.

El registro CY es el componente de la biblioteca “CB4X2”. Es un registro contador

de 4 bits bidireccional, es decir, puede contar de forma ascendente o descendente.

Posee funcionalidad para cargar el valor presente en las señales de entrada D[3:0] y

también tiene el terminal de entrada síncrono R (reset) siempre inactivo.

El registro P es el componente de la biblioteca “FD8RE”. Es exactamente igual que

el registro CX, pero con 8 bits. A diferencia del registro CX, el registro P no tiene la

señal de entrada síncrona R (reset) siempre inactiva, sino que en su lugar está

conectado el terminal de entrada RSP que controlará la puesta a cero de este registro.

Además, esta ruta de datos utiliza la ALU de 8 bits “ADD8” para calcular la suma de

los registros CX y P, almacenando el resultado en el registro P.

Nombre Tipo Funcionalidad

CLK Entrada Señal de reloj. En el flanco de subida de la señal CLK ocurren

los cambios en los registros.

LDX Entrada Carga el contenido del bus X en el registro CX.

LDY Entrada Carga el contenido del bus Y en el registro contador CY.

LDP Entrada Carga la salida de la ALU en el registro P.

RSP Entrada Pone a cero el registro P.

DCY Entrada Decrementa el registro contador CY.

CYZ Salida Indica cuando el registro contador CY es cero.

Tabla 5-1 Funcionalidad de las señales de control del camino de datos.

En la Tabla 5-1 está descrito el comportamiento de las señales de control del camino

de datos de la Figura 5-2.

Así por ejemplo, para realizar las operaciones dentro del bloque etiquetado como

estado S1 en el organigrama de la Figura 5-1 es suficiente con activar las señales


asociada

69

LDX, LDY y RSP. Para realizar las operaciones descritas en el bloque con nombre

estado S2 basta con activar las señales LDP y DCY.

El comportamiento de esta ruta de datos puede abstraerse en un bloque funcional

como el representado en la Figura 5-3. Este bloque funcional exporta únicamente los

valores de las entradas y las salidas de la ruta de datos correspondiente al

multiplicador binario de 4 bits.

Figura 5-3 Bloque funcional del camino de datos para el multiplicador binario

de 4 bits.

Para completar el diseño y que se realice la operación de multiplicación, es necesario

que las señales de entrada tomen los valores adecuados, en función de qué valores

vayan teniendo las señales de salida.

El componente encargado de activar y desactivar las señales de control es la unidad

de control y su comportamiento se especificará mediante un diagrama de estados.

Diseño de la unidad de control del multiplicador binario de 4 bits

La especificación del comportamiento de la unidad de control para el camino de

datos de la Figura 5-3 puede verse en la Figura 5-4.


asociada

70

Figura 5-4 Máquina de estados finitos para la especificación de la unidad de

control.

Consta de tres estados: S0, S1 y S2, y además de manejar las señales del camino de

datos tiene otras tres señales más: RST (reset), START y DONE.

La señal de entrada RST lleva a la máquina al estado inicial. En el instante de tiempo

cero el estado inicial es aleatorio, los estados de los biestables pueden ser

cualesquiera y es por ello que antes de comenzar a utilizar el circuito de

multiplicación es necesario un pulso en la señal de RST que lleve el circuito al

estado S0.

La señal de entrada START indica a la unidad de control que debe comenzar a

realizar una operación de multiplicación y que en el siguiente pulso de reloj los datos

a multiplicar X e Y van a estar disponibles en los buses de entrada del camino de

datos.

Finalmente, la señal DONE indica que la operación de multiplicación ha finalizado y

que el resultado está en el bus de salida P. Esta señal es necesaria porque el número

de ciclos que tarda en realizarse la operación de multiplicación no es constante,

depende de los operandos. En ausencia de esta señal debería esperarse siempre el

número máximo de ciclos.

Figura 5-5 Realización de una operación de multiplicación.

La Figura 5-5 muestra la secuencia de activación de las señales en la unidad de

control del circuito de multiplicación. En primer lugar, la activación de la señal de

RST, lleva a la unidad de control al estado S0. A continuación, la activación de la


asociada

71

señal de START indica que la operación de multiplicación tenga lugar. Tras varios

ciclos de reloj la unidad de control activa la señal de DONE para indicar que la

operación ha finalizado.

El diagrama de estados de la Figura 5-4 especifica todo el control necesario para la

operación de multiplicación.

En esta figura, las acciones están dibujadas dentro de un recuadro fuera de los

estados, a diferencia de los diagramas habituales, simplemente por razones de

espacio.

El diagrama está capturado con una herramienta que soporta el lenguaje de

descripción de hardware VHDL. En este lenguaje los operadores de asignación y de

igualdad son los símbolos “<=” y “=”, respectivamente, y de aquí su uso para

especificar las operaciones en el diagrama.

En el estado S0, que es el estado inicial o de partida de la máquina de estados finitos,

todas las líneas de control están inactivas a excepción de la señal de salida DONE

que indica que una operación ha terminado. La señal DONE está activa en el estado

S0 porque S0, además de ser el estado inicial, es también el estado final, y en el

estado final debe estar activa para indicar el fin de la operación de multiplicación.

Cuando la señal de entrada START es activada ocurre una transición al estado S1.

En este estado se activan las señales LDX, LDY y RSP que ocasionan la carga de los

registros CX, CY y la puesta a cero del registro P. Además DONE está inactiva.

Una vez en el estado S1, si el registro CY es cero la operación ha terminado, puesto

que esto quiere decir que estamos multiplicando por cero. Por el contrario, si el

registro CY no es cero ocurre una transición al estado S2.

En el estado S2 de manera iterativa se va acumulando en el registro P, el contenido

del registro CX, tantas veces como indica el contenido del registro CY. Esto se

realiza con la transición que nos hace ir una y otra vez a S2 siempre que CYZ sea

igual a cero.

Al final ocurrirá una transición al estado S0 cuando tras los decrementos oportunos

CY alcance el valor cero.

El símbolo indica la activación asíncrona de la señal de RST. Significa que, sin

depender de la señal de CLK, la máquina secuencial debe ir al estado S0. En la

implementación de la unidad de control se usarán las señales de PRESET y CLEAR

de los biestables para añadir este comportamiento.

El diagrama de bloques de la unidad de control se muestra en la Figura 5-6.


asociada

72

Diseño del multiplicador binario de 4 bits

Figura 5-6 Bloque funcional de la unidad de control del multiplicador binario

de 4 bits.

Una vez diseñados el camino de datos y la unidad de control, para finalizar el diseño

del multiplicador binario será únicamente necesario conectar los diagramas de

bloques de la Figura 5-3 y de la Figura 5-6, tal y como muestra la Figura 5-7.

Figura 5-7 Unidad de control y camino de datos del multiplicador binario de 4

bits.

En la Figura 5-7 el único detalle significativo es el hecho que las señales de reloj de

la unidad de control y del camino de datos están invertidas una respecto de la otra.

Esto es así ya que los cambios de estado ocurren en la transición positiva del reloj y

por tanto el funcionamiento del camino de datos debe producirse en las transiciones

negativas, lo cual es equivalente a invertir la señal de reloj conectada a la ruta de

datos.


La realización práctica consiste en la implementación de la unidad de control a partir

de un diseño propio del alumno, la captura del esquemático del camino de datos, la

simulación de ambos módulos de manera independiente y posteriormente la unión de

los módulos para realizar la operación de multiplicación.

Una característica del programa, que resulta muy útil para depurar la máquina de

estados, es la posibilidad de usar las letras del teclado como estímulos.


asociada

73

Para ello picamos es la señal en primer lugar para seleccionarla y posteriormente en

la letra que deseamos asociar a la señal. Por ejemplo para asociar la señal RST con la

letra r, basta con picar en la señal de RST en la ventana de simulación y luego picar

con el ratón en la letra r en la ventana de estímulos. La Figura 5-8 muestra las señales

RST y START asociados a las letras r y s. Para cambiar los valores de los estímulos

basta pulsar en el teclado las teclas “r” o “s”. Por cada pulsación la señal cambiará su

valor desde el nivel alto al nivel bajo o viceversa.

Figura 5-8 Ventana con estímulos asociados a teclas

Implementación de la unidad de control

Para la realización de este apartado es necesario que el alumno realice una propuesta

de diseño de unidad de control que implemente el control especificado en la Figura

5-4, y que la traiga en papel para la primera sesión de laboratorio de esta práctica. El

tipo de biestable y la codificación de estados serán a elección del alumno.

Figura 5-9 Ventana para la creación de símbolos

Realiza la simulación que consideres oportuna cara a verificar que el diseño

propuesto funciona correctamente. Una vez hecho esto, el esquema está preparado

para encapsularlo en un módulo funcional. Para crear el símbolo, seleccionamos

HierarchyCreate Macro Symbol from Current Sheet en el menú principal del

editor de esquemáticos. Aparece la ventana de creación de símbolos, Figura 5-9. A

diferencia de lo que aparece en la Figura 5-9, escribe como nombre del símbolo

“State Machine”, y en el campo comentario la frase “Máquina de estados del


asociada

74

multiplicador”, luego pica el botón de OK. La herramienta nos informará, mediante

un mensaje, de que el símbolo “State Machine” ha sido añadido a la biblioteca de

componentes y nos preguntará también si queremos editarlo. A esta pregunta

contestaremos picando el botón de No.

Implementación del camino de datos

Figura 5-10 Símbolo GND

Captura el camino de datos de la Figura 5-2. Para hacer esta captura debes tener en

cuenta varias consideraciones. En primer lugar, en este esquema el símbolo

etiquetado con “GND” corresponde al símbolo GND de la Figura 5-10.

Para dibujar los buses selecciona en el menú principal ModeDraw Buses. Por

ejemplo para dibujar el bus X, pica a la izquierda y traza el bus tal como está

dibujado en el esquema de la Figura 5-2. Para terminar el trazado del bus pica dos

veces. Entonces aparece la ventana de edición de bus, Figura 5-11. En el campo

“nombre” escribe X; en el campo “marca de terminación” selecciona INPUT y en el

campo “rango de líneas” introduce los valores 3 y 0, para indicar un total de 4 líneas.

Figura 5-11Ventana de edición de buses

Procede de la misma manera para dibujar el bus Y y el bus P, teniendo en cuenta que

P es de tipo OUTPUT y con un total de 8 líneas (de 7 a 0). Para los buses

intermedios, procede también de esta forma teniendo en cuenta que esos buses no

son de entrada ni de salida.


asociada

75

Una vez terminada la captura, realiza la simulación que consideres oportuna cara a

verificar que el diseño propuesto funciona correctamente y finalmente crea una

macro para este diseño, tal como hiciste en el apartado anterior para la unidad de

control, seleccionando HierarchyCreate Macro Symbol from Current Sheet en

el menú principal del editor de esquemáticos. Aparece la ventana de creación de

símbolos, Figura 5-9. A diferencia de lo que aparece en la Figura 5-9, escribe como

nombre del símbolo “Data path”, y en el campo comentario la frase “Camino de

datos del multiplicador”, luego pica el botón de OK. La herramienta nos informará,

mediante un mensaje, de que el símbolo “Data path” ha sido añadido a la biblioteca

de componentes y nos preguntará también si queremos editarlo. A esta pregunta

contestaremos picando el botón de No.

Implementación del multiplicador de 4 bits

En este apartado debes establecer las conexiones entre el camino de datos y la unidad

de control, tal y como indica la Figura 5-7.

Realiza la simulación que consideres oportuna cara a verificar que el diseño

propuesto funciona correctamente.

La Figura 5-12 muestra el resultado de la simulación para la multiplicación de los

números X=6 e Y=4 con el resultado de P=24. En esta simulación también se

muestra el secuenciamiento de las señales de control así como las señales de estado.

Figura 5-12 Resultado de la simulación de la multiplicación entre los números

X=6 e Y=4.

Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control asociada

76

Anexo

Figura 5-13 Ruta de datos para la multiplicación binaria de 4 bits.


asociada

77


1. Especifica la implementación de la unidad de control. Esta pregunta pretende

que, antes de comenzar la realización en laboratorio, especifiques en papel,

con todo detalle, el tipo de biestable que utilizarás, el circuito combinacional

para realizar la transición al estado siguiente, así como el circuito

combinacional que produce la salida.


1. ¿Cuántos ciclos de reloj tarda en realizarse una multiplicación?

2. ¿Qué mejoras podríamos introducir para que la multiplicación fuese más

rápida?

3. ¿Qué ocurre al activar la señal de reset a mitad de una multiplicación?

4. ¿Qué números tardan más en multiplicarse?

5. ¿Qué modificaciones son necesarias para multiplicar números en

complemento a dos?

6. ¿Por qué ha sido necesario utilizar un sumador de 8 bits si tanto X como Y

son operandos de 4 bits?

7. ¿Funciona el circuito en una simulación con retardo unitario de 1ns y periodo

de reloj de 10ns? ¿Por qué? ¿Qué debes modificar para que el circuito

funcione?

79

Práctica 6: Procesador multiciclo: Simulación y modificación del diseño del procesador para añadir nuevas instrucciones

Índice

Introducción 79

Objetivos 83

Realización práctica parte 1: Simulación del procesador multiciclo 84

Preparación del proyecto 84

Estudio del camino de datos 84


85

Estudio de la fase de iniciación del procesador 86

Estudio del secuenciamiento de las instrucciones 87

Realización práctica parte 2: Añadir nuevas instrucciones con números de ciclos

de ejecución fijos 89

Descripción de la instrucción jal 89

Añadir la instrucción jal 90

Descripción de la instrucción jr 92

Añadir la instrucción jr 92

Descripción de la instrucción addi 92

Añadir la instrucción addi 93

Preguntas frecuentes 93

Esquemas y diagramas 95

Introducción

Esta práctica trata sobre el estudio de una implementación reducida del repertorio de

instrucciones del procesador DLX. Para poder realizarla se requiere de un trabajo

previo consistente en el estudio de los contenidos referentes a este procesador. Es

preciso conocer el repertorio de instrucciones, así como los aspectos relacionados

con el ISA del procesador para poder entender la ruta de datos y el control del

mismo.

La práctica está dividida en dos partes. En la primera parte se realiza el estudio de

una implementación básica multiciclo del procesador. Es una aproximación inicial,

de cuyo aprovechamiento depende el posterior desarrollo de la segunda parte de la

práctica. Pretende que el alumno domine conceptos tales como ciclo de instrucción,

código de operación, modos de direccionamiento, etc... Todo este vocabulario debe

formar parte de los conocimientos del alumno antes de continuar con la segunda

parte de la práctica.

Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…

80

La segunda parte de la práctica es ya una tarea de diseño. Estudia el problema básico

de modificar el nivel ISA de un procesador para aumentar la funcionalidad del

mismo. El objetivo es modificar el camino de datos y la especificación de la unidad

de control.

La Figura 6-1 nos muestra los componentes estructurales a nivel de registros del

procesador que vamos a estudiar (en lo sucesivo lo llamaremos DLX) y las

interconexiones entre los mismos. En esta figura los componentes estructurales son

la unidad aritmético-lógica, los registros, el banco de registros, los multiplexores,

etc...

Figura 6-1 Estructura del procesador DLX. Ver también Figura 6-10 en el anexo.

La Figura 6-2 especifica el funcionamiento del bloque que representa la unidad de

control.


81

Figura 6-2 Especificación del control del procesador mediante un diagrama de estados.

Ver también Figura 6-11 en el anexo.

¿Cuál es la implementación de cada componente del camino de datos? ¿Qué función

realiza cada componente estructural del camino de datos? ¿Cuál es la justificación de

las interconexiones entre los componentes? ¿Qué representa el diagrama de estados

finitos?... Todas estas cuestiones debemos saber contestarlas como prerrequisito

antes de comenzar la realización práctica. Para cualquier duda que podamos tener

sobre estas cuestiones previas podemos consultar la bibliografía relacionada que

aparece en el proyecto docente de la asignatura, así como las transparencias

utilizadas en las clases de teoría.

Aunque las descripciones proporcionadas por la Figura 6-1 y la Figura 6-2 pueden

parecer exhaustivas, no son suficientes para abordar la implementación del

procesador. Para simular el procesador DLX tenemos que especificar todavía más,

tanto el camino de datos como la unidad de control.

Por una parte la Figura 6-3 es equivalente a la parte del camino de datos de la Figura

6-1 con todos los detalles necesarios para poder realizar una simulación en la

herramienta de Xilinx. La Figura 6-4 es la misma que la Figura 6-2, pero a mayor

escala. Vemos las siguientes diferencias:

1. Los buses y cables están completamente especificados en el esquema

capturado para Xilinx, esto es, todas las interconexiones están nominadas.

2. Algunas conexiones las hemos realizado sin necesidad de extender el bus

o el cable hasta la señal origen, únicamente nominamos el extremo del

bus o cable con el mismo nombre que la señal a la que lo queremos

conectar.


82

3. El bloque de la unidad de control no aparece. En su lugar, hemos dejado

todas las señales que partían de este bloque como entradas con nombre a

los correspondientes componentes estructurales del camino de datos que

manejaban.

4. Aparece la imprescindible y siempre presupuesta, pero casi nunca visible,

señal de reloj.

Figura 6-3 Camino de datos del procesador DLX capturado con la herramienta

Xilinx. Ver también Figura 6-13 en el anexo.

Y por otra parte la Figura 6-4 es una indicación parcial de cómo especificamos el

control del procesador DLX utilizando un diagrama de estados finitos. También es

fácil ver diferencias entre esta figura y la Figura 6-2:

1. La sintaxis es diferente para especificar los valores de las señales. Uso de

comillas, punto y comas, constantes de indeterminación, etc…

2. En cada estado del diagrama especificado en Xilinx indicamos los valores

que toman todas y cada una de las señales de control. No hay manera de

especificar el valor por defecto de una línea.

3. No es posible usar constantes simbólicas. Hay que sustituir los códigos

simbólicos por los equivalentes numéricos.

4. Aunque la figura no lo muestra, el diagrama de estados finitos necesita de

una lógica de inicialización.


83

Figura 6-4 Parte del diagrama de estados finitos del procesador DLX especificado

mediante la herramienta de Xilinx. Ver también Figura 6-12 en el anexo.

Tras todo lo expuesto hasta ahora, está claro que existen muchas diferencias entre la

especificación "conceptual" de un procesador y la especificación necesaria para

realizar una simulación del mismo en una herramienta. Estas diferencias están

motivadas por el mayor nivel de detalle necesario en este último caso y la propia

adaptación del diseño a la herramienta.

En esta práctica proponemos y estudiamos un diseño, especificado con el suficiente

detalle, para poder realizar una simulación con la herramienta Xilinx. Este diseño es

la base para realizar nuestras propias modificaciones.

Objetivos

1. Estudiar todos los detalles de la implementación propuesta del procesador

DLX para la simulación del mismo con la herramienta de Xilinx.

2. Conocer la librería de componentes desarrollados con los cuales está

implementado el camino de datos del procesador a nivel de registros.

3. Entender por qué es necesario un ciclo de iniciación antes de la ejecución

de la primera instrucción.

4. Realizar simulaciones de las instrucciones precargadas en la memoria

principal.

5. Identificar todos y cada uno de los ciclos de instrucción.

6. Aprender a modificar el camino de datos y la especificación del control

de un procesador para ampliar el repertorio de instrucciones del mismo.

7. Valorar el impacto de la inclusión de una nueva instrucción sobre el

diseño.


84

8. Aprender a utilizar la herramienta de Xilinx para captura de máquinas de

estados finitos.

Realización práctica parte 1: Simulación del procesador multiciclo

Preparación del proyecto

1. Copiamos desde la página de la asignatura en la dirección

"http://serdis.dis.ulpgc.es/~gii-fc/" el fichero comprimido "deluxe.zip" a un

directorio temporal.

2. Ejecutamos Xilinx y utilizamos FileRestore Project... para descomprimir el

fichero.

3. Abrimos el proyecto "deluxe.pdf".

4. Una vez abierto el proyecto, abrimos el esquemático correspondiente a la

hoja "dlxst.sch".

Si los pasos anteriores los hemos realizado correctamente, el editor de esquemáticos

nos presenta el esquema de la Figura 6-5. Este esquema es una primera vista de un

diseño jerárquico del procesador, mostrando los bloques del camino de datos y la

unidad de control y las interconexiones entre los mismos. Cada bloque encapsula la

complejidad inherente al diseño de las partes.

Figura 6-5 Diagrama de alto nivel de la implementación propuesta para la

simulación en Xilinx del procesador DLX.

Estudio del camino de datos

A continuación navegamos al interior del símbolo correspondiente al camino de

datos. En el esquema tiene el nombre "DLXDP" que corresponde a un acrónimo de

http://serdis.dis.ulpgc.es/~gii-fc/


85

"Deluxe Data Path". Para ello picamos con el ratón en el símbolo DLXDP y luego

seleccionamos HierarchyHierarchy Push para navegar al interior del mismo. El

esquema que aparece es el que ya vimos en la Figura 6-3.

1. Localiza los registros PC, IR, MDR, TEMPA, TEMPB y ALUOutput en el

esquema del camino de datos. Utiliza la opción Mode->Graphics para

añadir un texto identificativo cercano a cada registro

2. Estudia la implementación de los diferentes tipos de registros.

3. Explica cual es la diferencia entre la implementación de los registros PC e

IR y la implementación de los registros MDR, TEMPA, TEMPB y

ALUOutput.

4. Realiza una tabla con los diferentes multiplexores que usamos en el

esquema del camino de datos explicando el funcionamiento de cada uno

de ellos.

5. Añade a la tabla del apartado anterior una explicación del diseño de los

multiplexores.

6. Ofrece otra alternativa de diseño diferente a la propuesta para el banco de

registros. Explica ventajas e inconvenientes de la nueva propuesta en

relación con la original.

7. Explica cómo están realizadas las conexiones desde el registro IR hasta

los diferentes puntos donde deben llegar los campos de la instrucción.

8. Identifica qué componentes del camino de datos tienen entrada de reloj y

cuáles no y explica por qué es así.


Desde el esquema correspondiente al nivel superior, Figura 6-5, navegamos al

interior del símbolo "DLXSTUC" que corresponde a la especificación del

comportamiento de la unidad de control mediante un diagrama de estados finitos.

Una vista preliminar de este diagrama es la Figura 6-6.

1. Asocia cada uno de los estados de la Figura 6-6 con el estado

correspondiente de la Figura 6-2.

2. Los estados en el diagrama de estados finitos de la Figura 6-6 y de la

Figura 6-2 difieren en la especificación de las señales. Explica estas

diferencias.

3. Identifica la secuencia de estados correspondientes a la ejecución de las

instrucciones lw, sw, add, sub, or, and, beq y j en la Figura 6-6.

4. Explica por qué añadimos una señal de iniciación síncrona (reset) al

diagrama de estados.


86

Figura 6-6 Diagrama de estados finitos que especifica la unidad de control del

procesador. Ver también Figura 6-14 en el anexo.

Estudio de la fase de iniciación del procesador

Antes de iniciar este apartado cerramos todos los esquemas que pudiéramos tener

abiertos a excepción del esquema principal correspondiente a la hoja "deluxe.sch".

Debemos tener un único esquema abierto como el de la Figura 6-5.

El objetivo del ciclo de iniciación es garantizar que la máquina de estados finitos está

en el estado cero antes de comenzar a ejecutar la primera instrucción. De no realizar

un ciclo de iniciación, la máquina de estados finitos podría estar en cualquier otro

estado y el secuenciamiento de las instrucciones seguro que sería incorrecto.

1. Ejecutamos el simulador.

2. Añadimos las entradas de RST y CLK al simulador.

3. Asociamos el estímulo correspondiente a la tecla "r" a la señal RST y

"Bc0" a CLK.

4. Elegimos convenientemente el valor de la señal RST y el intervalo de

simulación para obtener el resultado de la Figura 6-7.


87

Figura 6-7 Ciclo de iniciación del procesador.

Tal y como nos muestra la Figura 6-7, la señal de reloj para la unidad de control es la

señal invertida del reloj para el camino de datos. Esto implica que los estados

comenzarán en los flancos de bajada de la señal CLK y que los componentes

secuenciales del camino de datos con entrada de reloj actualizarán los valores en los

flancos de subida dentro del estado.

Estudio del secuenciamiento de las instrucciones

Para realizar el estudio del secuenciamiento de las instrucciones sigue los siguientes

pasos:

1. Inicia nuevamente el simulador.

2. Añade las señales RST y CLK.

3. Añade la salida del registro contador de programa, la señal de control para

lectura de memoria, la entrada de direcciones del módulo de memoria, la

salida del registro de instrucción, las señales correspondientes al código

de operación de la instrucción en curso, la salida del registro de datos de

memoria, las señales de dirección del primer registro para lectura del

banco de registros, la salida del registro temporal A, las señales de

dirección del segundo registro para lectura del banco de registros, la

salida del registro temporal B, la señal de control para escritura en el

banco de registro, las señales de dirección del registro de escritura para el

banco de registros, las señales de datos de entrada en el banco de registros

y la salida del registro buffer de la unidad aritmético-lógica.

4. Cambia el nombre de los buses a otros más mnemónicos, para ello

selecciona un bus y utiliza la opción SignalBusBus Name...

5. Simula el tiempo suficiente para la ejecución de una instrucción. Este

tiempo es 60ns, con un periodo de reloj de 10ns.

El resultado de esta simulación aparece en la Figura 6-8. Los comentarios que

aparecen debajo de las señales los hemos insertado seleccionando en primer lugar la

señal (el comentario aparece en el lugar donde hemos picado con el ratón) y a

continuación la opción WaveformComment->Add...


88

Figura 6-8 Simulación de la primera instrucción.

La explicación de este cronograma es sencilla:

[00, 10) Se inicializa la unidad de control.

[10, 20) Etapa IF: Se carga una instrucción de la memoria de instrucciones y se

incrementa el PC. (PCPC+4; IRM[PC])

[20, 30) Etapa ID: Decodificación de la instrucción y acceso al banco de registros.

El valor del registro cero es guardado en el registro TEMPA.$0

[30, 40) Etapa EX. La ALU calcula la suma del valor leído del banco de registros y

los 16 bits de menor peso de la instrucción el signo extendido

(ALUOutput$0+IR[15:0]).

[40, 50) Etapa MEM: Dicha suma se utiliza para acceder a la memoria de datos. El

dato procedente de la memoria se escribe en el registro de datos de memoria.

(MDR<-M[ALUOutput])

[50, 60) Etapa WB: El contenido del registro de datos de memoria se escribe en el

registro destino del banco de registros. ($8MDR)

Al analizar la Figura 6-8 vemos que la instrucción traída de memoria es lw $8, 40($0)

y el resultado de la ejecución es almacenar el valor 1 en el registro $8.

Para finalizar esta sección realiza las siguientes actividades:

1. Continúa simulando en intervalos de periodos de reloj, añadiendo a la

simulación los comentarios aclarativos que consideres oportunos. Guarda

el resultado de la simulación con la opción FileSave Simulation State...

para un posterior análisis.

2. ¿Cuál es la traza del programa almacenado en memoria?

3. ¿Qué ha hecho el programa?


89

Realización práctica parte 2: Añadir nuevas instrucciones con números de ciclos de ejecución fijos

En esta segunda parte estudiamos el impacto sobre el camino de datos y la unidad de

control de añadir nuevas instrucciones con número de ciclos de ejecución constantes

al nivel ISA del procesador. El nivel ISA del procesador DLX, con el cual

trabajamos, es bastante limitado. Tiene instrucciones básicas de carga y

almacenamiento, aritmético-lógicas, saltos y bifurcaciones. Con este repertorio de

instrucciones tan limitado resulta bastante engorroso escribir programas en lenguaje

ensamblador que correspondan a trozos de programas reales.

Una limitación clara que tiene el actual nivel ISA del procesador DLX es la

imposibilidad de operar con constantes incluidas en la propia instrucción. Dicho de

otra manera, ausencia del modo de direccionamiento inmediato. Tampoco

proporciona ninguna instrucción para el manejo de procedimientos.

En esta sección añadiremos las instrucciones jal (jump and link) y jr (jump register)

para dar soporte al manejo de procedimientos y addi (add immediate) para

proporcionar algún soporte de datos inmediatos. Para ello modificaremos

apropiadamente el camino de datos y la unidad de control del procesador.

La realización práctica consiste en añadir las instrucciones jal, jr y addi al

procesador DLX. Todos los apartados comienzan con una especificación de la

instrucción: formato, tipo, sintaxis, operación y descripción de la misma.

Únicamente para la instrucción jal indicamos qué modificaciones tenemos que

realizar en el camino de datos y en la unidad de control, para jr y addi determinar las

modificaciones a realizar es trabajo personal.

Descripción de la instrucción jal

Formato:

3 nombre

6 26

Tipo: J

Sintaxis:

JAL nombre

donde -225

nombre < 225

Operación:

R3132[(PC)+4]

PC32{(PC+4)[31-28]||[nombre<<2]}

Descripción:

Los 26-bits del campo nombre son desplazados dos posiciones a la izquierda y

concatenados con los 4 bits superiores del registro contador de programa (PC) + 4

para formar una dirección destino de 32 bits. Esta dirección destino es

incondicionalmente situada en el registro contador de programa. La dirección de la

instrucción siguiente a jal es situada en el registro de propósito general R31.


90

Añadir la instrucción jal

Podemos cambiar el PC de acuerdo con la operación de la instrucción simplemente

usando el camino de datos para la instrucción de bifurcación. Sin embargo, no

tenemos ninguna manera de cargar el PC+4 en el registro R31, y esto nos obliga a

modificar el camino de datos.

Una solución posible es cambiar el multiplexor de dos entradas controlado por la

señal REGDST por un multiplexor con más entradas para que incluya la constante 31

como una nueva entrada. También tenemos que cambiar el multiplexor de dos

entradas controlado por la señal MEMAREG para que tenga el PC+4 como una

entrada más. Los pasos de ejecución serían entonces:

IF: Búsqueda de instrucción (no cambia).

ID: Decodificación de instrucción y lecturas de registros (no cambia).

EX:

R3132(PC)

PC32{PC[31-28]||[nombre<<2]}

Estamos escribiendo el PC después de que este haya sido incrementado en 4 (en la

etapa de búsqueda de instrucción) en el R31.

Además tenemos que modificar el diagrama de estados para que recoja los nuevos

valores de las señales REGDST y MEMAREG (ahora cada una de ellas controla más de

dos entradas) y añadir un nuevo estado que realice la etapa EX de la instrucción jal

(y luego retorne al estado cero) con ESCRPC=1, FUENTEPC[1:0]=10, ESCREG=1 y

los valores apropiados de REGDST y MEMAREG.

Hasta aquí hemos descrito "en papel" las modificaciones para incorporar la

instrucción jal al procesador DLX.

El siguiente paso es incorporar las modificaciones del camino de datos al esquema.

La biblioteca de componentes desarrollada tiene ya multiplexores de 4 entradas de 32

bits. Para trabajar cómodamente con el esquema es útil utilizar la opción de ampliar

una parte del esquema con el botón

A continuación añadimos las modificaciones a la especificación del control del

procesador DLX (incorporación del nuevo estado, cambios en las condiciones de

transición, modificación de los tipos de señales, actualización de los valores en las

señales, etc.) Una vez hecho, tenemos que actualizar la macro con la opción

SynthesysSynthetize. En caso de aparecer algún error, éste probablemente será

debido a un error de sintaxis al escribir los valores de las señales.

Para simular y depurar el diseño necesitamos que el programa que vamos a ejecutar

utilice la instrucción jal. Para incorporar esta instrucción navegamos al interior del

bloque nominado por "Sistema de memoria" en el camino de datos. A continuación

seleccionamos el módulo nominado "RAM", picamos sobre el módulo con el botón

derecho y sin soltar seleccionamos en el menú desplegable Edit LogiBLOCK Symbol.

Aparece la ventana de la Figura 6-9. Seleccionamos el botón Edit para cambiar el

contenido de la memoria RAM.


91

Figura 6-9 Ventana para la edición de los contenidos de la memoria.

Aparece un editor de texto con el fichero a editar que es el contenido de la memoria

RAM. Debemos cambiar únicamente los datos que aparecen después de la palabra

clave DATA (el módulo RAM no funcionará correctamente al modificar cualquier

otro campo). El formato del fichero para escribir los contenidos de los datos en

memoria es simplemente especificar la dirección del dato, a continuación el literal ':'

y luego el dato. Por ejemplo:

DATA

00:8c080040; lw $8, 0x40($0)

04:8c090044; lw $9, 0x44($0)

08:8c0d0048; lw $13, 0x48($0)

0C:00005020; add $10, $0, $0

10:016b5822; sub $11, $11, $11

14:00007022; sub $14, $0, $0

18:8dcc0050; bucle:lw $12, 80($14)

1C:016c5820; add $11, $11, $12

20:01485020; add $10, $10, $8

24:01cd7020; add $14, $14, $13

28:11490001; beq $10, $9, fin

2C:08000006; j bucle

30:ac0b004c; fin: sw $11, 0x4C($0)

40:00000001; constante 1

44:00000002; variable N, numero de elementos del vector

48:00000004; constante 4

4C:ffffffff; variable suma de las componentes del vector

50:00000007; primer componente del vector

54:00000005; segundo componente del vector

Es el programa que usamos como ejemplo en la práctica anterior.

Sustituimos el contenido de la memoria RAM por un programa que utilice la

instrucción jal, salimos del editor guardando los cambios del fichero de texto y

seleccionamos el botón OK en la ventana de la Figura 6-9. Contestamos Sí a la

pregunta para escribir sobre el módulo ram128x32 y nuevamente contestamos Sí a la

pregunta para escribir sobre el módulo ram128x32lb. Volvemos al nivel superior del

diseño y contestamos afirmativamente a todas las preguntas referentes a

actualizaciones de macros.


92

Ahora simulamos y depuraremos el diseño. Esto es, obtenemos una simulación del

procesador DLX incluyendo la ejecución de la instrucción jal y con comentarios que

nos indiquen las modificaciones de la ejecución.

Descripción de la instrucción jr

Formato:

0 rs rt=31 no usado no usado 8

6 5 5 5 5 6

Tipo: R

Sintaxis:

JR rs

Operación:

PC32(rs)

Descripción:

El contenido del registro de propósito general rs es la dirección destino del salto, y es

situado incondicionalmente en el registro contador de programa.

Añadir la instrucción jr

1. Redacta un documento con las modificaciones del camino de datos y de la

especificación de la unidad de control.

2. Incorpora las modificaciones del camino de datos al esquema.

3. Incorpora las modificaciones del diagrama de estados finitos.

4. Simula y depura el diseño.

Descripción de la instrucción addi

Formato:

8 rs rt inmediato

6 5 5 16

Tipo: I

Sintaxis:

ADDI rt, rs, inmediato

Operación:

rt32(rs)+[(inmediato15)16

||inmediato]

Descripción:

Los 16-bits del campo inmediato son extendido en signo y sumados al contenido del

registro de propósito general rs para formar un resultado de 32 bits en complemento

a dos, el cual es situado en el registro de propósito general rt.


93

Añadir la instrucción addi






Descripción de la instrucción jm

Formato:

6 rs rt=0 desplazamiento

6 5 5 16

Tipo: I

Sintaxis:

JM desplazamiento(rs)

Operación:

PC32(MEM[32(rs)+[(desplazamiento15)16

||desplazamiento]])

Descripción:

Los 16-bits del campo desplazamiento son extendidos en signo y sumados al

contenido del registro de propósito general rs para formar una dirección de 32 bits.

Con esta dirección se accede a memoria y se lee una palabra de 32 bits, que es la

dirección que se guarda en el registro PC (contador de programa).

Añadir la instrucción jm






Preguntas frecuentes

En esta sección se relacionan las preguntas frecuentes que se suelen realizar durante

el desarrollo de esta práctica:

1. Una vez realizadas las modificaciones para añadir las nuevas instrucciones,

¿cómo pruebo si funciona lo que he hecho?

Para eso es necesario cambiar el programa que se ejecuta en nuestro procesador

deluxe para probar si la instrucción añadida se ejecuta correctamente. Para ello hay

que seguir los siguientes pasos:


94

a. En el editor de esquemas, pica en el botón H de la barra vertical de la

izquierda y a continuación pica en el símbolo “Sistema de memoria”.

b. Botón derecho sobre el símbolo RAM->Edit Logiblock symbol

c. Para editar el contenido, primero hay que poner el path correcto (actualizado)

a nuestra máquina virtual. Ponemos C:\Xilinx\active\projects\deluxe\ram y le

picamos en el botón Edit.

d. Nos aparece una ventana de edición con las instrucciones del programa. Lo

modificamos para que incluya el tipo de instrucción que queremos probar.

Las instrucciones hay que añadirlas en lenguaje máquina.

e. Guardamos y ya tenemos el programa modificado y podemos hacer la

simulación de comprobación.

2. ¿Cómo añado una nueva constante con un valor determinado en el diseño

que ya existe?

Fíjate en el multiplexor de la segunda entrada de la ALU que tiene una constante 4

como entrada. Debes hacerla igual. Entra en el símbolo 4 y verás dentro que tienes

un símbolo tipo constant, que es un LogiBlock.

Abre un nuevo sheet, y ve a Tools->LogiBlock Module Generator. En el tipo, elige

constants, y el ancho del número de bits que necesites. El valor de inicialización

tiene que ser el que tu quieras que tenga tu constante. Le das un nombre, lo creas y

luego haces como en el 4, le pones un bus de salida.

A partir de ese esquema creas un símbolo (Hierarchy->Create Symbol from Current

Sheet) y lo pones en el esquema, en la entrada que te interesa del multiplexor. Y ya

tienes tu constante!

3. ¿Cuántos estados son necesarios para la operacion jal? En el libro de

prácticas pone que solo hace falta un estado para realizar las dos operaciones

de EX (R31<-32[(PC)+4] & PC<-32{(PC+4)[31-28]||[nombre<<2]}). pero, al

ejecutar las dos a la vez, ¿no se metería la dirección de destino en el registro

31? es decir, al sacar PC+4 del contador mientras se le introduce la nueva

dirección, ¿no se almacenaría esta nueva dirección en el registro 31? Por eso

pienso que en vez de un estado es mejor dos.

Si se investiga un poco en cómo está hecho el banco de registros, se observa que lo

que se escribe en R31 es el dato que está en la entrada del banco justo antes del

flanco de subida del reloj, y ese dato es el PC+4. Una vez escrito ese dato (en el

flanco de subida) el dato nuevo del PC será el PC<-32{(PC+4)[31-

28]||[nombre<<2]}. Este último dato no se escribe en R31 puesto que aparece

después de haber pasado el flanco de subida.

4. Necesito añadir una nueva condición a la máquina de estados, pero que

dependa del campo función de las instrucciones de tipo R en vez del campo

de código de operación como hemos hecho hasta ahora. ¿Cómo puedo crear

esa nueva condición? Y al crearla, ¿cómo puedo evitar que se llame igual que

la otra condición (la del código de operación) si vienen del mismo bus?


95

Si necesitas el campo función en la MEF, se lo pasamos como hicimos con el código

de operación. Definimos una salida en la RD que sean los 6 bits menos significativos

de la instrucción. Nos apararece un nuevo pin en la RD.

En la MEF definimos una nueva entrada de 6 bits así que al sintetizar nos aparece un

nuevo pin en la UC, y en el esquema global conectamos esos nuevos pines entre sí.

5. Cuando modifico el autómata de la MEF y hago la síntesis (<Synthetize>) me

aparece un error en el estado "S1", en la señal EscrPC<='0', y el caso es que

no he tocado el valor de esa señal.

Como las señales RegDest y MemaReg pasan a ser de 2 bits, hay que especificarlo

en la parte superior de la hoja de la MEF donde están definidas con unos símbolos en

azul. Pinchamos en el símbolo, Boton derecho, Properties, Range -> 1:0

Además dentro de los estados los valores que le damos a las señales hay que

especificarlos de la siguiente manera:

Señales de 1 bit: el valor entre comillas simples pej: IorD<='1'

Señales de más de 1 bit: el valor entre comillas dobles pej: FuentePC<="00"

De todas formas esto se ve si ampliamos lo suficiente el zoom en la MEF, pero lo

comentamos por si no lo han visto.

Esquemas y diagramas

Este apéndice incluye algunos de los esquemas y diagramas que han aparecido

durante el texto a una mayor escala.


96

Figura 6-10 Estructura del procesador DLX.


97

Figura 6-11 Especificación del control del procesador mediante un diagrama de estados.


98

Figura 6-12 Parte del diagrama de estados finitos del procesador DLX especificado mediante la herramienta Xilinx.


99

Figura 6-13 Camino de datos del procesador DLX capturado con la herramienta Xilinx.


100

Figura 6-14 Diagrama de estados finitos que especifica la unidad de control del procesador.

Errores más frecuentes

101


Índice

Errores generales 101

Errores en el editor esquemático 101

Errores en el simulador 102

En este capítulo están descritos los errores más frecuentes, así como algunas guías para

evitarlos.

Los errores están clasificados en tres categorías: Errores generales, Errores en el editor

esquemático y Errores en el simulador. En la categoría Errores generales están los

errores que tienen que ver con el uso del gestor de proyectos. En la categoría Errores en

el editor esquemático están los errores más frecuentes cuando usamos la herramienta

para la captura de esquemas y en la categoría Errores en el simulador, los errores más

habituales cuando utilizamos la herramienta de simulación. Las situaciones descritas en

las dos últimas categorías están muchas veces interrelacionadas y deberían aparecer en

algunos casos en ambas categorías, ya que muchos errores en la simulación son

consecuencia directa de un mal uso de la herramienta de captura de esquemas, aún así

aparecen en una sola de ellas simplemente por mayor facilidad de búsqueda.

Errores generales

1. Para nombrar proyectos, macros, o subdirectorios no deben utilizarse

identificadores con más de 8 caracteres. Esto es aplicable a todos los nombres en

el camino completo, así por ejemplo, en c:\<directorio>\<nombre de proyecto>

el campo <directorio> y el campo <nombre de proyecto> tienen que tener como

máximo 8 caracteres de longitud.

2. Al copiar un proyecto a otro directorio no debe olvidarse copiar el fichero con

extensión .pdf. Es imprescindible copiar el directorio del proyecto así como el

fichero .pdf a la nueva localización. Para copiar un proyecto es preferible usar la

opción FILE->COPY PROJECT en el menú principal en la ventana del gestor

de proyectos a usar las herramientas del sistema operativo para copiar ficheros.

Otra posibilidad también válida es usar la característica ARCHIVE, esto pondrá

toda la información del proyecto en un fichero comprimido formato zip.

3. Al copiar un proyecto a un disquete utilizando la opción FILE->COPY

PROJECT la herramienta avisa que el disquete no tiene espacio suficiente para

guardar el proyecto. Esta situación suele ocurrir cuando intentamos guardar en

un disquete proyectos en los cuales hay simulaciones con tiempos de simulación

grandes. Es este caso puedes utilizar la característica ARCHIVE para guardar el

proyecto de manera comprimida o bien eliminar del proyecto los ficheros de

simulación que genera automáticamente el simulador (fichero con extensión

.tve). En el caso de persistir el error prueba a utilizar un disquete vacío.

Errores en el editor esquemático

1. El editor de esquemáticos muestra una hoja de diseño vacía en lugar del diseño

capturado. Una forma de encontrar el diseño es picar en el botón de zoom de

área completa en la barra de herramientas principal, de esta manera toda la

hoja de diseño aparece en la ventana del esquemático. Es posible hacer zoom de


102

un área particular picando en primer lugar en el botón , luego pica con el

ratón en el vértice superior izquierdo de un recuadro imaginario conteniendo la

parte del esquemático que se quiere ampliar y posteriormente en la esquina

inferior izquierda de ese recuadro. El recuadro marcado ocupará ahora toda la

hoja del esquemático.

2. Cuando un símbolo está situado cerca de otro, ambos parecen estar

interconectados, pero no es así. Los símbolos deben conectarse siempre con

cables. Lo mejor para no cometer errores es no situar un símbolo cerca de otro.

El paso “Integrity Test”, al generar la netlist avisa de esta situación. Los

mensajes de este paso aparecen en la subventana de mensajes dentro de la

ventana principal del gestor de proyectos. En el paso de simulación

probablemente debido a estas conexiones no realizadas aparecerán salidas con

valor X (desconocido) o Z (alta impedancia).

3. Nombrar diferentes nodos con el mismo identificador ocasiona que estos sean

todos el mismo punto eléctrico. Cada nodo tiene que tener un nombre propio

único, a menos que el diseñador lo que realmente quiera sea que dos nodos en

diferente lugar del esquema sean el mismo punto eléctrico. En el paso de

simulación, probablemente debido a estos cortocircuitos, aparecerán salidas con

valor X (desconocido) o Z (alta impedancia).

4. Al actualizar el diseño de una macro deben actualizarse también los datos del

simulador. Esto puede realizarse en dos pasos: en el primero hay que utilizar la

opción de UPDATE SIMULATOR en el editor de esquemáticos y en el segundo

exportar la netlist.

5. Al usar una tierra (GND) o alimentación (Vcc) deben utilizarse los símbolos de

la SC Symbol Libray y no el símbolo GND en la barra de herramienta de la

izquierda, en la ventana del editor de esquemáticos.

6. El editor de esquemáticos muestra los símbolos en color gris. Este error puede

ocurrir al añadir un esquema ya existente a un proyecto nuevo. Para evitar esta

situación, deben incorporarse al proyecto las librerías correspondientes del

esquema a añadir. Por ejemplo, si el fichero con el esquemático tiene de nombre

“ALU4.SCH” debe añadirse la librería “ALU4”, para ello selecciona FILE-

>PROJECT LIBRARIES..., pica en la librería ALU4 y luego pica en el botón

ADD>>. La librería “ALU4” aparecerá ahora como una librería del proyecto.

Para actualizar el esquema cierra y vuelve abrir el editor de esquemas.

Errores en el simulador

1. El simulador no muestra las señales. Cuando la escala de visualización es muy

pequeña las señales tienen que dibujarse en muy pocos pixeles, la solución para

evitar esta situación es aumentar la escala de visualización picando en el botón

.

2. Los valores visualizados de señales agrupadas en un bus son incorrectos. Esto

puede ocurrir si el bit más significativo es el menos significativo y viceversa.

Para corregir esta situación usa la opción SIGNAL->BUS->Change Direction.

3. Las señales del esquema no aparecen en el simulador. Esto puede ocurrir cuando

el esquema está abierto, pero no pertenece al proyecto. Basta usar la opción

Document->Add en la ventana principal del gestor del proyecto para incorporar

el fichero conteniendo el esquema al proyecto y reiniciar la herramienta de

simulación.


103

4. Aparece una señal con el valor X (desconocido) o Z (alta impedancia). Las

causas pueden ser las descritas en Errores en el editor esquemático. Otra posible

causa más es haber conectado un estímulo a una señal de salida.

Prácticas de Fundamentos de los...

Documents

Transcript of Prácticas de Fundamentos de los...