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
Autocuestionario (a rellenar ANTES de la sesión de laboratorio) ........................ 31
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) .......... 31
Práctica 3: Retardo de puertas ............................................................................... 33
Introducción ........................................................................................................... 33
Objetivos ................................................................................................................ 36
Desarrollo de la práctica ....................................................................................... 36
Ampliador aritmético ......................................................................................... 36
Realización práctica ........................................................................................... 37
Autocuestionario (a rellenar ANTES de la sesión de laboratorio) ........................ 47
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) .......... 47
Práctica 4: Captura y simulación de elementos biestables ................................... 49
Introducción ........................................................................................................... 49
Objetivos ................................................................................................................ 54
Desarrollo de la práctica ....................................................................................... 55
Realización práctica ........................................................................................... 55
Autocuestionario (a rellenar ANTES de la sesión de laboratorio) ........................ 63
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) .......... 63
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
Desarrollo de la práctica ....................................................................................... 66
Multiplicador binario ......................................................................................... 66
Realización práctica ........................................................................................... 72
Anexo ...................................................................................................................... 76
Autocuestionario (a rellenar ANTES de la sesión de laboratorio) ........................ 77
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) .......... 77
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.
Práctica 1: Introducción a las herramientas 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”)
Práctica 1: Introducción a las herramientas de diseño
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.
Práctica 1: Introducción a las herramientas de diseño
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.
Práctica 1: Introducción a las herramientas de diseño
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.
Práctica 1: Introducción a las herramientas de diseño
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.
Práctica 1: Introducción a las herramientas de diseño
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”.
Práctica 1: Introducción a las herramientas de diseño
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.
Práctica 1: Introducción a las herramientas de diseño
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.
Práctica 1: Introducción a las herramientas de diseño
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.
Práctica 1: Introducción a las herramientas de diseño
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.
Práctica 1: Introducción a las herramientas de diseño
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:
𝑻𝒊𝒆𝒎𝒑𝒐 𝑺𝒊𝒎𝒖𝒍𝒂𝒄𝒊ó𝒏 = 𝟐𝑵ú𝒎𝒆𝒓𝒐 𝒅𝒆 𝒆𝒏𝒕𝒓𝒂𝒅𝒂𝒔 ·𝑷𝒆𝒓í𝒐𝒅𝒐 𝑩𝟎
𝟐
Práctica 1: Introducción a las herramientas de diseño
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.
Práctica 1: Introducción a las herramientas de diseño
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:
𝒕(𝑵) = 𝑵 · 𝑷𝒆𝒓í𝒐𝒅𝒐 𝑩𝟎
𝟐
Práctica 1: Introducción a las herramientas de diseño
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
Desarrollo de la práctica 18
Sumador binario de un bit 18
Realización práctica 19
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
Autocuestionario (a rellenar ANTES de la sesión de laboratorio) 31
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) 31
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.
Práctica 2: Circuitos combinacionales
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.
Desarrollo de la práctica
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
Práctica 2: Circuitos combinacionales
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.
Realización práctica
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.
Práctica 2: Circuitos combinacionales
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.
Práctica 2: Circuitos combinacionales
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.
Práctica 2: Circuitos combinacionales
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
Práctica 2: Circuitos combinacionales
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.
Práctica 2: Circuitos combinacionales
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
Práctica 2: Circuitos combinacionales
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
Práctica 2: Circuitos combinacionales
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
Práctica 2: Circuitos combinacionales
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.
Práctica 2: Circuitos combinacionales
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.
Práctica 2: Circuitos combinacionales
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
Práctica 2: Circuitos combinacionales
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:
𝒕(𝒀, 𝑿) = (𝒀 · 𝟐𝟓𝟔 + 𝑿) · 𝑷𝒆𝒓í𝒐𝒅𝒐 𝑩𝟎
𝟐
Práctica 2: Circuitos combinacionales
31
Autocuestionario (a rellenar ANTES de la sesión de laboratorio)
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?
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio)
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
Desarrollo de la práctica 36
Ampliador aritmético 36
Realización práctica 37
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
Autocuestionario (a rellenar ANTES de la sesión de laboratorio) 47
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) 47
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,
Práctica 3: Retardo de puertas
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
Práctica 3: Retardo de puertas
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
Práctica 3: Retardo de puertas
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.
Desarrollo de la práctica
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.
Práctica 3: Retardo de puertas
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.
Realización práctica
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.
Práctica 3: Retardo de puertas
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.
Práctica 3: Retardo de puertas
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.
Práctica 3: Retardo de puertas
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.
Práctica 3: Retardo de puertas
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
Práctica 3: Retardo de puertas
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.
Práctica 3: Retardo de puertas
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.
Práctica 3: Retardo de puertas
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.
Práctica 3: Retardo de puertas
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.
Práctica 3: Retardo de puertas
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.
Práctica 3: Retardo de puertas
47
Autocuestionario (a rellenar ANTES de la sesión de laboratorio)
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.
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio)
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
Desarrollo de la práctica 55
Realización práctica 55
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
Autocuestionario (a rellenar ANTES de la sesión de laboratorio) 63
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) 63
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).
Práctica 4: Captura y simulación de elementos biestables
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
Práctica 4: Captura y simulación de elementos biestables
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
Práctica 4: Captura y simulación de elementos biestables
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.
Práctica 4: Captura y simulación de elementos biestables
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.
Práctica 4: Captura y simulación de elementos biestables
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
Los objetivos de esta práctica son:
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.
Práctica 4: Captura y simulación de elementos biestables
55
5. Uso de nuevas características del programa de simulación.
6. Propuesta de patrones de test para la verificación del circuito.
Desarrollo de la práctica
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.
Realización práctica
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.
Práctica 4: Captura y simulación de elementos biestables
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.
Práctica 4: Captura y simulación de elementos biestables
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.
Práctica 4: Captura y simulación de elementos biestables
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.
Práctica 4: Captura y simulación de elementos biestables
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.
Práctica 4: Captura y simulación de elementos biestables
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.
Práctica 4: Captura y simulación de elementos biestables
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.
Práctica 4: Captura y simulación de elementos biestables
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.
Práctica 4: Captura y simulación de elementos biestables
63
Autocuestionario (a rellenar ANTES de la sesión de laboratorio)
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?
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio)
1. Explica el cronograma de la Figura 4-13.
2. Explica el cronograma de la Figura 4-16.
3. Explica el cronograma de la Figura 4-18.
4. Explica el cronograma de la Figura 4-20.
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
Desarrollo de la práctica 66
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
Realización práctica 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
Autocuestionario (a rellenar ANTES de la sesión de laboratorio) 77
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) 77
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
Los objetivos de esta práctica son:
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.
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
asociada
66
Desarrollo de la práctica
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.
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
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.
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
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
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
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.
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
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
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
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.
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
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.
Realización práctica
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.
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
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
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
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.
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
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.
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control
asociada
77
Autocuestionario (a rellenar ANTES de la sesión de laboratorio)
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.
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio)
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
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
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del 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
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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í.
Estudio de la especificación del control mediante un diagrama de estados finitos
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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...
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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?
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
93
Añadir la instrucción addi
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 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
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.
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:
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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?
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
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.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
96
Figura 6-10 Estructura del procesador DLX.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
97
Figura 6-11 Especificación del control del procesador mediante un diagrama de estados.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
98
Figura 6-12 Parte del diagrama de estados finitos del procesador DLX especificado mediante la herramienta Xilinx.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
99
Figura 6-13 Camino de datos del procesador DLX capturado con la herramienta Xilinx.
Práctica 6: Procesador multiciclo: Simulación y modificación del diseño…
100
Figura 6-14 Diagrama de estados finitos que especifica la unidad de control del procesador.
Errores más frecuentes
101
Errores más frecuentes
Í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
Errores más frecuentes
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.