Libro Prácticas Gii FC 2019 v03

Prácticas de
Fundamentos de
Computadores
Grado en Ingeniería Informática – Plan 2019
Escuela de Ingeniería Informática
Autores: Cuenca Hernández, Carmelo
Quintana Domínguez, Francisca
Título: Prácticas de Fundamentos de 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, 2019
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 ..................................................................................................... 3
Realización práctica ............................................................................................. 3
Autocuestionario (a rellenar ANTES de la sesión de laboratorio)........................ 15
Cuestionario de laboratorio (a rellenar durante la sesión de laboratorio) .......... 15
Práctica 2: Circuitos combinacionales ................................................................... 17

Introducción ........................................................................................................... 17
Objetivos ................................................................................................................ 17
Desarrollo de la práctica ....................................................................................... 18
Sumador binario de un bit .................................................................................. 18
Realización práctica ........................................................................................... 19
Práctica 3: Diseño modular y jerárquico ............................................................... 33

Introducción ........................................................................................................... 33
Objetivos ................................................................................................................ 35
ALU de 4 bits ..................................................................................................... 36
Anexo...................................................................................................................... 53
Práctica 4: Captura y simulación de elementos biestables................................... 57

Introducción ........................................................................................................... 57
Objetivos ................................................................................................................ 64
i
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control

asociada ..................................................................................................................... 73
Introducción ........................................................................................................... 73
Objetivos ................................................................................................................ 73
Multiplicador binario ......................................................................................... 74
Anexo...................................................................................................................... 85
Práctica 6: Componentes de memoria ................................................................... 87

Introducción ........................................................................................................... 87
Objetivos ................................................................................................................ 89
Errores más frecuentes ............................................................................................ 99

Errores generales................................................................................................... 99
Errores en el editor esquemático ........................................................................... 99
Errores en el simulador ....................................................................................... 100
ii
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 3
Realización práctica 3
Paso 1. Iniciar Xilinx 4
Paso 2. Inicio de un nuevo proyecto 5
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
1
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.
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.
2
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”)
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.
3
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.
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.
4
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.
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.
5
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.
6
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.
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”.
7
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
8
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. 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.
9
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.
10
Figura 1-14 Ventanas del simulador lógico funcional y visualización de señal.
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.
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 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
12
permite probar todas las combinaciones de la tabla de verdad del circuito se calcula
como:
𝑷𝑷𝑷𝑷𝑷𝑷í𝒐𝒐𝒐𝒐𝒐𝒐 𝑩𝑩𝑩𝑩
𝑻𝑻𝑻𝑻𝑻𝑻𝑻𝑻𝑻𝑻𝑻𝑻 𝑺𝑺𝑺𝑺𝑺𝑺𝑺𝑺𝑺𝑺𝑺𝑺𝑺𝑺𝑺𝑺ó𝒏𝒏 = 𝟐𝟐𝑵𝑵ú𝒎𝒎𝒎𝒎𝒎𝒎𝒎𝒎 𝒅𝒅𝒅𝒅 𝒆𝒆𝒆𝒆𝒆𝒆𝒆𝒆𝒆𝒆𝒆𝒆𝒆𝒆𝒆𝒆 ·
𝟐𝟐
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.
20
𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇 𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆𝑆ó𝑛𝑛 = 22 · = 40𝑛𝑛𝑛𝑛
2
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
13
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.
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:
𝒕𝒕(𝑵𝑵) = 𝑵𝑵 ·
𝟐𝟐
14
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?
15
Práctica 2: Circuitos combinacionales
Índice
Introducción 17
Objetivos 17
Sumador binario de un bit 18
Realización de un sumador binario de un bit 19
Realización de un sumador binario de 2 bits 22
Realización de un sumador binario de 8 bits 29
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.
17
Por otra parte un sumador binario de 8 bits tiene 16 entradas y 9 salidas, dando un
total de 25 señales a visualizar. Para facilitar su visualización es necesario ahondar en
las posibilidades de representación que ofrece la herramienta.
También puesto que para la suma de dos números binarios de 8 bits existen en total
65536 posibilidades diferentes en las entradas, también notaremos la necesidad de
utilizar estrategias para asignar los estímulos a las señales de entrada, más allá de la
simple asignación de entradas a estímulos mostrada en la práctica anterior.
Finalmente veremos lo inadecuado de utilizar este método de diseño si queremos
escalar el sumador hasta 64 bits. A pesar de que el escalado del circuito es muy fácil
de manera conceptual, usar la simple replicación nos lleva a una forma de trabajar muy
engorrosa por el tedio que supone trabajar con circuitos muy voluminosos. Con ello
introduciremos la necesidad del diseño jerárquico y de otras herramientas de captura.
Sumador binario de un bit

El diseño a realizar en esta práctica es el circuito combinacional correspondiente a un
sumador completo de un bit y su expansión a 2 y 8 bits.
Un sumador binario de un bit es un circuito combinacional con tres entradas y dos
salidas. Los nombres de las tres entradas son: INPUT0 e INPUT1, que corresponden
a los bits a sumar, y CARRY_INPUT, que es el bit de acarreo. Los nombres de las
salidas son SUM y CARRY_OUTPUT, siendo SUM el resultado de la suma binaria y
CARRY_OUPUT el acarreo de salida.
Entradas del circuito Salidas del circuito
INPUT0 INPUT1 CARRY_INPUT SUM CARRY_OUTPUT
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1
Tabla 2-1 Tabla de verdad correspondiente a un sumador binario de un 1 bit.
El funcionamiento de este circuito puede describirse usando una tabla de verdad. Una
tabla de verdad es una representación tabular de las entradas y las salidas del circuito,
en la cual cada fila de la tabla posee una de las posibles combinaciones de entrada del
circuito y el valor de las salidas correspondiente a esas entradas. La Tabla 2-1 es la
tabla de verdad para el circuito sumador binario. En ella se ve, por ejemplo, que para
la combinación de entrada correspondiente a INPUT0 = 1, INPUT1 = 0,
CARRY_INPUT = 1, la combinación de salida es SUM = 0 y CARRY_OUPUT = 1.
18
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:
SUM = INPUT 0 ⊕ INPUT 1 ⊕ CARRY _ INPUT
CARRY _ OUTPUT = INPUT 0 ∗ INPUT 1 + CARRY _ INPUT * ( INPUT 0 ⊕ INPUT 1)
En las ecuaciones anteriores los símbolos matemáticos ⊕, * y + corresponden

respectivamente a las operaciones lógicas de XOR, AND y OR, que como vimos en la
primera práctica son algunas de las funciones lógicas básicas (puertas lógicas), y que
tienen asociadas unos símbolos gráficos que posibilitan la representación esquemática
de las ecuaciones anteriores. Así, a las ecuaciones anteriores les corresponde el
esquema de la Figura 2-1.
Figura 2-1 Representación esquemática de un sumador binario de 1 bit.
Llegados a este punto es de vital importancia recordar lo aprendido en la práctica
anterior, ya que los primeros pasos a realizar (para iniciar la herramienta, crear el
proyecto, capturar el esquema,…) son los que vimos allí. Dado que no es preciso
memorizar cada detalle, es un buen consejo tener a mano el guión de la primera
práctica.
La realización práctica consta de tres pasos, en el primero realizaremos un sumador
binario de un bit y simularemos su comportamiento. En el segundo realizaremos un
sumador binario de dos bits y en el tercero un sumador binario de ocho bits.
Realización de un sumador binario de un bit
Primero, creamos un proyecto cuyo nombre sea ADD1_95, rellenando los campos para
la creación de un nuevo proyecto tal y como se muestra en la Figura 2-2. En el campo
directorio debes hacer referencia a tu directorio personal de trabajo.
19
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
FileSave As y rellenamos los campos de la ventana con los valores indicados en la
Figura 2-4. Finalmente picamos en el botón Aceptar.
20
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
OptionsCreate Netlist... y la exportamos en el formato EDIF 200 usando la opción
del menú principal OptionsExport Netlist... Antes de exportar la netlist podemos
comprobar que todo es correcto seleccionando OptionsIntegrity Test. Finalmente
abandonamos el editor de esquemas con FileExit.
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 SignalAdd Signals... para añadir las entradas y salidas en la ventana
de visualización de señales. Luego, seleccionando SignalAdd 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.
21
Figura 2-5 Simulación del sumador binario de un bit.
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 FileSave Simulation State y cerramos la herramienta
de simulación con FileExit.
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 DocumentAdd... y buscamos el fichero esquemático
anterior en el proyecto ADD1_95, tal como se muestra en la Figura 2-6.
22
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 ToolsDesign 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 ModeSelect 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 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
EditCopy y luego lo recuperamos del portapapeles con la opción EditPaste.
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ú EditUndo.
23
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.
Figura 2-8 Ventana para cambiar el nombre a los terminales de entrada y salida.
24
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
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.
25
Figura 2-10 Esquema final del sumador binario de dos bits.
Creamos ahora una netlist usando OptionsCreate Netlist... y la exportamos en el

formato EDIF 200 usando la opción del menú principal OptionsExport Netlist...
Antes de exportar la netlist comprobamos que todo es correcto con
OptionsIntegrity Test. Finalmente abandonamos el editor de esquemas con
FileExit.
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 SignalAdd 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.
26
Luego, con SignalAdd 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
simulación seleccionamos la opción SignalBusCombine 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.
27
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 SignalBusBus
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 SignalBusBinary. 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
SignalBusChange Direction.
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
28
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
FileSave Simulation State y cerramos la herramienta de simulación con
FileExit.
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.
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
29
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
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:
𝟐𝟐
30
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:
𝒕𝒕(𝒀𝒀, 𝑿𝑿) = (𝒀𝒀 · 𝟐𝟐𝟐𝟐𝟐𝟐 + 𝑿𝑿) ·
𝟐𝟐
NOTA: Adicionalmente, en esta práctica realizamos el diseño de un sumador/restador

de 8 bits tal cual se muestra en el Gajski (sección 5.3 pag 187). El diseño lo realizamos
creando un módulo sumador de 8 bits (SUM8) al que le conectamos una nueva señal
de entrada S y 8 puertas XOR. Hay que tener en cuenta que los resultados vienen en
complemento a 2, así que la visualización en Xilinx en decimal no es la mejor opción.
31

1. ¿Cuál es la tabla de verdad de un sumador binario de dos bits?
2. ¿Qué significa “encadenar” los sumadores binarios de un bit para construir
sumadores de más bits?
3. ¿Por qué no es interesante desde el punto de vista de la simulación visualizar
los acarreos intermedios?
4. ¿Qué es el tiempo de simulación?
5. ¿Cómo influirá el periodo de la señal Bc0 del contador binario con el tiempo
de simulación?
6. ¿Qué es un bus?
7. ¿Por qué el valor de CI0 es 0 en todas las simulaciones excepto en la del
sumador binario de un bit?
8. ¿Por qué no hemos fijado el valor de CO7?
9. ¿Cuál es la técnica descrita en el guión de la práctica para reutilizar los diseños?
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?
32
Práctica 3: Diseño modular y jerárquico
Índice
Introducción 33
Objetivos 35
ALU de 4 bits 36
Realización de un módulo sumador de 1 bit 40
Realización del ampliador aritmético de 1 bit 42
Realización del ampliador lógico de 1 bit 44
Realización de la ALU de 4 bits 45
Simulación de la ALU de 4 bits 48
Realización de la ALU de 32 bits 51
Anexo 53
Introducción
El diseño de determinados circuitos digitales por métodos puramente formales, tales
como la especificación de su funcionamiento mediante una tabla de verdad y su
posterior simplificación empieza a ser inviable a medida que aumenta el número de
entradas del circuito. Por ejemplo, la especificación de la tabla de verdad para un
sumador binario de 8 bits implicaría especificar, para cada una de las 28 x 28 = 65536
combinaciones de entrada, los correspondientes valores de las salidas, lo cual hace
impracticable la construcción de dicha tabla de verdad.
La solución para la construcción de tales circuitos está en la capacidad humana de
descomponer un problema en problemas más simples y luego combinar las soluciones
de los problemas más simples para obtener la solución del problema original.
Para abordar el diseño del circuito sumador binario de 8 bits, la solución fue
considerarlo como cuatro sumadores de dos bits y estos a su vez formados por
sumadores de un bit. El resultado es un diseño jerárquico por niveles, tal y como se
muestra en la Figura 3-1.
33
Figura 3-1 Diseño jerárquico de un sumador binario de 8 bits.
En el nivel más bajo en complejidad de la jerarquía está el diseño con puertas lógicas
para construir el sumador binario de un bit. En el nivel más alto está el sumador binario
de 8 bits. Este proceso podría continuar hasta construir un módulo sumador de 32 ó 64
bits que pudiera utilizarse en el diseño de un procesador. Intentar capturar el diseño de
un sumador de 32 ó 64 bits mediante las técnicas de copiar y pegar descritas en la
práctica anterior, nos conduciría a un diseño con un número masivo de puertas lógicas
y conexiones, en el cual la probabilidad de cometer un error sería muy alta.
Para prevenir errores sería de gran ayuda poder ocultar los detalles de implementación,
definiendo módulos funcionales de los diseños ya capturados y comprobados. Los
módulos funcionales pasarían a ser componentes de la biblioteca de símbolos de
diseño, que podríamos utilizar de manera similar a las puertas lógicas, pero con una
funcionalidad mucho mayor. Posteriormente, podríamos definir nuevos módulos con
los ya construidos, dando lugar a un diseño jerárquico.
Esta metodología de diseño tiene como principales ventajas:
1. Facilita la reutilización del diseño. Un módulo bien diseñado puede utilizarse
en muchos proyectos con el consiguiente ahorro de trabajo.
2. Ocultación de información. Encapsular un diseño en un módulo, ocultando al
diseñador los detalles de implementación, facilita el manejo del mismo.
Únicamente es necesario conocer la relación entre las entradas y salidas del
circuito.
34
3. Copia. Construir un circuito copiando muchas veces un módulo funcional que

únicamente muestra información de las entradas y salidas es mucho más fácil
que replicar otro que contiene todos los detalles acerca de las puertas y las
conexiones que lo implementan.
4. Comprobación. La comprobación de un único y gran circuito es mucho más
difícil que comprobar un circuito compuesto por módulos que han sido
comprobados individualmente. En este último caso, los errores más frecuentes
se encuentran en las interfaces entre los módulos.
5. Diseño en equipo. Un diseño modular permite el trabajo en equipo. La
definición exacta de las interfaces entre módulos posibilita el trabajo en
paralelo de varios diseñadores.
Objetivos
De manera general, los objetivos de esta tercera práctica son los siguientes:
1. Aprendizaje de las técnicas de diseño modular y jerárquico.
2. Utilización del editor esquemático para la definición de módulos funcionales y
captura de esquemas jerárquicos.
3. Diseño de una unidad aritmético lógica compleja.
4. Manejo de múltiples esquemas.
5. Uso de las capacidades de la herramienta para el manejo de buses.
6. Simulación de circuitos complejos.
En esta tercera práctica vamos a construir una unidad aritmética lógica (ALU,
Arithmetic-Logic Unit) de números de 32 bits codificados en complemento a dos o
binario, utilizando técnicas de diseño modular y jerárquico. La ALU debe ser capaz de
realizar operaciones aritméticas de suma, resta, incremento, decremento, y operaciones
lógicas de AND, OR, identidad y complemento entre las entradas. Puesto que las
entradas en las operaciones aritméticas están también codificadas en complemento a
dos, la ALU debe tener una salida para indicar la situación de desbordamiento. La
Figura 3-2 representa el símbolo gráfico de la ALU de 32 bits. Las señales M, S1 y S0
sirven para seleccionar la operación que la ALU debe realizar con los operandos A y
B de 32 bits. F son los 32 bits del resultado. La señal CO es el acarreo de salida para
las operaciones binarias. Finalmente, la señal desbordamiento indica esta situación en
el caso de operaciones de sumas y restas con números representados en complemento
a dos.
35
A B
32 32
1
M
CO 1
Unidad aritmético lógica S0
1
1
S1
32 F
1 Desbordamiento
Figura 3-2 Símbolo gráfico de una ALU de 32 bits.
En las prácticas 1 y 2 el diseño siempre ha sido propuesto en el propio guión de la

práctica, siendo el principal trabajo a realizar la captura y simulación del mismo. Esto
era así por la falta de conocimientos teóricos previos, que imposibilitaban la propia
labor de diseño, y también porque el principal objetivo de las mismas era el aprendizaje
de la herramienta. En esta práctica la situación cambia, y al final de la misma se deja
parte del diseño a la propia creatividad de cada uno.
En primer lugar, implementaremos una ALU de 4 bits, y posteriormente realizaremos
las modificaciones necesarias para escalar el diseño a 32 bits.
ALU de 4 bits
Como todas las operaciones aritméticas están basadas en la suma, se puede diseñar una
ALU simplemente modificando las entradas de un sumador de acarreo propagado. La
lógica de modificación utilizada en las operaciones aritméticas se denomina a veces
ampliador aritmético (AE, Arithmetic Extender), y la lógica de modificación utilizada
en las operaciones lógicas se denomina ampliador lógico (LE, Logic Extender). Cada
uno o ambos ampliadores se conectan a la entrada del sumador, como se indica por las
líneas discontinuas de la Figura 3-3. Ahora mostraremos como diseñar estos
ampliadores de uno en uno.
A3 B3 A2 B2 A1 B1 A0 B0
A A A A
L E L E L E L E
E E E E
C4 X3 Y3 C3 X2 Y2 C2 X1 Y1 C1 X0 Y0 C0
∑ 1 bit ∑ 1 bit ∑ 1 bit ∑ 1 bit
F3 F2 F1 F0
Figura 3-3 Sumador de 4 bits con ampliadores aritméticos (AE) y lógicos (LE).
Como la ALU en cuestión realiza cuatro operaciones aritméticas y cuatro operaciones

lógicas, es necesario introducir una variable de control de modo, M, que seleccionará
36
operaciones aritméticas o lógicas de manera tal que siempre que M=1, la ALU realice
operaciones aritméticas y cuando M=0 realice operaciones lógicas. También es
necesario utilizar dos variables de selección, S1 y S0, que habilitarán la selección de
las cuatro operaciones aritméticas o de las cuatro operaciones lógicas. Los valores
asignados a S1 y S0, para cada operación aritmética, se resumen en la Tabla 3-1.
M S1 S0 Función F X Y C0
1 0 0 Decremento A-1 A Todos 0
unos
1 0 1 Suma A+B A B 0
1 1 0 Resta A+B’+1 A B’ 1
1 1 1 Incremento A A Todos 1
ceros
Tabla 3-1 Tabla funcional para las operaciones aritméticas.
Como se observa, la tabla también muestra el valor de la salida F de la ALU, así como
los valores de las entradas del sumador X, Y y C0. Obsérvese que, de acuerdo con esta
tabla, la entrada X del sumador requiere siempre el valor de A, mientras que la entrada
Y puede disponer de todos unos, B, B’ o todos ceros. Estos valores para la entrada Y
serán generados por el AE, cuya tabla de verdad se muestra en la Tabla 3-2.
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 para la entrada Yi al sumador.
Esta tabla se ha obtenido a partir de la Tabla 3-1 simplemente expandiendo la columna

Y en las columnas Bi e Yi, indicando cual es el valor de cada Yi en función de M, S1,
S0 y también del correspondiente valor de Bi. A partir de esta tabla puede obtenerse la
expresión booleana para Yi.:
Yi = MS1’Bi + MS0’ Bi’
Finalmente, el circuito lógico de este AE se muestra en la Figura 3-4. La Figura 3-27,
que se añade como anexo, es este mismo esquema a mayor tamaño.
37
Figura 3-4 Esquema lógico del AE.
A partir de la Tabla 3-1 obtenemos la ecuación lógica para el bit de acarreo inicial:
C0 = MS1
Esta ecuación indica que el acarreo inicial toma el valor lógico 1, si y sólo si, la
operación es aritmética y, resta o incrementa.
Una vez descrito el procedimiento de diseño de un AE, se puede realizar de igual
manera el diseño de un LE, tal y como se define en la Tabla 3-3. En esta tabla puede
verse que las entradas Y y C0 siempre están al valor 0 para operaciones lógicas,
mientras que las entradas X requieren diferentes expresiones booleanas para cada una
de estas operaciones.
M S1 S0 Función F X Y C0
0 0 0 Complemento A’ A’ 0 0
0 0 1 AND A AND B A AND B 0 0
0 1 0 Identidad A A 0 0
0 1 1 OR A OR B A OR B 0 0
Tabla 3-3 Tabla funcional del LE.
Basándose en esta tabla funcional, se puede desarrollar la tabla de verdad para el LE,
que se muestra en la Tabla 3-4. A partir de esta tabla de verdad puede obtenerse la
siguiente expresión boolena para describir algebraicamente el LE:
M S1 S0 Xi
0 0 0 Ai’
0 0 1 Ai Bi
0 1 0 Ai
0 1 1 Ai+Bi
1 X X Ai
Tabla 3-4 Tabla de verdad del LE.
38
Xi = M’S1’S0’Ai’ + M’S1S0Bi + S0AiBi + S1Ai + MAi

Una vez obtenida esta expresión se procede a la construcción del circuito lógico del
LE, mostrado en la Figura 3-5. En la Figura 3-28 está este mismo esquema a mayor
tamaño.
Figura 3-5 Esquema lógico del LE.
Hasta ahora, se han obtenido los circuitos lógicos para el AE y el LE, y la siguiente
tarea es conectarlos con un sumador para formar una unidad aritmético lógica
completa, como la ALU de cuatro bits mostrada en la Figura 3-3. Obsérvese que, en
la ALU, las operaciones lógicas se realizan en el ampliador lógico y los sumadores de
un bit se utilizan para pasar los resultados del LE sin cambiarlos. En otras palabras, los
sumadores de un bit se utilizan como conexiones con retardo fijo.
Obsérvese también que el acarreo de salida del bit más significativo representa un
acarreo en el caso de aritmética sin signo y que la puerta XOR de los acarreos de salida
de los dos bits más significativos se obtiene si ha habido desbordamiento en el caso de
aritmética en complemento a 2.
En primer lugar, diseñaremos la ALU de 4 bits. Los pasos a realizar para completar el
diseño están completamente definidos en este guión de práctica y son construir un
módulo sumador de 1 bit, un AE y un LE de 1 bit y combinar los módulos para
construir la ALU de 4 bits. Finalmente construiremos la ALU de 32 bits.
39
Realización de un módulo sumador de 1 bit
Figura 3-6 Inicialización del proyecto para la ALU de 4 bits.
Inicia la herramienta Xilinx. Luego crea un proyecto de nombre ALU4_95 tal y como
indica la Figura 3-6. En el campo directorio debes hacer referencia a tu directorio
personal de trabajo.
Luego, usa la opción de la barra de menú en la ventana del gestor de proyectos
DocumentAdd y añade el esquema C:\TEMP\CCUENCA\ADD1.SCH de la
práctica anterior al proyecto actual, según se muestra en la Figura 3-7. Con toda
seguridad que tienes que cambiar el directorio C:\TEMP\CCUENCA por el nombre
de tu directorio de trabajo personal.
Figura 3-7 Ventana para añadir el esquema del sumador binario de 1 bit al
proyecto ALU4_95.
Pica dos veces en el nombre del esquema para abrirlo. Una vez que esté abierto el
esquema realiza los siguientes cambios:
1. Pica dos veces sobre el terminal INPUT0. Cuando aparezca la ventana para los
terminales de entrada y salida, Figura 3-8, cambia el nombre del terminal de
INPUT0 a A. De la misma manera cambia INPUT1 por B, CARRY_INPUT
por CIN y CARRY_OUTPUT por COUT.
2. Realiza una conexión directa entre los terminales de entrada y la salida de los
IBUF, y entre los terminales de salida y la salida de los OBUF.
3. Elimina los buffers IBUF y los buffers OBUF.
40
Figura 3-8 Ventana para los terminales de entrada y salida.
Una vez que has hecho todo esto, el esquema del sumador binario debe ser similar al
de la Figura 3-9.
Figura 3-9 Sumador binario de 1 bit, modificado para encapsularlo en un

módulo funcional.
Ahora tenemos el esquema preparado para encapsularlo en un módulo funcional. Para

crear el símbolo, seleccionamos HierarchyCreate Macro Symbol from Current
Sheet en el menú principal del editor de esquemáticos. Aparece la ventana de creación
de símbolos, Figura 3-10. Escribe como nombre del símbolo MY_ADD1, y en el
campo comentario la frase “Mi sumador de 1 bit”, luego pica el botón de OK. La
herramienta nos informará, mediante un mensaje, que MY_ADD1 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.
41
Figura 3-10 Ventana para la creación de símbolos.
Realización del ampliador aritmético de 1 bit

En este punto, debemos tener el editor de esquemáticos sin ningún esquema.
Seleccionamos FileNew Sheet en el menú del editor de esquemáticos para obtener
un esquema en blanco donde poder trabajar. Aparecerá una hoja en blanco con el
nombre ALU4_951. En este esquema vamos a capturar el diseño lógico de la
ampliación aritmética. En primer lugar seleccionamos FileSave As para cambiar el
nombre del esquema a AE, según se muestra en la Figura 3-11.
Figura 3-11 Ventana para guardar el esquema con el nombre AE.
A continuación, captura el diseño de la AE, tal y como se especifica en la Figura 3-12.
42
Figura 3-12 Esquema lógico del AE.
En el esquema de la Figura 3-12 puedes ver que la orientación de las puertas lógicas
no es la habitual, sino que las puertas tienen una rotación de 90ª a la derecha. Para
conseguir la rotación de un símbolo a la derecha puedes utilizar la combinación de
teclas Control+R (la tecla Control y la tecla R pulsada a la vez), para rotar a la
izquierda Control+L, y para conseguir la imagen especular del símbolo puedes usar
Control+M.
Una vez que finalizamos, salvamos el esquema con FileSave. Luego usamos los
menús OptionsCreate Netlist, OptionsIntegrity Test y OptionsExport
Netlist... para crear, comprobar y exportar la netlist en formato EDIF200.
Cerramos el editor de esquemáticos y simulamos el circuito. El resultado de la
simulación se muestra en la Figura 3-13. A continuación, crearemos un módulo con
este esquema. Seleccionamos en la barra de menú HierarchyCreate Macro
Symbol from Current Sheet. En el campo nombre escribimos MY_AE, y en el
campo comentario “Ampliador aritmético”, picamos en el botón de OK y contestamos
que No a la pregunta de si queremos editar el símbolo.
Figura 3-13 Simulación del AE.
43
Realización del ampliador lógico de 1 bit

En este punto, debemos tener otra vez el editor de esquemáticos sin ningún esquema.
Seleccionamos FileNew Sheet en el menú del editor de esquemáticos para obtener
un esquema en blanco donde poder trabajar. Aparecerá una hoja en blanco con el
nombre ALU4_952. En primer lugar seleccionamos FileSave As para cambiar
nombre del esquema a LE, y a continuación capturaremos el diseño del LE, según se
muestra en la Figura 3-14.
Figura 3-14 Esquema lógico del LE
Una vez que finalizamos, salvamos el esquema con FileSave. Luego usamos los
menús OptionsCreate Netlist, OptionsIntegrity Tests y OptionsExport
Netlist... para crear, comprobar y exportar la netlist en formato EDIF200. Hecho esto,
simulamos el circuito y comprobamos que funciona correctamente, según aparece en
la Figura 3-15.
Figura 3-15 Simulación del LE.
44
A continuación, creamos otro módulo con este esquema, seleccionando en la barra de

menú HierarchyCreate Macro Symbol from Current Sheet. En el campo nombre
escribimos MY_LE, y en el campo comentario “Ampliador lógico”. Picamos en el
botón de OK y contestamos que No a la pregunta de si queremos editar el símbolo.
Realización de la ALU de 4 bits
Llegados a este punto hemos capturado el diseño de tres módulos: el sumador binario
de un bit, el ampliador aritmético y el ampliador lógico. Y ahora es el momento de
unir todos los módulos para construir la ALU de cuatro bits. Para ello seleccionamos
FileNew Sheet en el editor de esquemáticos, aparecerá una hoja en blanco con el
nombre ALU4_953 y cambiamos el nombre al esquema seleccionando FileSave
As... En el campo nombre de archivo escribimos ALU4 y picamos en el botón de
continuar. Para añadir los símbolos de los módulos definidos anteriormente selecciona
ModeSimbols en el editor de esquemáticos. Aparece la ventana de símbolos, y en
la parte superior puedes encontrar los módulos MY_ADD1, MY_AE y MY_LE, según
se muestra en la Figura 3-16.
Figura 3-16 Ventana de símbolos.
Sitúa 4 símbolos de cada uno de los módulos MY_ADD1, MY_AE y MY_LE, conecta
los acarreos de las etapas intermedias para crear la cadena de acarreos, también los
terminales de salida X de los LE con los terminales de entrada A del sumador binario
de 1 bit, finalmente los terminales Y de salida de los AE con los terminales de entrada
B del sumador binario de 1 bit, tal y como aparecen en la Figura 3-17.
45
Figura 3-17 Esquema premilinar de la ALU de 4 bits.
A continuación, dibujaremos dos buses de entrada y uno de salida, tal y como se

muestra en la Figura 3-18. Para ello selecciona en el menú principal ModeDraw
Buses. Pica desde una posición próxima al LE más a la izquierda y traza un bus hasta
una posición cercana al LE más a la derecha, Figura 3-18. Para terminar el trazado del
bus pica dos veces. Entonces aparece la ventana de edición de bus, Figura 3-19. En el
campo “nombre” escribe A; 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 3-18 Esquema con los buses A, B y F definidos.
46
Figura 3-19 Ventana de edición de buses.
Ahora tenemos que conectar los buses a las entradas de los ampliadores lógicos y
aritméticos y a las salidas de los sumadores. Selecciona en el menú principal Mode-
>Draw Bus Taps. Pica el cursor sobre el bus A, y a continuación sobre la entrada
etiquetada con el nombre A del ampliador lógico aparecerá una línea etiquetada con el
nombre A3 y que representa la conexión entre la línea A3 del bus A y la entrada A del
ampliador lógico. Pica sobre la siguiente para crear la conexión entre la línea A2 del
bus y la entrada A del siguiente ampliador lógico. Repite para crear las conexiones A1
y A0. Para terminar, pulsa la tecla ESC.
Si cometes un error, puedes pulsar dos veces en el nombre de la conexión al bus, por
ejemplo, A2, y luego cambiar el nombre de la conexión en la ventana que aparece para
tal efecto.
Repite el proceso anteriormente descrito para establecer las conexiones al bus de
entrada B. En este caso las conexiones hay que establecerlas dos veces puesto que las
líneas correspondientes al bus B se conectan a ambos ampliadores. Finalmente conecta
las salidas de los sumadores al bus de salida F. El resultado debe ser similar al de
Figura 3-20.
Figura 3-20 Esquema de la ALU de 4 bits con los buses conectados.
A continuación, definimos los terminales de entrada M, S1 y S0 y los conectamos a

las entradas de todos los ampliadores. Para terminar, añadimos la lógica necesaria para
calcular el acarreo inicial y la señal de desbordamiento, tal como muestra la Figura 3-
21. En el esquema la señal de desbordamiento y CO4 corresponden a terminales de
salida.
47
Figura 3-21 Lógica para el cálculo del acarreo inicial y la señal de

desbordamiento.
El esquema final debe ser similar al de Figura 3-22. En la Figura 3-29, que se añade
como anexo, está este mismo esquema a mayor escala.
Figura 3-22 Esquema final de la ALU de 4 bits.
Simulación de la ALU de 4 bits

Una vez capturado el esquemático realizamos la simulación del circuito. Añadimos al
simulador los terminales de entrada y salida por este orden: los buses de entrada A y
B, las señales de control S0, S1 y M, el bus de salida F, el acarreo final y el bit de
desbordamiento.
Para asociar estímulos a los buses es necesario deshacer los buses. Pica sobre el bus A
y a continuación selecciona SignalBusFlatten en la barra de menú. De igual
manera deshaz también el bus B.
48
A continuación, realiza la siguiente asignación de estímulos: A3 con el bit Bc3 del

contador, A2 con el bit Bc2, A1 con el Bc1 y finalmente A0 con el Bc0. Para el bus B,
B3 con el bit Bc7 del contador, B2 con el bit Bc6, B1 con el Bc5 y finalmente B0 con
el Bc4.
A S0 le asignas Bc8, a S1 le asignas Bc9 y a M le asignas BcA. Así acabamos la
asignación de estímulos a los terminales de entrada.
Una vez asignados los estímulos, vuelve a agrupar los buses A y B. También define
un bus con las señales de control S0, S1 y M. Para facilitar la interpretación de los
resultados, cambia el formato de visualización de los buses a decimal picando en
primer lugar sobre el bus y luego seleccionando SignalBusDisplay Decimal.
Selecciona el bus A y cambia su dirección de agrupación con SignalBusChange
Direction. Esta orden tiene el mismo efecto que desagrupar el bus, ordenar las señales
en orden inverso y posteriormente volver a reagrupar las señales. Cambia de igual
manera también la dirección del bus B.
Realiza una simulación el suficiente tiempo para que las señales de entrada tomen
todas las combinaciones posibles, según muestra la Figura 3-23.
Figura 3-23 Simulación de la ALU de 4 bits.
Para comprobar el funcionamiento de la ALU diseñada recuerda que el bus de control

formado por las líneas de control de operación M, S1 y S0 definen la operación a
realizar por la ALU de acuerdo con la Tabla 3-5.
M S1 S0 F
0 0 0 Complemento
0 0 1 AND
0 1 0 Identidad
0 1 1 Or
1 0 0 Decremento
1 0 1 Suma
1 1 0 Resta
1 1 1 Incremento
Tabla 3-5 Tabla funcional de la ALU de 4 bits.
49
Así por ejemplo, en la Figura 3-23 vemos que en la posición indicada por el cursor, si
interpretamos los buses como números representados el bus de control toma el valor
5, indicando una operación de suma entre el bus A, que tiene un valor de 10 en sus
líneas, y el bus B, con el valor de 6. El resultado de esta operación de suma se muestra
en el bus de salida F y es cero, como consecuencia de la incorrección de la operación,
la señal de acarreo de salida toma el valor alto. Ahora bien, si interpretamos los buses
como números en complemento a dos, el bus A con codificación 10 correspondería al
valor decimal de –6, que sumado al bus B con valor decimal 6 daría como resultado
para la operación de suma el valor decimal 0, que es correcto y por tanto no se activa
el bit de desbordamiento para operaciones en complemento a dos.
De igual manera comprueba el resto de las operaciones aritméticas y lógicas.
En caso de errores, estos pueden estar o bien en las conexiones entre los módulos o
bien entre los propios módulos.
Puedes arrancar o regresar al simulador desde el editor de esquemas simplemente
picando el botón en la barra de herramientas debajo del menú principal de la
ventana principal del editor de esquemas. También desde el simulador puedes arrancar
o regresar al editor de esquemas picando en el botón en la barra de herramientas
debajo del menú principal de la ventana principal del simulador.
Para depurar los errores en las conexiones entre los módulos, 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-24. 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-24 Ventana de herramientas de simulación.
Puede ocurrir que la causa del error sea el diseño del módulo y no las relaciones con
los otros módulos. En un principio esta situación delataría que el diseño no ha sido lo
suficientemente probado y fue dado por bueno con demasiada rapidez, aunque a veces,
por la naturaleza del error este sólo se pone de manifiesto cuando conectamos el
módulo en cuestión con otro componente.
Un método para depurar un módulo ya construido consiste en ver su esquema
utilizando las opciones del menú principal en el editor de esquemas Hierarchy->Push
(o el botón en la barra auxiliar de herramientas) y Hierarchy->Pop. Al utilizar la
primera de las dos órdenes el cursor cambia a una flecha con una “H”, indicando que
50
hemos cambiado de modo. Picando dos veces sobre un símbolo en el diseño

esquemático, veremos la hoja correspondiente a su diseño. Así es posible, por ejemplo,
modificarla si lo consideramos oportuno o añadir señales para la depuración del
módulo. Para regresar al esquema principal está la opción Hierarchy->Pop o
simplemente cerrar la hoja del esquema. En el caso de haber realizado modificaciones
aparece el mensaje Figura 3-25. Picando en el botón Sí, las modificaciones realizadas
al módulo son aceptadas. Picando en el botón No, las modificaciones no tendrán
ningún efecto.
Figura 3-25 Pregunta al abandonar un subesquema.
Realización de ALUs de mayor número de bits

La construcción de una ALU de mayor número de bits es realmente una cuestión de
diseño, no de captura del diseño y simulación como han sido las prácticas anteriores,
y la actual hasta este punto.
Para diseñar una ALU de 8 bits se puede generar un módulo con la ALU de 4 bits
diseñada hasta este punto (ALU4), y luego se pueden colocar 2 módulos ALU4
encadenando la salida de acarreo de uno de los módulos con la entrada de acarreo del
siguiente módulo. Para ello, el módulo ALU4 debe tener una entrada de acarreo, y eso
se consigue eliminando la puerta AND que genera el acarreo C0 como el producto de
M y S1, y colocando un terminal de entrada CIN. Posteriormente, en el esquemático
de la ALU de 8 bits se añadiría la puerta AND que generaría el acarreo de entrada C0
para el módulo ALU4 que genera los bits menos significativos.
Para diseñar una ALU de 16 bits siguiendo la misma filosofía basta con colocar 4
módulos ALU4 encadenando los acarreos. Del mismo modo, para una ALU de 32 bits
serían 8 los módulos ALU4 que se encadenarían.
La Figura 3-2 muestra el diagrama de bloques de la ALU de 32 bits una vez terminada
y empaquetada en un módulo. A y B son los buses de entrada, y F es el bus de salida.
Todos los buses tienen un ancho de 32 bits. M, S1 y S0 son las señales de control que
definen la operación a realizar por la ALU, de acuerdo con la Tabla 3-5 que ya hemos
comentado.
Las soluciones a los problemas de diseño no son únicas. El diseño de la ALU de mayor
número de bits puede realizarse también siguiendo otra filosofía: generando los
módulos LE8, AE8 y ADD8, que luego se replicarían 4 veces y se conectarían
siguiendo la misma filosofía que en la ALU de 4 bits. Un diagrama posible de macro
tareas a realizar es el mostrado en la Figura 3-26.
51
Figura 3-26 Posibles pasos para la construcción de una ALU de 32 bits.
52
Anexo
Figura 3-27 Diagrama esquemático del AE.
53
Figura 3-28 Diagrama esquemático del LE.
54
Figura 3-29 Diagrama esquemático de la ALU de 4 bits.
55

1. ¿Qué es una ALU?
2. ¿Puede la ALU diseñada sumar números en complemento a dos? ¿Por qué?
3. ¿Qué función realiza el módulo de ampliación aritmética en la ALU?
4. ¿Qué función realiza el módulo de ampliación lógica en la ALU?
5. ¿Qué indican a la ALU las señales M, S1 y S0?
6. ¿Qué ocurre si sobre un símbolo pulsamos las teclas Control+R, Control+L ó
Control+M?
7. ¿Cuál es la secuencia de operaciones para definir un símbolo?
8. ¿Para qué sirve la opción SignalBusesChange Direction en el simulador?
9. Indica un diagrama de macrotareas a realizar para construir una ALU de 32
bits, diferente al propuesto en la práctica.
10. ¿Cómo se obtiene una hoja en blanco en el editor de esquemáticos?

1. ¿Cuánto tiempo de simulación es necesario para comprobar todos los patrones
de entrada de la ALU de 4 bits?
2. ¿Es escalable directamente la ALU de 4 bits a 32 bits? ¿Por qué?
3. ¿Qué indica el bit de acarreo de salida en la ALU de 32 bits en las operaciones
con números representados en binario? ¿Y con números representados en
complemento a dos?
4. ¿Qué técnicas de diseño has utilizado para construir la ALU de 32 bits?
5. ¿Qué indica el bit de desbordamiento en la ALU de 32 bits en las operaciones
con números representados en binario? ¿Y con números representados en
complemento a dos?
6. Entre todas las operaciones de la ALU diseñada ¿cuál tarda menos tiempo en
realizarse? ¿Y cuál tarda más? ¿Por qué?
7. Explica cómo has comprobado el diseño de la ALU de 32 bit.
8. ¿Cuál es el diseño con bloques funcionales que has implementado para la ALU
de 32 bits?
56
Práctica 4: Captura y simulación de elementos
biestables
Índice
Introducción 57
Objetivos 64
Latch SR 64
Simulación funcional del latch SR 67
Simulación con retardo unitario del latch SR 68
Latch D síncrono 69
Biestable D maestro esclavo 70
Biestable D disparado por flanco con entradas asíncronas de set y clear. 70
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).
57
Práctica 4: Captura y simulación de elementos biestables
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
58
0, el latch se establecerá a 1 o pondrá a 0, respectivamente, que es justamente lo

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.
59
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 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.
60
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.
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.
61
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.
62
Nombre Símbolo del Tabla Ecuación Tabla de

del biestable característica característica excitación
biestable
SR
S R Q(t+1) Q(t) Q(t+1) S R
0 0 Q(t) 0 0 0 X
Q(t+1) = S +
0 1 0 0 1 1 0
R’Q
1 0 1 1 0 0 1
1 1 X 1 1 X 0
JK
J K Q(t+1) Q(t) Q(t+1) J K
0 0 Q(t) 0 0 0 X
0 1 0 Q(t+1)=JQ’+K’Q 0 1 1 X
1 0 1 1 0 X 1
1 1 Q’(t) 1 1 X 0
D Q(t+1) Q(t) Q(t+1) D

0 0 0 0 0
D 1 1 Q(t+1) = D 0 1 1
1 0 0
1 1 1
T Q(t+1) Q(t) Q(t+1) T

0 Q(t) 0 0 0
Q(t+1) = TQ’
T 1 Q’(t) 0 1 1
+T’Q
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
63
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.
5. Uso de nuevas características del programa de simulación.
6. Propuesta de patrones de test para la verificación del circuito.
El desarrollo de la práctica consiste en capturar múltiples esquemas correspondientes
a latches o biestables y confrontar que los resultados experimentales coinciden con los
teóricos.
En cada uno de los apartados vamos a realizar una o dos simulaciones que deben
comprender pues es lo que luego se les preguntará en los cuestionarios de laboratorio.
La realización práctica es casi en su totalidad guiada. Comienza con el estudio de un
latch SR, continua con un latch D síncrono, sigue con un biestable D maestro-esclavo
y termina con un biestable D disparado por flanco con entradas asíncronas de preset y
clear. Para el último apartado el alumno deberá proponer además un vector de test para
comprobar el circuito.
Latch SR
Inicia la herramienta Xilinx. Luego crea un proyecto de nombre “flipflop”, tal y como
indica la Figura 4-7. En el campo directorio debes hacer referencia a tu directorio
personal de trabajo.
Figura 4-7 Ventana de nuevo proyecto.
64
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.
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 OptionsCreate Netlist... y la
exportamos en el formato EDIF 200 usando la opción del menú principal
OptionsExport Netlist... Antes de exportar la netlist podemos comprobar que todo
es correcto seleccionando OptionsIntegrity Test. Finalmente abandonamos el
editor de esquemas con FileExit.
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
SignalAdd 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.
65
Figura 4-10 Ventana de selección de estímulos.
Para modelar las señales S y R tenemos que editar fórmulas. Selecciona SignalAdd
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.
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.
66
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.
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.
67
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.
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.
68
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.
69
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.
70
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.
71

1. ¿Qué es una fórmula? ¿Cómo se edita su valor? ¿Cómo se asocia una fórmula
a una señal de entrada?
2. ¿Cómo se asigna un nombre a una conexión entre terminales?
3. ¿Cómo se detiene la simulación cuando la herramienta de simulación detecta
un comportamiento oscilatorio?
4. ¿Qué ventajas presenta la simulación funcional sobre la simulación con retardo
unitario?
5. ¿Cómo se fija el tiempo de simulación?
6. ¿Cómo se fija el retardo unitario de la simulación?
7. ¿Cómo se cambia entre simulación funcional y simulación con retardo
unitario?
8. ¿Para qué sirven las señales de PRS y CLR en el esquema de la Figura 4-6?

1. Explica el cronograma de la Figura 4-13.
5. Explica las similitudes y las diferencias entre la Figura 4-13 y la Figura 4-16
72
Práctica 5: Captura y simulación de una ruta de datos
y de la unidad de control asociada
Índice
Introducción 73
Objetivos 73
Multiplicador binario 74
Diseño de la ruta de datos del multiplicador binario de 4 bits 74
Diseño de la unidad de control del multiplicador binario de 4 bits 78
Diseño del multiplicador binario de 4 bits 80
Implementación de la unidad de control 81
Implementación del camino de datos 82
Implementación del multiplicador de 4 bits 83
Anexo 85
Introducción
Los caminos datos se emplean en todas las implementaciones de procesadores estándar
y de ASIC (circuitos integrados de propósito específico) para realizar cálculos
numéricos complejos y manipular datos. Un camino de datos consta de elementos de
memoria temporal, además de unidades aritméticas, lógicas, y de desplazamiento.
En estos caminos de datos tiene lugar la ejecución de algoritmos bajo la supervisión
de la unidad de control. Una unidad de control no es más que la implementación de
una máquina de estados finitos en la que, en cada estado, dependiendo de los valores
de las señales provenientes del camino de datos o externas, se produce la correcta
activación de las señales de control del camino de datos.
En esta práctica se diseñará una unidad de control para un camino de datos que
realizará la operación de multiplicación binaria.
Objetivos
1. Diseño, implementación y depuración de un circuito secuencial.
2. Aprendizaje de nuevas funcionalidades de la herramienta de simulación.
3. Utilización de las técnicas de modularización y jerarquización para el diseño
de sistemas complejos.
73
Práctica 5: Captura y simulación de una ruta de datos y de la unidad de control asociada
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.
74
Inicio/Fin Estado S0
CX = X Estado S1
CY = Y
P=0
Sí
¿CY=0?
No
P = P + CX
CY = CY-1 Estado S2
Figura 5-1 Un algoritmo de multiplicación: P=X*Y
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.
75
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.
76
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-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 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.
77
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.
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.
78
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 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.
79
Diseño del multiplicador binario de 4 bits
Figura 5-6 Bloque funcional de la unidad de control del multiplicador binario

de 4 bits.
Una vez diseñados el camino de datos y la unidad de control, para finalizar el diseño
del multiplicador binario será únicamente necesario conectar los diagramas de bloques
de la Figura 5-3 y de la Figura 5-6, tal y como muestra la Figura 5-7.
Figura 5-7 Unidad de control y camino de datos del multiplicador binario de 4

bits.
En la Figura 5-7 el único detalle significativo es el hecho que las señales de reloj de la
unidad de control y del camino de datos están invertidas una respecto de la otra. Esto
es así ya que los cambios de estado ocurren en la transición positiva del reloj y por
tanto el funcionamiento del camino de datos debe producirse en las transiciones
negativas, lo cual es equivalente a invertir la señal de reloj conectada a la ruta de datos.
La realización práctica consiste en la implementación de la unidad de control a partir
de un diseño propio del alumno, la captura del esquemático del camino de datos, la
simulación de ambos módulos de manera independiente y posteriormente la unión de
los módulos para realizar la operación de multiplicación.
Una característica del programa, que resulta muy útil para depurar la máquina de
estados, es la posibilidad de usar las letras del teclado como estímulos.
80
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
HierarchyCreate 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
81
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 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 ModeDraw 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.
82
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.
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 HierarchyCreate 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.
83
Figura 5-12 Resultado de la simulación de la multiplicación entre los números

X=6 e Y=4.
84
Anexo
Figura 5-13 Ruta de datos para la multiplicación binaria de 4 bits.
85
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?
86
Práctica 6: Componentes de memoria
Índice
Introducción 87
Objetivos 89
Banco de registros de 8 registros de 32 bits con 2 puertos de lectura y uno de
escritura 90
Banco de registros de 32 registros de 32 bits con 2 puertos de lectura y uno de
escritura 93
Introducción
Los componentes de memoria almacenan información binaria (0s o 1s) para un
posterior acceso o procesamiento, y están presentes en el diseño de circuitos digitales
simples y complejos (como por ejemplo la ruta de datos del procesador). La
complejidad de los componentes de memoria es variada, yendo desde los más simples,
como las celdas básicas de almacenamiento construidas con un transistor y un
condensador o los biestables, hasta los más complejos, como los bancos de registros o
las memorias para almacenamiento masivo de información.
El conocimiento del diseño del banco de registros resulta necesario para el
entendimiento de la estructura de un procesador. El banco de registros es el
componente de memoria más cercano a la unidad aritmético-lógica (ALU) del
procesador, siendo el lugar físico donde están almacenados los operandos de las
instrucciones que ejecuta el procesador.
Un banco de registros está definido por sus parámetros de diseño, que son: el número
de registros, normalmente un número potencia de 2 (8, 16, 32…); la anchura o
número de bits de cada registro (16, 32…); el número de puertos de lectura (1,
2…) que determina el número máximo de registros que se pueden leer
simultáneamente; y el número de puertos de escritura (1, 2…) que fija de manera
análoga el número de registros que se pueden escribir simultáneamente.
Los parámetros de diseño del banco de registros determinan las entradas y salidas del
banco de registros. Por ejemplo, la Figura 6-1 muestra el diagrama de bloques de un
banco de 8 registros de 32 bits cada uno, con 2 puertos de lectura y uno de escritura,
mientras que la Tabla 6-1 contiene una descripción de la funcionalidad de cada una de
las señales del banco de registros.
87
Figura 6-1 Banco de registros de 8 registros de 32 bits cada uno, con 2 puertos
para lectura y uno de escritura. Los parámetros de diseño determinan el
número y el tipo de las señales del componente.
Tabla 6-1 Descripción funcional de las señales de un banco de 8 registros de 32

bits cada uno, con 2 puertos de lectura y uno de escritura.
Nombre Funcionalidad
RAA (Read Address A) 3 bits de entrada para direccionar qué número de
registro leer. El número de registro leído coincide con el valor del
número binario presente en esta entrada.
DA (Data A) Los 32 bits de salida que corresponden con el contenido del
registro de 32 bits direccionado por la señal RAA.
RAB (Read Address B) 3 bits de entrada para direccionar qué número de
registro leer. El número de registro leído coincide con el valor del
número binario presente en esta entrada.
DB (Data B) Los 32 bits de salida que corresponden con el contenido del
registro de 32 bits direccionado por la señal RAB.
WA (Write Address) 3 bits de entrada para direccionar qué número de
registro escribir. El registro escrito coincide con el valor del número
binario presente en esta entrada.
DI (Data Input) 32 bits de entrada que contienen el valor a escribir en el
registro indicado por la señal WA.
WE (Write Enable) Las escrituras en el banco de registros son síncronas.
El contenido de DI es escrito en el registro WA cuando ocurre el flanco
de subida de la señal de reloj C y además la señal WE está activa.
C (Clock) Señal de reloj que determina el funcionamiento síncrono del
banco de registros.
Hay dos puertos de lectura etiquetados como A y B, y un único puerto de escritura.

Las señales para direccionar los registros son RAA, RAB y WA con una anchura, en
todos los casos, de 3 bits (dado que hay 8 registros); las dos primeras direccionan los
88
puertos de lectura (puertos A y B) y la última el puerto de escritura. Las señales de

datos son DA, DB y DI. Todas de 32 bits ya que ésta es la anchura de los registros en
el interior del banco de registros. DA y DB contienen los datos de salida resultados de
la lectura y DI el dato de entrada para escribir en el banco de registros. La señal de
control WE del puerto de escritura tiene que estar activa de forma que cuando ocurra
el flanco de subida de la señal de reloj el dato presente en DI se escriba en el registro
direccionado por WA. En este diseño los puertos A y B están siempre leyéndose (otra
opción de diseño podría ser tener una señal más de lectura RD y que las salidas DA y
DB estuvieran en alta impedancia en el caso de no activarse la señal RD). Finalmente,
C es la señal de reloj necesaria para que las operaciones de lectura y escritura en el
banco de registros sean síncronas; esto significa que los datos en la salida de los puertos
de lectura son los datos leídos desde el banco de registros en el flanco de la señal de
reloj (C), y el dato escrito en el banco de registros es el dato presente en DI en el
momento del flanco de reloj con independencia de los valores que DI haya tenido antes
o tenga después del flanco de la señal de reloj.
La Figura 6-2 muestra un ciclo de lectura seguido de otro de lectura-escritura en el
banco de registros de ejemplo (por diseño, un ciclo de escritura también es un ciclo de
lectura, ya que cada vez que el banco de registros es escrito, también es leído). El
registro utilizado para leer y escribir en este ejemplo siempre es el registro $5. En el
primer ciclo de reloj, leemos el registro $5 ya que la señal RAA2 del cronograma tiene
un valor de 5. El contenido del registro $5 es 0, tal como muestra la señal DA31. En el
segundo ciclo de reloj, que va desde los 100ns a los 200ns, la señal de escritura WE
está activa durante todo el ciclo. Aunque el bus de entrada DI contiene desde el inicio
el valor 0xFFFFFFFF, éste no aparece en el valor del puerto de lectura DA31 hasta que
ocurre el flanco de subida de reloj en el instante 150ns. El posterior cambio del valor
de DI31 a 0x00000000 en el instante de tiempo 175ns no tiene ningún efecto ni en la
entrada ni en la salida.
Figura 6-2 Simulación de un ciclo de lectura y otro de lectura-escritura en el

banco de registros. La lectura y la escritura mostradas ocurren en el registro
$5. La señal de escritura WE está activa durante todo el ciclo de escritura. Aún
así, la escritura ocurre en el instante de tiempo 150ns cuando ocurre el flanco
de subida de la señal de reloj. Nótese que el cambio en el valor de la señal DI31
en el instante de tiempo 175ns no tiene ningún efecto.
Objetivos
1. Estudio práctico tanto estructural como funcional de los bancos de registros.
2. Estudio práctico de los ciclos de lectura y escritura de los bancos de registros.
3. Utilización de las técnicas de diseño jerárquico para diseñar elementos más
complejos a partir de otros más básicos ya diseñados y probados.
89
4. Diseño de pruebas para comprobar el correcto funcionamiento de un diseño.

5. Utilización de opciones más avanzadas de simulación para añadir estímulos
como la opción de teclado de “Select Stimulator” y de bus de “Logical States”
y la herramienta “LogiBLOX Module Generator”.
El tiempo programado para la realización de esta práctica es de 4 horas. La parte
experimental está organizada en dos partes: la primera corresponde a completar las
conexiones en una plantilla de diseño esquemático de un banco de registros con 8
registros de 32 bits con 2 puertos de lectura y uno de escritura; y la segunda parte
reutiliza el módulo resultado de la primera parte, haciendo uso de la técnica de diseño
modular y jerárquico, en una plantilla en la que también hay que completar las
conexiones para conseguir un banco de 32 registros de 32 bits con 2 puertos de
escritura y uno de escritura.
Todos los apartados incluyen la realización de simulaciones para verificar que el
diseño funciona correctamente.
Para el primer diseño, el estudiante capturará una plantilla teniendo que completarla
con las conexiones entre los diferentes componentes de la plantilla. En el segundo
diseño, el estudiante aplicará lo aprendido para ampliar la altura del banco de registros
completando con las conexiones una plantilla propuesta en la que utiliza el banco de
registros resultante del primer diseño.
Banco de registros de 8 registros de 32 bits con 2 puertos de lectura y uno
de escritura
Inicia la herramienta Xilinx. Luego crea de la manera habitual un proyecto de nombre
“regs”. En este proyecto, crea para el primer diseño una hoja para el esquemático de
nombre “reg8x32” y una vez que lo finalices, crea para el segundo diseño otra hoja de
nombre “reg32x32”. El objetivo final de la primera parte de esta realización práctica
consiste en el diseño de un banco de registros de 8 registros de 32 bits como el de la
Figura 6-1. La Figura 6-3 muestra la plantilla para este primer diseño, que incluye
todos los componentes necesarios, pero no las interconexiones entre los componentes.
En la Figura 6-3 podemos distinguir 3 zonas: los registros, la lógica de
direccionamiento de lectura y la lógica de direccionamiento de escritura.
La Figura 6-4 muestra la lógica correspondiente a los 8 registros de 32 bits. Los
registros están construidos con componentes estándares de la librería. La señal CE
(clock enable) es la que permite la sincronización de la escritura.
La lógica de decodificación de las direcciones de lectura se muestra en la Figura 6-5.
Consta de dos multiplexores construidos con la herramienta “LogiBLOX Module
Generator” de Xilinx (el estudiante tiene que utilizar la herramienta y construir los
multiplexores). Cada multiplexor tiene 8 entradas de 32 bits.
La lógica de decodificación de la dirección de escritura se muestra en la Figura 6-6.
Consta de un decodificador de 3 a 8 con una señal de habilitación E conectada a la
señal WE del banco de registros. Un valor 0 en esta señal inhabilita el decodificador,
por lo que todas las salidas del decodificador estarán a 0.
90
Una vez acabado el diseño comprueba el funcionamiento del mismo. Por ejemplo,
realiza un ciclo de escritura que escriba un valor 5 en el registro $5, luego otro ciclo
de escritura que escriba un valor 6 en el registro $6, y finalmente un ciclo de sólo
lectura que lea los registros $5 y $6. La Figura 6-7 muestra el resultado de la
simulación descrita anteriormente. En esta simulación se han utilizado opciones
avanzadas para añadir los estímulos a las señales de entrada. Mientras que la señal de
reloj C tiene asignado el bit 0 del contador, la señal WE tiene asignada la tecla “w” del
teclado, por lo que cada pulsación de dicha tecla cambia el valor de la señal de 0 a 1 o
de 1 a 0 (ver la Figura 6-8). El resto de las señales de entrada utiliza la opción bus de
la ventana “Stimulator State Selection” (ver la Figura 6-9).
Figura 6-3 Plantilla para el diseño de un banco de 8 registros de 32 bits con 2

puertos de lectura y uno de escritura. Incluye los componentes necesarios, pero
no incluye las interconexiones entre ellos.
Figura 6-4 Lógica de 8 registros de 32 bits. Los registros están construidos a

partir de componentes de la librería y tienen una entrada CE (clock enable)
para sincronizar las escrituras.
91
Figura 6-5 Lógica de decodificación de las direcciones de lectura. Consta de dos

multiplexores construidos con la herramienta “LogiBLOX Module Generator”.
Cada multiplexor tiene 8 entradas de 32 bits. El estudiante tiene que construir
con la herramienta los multiplexores.
Figura 6-6 Lógica de direccionamiento del puerto de salida. Consta de un

decodificador de 3 a 8 con una señal de habilitación (E) que se ha conectado a
la señal WE del puerto de escritura. Cuando la señal WE está inactiva (0) el
decodificador no decodifica (todas las salidas valen 0).
92
Figura 6-7 Simulación de dos ciclos de escritura y uno de lectura. En el primer

ciclo de escritura, se escribe un 5 en el registro $5; en el segundo ciclo se escribe
un 6 en el registro $6. En el ciclo de lectura, se leen los dos registros, el registro
$5 y el registro $6.
Figura 6-8 Ventana de selección de estímulos. Para asociar una tecla del teclado
a una señal, selecciona la señal y luego la tecla. Cada vez que pulses la tecla en
el teclado del ordenador durante la simulación el estado binario de la señal
cambiará.
Figura 6-9 Ventana del simulador para la asignación de un valor a un bus. Esta
ventana la abrimos con un click en el botón “Logical States” que está en
la barra de herramientas del simulador lógico.
Banco de registros de 32 registros de 32 bits con 2 puertos de lectura y

uno de escritura
Existen diferentes alternativas de diseño para un banco de registros de 32 registros de
32 bits con dos puertos de lectura y uno de escritura. Una posibilidad directa consistiría
en la adaptación de las capacidades del diseño del apartado anterior. Bastaría con poner
32 registros en lugar de 8 registros, y ampliar las entradas y salidas en el decodificador
y los multiplexores. El inconveniente de esta propuesta es su falta de escalabilidad.
Los multiplexores y decodificadores tienen muchas entradas en el nivel más bajo, en
el nivel de las puertas lógicas, lo que los hace inviables en la práctica. Otra solución
más elegante y menos directa es la combinación del diseño modular y jerárquico con
93
la utilización de las técnicas de escalabilidad horizontal y vertical para el diseño de los

componentes de memoria. En este caso, utilizaremos únicamente las técnicas de
escalabilidad vertical o en altura, ya que el ancho de 32 bits del componente de 8
registros es de 32 bits y hace innecesario el escalado horizontal.
Funcionalmente el diseño a realizar es equivalente al de la Figura 6-1, pero con 5 bits
para las líneas de direccionamiento en lugar de 3 bits ya que direccionan 32 registros
en lugar de 8 (ver la Figura 6-10).
Figura 6-10 Diagrama funcional de un banco de registros de 32 registros de 32

bits con 2 puertos de lectura y uno de escritura.
La Figura 6-11 muestra una plantilla con los componentes (sin todas las conexiones)
para el diseño del banco de registros de 32 registros de 32 bits. Otra vez, la estructura
está organizada en 3 partes: los registros (formados por los 4 bancos de registros de 8
registros de 32 bits), la lógica de escritura y la lógica de lectura. La lógica de escritura
puede verse en la Figura 6-12. El elemento clave es el decodificador de 2 a 4 que toma
como entradas los 2 bits más altos de direccionamiento del puerto de escritura (que
son visibles en la figura). Estas dos señales determinan el módulo a escribir mientras
que los 3 bits inferiores de la señal WA se utilizarán para direccionar el registro dentro
del submódulo. El diseño muestra cómo la señal WE habilita o deshabilita las
escrituras. La lógica de lectura está compuesta por 2 multiplexores de 4 a 1 de 32 bits
realizados con la herramienta “LogiBLOX Module Generator” (el estudiante tiene que
construirlos), y encapsulados como módulos de la librería para ocupar menos espacio
en la hoja del esquema (ver la Figura 6-13).
La parte práctica consiste en completar las conexiones y construir un componente
modular que sea instanciable como un elemento más de la librería para el banco de 32
registros de 32 bits y comprobar el funcionamiento correcto del diseño. Realiza la
prueba del diseño utilizando lecturas y escrituras en registros que estén ubicados en
diferentes submódulos.
La Figura 6-14 muestra un intervalo de tiempo de la simulación (entre los 180ns y
190ns). En el cronograma apreciamos que en el primer ciclo la escritura se realiza en
el registro $18, y las lecturas en los registros $17 y $18. El valor del registro $17 es 16
durante todo el ciclo, mientras que el del registro $18 cambia de 0 a 17. En el ciclo
94
siguiente el registro $18 tiene el valor constante 17 y el que cambia de valor 0 a 18 es

el registro $19.
Nota: Como trabajo adicional en esta práctica se puede realizar el diseño de un banco
de registros de más de 32 registros usando los módulos anteriores, siguiendo la misma
filosofía. Por otro lado, también se puede plantear el diseño de un banco de registros
de 8 registros donde cada registro almacene 64 bits de datos, utilizando el módulo del
banco de registros de 8 registros de 32 bis cada uno como módulo básico.
Figura 6-11 Plantilla para diseñar un banco de 32 registros de 32 bits a partir

de módulos de bancos de 8 registros de 32 bits utilizando la técnica de escalado
vertical para los componentes de memoria.
95
Figura 6-12 Lógica de escritura del banco de registros. Incluye un

decodificador para la selección del submódulo adecuado del banco de 8
registros.
Figura 6-13 Lógica de lectura del banco de 32 registros de 32 bits. Está diseñada
a partir de multiplexores 4 a 1 de 32 bits construidos con la herramienta
“LogiBLOX Module Generator”.
96
Figura 6-14 Simulación del banco de 32 registros de 32 bits. La señal de escritura WE está activa durante los dos ciclos
de reloj mostrados, lo que indica que los dos ciclos son de escritura. En el primer ciclo de reloj el registro $18 es escrito
y luego el registro $19 tal y como muestra la señal WA4. Los valores a escribir son 17 y 18, respectivamente. El registro
$18 cambia en el primer ciclo del valor 0 al 17. El registro $19 cambia del valor 0 a 18 durante el segundo ciclo.
97
1. ¿Cómo se asocia un estímulo a una señal de teclado? ¿Qué ocurre cuando
pulsamos la tecla asociada con el valor de la señal?
2. ¿Cómo se le asigna un valor constante a una señal que es un bus?
3. ¿Qué es un banco de registros?
4. ¿Qué es la herramienta “LogiBLOX Module Generator”?
5. ¿Cuáles son los parámetros de diseño de un banco de registros?
6. Calcula el número de señales de direccionamiento para un banco de 16
registros de 64 bits.

1. Incluye y explica tu diseño del banco de 8 registros de 32 bits.
2. Incluye y explica tu cronograma equivalente al de la Figura 6-2.
3. Incluye y explica tu diseño del banco de 32 registros de 32 bits.
4. Incluye y explica tu cronograma equivalente al de la Figura 6-14.
5. ¿Cómo diseñarías un banco de registros de 64 registros de 64 bits? ¿Cómo
lo probarías?
6. ¿Qué modificaciones habría que hacer para que el banco de registros se lea
en el flanco de bajada de la señal de reloj y se escriba en el flanco de subida?
Este es un requisito necesario para el diseño segmentado del procesador.
98
Errores más frecuentes

Índice
Errores generales 99
Errores en el editor esquemático 99
Errores en el simulador 100
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
99
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 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
100
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.
4. Aparece una señal con el valor X (desconocido) o Z (alta impedancia). Las causas
pueden ser las descritas en Errores en el editor esquemático. Otra posible causa
más es haber conectado un estímulo a una señal de salida.
101

Libro Prácticas Gii FC 2019 v03

Cargado por

Copyright:

Formatos disponibles

Libro Prácticas Gii FC 2019 v03

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Libro Prácticas Gii FC 2019 v03

Cargado por

Copyright:

Formatos disponibles

Prácticas de

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

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

Práctica 3: Diseño modular y jerárquico ............................................................... 33

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

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

Práctica 6: Componentes de memoria ................................................................... 87

Errores más frecuentes ............................................................................................ 99

XILINX´s Foundation Series Software

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

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

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

Figura 1-2 Ventana del gestor de proyectos.

Paso 2. Inicio de un nuevo proyecto

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

Figura 1-4 Inicialización del proyecto NAND.

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

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

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

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

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

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.

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

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

Figura 1-11 Esquema completo del circuito.

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

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

Paso 4. Simulación funcional del diseño

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

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

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,

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

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

Figura 1-18 Resultado de la simulación

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

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

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

Sumador binario de un bit

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

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

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

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

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

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

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

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

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

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

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

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

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

Creamos ahora una netlist usando OptionsCreate Netlist... y la exportamos en el