Diseño FPGA VHDL

Diseño básico en FPGA con VHDL
Manual del participante

Contenido
PRESENTACIÓN.................................................................................................................................... 4
OBJETIVO DEL CURSO.......................................................................................................................... 5
1 INTRODUCCIÓN ........................................................................................................................... 6
1.1 Dispositivos lógicos programables (PLD)............................................................................. 6
1.1.1 Estructura interna de un PLD .......................................................................................... 8
1.2 Arreglo Lógico Genérico (GAL) .......................................................................................... 10
1.2.1 Programación de un arreglo GAL .................................................................................. 10
1.3 Macroceldas lógicas de salida ........................................................................................... 11
1.4 Dispositivos lógicos programables complejos (CPLD) ....................................................... 12
1.4.1 Arreglos de compuertas programables en campo (FPGA) ............................................ 13
1.5 Metodología de diseño con FPGA's................................................................................... 15
1.6 Configuración y uso del software y hardware FPGA......................................................... 16
1.7 Breve historia del lenguaje VHDL ...................................................................................... 16
2 TARJETA DE DESARROLLO NEXYS 2 ........................................................................................... 18
2.1 Características generales................................................................................................... 18
2.2 Verificación de funcionamiento ........................................................................................ 20
3 ORGANIZACIÓN DE VHDL .......................................................................................................... 22
3.1 Unidades básicas de diseño .............................................................................................. 22
3.2 Entidad .............................................................................................................................. 22
3.2.1 Puertos de entrada y salida........................................................................................... 23
3.2.2 Modos............................................................................................................................ 24
3.2.3 Tipos de datos ............................................................................................................... 24
3.2.4 Declaración de entidades.............................................................................................. 25
3.2.5 Identificadores............................................................................................................... 26
3.2.6 Diseño de entidades mediante vectores....................................................................... 26
3.2.7 Declaración de entidades mediante librerías y paquetes............................................. 28
3.3 Paquetes............................................................................................................................ 28
3.4 Arquitecturas..................................................................................................................... 29
3.4.1 Descripción funcional .................................................................................................... 29
1
3.4.2 Descripción por flujo de datos ...................................................................................... 31
4 AMBIENTE DE TRABAJO XILINX ISE DESIGN SUITE 12.1 ............................................................ 33
4.1 Arranque del programa..................................................................................................... 33
4.2 Creación de proyecto ........................................................................................................ 35
4.3 Creación de un archivo fuente HDL................................................................................... 38
4.4 Implementación en la tarjeta Nexys2 ............................................................................... 44
Ejercicio 4.1.- Creación de un proyecto .................................................................................... 46
5. DISEÑO LÓGICO COMBINACIONAL EN VHDL ............................................................................ 47
5.1. Programación de estructuras básicas mediante declaraciones concurrentes.................. 47
5.1.1. Declaraciones condicionales asignadas a una señal (when-else) ................................. 47
Ejercicio 5.1.-Primer ejercicio con declaración When-Else....................................................... 48
Ejercicio 5.2.-Segundo ejercicio con declaración When-Else.................................................... 49
5.1.2. Operadores lógicos........................................................................................................ 49
5.1.3. Declaraciones concurrentes asignadas a señales ......................................................... 49
Ejercicio 5.3.- Circuito lógico con compuertas .......................................................................... 50
Ejercicio 5.4.- Segundo circuito lógico con compuertas ........................................................... 50
5.1.4. Selección de una señal (with-select-when)................................................................... 50
Ejercicio 5.5. - Declaración With-Select-When ......................................................................... 51
Ejercicio 5.6.- Implementación de tabla de verdad .................................................................. 51
5.2. Programación de estructuras básicas mediante declaraciones secuenciales................... 52
5.2.1 Declaración if-then-else (si-entonces-si no)..................................................................... 52
Ejercicio 5.7.- Comparador de 2 bits ......................................................................................... 54
5.2.2 Operadores relacionales .................................................................................................. 54
5.3. Buffers triestado................................................................................................................ 54
Ejercicio 5.8.- Buffer triestado .................................................................................................. 55
5.4. Multiplexores .................................................................................................................... 55
5.5. Sumadores......................................................................................................................... 57
Ejercicio 5.9.- Medio Sumador .................................................................................................. 58
5.5.1. Diseño de un sumador completo .................................................................................. 58
Ejercicio 5.10.- Sumador completo ........................................................................................... 60
5.6. Decodificador de BCD a display de siete segmentos ........................................................ 60
Ejercicio 5.11.- Decodificador BCD a siete segmentos.............................................................. 62
2
6 DISEÑO LÓGICO SECUENCIAL EN VHDL..................................................................................... 63
6.1 Sistema secuencial ............................................................................................................ 63
6.2 Flip-flops............................................................................................................................ 64
6.2.1 Flip-Flop D ........................................................................................................................ 64
6.3 Atributo event ................................................................................................................... 65
Ejercicio 6.1.- Implementación del Flip-Flop D.......................................................................... 65
6.4 Flip-Flop SR.............................................................................................................................. 66
Ejercicio 6.2.- Implementación del Flip-Flop SR ........................................................................ 67
6.5 Registros............................................................................................................................ 67
Ejercicio 6.3.- Registro paralelo de 8 bits .................................................................................. 68
6.6 Contadores ........................................................................................................................ 68
Ejercicio 6.4.- Contador binario de 4 bits.................................................................................. 69
7. VHDL ESTRUCTURAL.................................................................................................................. 71
7.1. Creación de un diseño estructural .................................................................................... 71
Ejercicio 7.1 Diseño estructural................................................................................................. 73
7.2. Divisor de frecuencia......................................................................................................... 73
Ejercicio 7.2 Implementación de un divisor de frecuencia ....................................................... 75
Ejercicio 7.3 Contador de 4 bits con divisor de frecuencia ....................................................... 75
8. Simulación de diseños ................................................................................................................... 76
8.1 Creación de un archivo de prueba .......................................................................................... 76
8.2 Arranque de la aplicación ModelSim XE ................................................................................. 80
8.3 Revisión de la simulación ........................................................................................................ 82
Ejercicio 8.1 Simulación de un Flip-Flop D ................................................................................ 83
Ejercicio 8.2 Simulación de un divisor de frecuencia ................................................................ 83
Ejercicio 8.3 Simulación de un contador de 4 bits con divisor de frecuencia ........................... 83
9. Máquina de estados en VHDL ....................................................................................................... 84
9.1 Definición de máquina de estados.......................................................................................... 84
9.2 Diseño de una máquina de estados Moore ............................................................................ 86
Ejercicio 9.1 Simulación de una máquina de estados ............................................................... 90
Ejercicio 9.2 Contador de 3 bits con máquina de estados ........................................................ 90
BIBLIOGRAFIA.................................................................................................................................... 91
3
PRESENTACIÓN
El lenguaje de descripción de hardware VHDL es considerado como una de las máximas
herramienta de diseño por las industrias y universidades de todo el mundo, pues
proporciona a los usuarios muchas ventajas de la planeación y diseño de los sistemas
electrónicos digitales.
Este curso abarca los conocimientos básicos para comenzar a diseñar en VHDL haciendo
uso de la tarjeta de desarrollo Nexys 2, sin embargo, dichos conocimientos son aplicables
también para cualquier otra tarjeta de desarrollo de la marca Digilent, Inc, tales como la
Basys o la Basys 2 por mencionar solo algunas, ya que lo único que cambia es la ubicación
de los pines de entrada y de salida del FPGA.
En el primer capítulo se muestra una introducción a los diferentes dispositivos lógicos

programables (PLDs), una breve introducción al software utilizado para programar las
FPGAs Spartan 3 y Spartan 3E, así como una breve historia del lenguaje VHDL.
En el segundo capítulo se muestra las características generales de la tarjeta de desarrollo

Nexys 2.
El tercer capítulo trata acerca de las partes que conforman un diseño en VHDL, la entidad y
la arquitectura, así como las librerías que se utilizan.
En el cuarto capítulo se introduce al ambiente de desarrollo del software XILINX ISE

DESIGN SUITE 12.1, también se muestra como crear un proyecto y como implementarlo
en la tarjeta Nexys 2.
En el quinto capítulo se introduce al diseño lógico combinacional en VHDL, se muestran

los operadores lógicos, declaraciones concurrentes asignadas a señales y se realizan los
diseños de buffers, multiplexores, sumadores y un decodificador.
El uso del reloj interno de la tarjeta para el diseño lógico secuencial se muestra en el
capítulo 6, en el cual se muestra el diseño de flip-flops, registros y contadores.
Una introducción a VHDL estructural se muestra en el capítulo 7, en la cual se hace énfasis

en la importancia de esta metodología para reducir el tiempo de diseño de algún proyecto
entre otras ventajas.
El capítulo ocho muestra la manera de simular nuestros diseños desarrollados haciendo uso
del software ModelSIM.
Por último en el capítulo nueve se muestra los elementos básicos que conforman una
máquina de estados en VHDL.
4
OBJETIVO DEL CURSO

El participante comprenderá y aplicará los principios básicos del lenguaje VHDL haciendo
uso de una tarjeta de desarrollo basada en un FPGA de manera adecuada.
5
1 INTRODUCCIÓN
Objetivo de la unidad
El participante identificará las características principales de los dispositivos lógicos

programables y del lenguaje VHDL mediante la presentación de dichos temas de acuerdo al
plan de sesión.
En la actualidad el nivel de integración alcanzado con el desarrollo de la microelectrónica

ha hecho posible desarrollar sistemas completos dentro de un solo circuito integrado SOC
(System On Chip), con lo cual se han mejorado de manera notoria características como
velocidad, confiabilidad, consumo de potencia y sobre todo el área de diseño. Esta última
característica nos ha permitido observar día a día cómo los sistemas de uso industrial,
militar y de consumo han minimizado el tamaño de sus desarrollos.
El proceso de miniaturización de los sistemas electrónicos comenzó con la interconexión de

elementos discretos como resistencias, capacitores, resistores, bobinas, etc., todos
colocados en un chasis reducido y una escasa separación entre ellos. Posteriormente se
diseñaron y construyeron los primeros circuitos impresos, que relacionan e interconectan
los elementos mencionados a través de cintas delgadas de cobre adheridas a un soporte
aislante (por lo general baquelita) que permite el montaje de estos elementos.
Más tarde, el desarrollo del transistor de difusión planar, construido durante 1947 y 1948,
permitió en 1960 la fabricación del primer circuito integrado monolítico. Este integra
cientos de transistores, resistencias, diodos y capacitores, todos fabricados sobre una
pastilla de silicio. Como es del conocimiento general, el término monolítico se deriva de las
raíces griegas "mono" y "lithos" que significan uno y piedra, respectivamente; por tanto,
dentro de la tecnología de los circuitos integrados un circuito monolítico está construido
sobre una piedra única o cristal de silicio que contiene tanto elementos activos (transistores,
diodos), como elementos pasivos (resistencias, capacitores), y las conexiones entre ellos.
1.1 Dispositivos lógicos programables (PLD)
Los dispositivos lógicos programables (o PLD, por sus siglas en inglés) favorecen la
integración de aplicaciones y desarrollos lógicos mediante el empaquetamiento de
soluciones en un circuito integrado. El resultado es la reducción de espacio físico dentro de
la aplicación; es decir, se trata de dispositivos fabricados y revisados que se pueden
personalizar desde el exterior mediante diversas técnicas de programación. El diseño se
basa en bibliotecas y mecanismos específicos de mapeado de funciones, mientras que su
6
implementación tan sólo requiere una fase de programación del dispositivo que el diseñador
suele realizar en unos segundos.
En la actualidad, el diseño de ASIC (circuitos integrados desarrollados para aplicaciones

específicas) domina las tendencias en el desarrollo de aplicaciones a nivel de
microelectrónica. Este diseño presenta varias opciones de desarrollo, sin embargo, su
diseño ahora sólo es adecuado en aplicaciones que requieren un alto volumen de
producción; por ejemplo, sistemas de telefonía celular, computadoras portátiles, cámaras de
video, etcétera.
Los FPGA (arreglos de compuertas programables en campo) y CPLD (dispositivos lógicos

programables complejos) ofrecen las mismas ventajas de un ASIC, sólo que a un menor
costo; es decir, el costo por desarrollar un ASIC es mucho más alto que el que precisaría un
FPGA o un CPLD, con la ventaja de que ambos son circuitos reprogramables, en los cuales
es posible modificar o borrar una función programada sin alterar el funcionamiento del
circuito.
En la actualidad existe una gran variedad de dispositivos lógicos programables, los cuales
se usan para reemplazar circuitos SSI (pequeña escala de integración), MSI (mediana escala
de integración) e incluso circuitos VLSI (muy alta escala de integración), ya que ahorran
espacio y reducen de manera significativa el número y el costo de los diseños. Estos
dispositivos, llamados PLD (tabla 1.1), se clasifican por su arquitectura, es decir, la forma
funcional en que se encuentran ordenados los elementos internos que proporcionan al
dispositivo sus características.
Tabla 1.1 Dispositivos lógicos programables
7
1.1.1 Estructura interna de un PLD
Los dispositivos PROM, PLA, PAL y GAL están formados por arreglos o matrices que
pueden ser fijos o programables, mientras que los CPLD y FPGA se encuentran
estructurados mediante bloques lógicos configurables y celdas lógicas de alta densidad,
respectivamente.
La arquitectura básica de un PLD está formada por un arreglo de compuertas AND y OR

conectadas a las entradas y salidas del dispositivo. La finalidad de cada una de ellas se
describe a continuación.
a) Arreglo AND. Está formado por varias compuertas AND interconectadas a través de
alambres, los cuales cuentan con un fusible en cada punto de intersección (Figura 1.1a). En
esencia, la programación del arreglo consiste en fundir o apagar los fusibles para eliminar
las variables que no serán utilizadas (Figura 1.1b). Obsérvese cómo en cada entrada a las
compuertas AND queda intacto el fusible que conecta la variable seleccionada con la
entrada a la compuerta. En este caso, una vez que los fusibles se funden no pueden volver a
programarse.
Figura 1.1 Arreglos AND: a) no programado y b) programado
8
b) Arreglo OR. Está formado por un conjunto de compuertas OR conectadas a un arreglo

programable, el cual contiene un fusible en cada punto de intersección. Este tipo de arreglo
es similar al de compuertas AND explicado en el punto anterior, ya que de igual manera se
programa fundiendo los fusibles para eliminar las variables no utilizadas. En la figura 1.2 se
observa el arreglo OR programado y sin programar.
Figura 1.2 Estructura básica de PLD

De acuerdo con lo anterior, observemos en la tabla 1.2 la estructura de los dispositivos
lógicos programables básicos.
Tabla 1.2Dispositivos lógicos programables

9
• La PROM no se utiliza como un dispositivo lógico, sino como una memoria

direccionable, debido a las limitaciones que presenta con las compuertas AND fijas.
• En esencia, el PLA se desarrolló para superar las limitaciones de la memoria PROM. Este
dispositivo se llama también FPLA (arreglo lógico programable en campo), ya que es el
usuario y no el fabricante quien lo programa.
• El PAL se desarrolló para superar algunas limitaciones del PLA, como retardos
provocados por la implementación de fusibles adicionales, que resultan de la utilización de
dos arreglos programables y de la complejidad del circuito. Un ejemplo típico de estos
dispositivos es la familia PAL16R8, la cual fue desarrollada por la compañía AMD
(Advanced Micro Devices) e incluye los dispositivos PAL16R4, PAL16R6, PAL16L8,
PAL16R8, dispositivos programables por el usuario para reemplazar circuitos
combinacionales y secuenciales SSI y MSI en un circuito.
1.2 Arreglo Lógico Genérico (GAL)
El arreglo lógico genérico (GAL) es similar al PAL, ya que se forma con arreglos AND
programable y OR fijo, con una salida lógica programable. Las dos principales diferencias
entre los dispositivos GAL y PAL radican en que el primero es reprogramable y contiene
configuraciones de salida programables.
Los dispositivos GAL se pueden programar una y otra vez, ya que usan la tecnología E2
CMOS (Ellectrically Erasable CMOS: CMOS borrable eléctricamente), en lugar de
tecnología bipolar y fusibles (Fig. 1.3).
Figura 1.3Diagrama de bloques del arreglo GAL
1.2.1 Programación de un arreglo GAL
A diferencia de un PAL, el GAL está formado por celdas programables, las cuales se
pueden reprogramar las veces que sea necesario. Como se observa en la figura 1.4, cada fila
se conecta a una entrada de la compuerta AND y cada columna a una variable de entrada y
10
sus complementos. Cuando se programa una celda, ésta se activa mediante la aplicación de
cualquier combinación de las variables de entrada o sus complementos a la compuerta
AND. Esto permite la implementación de cualquier función (producto de términos)
requerida.
Figura 1.4 Programación del dispositivo GAL
1.3 Macroceldas lógicas de salida
Una macrocelda lógica de salida (u OLMC, de output logic macrocell) está formada por
circuitos lógicos que se pueden programar como lógica combinacional o secuencial. Las
configuraciones combinacionales se implementan por medio de programación, mientras
que en las secuenciales la salida resulta de un flip-flop. En la figura 1.5 se observa la
arquitectura de una macrocelda del dispositivo GAL22V10, la cual de manera general está
formada por un flip-flop y dos multiplexores.
Figura 1.5Arquitectura de una macrocelda OLMC 22V1O
11
Puede haber de ocho a dieciséis entradas de las compuertas AND en la compuerta OR. Esto
indica las operaciones producto que pueden efectuarse en cada macrocelda. El área
punteada está formada por dos multiplexores y un flip-flop; el multiplexor 1 de 4 conecta
una de sus cuatro líneas de entrada al buffer triestado de salida, en función de las líneas de
selección SO y SI.
Por otro lado, el multiplexor de 1 de 2 conecta por medio del buffer la salida del flip-flop o
la salida del buffer triestado al arreglo AND; esto se determina por medio de S1. Cada una
de las líneas de selección se programa mediante un grupo de celdas especiales que se
encuentran en el arreglo AND.
1.4 Dispositivos lógicos programables complejos (CPLD)
Un circuito CPLD consiste en un arreglo de múltiples PLD agrupados como bloques en un

chip. En algunas ocasiones estos dispositivos también se conocen como EPLD (Enhanced
PLD: PLD mejorado), Super PAL, Mega PAL, etc. Se califican como de alto nivel de
integración, ya que tienen una gran capacidad equivalente a unos 50 PLD sencillos.
En su estructura básica, cada CPLD contiene múltiples bloques lógicos (similares al

GAL22V10) conectados por medio de señales canalizadas desde la interconexión
programable (PI). Esta unidad PI se encarga de interconectar los bloques lógicos y los
bloques de entrada/salida del dispositivo sobre las redes apropiadas (Fig. 1.6).
Figura 1.6Arquitectura básica de un CPLD
Los bloques lógicos, también conocidos como celdas generadoras de funciones, están
formados por un arreglo de productos de términos que implementa los productos efectuados
en las compuertas AND, un esquema de distribución de términos que permite crear las
sumas de los productos provenientes del arreglo AND y por macroceldas similares a las
incorporadas en la GAL22V10 Cabe mencionar que el tamaño de los bloques lógicos es
importante, ya que determina cuánta lógica se puede implementar dentro del CPLD; esto
es, fija la capacidad del dispositivo.
12
1.4.1 Arreglos de compuertas programables en campo (FPGA)
Los dispositivos FPGA se basan en lo que se conoce como arreglos de compuertas, los
cuales consisten en la parte de la arquitectura que contiene tres elementos configurables:
bloques lógicos configurables (CLB), bloques de entrada y de salida (IOB) y canales de
comunicación. A diferencia de los CPLD, la densidad de los FPGA se establece en
cantidades equivalentes a cierto número de compuertas.
Por adentro, un FPGA está formado por arreglos de bloques lógicos configurables (CLB),
que se comunican entre ellos y con las terminales de entrada/ salida (E/S) por medio de
alambrados llamados canales de comunicación. Cada FPGA contiene una matriz de bloques
lógicos idénticos, por lo general de forma cuadrada, conectados por medio de líneas
metálicas que corren vertical y horizontalmente entre cada bloque (Fig. 1.7).
Figura 1.7 Arquitectura básica de un FPGA
En la figura 1.8 se puede observar una arquitectura FPGA de la familia XC4000 de la

compañía Xilinx. Este circuito muestra a detalle la configuración interna de cada uno de los
componentes principales que conforman este dispositivo.
13
Figura 1.8 Arquitectura del FPGA XC4000 de Xilinx
Los bloques lógicos (llamados también celdas generadoras de funciones) están

configurados para procesar cualquier aplicación lógica. Estos bloques tienen la
característica de ser funcionalmente completos; es decir, permiten la implementación de
cualquier función booleana representada en la forma de suma de productos. El diseño
lógico se implementa mediante bloques conocidos como generadores de funciones o LUT
(Look Up Table: tabla de búsqueda), los cuales permiten almacenar la lógica requerida, ya
que cuentan con una pequeña memoria interna, por lo general de 16 bits.
Cuando se aplica alguna combinación en las entradas de la LUT, el circuito la traduce en

una dirección de memoria y envía fuera del bloque el dato almacenado en esa dirección. En
la figura 1.9 se observan los tres LUT que contiene esta arquitectura, los cuales se
encuentran etiquetados con las letras G, F y H.
Figura 1.9 Arquitectura de un bloque lógico configurable FPGA
14
En un dispositivo FPGA, los CLB están ordenados en arreglos de matrices programables

(Programmable Switch Matrix o PSM), la matriz se encarga de dirigir las salidas de un
bloque a otro. Las terminales de entrada y salida del FPGA pueden estar conectadas
directamente al PSM o CLB, o se pueden conectar por medio de vías o canales de
comunicación.
En algunas ocasiones se pueden confundir los dispositivos de FPGA y CPLD, ya que

ambos utilizan bloques lógicos en su fabricación. La diferencia entre ellos radica en el
número de flip-flops utilizados, mientras la arquitectura del FPGA es rica en registros.
1.5 Metodología de diseño con FPGA's
La metodología de diseño es similar a la cualquier sistema digital, salvo que al final se

obtiene un archivo ejecutable que se descarga a la FPGA para que se reconfigure,
implementando así el diseño esperado.
Primero hay que tener una descripción del circuito a realizar. Tradicionalmente en las
ingenierías se realizan planos o esquemas para esta descripción, de forma similar a como
un arquitecto diseña un edificio. Sin embargo es posible realizar una descripción del
hardware utilizando algún lenguaje de descripción de hardware, como VHDL o Verilog
Con esta descripción se pueden realizar simulaciones del circuito, para comprobar que lo
diseñado trabaja correctamente de lo contrario se volverá a modificar la descripción
(esquemas ó programa) hasta que la simulación sea satisfactoria. Hasta aquí sólo se ha
utilizado la computadora y no se tocado hardware. Sin embargo en el caso del software, la
propia simulación es la ejecución del programa. Se observa directamente el resultado del
programa y se modifican el código fuente hasta que se eliminen los errores.
En el caso del hardware hay que construir el circuito. Y aquí es donde vienen las FPGA's
para hacerlo. A partir de la especificación hardware y utilizando un compilador especial,
obtenemos un archivo binario, llamado bitstream que contiene toda la información
necesaria para configurar la FPGA. Este archivo, que es el equivalente a un programa
ejecutable en el caso del software, es el que hay que cargar en la FPGA. Se carga este
archivo en la FPGA y listo. Ya se tiene el hardware que queríamos situado en el interior de
un chip. No se ha tenido que soldar, ni comprar componentes, ni perder tiempo haciendo un
prototipo. Ahora los cambios en el diseño se pueden hacer igual de rápidos que en el caso
de software. Sólo hay que cambiar la especificación del diseño, volver a compilar y
reconfigurar la FPGA con el nuevo bitstream generado.
La especificación de un circuito se realizaba sólo de una manera: utilizando esquemas

gráficos, en los que cada símbolo representa un componente o elemento lógico:
15
multiplexores, puertas lógicas, etc. Existe otra manera de describir un circuito: utilizando
los llamados lenguajes de descripción hardware. Existen varios: VHDL, Verilog, Handle
C, JBits. La ventaja de estos lenguajes es que además de permitir describir el circuito,
permiten definir bancos de pruebas (testbench), que son muy útiles para la simulación y la
depuración.
1.6 Configuración y uso del software y hardware FPGA

El software de diseño programación y simulación INTEGRATED
SOFTWAREENVIROMENT (ISE) 12.1es una herramienta útil para estudiantes y
profesionales que desean acelerar y mejorar sus habilidades para el desarrollo de
aplicaciones digitales empleando un entorno de programación gráfico o usando lenguaje
VHDL y realizar la simulación de su funcionamiento sin el riesgo de ocasionar daños a los
circuitos.
1.7 Breve historia del lenguaje VHDL
VHDL es el Lenguaje de Descripción de Hardware, que se desarrolló en los años de1980s

como un proyecto de investigación de circuito integrado de gran velocidad el cual fue
consolidado por el Departamento Americano de Defensa. Un equipo de ingenieros de tres
compañías - IBM, Texas Instruments e Intermetrics fue contratado por el Departamento de
Defensa para completar la especificación y aplicación de un nuevo idioma basado en
método de descripción de diseños digitales ideado por ellos.
La primera versión públicamente disponible de VHDL, versión 7.2, se liberó en 1985.En

1986, el Instituto de Ingenieros Eléctricos y Electrónicos (IEEE) se presentó con una
propuesta para estandarizar el idioma que hizo en 1987, después de que las mejoras
sustanciales y modificaciones fueron hechas por un equipo de gobierno y representantes
académicos. La norma resultante, IEEE 1076-1987, es la base virtual para cada simulación
y el producto de la síntesis vendido hoy. Una nueva versión mejoró el lenguaje, la IEEE
1076-1993, se lanzó en 1994.
Aunque IEEE Standard 1076 define el lenguaje de VHDL completo, hay aspectos del
lenguaje que hacen difícil la descripción completamente portátil del diseño (descripciones
que pueden simularse usando las herramientas de diferentes vendedores). El problema
proviene del hecho que VHDL soporta muchos tipos de datos abstractos, pero esto no se
dirige al problema simple de caracterizar señales diferentes o las condiciones de la
simulación normalmente usadas como los desconocidos y alta-impedancia.
16
Poco después IEEE 1076-1987 fue adoptada, las compañías de simuladores empezaron
reforzando VHDL con los nuevos tipos no estandarizados y permitirles a sus clientes
simular los circuitos electrónicos complejos con precisión. Esto causó problemas porque las
descripciones de un diseño entraron en un simulador donde a menudo eran incompatibles
con otros ambientes de simulación. VHDL estaba volviéndose no estandarizable
rápidamente creando un problema. Otra norma se desarrolló por un comité de IEEE. Esta
norma, numerada 1164, define un paquete estándar (un lenguaje VHDL que permite
coleccionar las declaraciones normalmente usadas en una biblioteca externa) conteniendo
las definiciones para un tipo de los datos normalizados. Este tipo de datos normalizado se
llama el std_logic, y el paquete1164 IEEE es frecuentemente llamado el paquete de la
Lógica estándar.
Las normas IEEE 1076-1987 e IEEE 1164 completan el estándar VHDL siendo elmás
usado hoy.
17
2 TARJETA DE DESARROLLO NEXYS 2

El participante identificará las características generales de la tarjeta de desarrollo Nexys 2

mediante la presentación de dicho tema de acuerdo al plan de sesión.
La tarjeta Nexys 2, es una plataforma de desarrollo completa y lista para usar basado en un
FPGA Xilinx Spartan 3E. Consta de un puerto USB 2.0 de alta velocidad, 16 Mbytes de
memoria RAM así como varios dispositivos y puertos de entrada/salida que la convierten
en una plataforma ideal para sistemas digitales de todo tipo, incluyendo sistemas
embebidos basados en el microprocesador Xilinx’s MicroBlaze.
2.1 Características generales
La Nexys2 contiene una FPGA de Xilinx modelo Spartan‐3E XC3S500E o XC3S1200E con
encapsulado FG320 (figura 2.1). Estas FPGA tienen respectivamente 500 000 o 1 200 000
puertas lógicas equivalentes.
Figura 2.1 Tarjeta Nexys2
18
Sus características principales son:
• FPGA Xilinx Spartan-3E, 500K puertas.

• Puerto USB2 para alimentación de la placa, configuración del dispositivo y transferencia
de datos a alta velocidad.
• Compatible con ISE/Webpack y EDK.
• Fast Micron PSDRAM de 16MB.
• Intel StrataFlash Flash de 16MB.
• Xilinx Platform Flash ROM.
Fuentes de alimentación conmutadas de alta eficiencia (adecuadas para aplicaciones
alimentadas por batería).
• Oscilador de 50MHz, además de un socket para la posible adición de un segundo
oscilador.
• 75 entradas/salidas de la FPGA enrutadas hacia los conectores de expansión (un conector
de alta velocidad Hirose FX2 con 43 señales y cuatro conectores Pmod 2×6).
• Todas las señales de entrada/salida son ESD y protegidas por circuito, asegurando una
larga vida de operación en cualquier tipo de ambiente de uso.
• Las entradas/salidas de la placa incluyen 8 LEDs, un display de cuatro dígitos de siete
segmentos, 4 pulsadores y 8 conmutadores.
La figura 2.2 muestra el diagrama a bloques de la tarjeta Nexys 2.
Figura 2.2 Diagrama a bloques tarjeta Nexys 2
En la figura 2.3 se muestran las conexiones en la placa de los pulsadores, interruptores

yLEDS. Analizando la figura podemos observar que al pulsar o conectar un interruptor
enviamos un ‘1’ al pin de la FPGA, y de manera análoga, los LED se encienden al poner un
‘1’ en el pin de la FPGA correspondiente. Por lo tanto, en la tarjeta Nexys2 se trabaja con
lógica directa con los pulsadores, interruptores y LED.
19
Como se puede apreciar, los pulsadores tampoco tienen circuitería de anulación de rebotes.
En la figura también se indican los pines de la FPGA que se conectan a éstos.
Figura 2.3Conexiones de los pulsadores, interruptores y LED de propósito general en la tarjeta Nexys2
2.2 Verificación de funcionamiento
Para garantizar el funcionamiento de las tarjetas se establece el siguiente protocolo de

revisión que permitirá conocer el estado del dispositivo. Descargar de la siguiente página
web: http://www.digilentinc.com/Products/Detail.cfm?Prod=NEXYS2 el archivo
demowithmemcfg.bit en la tarjeta. Una vez realizado esto la tarjeta debe encender
mostrando el mensaje PASS/128 (figura 2.4)
20
Figura 2.3 Verificación del correcto funcionamiento de la tarjeta Nexys 2
21
3 ORGANIZACIÓN DE VHDL
El participante reconocerá la organización básica de VHDL identificando las partes

principales de dicho lenguaje de acuerdo al plan de sesión.
Tal como se había indicado anteriormente, VHDL (Hardware Description Language) es un

lenguaje orientado a la descripción o modelado de sistemas digitales; es decir, se trata de un
lenguaje mediante el cual se puede describir, analizar y evaluar el comportamiento de un
sistema electrónico digital.
3.1 Unidades básicas de diseño
La estructura general de un programa en VHDL está formada por módulos o unidades de

diseño, cada uno de ellos compuesto por un conjunto de declaraciones e instrucciones que
definen, describen, estructuran, analizan y evalúan el comportamiento de un sistema digital.
Existen cuatro tipos de unidades de diseño en VHDL: declaración de entidad (entity
declaration), arquitectura (architecture), declaración del paquete (package declaration) y
cuerpo del paquete (package body). En el desarrollo de programas en VHDL pueden
utilizarse o no tres de los cinco módulos, pero dos de ellos (entidad y arquitectura) son
indispensables en la estructuración de un programa.
3.2 Entidad
Una entidad (entity) es el bloque elemental de diseño en VHDL, Las entidades son todos
los elementos electrónicos (sumadores, contadores, compuertas, flip-flops, memorias,
multiplexores, etc.) que forman de manera individual o en conjunto un sistema digital. La
entidad puede representarse de muy diversas maneras; por ejemplo, la figura 3.1a) muestra
la arquitectura de un sumador completo a nivel de compuertas; ahora bien, esta entidad se
puede representar a nivel de sistema indicando tan sólo las entradas (Cin, A y B) y salidas
(SUMA y Cout) del circuito: figura 3.1b). De igual forma, la integración de varios
subsistemas (medio sumador) puede representarse mediante una entidad [Fig. 3.1c)]. Los
subsistemas pueden conectarse internamente entre sí; pero la entidad sigue identificando
con claridad sus entradas y salidas generales.
22
Figura 3.1 a) Descripción a nivel de compuertas, b) Símbolo funcional de la entidad; c) Diagrama a

bloques representativo de la entidad.
3.2.1 Puertos de entrada y salida
Cada una de las señales de entrada y salida en una entidad son referidas como puerto, el
cual es similar a una terminal (pin) de un símbolo esquemático.
Todos los puertos que son declarados deben tener un nombre, un modo y un tipo de dato. El
nombre se utiliza como una forma de llamar al puerto; el modo permite definir la dirección
que tomará la información y el tipo define qué clase de información se transmitirá por el
puerto. Por ejemplo, respecto a los puertos de la entidad que representan a un comparador
de igualdad (Figura 3.2), las variables a y b denotan los puertos de entrada y la variable c se
refiere al puerto de salida.
Figura 3.2 Comparador de igualdad
23
3.2.2 Modos
Un modo permite definir la dirección en la cual el dato es transferido a través de un puerto.

Puede tener uno de cuatro valores: in (entrada), out (salida), inout (entrada/salida) y buffer
(Figura 3.3).
• Modo in. Se refiere a las señales de entrada a la entidad. Este sólo es unidireccional y
nada más permite el flujo de datos hacia dentro de la entidad.
• Modo out. Indica las señales de salida de la entidad.
• Modo inout. Permite declarar a un puerto de forma bidireccional —es decir, de
entrada/salida—; además permite la retroalimentación de señales dentro o fuera de la
entidad.
• Modo buffer. Permite hacer retroalimentaciones internas dentro de la entidad, pero a
diferencia del modo inout, el puerto declarado se comporta como una terminal de salida.
Figura 3.3 Modos y el curso de sus señales
3.2.3 Tipos de datos
Los tipos son los valores (datos) que el diseñador establece para los puertos de entrada y
salida dentro de una entidad; se asignan de acuerdo con las características de un diseño en
particular. Algunos de los tipos más utilizados en VHDL son:
• Bit El cual tiene valores de 0 y 1 lógico.
• Boolean (Booleano) que define valores de verdadero o falso en una expresión
• Bit_vector (Vectores de bits) que representa un conjunto de bits para cada variable de
entrada o salida.
• Integer (Entero) que representa un número entero.
• Std_logic Extensiones del tipo Bit, pueden tomar 9 valores diferentes:
‘U’ --No inicializado
‘X’ --Forzando valor desconocido
‘0’ --Forzando un 0
‘1’ --Forzando un 1
24
‘Z’ --Alta impedancia

‘L’ -- 0 Debil
‘H’ -- 1 Debil
‘-’ -- Sin importancia (don’t care)
• Std_logic_vector Vectores del std_logic
3.2.4 Declaración de entidades
Como se mencionó anteriormente, los módulos elementales en el desarrollo de un programa

dentro del lenguaje de descripción en hardware (VHDL) son la entidad y la arquitectura.
La declaración de una entidad consiste en la descripción de las entradas y salidas de un

circuito de diseño identificado como entity (entidad); es decir, la declaración señala las
terminales o pines de entrada y salida con que cuenta la entidad de diseño.
Por ejemplo, la forma de declarar la entidad correspondiente al circuito sumador de la

figura 3.1 se muestra a continuación:
1 --Declaración de la entidad de un circuito sumador

2entity sumador is
3port (A, B, Cin: in bit;
4 SUMA, Cout: out bit);
5end sumador;
Listado 3.1 Declaración de la entidad sumador de la figura 2.1b).
Los números de las líneas (1, 2, 3, 4, 5) no son parte del código; se usan como referencia
para explicar alguna sección en particular. Las palabras en negritas están reservadas para el
lenguaje de programación VHDL; esto es, tienen un significado especial para el programa;
el diseñador asigna los otros términos.
Ahora comencemos a analizar el código línea por línea. Observemos que la línea 1 inicia
con dos guiones (--), los cuales indican que el texto que está a la derecha es un comentario
cuyo objetivo es documentar el programa, ya que el compilador ignora todos los
comentarios. En la línea 2 se inicia la declaración de la entidad con la palabra reservada
entity, seguida del identificador o nombre de la entidad (sumador) y la palabra reservada is.
Los puertos de entrada y salida (port) se declaran en las líneas 3 y 4, respectivamente —en
este caso los puertos de entrada son A, B y Cin—, mientras que SUMA y Cout representan
los puertos de salida. El tipo de dato que cada puerto maneja es del tipo bit, lo cual indica
25
que sólo pueden manejarse valores de '0' y '1' lógicos. Por último, en la línea 5 termina la
declaración de entidad con la palabra reservada end, seguida del nombre de la entidad
(sumador).
Debemos notar que como cualquier lenguaje de programación, VHDL sigue una sintaxis y
una semántica dentro del código, mismas que hay que respetar. En esta entidad conviene
hacer notar el uso de punto y coma (;) al finalizar una declaración y de dos puntos (:) al
asignar nombres a las entradas y salidas.
3.2.5 Identificadores
Los identificadores son simplemente los nombres o etiquetas que se usan para referir
variables, constantes, señales, procesos, etc. Pueden ser números, letras del alfabeto y
guiones bajos ( _ ) que separen caracteres y no tienen una restricción en cuanto a su
longitud. Todos los identificadores deben seguir ciertas especificaciones o reglas para que
se puedan compilar sin errores, mismas que aparecen en la tabla 3.1.
Tabla 3.1 Especificaciones para la escritura de identificadores
3.2.6 Diseño de entidades mediante vectores
La entidad sumador realizada en el circuito del listado 3.1, usa bits individuales, los cuales
sólo pueden representar dos valores lógicos (0 o 1). De manera general, en la práctica se
utilizan conjuntos (palabras) de varios bits; en VHDL las palabras binarias se conocen
como vectores de bits, los cuales se consideran un grupo y no como bits individuales.
Como ejemplo considérense los vectores de 4 bits que se muestran a continuación:
vector_A = [A3, A2, Al, AO]

vector_B = [B3, B2, Bl, BO]
vector_SUMA = [S3, S2, SI, SO]
26
En la figura 3.4 se observa la entidad del sumador analizado antes, sólo que ahora las
entradas A, B y la salida SUMA incorporan vectores de 4 bits en sus puertos. Obsérvese
cómo la entrada Cin y la salida Cout son de un bit.
Figura 3.4 Entidad representada por vectores
La manera de describir en VHDL una configuración que utilice vectores consiste en la

utilización de la sentencia bit_vector, mediante la cual se especifican los componentes de
cada uno de los vectores utilizados. La parte del código que se usa para declarar un vector
dentro de los puertos es el siguiente:
port (vector_A, vector_B: in bit_vector (3 downto 0);

vector_SUMA: out bit_vector (3 downto 0));
Esta declaración define los vectores (A, B y SUMA) con cuatro componentes distribuidos
en orden descendente por medio del comando:
3 downto 0 (3 hacia 0) los cuales se agruparían de la siguiente manera.
vector_A(3) = A3 vector_B(3) = B3 vector_SUMA(3) = S3

vector_A(2) = A2 vector_B(2) = B2 vector_SUMA(2) = S2
vector_A(l) = Al vector_B(l) = B1 vector_SUMA(l) = SI
vector A(0) = A0 vector_B(0) = B0 vector SUMA(0) = S0
A continuación se describe en VHDL la entidad del circuito sumador representado en la

figura 2.4. Observe cómo la entrada Cin (Carry in) y la salida Cout (Carry out) se expresan
de forma individual.
entity sumador is
port (A,B: in bit_vector (3 downto 0);
Cin: in bit;
Cout: out bit;
SUMA: out bit_vector(3 downto 0));
end sumador;
27
3.2.7 Declaración de entidades mediante librerías y paquetes
Una parte importante en la programación con VHDL radica en el uso de librerías y

paquetes que permiten declarar y almacenar estructuras lógicas, seccionadas o completas
que facilitan el diseño.
Una librería o biblioteca es un lugar al que se tiene acceso para utilizar las unidades de
diseño predeterminadas por el fabricante de la herramienta (paquete) y su función es
agilizar el diseño. En VHDL se encuentran definidas dos librerías llamadas ieee y work.
Cuando en el diseño se utiliza algún paquete es necesario llamar a la librería que lo

contiene. Para esto se utiliza la siguiente declaración:
library ieee;
Lo anterior permite el uso de todos los componentes incluidos en la librería ieee. En el caso
de la librería de trabajo (work), su uso no requiere la declaración library, dado que la
carpeta work siempre está presente al desarrollar un diseño.
3.3 Paquetes
El paquete std_logic_1164 (estándar lógico_1164) que se encuentra en la librería ieee

contiene todos los tipos de datos que suelen emplearse en VHDL (std_logic_vector,
std_logic, entre otros).
El acceso a la información contenida en un paquete es por medio de la sentencia use,

seguida del nombre de la librería y del paquete, respectivamente:
use nombre_librería.nombre_paquete.all;
por ejemplo:
use IEEE.STD_LOGIC_1164.ALL;
El paquete “use IEEE.STD_LOGIC_ARITH.ALL”; define funciones y operadores

aritméticos, como igual (=), mayor que (>), menor que (<), entre otros.
28
3.4 Arquitecturas
Una arquitectura (architecture) se define como la estructura que describe el funcionamiento

de una entidad, de tal forma que permita el desarrollo de los procedimientos que se llevarán
a cabo con el fin de que la entidad cumpla las condiciones de funcionamiento deseadas.
La gran ventaja que presenta VHDL para definir una arquitectura radica en la manera en
que pueden describirse los diseños; es decir, mediante el algoritmo de programación
empleado se puede describir desde el nivel de compuertas hasta sistemas complejos.
3.4.1 Descripción funcional
En la figura 3.5 se describe funcionalmente el circuito comparador. Se trata de una

descripción funcional porque expone la forma en que trabaja el sistema; es decir, las
descripciones consideran la relación que hay entre las entradas y las salidas del circuito, sin
importar cómo esté organizado en su interior. Para este caso:
Figura 3.5Descripción funcional de un comparador de igualdad de dos bits
El código que representa el circuito de la figura 3.5 se muestra en el listado 3.2:
29
Listado 3.2 Arquitectura funcional de un comparador de igualdad de 2 bits
Nóte cómo la declaración de la entidad (entity) se describe en las líneas de la 1 a la 7; el

código ocupa de la línea 8 a la 18, donde se desarrolla el algoritmo (architecture) que
describe el funcionamiento del comparador. Para iniciar la declaración de la arquitectura
(línea 8), es necesario definir un nombre arbitrario con que se pueda identificar —en
nuestro caso el nombre asignado fue funcional— además de incluir la entidad con que se
relaciona (comp). En la línea 9 se puede observar el inicio (begin) de la sección donde se
comienzan a declarar los procesos que rigen el comportamiento del sistema.
La declaración del proceso (línea 10) se utiliza para la definición de algoritmos y comienza
con una etiqueta opcional (en este caso compara), seguida de dos puntos (:), la palabra
reservada process y une la lista sensitiva (a y b), que hace referencia a las señales que
determinan el funcionamiento del proceso. Al seguir el análisis, puede notarse que de la
línea 12 a la 17 el proceso se ejecuta mediante declaraciones secuenciales del tipo if-then-
else (si-entonces- si no). Esto se interpreta como sigue (línea 12): si el valor de la señal a es
igual al valor de la señal b, entonces '1' se asigna a c, si no (else)se asigna un '0' (el
símbolo < = se lee como "se asigna a"). Una vez que se ha definido el proceso, se termina
con la palabra reservada end process y de manera opcional el nombre del proceso
(compara); de forma similar se añade la etiqueta (funcional) al terminar la arquitectura en la
línea 18.
30
3.4.2 Descripción por flujo de datos
La descripción por flujo datos indica la forma en que los datos se pueden transferir de una
señal a otra sin necesidad de declaraciones secuenciales (if-then-else). Este tipo de
descripciones permite definir el flujo que tomarán los datos entre módulos encargados de
realizar operaciones. En este tipo de descripción se pueden utilizar dos formatos: mediante
instrucciones when else (cuando-si no) o por medio de ecuaciones booleanas.
a) Descripción por flujo de datos mediante when-else
A continuación se muestra el código del comparador de igualdad de dos bits descrito antes
(figura 3.6) Nótese que la diferencia entre los listados 3.2 y 3.3 radica en la eliminación del
proceso y en la descripción sin declaraciones secuenciales (if-then-else).
Listado 3.3 Arquitectura por flujo de datos
b) Descripción por flujo de datos mediante ecuaciones booleanas
Figura 3.6 a) Entidad del comparador de dos bits, b) Comparador de dos bits realizado con
compuertas.
Otra forma de describir el circuito comparador de dos bits es mediante la obtención de sus
ecuaciones booleanas. En el listado 3.4 se observa este desarrollo. El interior del circuito
31
comparador de la figura 3.6a) puede representarse por medio de compuertas básicas [Fig.
3.7b)] y este circuito puede describirse mediante la obtención de sus ecuaciones booleanas.
Listado 3.4 Arquitectura de forma de flujo de datos construido por medio de ecuaciones booleanas.
La forma de flujo de datos en cualquiera de sus representaciones describe el camino que los
datos siguen al ser transferidos de las operaciones efectuadas entre las entradas a y b a la
señal de salida c.
32
4 AMBIENTE DE TRABAJO XILINX ISE DESIGN SUITE 12.1
El participante identificará las características principales del ambiente de trabajo del

software Xilinx ISE mediante una práctica demostrativa de acuerdo al plan de sesión.
En este capítulo se describe la manera de utilizar el programa Xilinx ISE Design Suite,
como se encuentra constituido así como la creación de un nuevo proyecto y la creación del
archivo bit para descargarlo a la tarjeta de desarrollo Nexys 2.
4.1 Arranque del programa
Para comenzar crearemos un proyecto nuevo, primero arrancamos el programa Xilinx

Project Navigator, que se encuentra en Inicio→ Todos los Programas→ Xilinx ISE
12.1→Project Navigator (figura 4.1).
Figura 4.1. Pantalla inicial software Xilinx ISE
En la pantalla inicial del programa se observan cuatro (4) ventanas como muestra la Figura
4.2
33
Nos puede aparecer una ventana con el Tip of the day que son indicaciones que hace la
herramientas cada vez que la arrancamos. Damos clic en OK, con lo que se cierra dicha
ventana.
Figura 4.2. Descripción pantalla inicial software ISE 8.2i
La ventana 1 llamada Sources muestra los diferentes archivos fuente adicionados al

proyecto.
La ventana 2 llamada Processes muestra los diferentes procesos que se pueden realizar al
archivo fuente seleccionado en la ventana 1.
La ventana 3 es el área de trabajo para mostrar y/o editar los diferentes archivos fuente
seleccionados en la ventana 1.
La ventana 4 llamada Transcript muestra mensajes de estado de los diferentes procesos
ejecutados durante el diseño, es así como aquí aparecen las advertencias, los errores
detectados en la revisión de sintaxis, compilación y simulación de un diseño electrónico.
La forma corta para iniciar el Integrated Software Enviroment (ISE) es dar doble clic en el
icono del programa ISE mostrado en la Figura 4.3, el cual está ubicado en el escritorio.
34
Figura 4.3. Ícono del programa Xilinx ISE Design Suite 12.1
4.2 Creación de proyecto

Para crear el nuevo proyecto procedemos de la siguiente manera:
A.- Seleccione File >New Project. Como lo indica la Figura 4.4.
Figura 4.4 Creación de proyecto
La página de creación de nuevo proyecto aparece, aquí damos la información general del
proyecto de la siguiente manera:
Project Name: Especifique el nombre del proyecto.
Project Location: Especifique la localización del proyecto. Por defecto el nombre de la

carpeta es el mismo dado en el campo de nombre del proyecto. Para cambiar la ruta del
directorio haga clic en el botón ubicado al lado del campo Project Location y de la ruta
deseada.
NOTA: Cada proyecto debe tener su propia carpeta. Si múltiples proyectos quedan en la
misma carpeta pueden ocurrir conflictos.
Description: Permite escribir una descripción del proyecto.

35
Top-Level Source Type: Especifique el top-level source type. Seleccione HDL de la lista.
La Figura 4.5 muestra la pantalla del nuevo proyecto.
Figura 4.5 Pantalla del nuevo proyecto
En la configuración de los parámetros en un nuevo proyecto puede obtener ayuda para las
diferentes ventanas dando clic en el botón de More Info.
B.- Clic Next para moverse a la página de propiedades del dispositivo.
Use esta página (figura 4.6) para seleccionar el dispositivo y otra información del diseño de
su proyecto, seleccionar la herramienta de síntesis y lenguaje, y el simulador.
Product Category: Específica la categoría del producto según su aplicación. Esta selección
filtra las familias de dispositivos y dispositivos disponibles en los dos siguientes campos,
seleccionar All en este campo.
Family: Específica la familia de dispositivos, o arquitectura Xilinx, dentro del cual se

implementara su diseño, seleccionar Spartan 3E para la tarjeta Nexys 2.
36
Device: Especifique el dispositivo en el cual implementara su proyecto, escoja XC3S500E

si la tarjeta Nexys 2 es de 500K compuertas, si es de 1200K compuertas seleccionar
XC3S1200E. Como pudo darse cuenta, los números que se muestran después de la “S”
muestran el número de compuertas del FPGA Spartan 3E.
Package: Específica la presentación del dispositivo con respecto al número de entradas y

salidas. Escoja el FG320 para la tarjeta Nexys 2.
Speed: Especifíca la velocidad del dispositivo seleccionado. Para este caso escoja -4.
Top-Level Source Type: Especifica el tipo de fuente para el nivel de diseño.
Synthesis Tool: Especifíca la herramienta de síntesis y lenguaje de síntesis usado para su

diseño en este caso Xilinx Synthesis Technology (XST) es suministrado con ISE. Escoja
XST (VHDL/Verilog).
Simulator Especifica la herramienta usada para simulación.
Figura 4.6 Pantalla del nuevo proyecto
C. Haga clic en next nuevamente, así se muestra en pantalla el resumen de las propiedades
del nuevo proyecto creado (figura 4.7).
37
Figura 4.7 Ventana resumen de las propiedades del proyecto
Haga clic en finish, de esta manera el proyecto esta creado, En la ventana sources se
observa el icono del nuevo proyecto (figura 4.8).
Figura 4.8 Nuevo icono del proyecto
4.3 Creación de un archivo fuente HDL
En esta sección, se muestra la creación del archivo fuente HDL para el diseño, para lo cual
se procede como sigue:
38
A. Clic en New Source de la pestaña Project como muestra la

Figura 4.9.
Figura 4.9 Crear nuevo archivo fuente del proyecto
B Seleccione un tipo de archivo fuente de la lista dependiendo del dispositivo y diseño

especificado para su proyecto, para este caso seleccione VHDL Module como tipo de
fuente.
C. Digite en el campo file name el nombre iniciando por una letra (A-Z, a-z) y debe
contener solamente caracteres alfanuméricos (A-Z, a-z, 0-9) y underscores (_).
Location contiene la ruta del proyecto actual por defecto.
Verifique que la casilla Add to project este seleccionada, para adicionar el archivo fuente
al proyecto como muestra la figura 4.10, para información y ayuda detallada dar clic en
botón More Info
Figura 4.10 Selección tipo de fuente

39
D. Clic en Next.
E. Declare los puertos para el diseño de la compuerta con cuatro entradas y una salida, esta
se define seleccionando out, llenando la información como se muestra en la figura 4.11
Figura 4.11 Declarar entradas y salidas del proyecto

F. Clic Next.
En la figura 4.12 se observa el cuadro resumen del nuevo archivo fuente del proyecto que
se está realizando. Ahora damos clic en Finish
Figura 4.12 Resumen del nuevo archivo fuente
40
El archivo fuente contiene el par entidad / arquitectura visualizados en el espacio de

trabajo, como se muestra en la figura 4.13
Figura 4.13 Espacio de trabajo para editar archivo fuente
Como se pudo apreciar en la figura 4.13, no sólo se ha creado la entidad, sino que se han
incluido unas cabeceras, bibliotecas y la declaración de la arquitectura.
La cabecera es un apartado con comentarios para que lo rellenemos nosotros, para que
tengamos un control del autor, la fecha y la descripción del diseño, entre otra información.
Recuerda que en VHDL los comentarios se identifican con dos guiones “—”. Es interesante
que se rellene, especialmente si se trabaja en grupo. Pero incluso si se trabaja solo es
conveniente rellenarlo porque es común olvidarse de lo que se hace una vez que ha
transcurrido cierto tiempo.
Después de la cabecera se incluyen las referencias a las bibliotecas del IEEE, que son
necesarias para poder utilizar los tipos de datos que emplearemos.
Para muchos casos basta con utilizar la biblioteca IEEE.STD_LOGIC_1164.En general, se

recomienda utilizar la biblioteca NUMERIC_STD (figura 4.14 b) en vez de la
STD_LOGIC_ARITH (figura 4.14 a) para la realización de procesos matemáticos.
41
a) b)
Figura 4.14 Bibliotecas más usadas en VHDL
Después de las referencias a las bibliotecas hay unos comentarios que puedes quitar. A
continuación está la entidad. Para describir el funcionamiento o la estructura interna del
circuito se utiliza la arquitectura.
En la parte de la arquitectura escriba lo siguiente para generar una compuerta and:
Architecture Behavioral of New Source is

C<= A and B;
end Behavioral;
Una vez que se haya incluido el código de la estructura, se guarda el fichero y se

comprueba si se ha tenido algún error de sintaxis haciendo clic en Synthesize - XST→Check
Syntax. Esto está en la subventana de Processes (figura 4.15).
Figura 4.15 Comprobación de sintaxis
Si se tiene algún error, se debe localizar y corregir. Cuando no se tengan errores, se puede
hacer clic directamente en Synthesize - XST para sintetizar.
Una vez que hayamos sintetizado tenemos que indicar los pines de la FPGA que vamos a
utilizar y su correspondencia con los puertos de la entidad, esto se logra por medio de un
archivo con terminación UCF (User Constraints File), para lo cual se selecciona
Project>New Source y se escoge Implementation Constraints File, se le da un nombre y se
42
da clic en Next (Figura 4.16). Después aparece una pantalla de confirmación en la que se
debe dar clic en Finish.
Figura 4.16 Creación del archivo ucf

Una vez realizado esto, se verifica en la ventana sources que el archivo ha sido creado y se
da doble clic para abrir el archivo que contiene la localización de los pines del proyecto en
cuestión (Figura 4.17).
Figura 4.17 Edición del archivo ucf
En un principio, el archivo UCF aparecerá en blanco, por lo que se debe escribir que
terminal del FPGA le corresponde a cada una de las entradas y salidas del proyecto en el
que se esté trabajando, como se puede observar en la figura 4.17, se está haciendo uso de
tres terminales en un proyecto, a la variable A le corresponde la terminal G18, a la B la
43
terminal H18 y finalmente a la C le corresponde la J14, esa es la sintaxis que debe llevar
para una correcta configuración con cada una de las variables del proyecto.
Recuerde que las terminales del FPGA se encuentran en la figura 2.3, impresos en la misma
tarjeta Nexys 2 o en el manual de usuario de la misma.
Ahora hacemos doble clic en Generate Programming File dentro de la ventana Processes,
y esperamos a que termine el proceso de síntesis e implementación, viendo si hay algún
error o advertencia de importancia (warning).
4.4 Implementación en la tarjeta Nexys2
Aunque la tarjeta Nexys2 se puede programar con el conector JTAG, viene con un puerto
USB que permite programarla de manera más cómoda. El único inconveniente es que hay
que instalar el programa gratuito Adept.
Se debe asegurar que los jumpers de POWER SELECT (jumpers de selección alimentación)
se encuentren en la posición USB.
A continuación se explica cómo se programa la tarjeta Nexys2 con la versión 2 del Adept.
Ejecutar el programa Adept: Inicio→ Todos los Programas→ Digilent→ Adept. En la

figura 4.18se muestra la pantalla inicial cuando no hay ningún dispositivo conectado. Esto
se puede ver en la parte derecha de la ventana.
Figura 4.18 Pantalla inicial del Adept sin dispositivos conectados
44
Posteriormente se conecta la tarjeta Nexys2 a la computadora mediante el cable USB y

ponemos el interruptor de alimentación en la posición ON. Transcurrido un tiempo, en la
ventana del Adept aparecerá que se ha conectado una tarjeta, en la parte derecha pondrá
Onboard USB. Si no saliese nada, se debe hacer clic en el menú que pone No Devices
Connected a ver si cambia. Si no cambiase, se debe probar cerrando el Adept y volviéndolo
a arrancar.
La primera vez que conectemos la tarjeta puede ser que Windows haya detectado un nuevo
hardware y tengamos que dar permiso para la instalación de los drivers que vienen con la
tarjeta (no tenemos que introducir un disco, la propia tarjeta le proporciona los drivers).
Ahora se hace clic en Initialize Chain y, como se ve en la figura 4.19, aparecerán dos
componentes: uno es la FPGA y otro la memoria (PROM). Indicará también el modelo de
FPGA, que en este caso es la XC3S500E.
Figura 4.19 Pantalla del Adept que ha detectado la cadena JTAG de dispositivos (FPGA y PROM)
A continuación se da clic en el botón browse correspondiente a la FPGA, y buscamos el

fichero con extensión bit que hemos generado en nuestro proyecto. Aparecerá una
advertencia (warning) indicando el mensaje: “Startup clock for this file is CCLK instead of
JTAG CLK. Problems will likely occur. Associate config file with device anyway?” A este
mensaje contestamos Sí.
Otra cosa es que salga un mensaje de error indicando: “Unable to associate file with device
due to IDCODE conflicto”. Esto es un error que indica que la FPGA que hemos escogido
45
no es la misma que la que está en la placa. En este caso, tendremos que verificar que el
modelo de FPGA sea el mismo.
Si todo ha salido bien, sólo tenemos que hacer clic en Program y se programará la FPGA.
Ahora solo queda verificar el correcto funcionamiento de nuestro diseño en la tarjeta de
desarrollo.
Ejercicio 4.1.- Creación de un proyecto
Crear e implementar en la tarjeta Nexys 2 el diseño explicado del subtema 4.1 al 4.4.
46
5. DISEÑO LÓGICO COMBINACIONAL EN VHDL

El participante aplicará los principios del diseño combinacional en VHDL mediante

diversos ejercicios prácticos utilizando la tarjeta de desarrollo Nexys 2 de manera
adecuada.
En este capítulo se diseñan los circuitos combinacionales más utilizados en el diseño lógico
a través del lenguaje de descripción en hardware. Esto permite introducir nuevos conceptos,
palabras reservadas, reglas, algoritmos, etc., que muestran la potencia y profundidad del
lenguaje VHDL.
5.1. Programación de estructuras básicas mediante declaraciones

concurrentes
Las declaraciones concurrentes suelen usarse en las descripciones de flujo de datos. Esto se
debe a que en una declaración concurrente no importa el orden en que se escriban las
señales, ya que el resultado para determinada función sería el mismo.
En VHDL existen tres tipos de declaraciones concurrentes:
• Declaraciones condicionales asignadas a una señal (when-else)

• Declaraciones concurrentes asignadas a señales
• Selección de una señal (with-select-when)
5.1.1. Declaraciones condicionales asignadas a una señal (when-else)
La declaración when-else se utiliza para asignar valores a una señal, determinando así la
ejecución de una condición propia del diseño. Para ejemplificar, consideremos la entidad
mostrada en la figura 5.1, cuyo funcionamiento se define en la tabla de verdad.
47
Figura 5.1 Ejemplo para declaraciones when-else
La entidad se puede programar mediante declaraciones condicionales (when-else), debido

a que este modelo permite definir paso a paso el comportamiento del sistema, según se
muestra a continuación:
1 -- Ejemplo combinacional básico
2 library ieee;
3 use ieee.std_logic_1164.all ;
4 entity tabla is port(
5 a,b,c: in std_logic;
6 f: out std_logic);
7 end tabla;
8 architecture Behavioral of tabla is
9 begin
10 f<= '1' when(a= '0' and b= '0' and c= '0' ) else
11 '1' when (a= '0' and b= '1' and c= '1' ) else
14 '0';
15 end Behavioral;
Nótese que la función de salida f (línea 10) depende directamente de las condiciones que
presentan las variables de entrada, además y dado que la ejecución inicial de una u otra
condición no afecta la lógica del programa, el resultado es el mismo; es decir, la condición
de entrada "111", visualizada en la tabla de verdad, puede ejecutarse antes que la condición
"000" sin alterar el resultado final.
Ejercicio 5.1.-Primer ejercicio con declaración When-Else.
En base a lo visto en el capítulo 4, introducir el diseño anterior en la tarjeta Nexys 2.

Utilizar SW0 como la entrada a, SW1 como la entrada b y SW2 como la entrada c. La
salida f estará dada por el led LD0. Verificar el correcto funcionamiento del diseño
realizado.
48
Ejercicio 5.2.-Segundo ejercicio con declaración When-Else
Realizar haciendo uso de la declaración When-Else un diseño lógico de 4 entradas que van
desde 0000 hasta 1111 y que produzca una salida alta siempre que la entrada decimal
equivalente sea mayor que 10. Verificar el correcto funcionamiento del diseño realizado.
5.1.2. Operadores lógicos
Los operadores lógicos más utilizados en la descripción de funciones booleanas, y

definidos en los diferentes tipos de datos bit, son los operadores and, or, nand, xor, xnor y
not. Las operaciones que se efectúen entre ellos (excepto not) deben realizarse con datos
que tengan la misma longitud o palabra de bits.
En el momento de ser compilados los operadores lógicos presentan el siguiente orden y

prioridad:
1) Expresiones entre paréntesis

2) Complementos
3) Función AND
4) Función OR
Las operaciones xor y xnor son transparentes al compilador y las interpreta mediante la
suma de productos correspondiente a su función.
5.1.3.Declaraciones concurrentes asignadas a señales
En este tipo de declaración encontraremos las funciones de salida mediante la ecuación

booleana que describe el comportamiento de cada una de las compuertas. Obsérvese que
ahora el circuito de la figura 5.2 cuenta con tres salidas (xl, x2 y x3) en lugar de una.
Figura 5.2 Circuito lógico realizado con compuertas
El programa correspondiente al circuito de la figura 5.2 se muestra en el listado siguiente:
49
library ieee;
use ieee.std_logic_1164.all;
entity logic is port (

a,b,c,d,e,f: in std_logic;
xl,x2,x3: out std_logic) ;
end logic;
architecture behavioral of logic is

begin
xl <= a xnor b;
x2 <= ( ( (c and d)or(a xnor b) ) nand
( (e xor f)and(c and d) ) ) ;
x3 <= (e xnor f) and (c and d) ;
end behavioral;
Ejercicio 5.3.- Circuito lógico con compuertas

Utilizar de SW0 a SW5 como entradas. Las salidas estarán dadas por los leds LD0, LD1 Y
LD2. Verificar el correcto funcionamiento del diseño realizado obteniendo su tabla de la
verdad.
Ejercicio 5.4.- Segundo circuito lógico con compuertas
Realizar un diseño lógico por medio de compuertas que tenga 4 entradas que van desde
0000 hasta 1111 y que produzca una salida alta siempre que la entrada decimal equivalente
sea mayor que 10. Verificar el correcto funcionamiento del diseño realizado.
5.1.4.Selección de una señal (with-select-when)
La declaración with – select - when se utiliza para asignar un valor a una señal con base en
el valor de otra señal previamente seleccionada. Por ejemplo, en el listado correspondiente
a la figura 5.3 se muestra el código que representa a este tipo de declaración. Como puede
observarse, el valor de la salida c depende de las señales de entrada seleccionadas a(0) y
a(1), de acuerdo con la tabla de verdad correspondiente.
50
Figura 5.3 Tabla de verdad.
library ieee;
use ieee.std_logic_l164.all;
entity circuito is port(
a: in std_logic_vector (1 downto 0) ;
c: out std_logic);
end circuito;
architecture behavioral of circuito is
begin
with a select
c <= '1' when "00",
'0' when "01",
'1' when "10",
'0' when others1;
end behavioral;
Ejercicio 5.5. - Declaración With-Select-When

Utilizar de SW0 a SW1 como la entrada a. La salida estará dada por el led LD0. Verificar el
correcto funcionamiento del diseño.
Ejercicio 5.6.- Implementación de tabla de verdad
Implementar tabla de verdad 5.1 en la tarjeta de desarrollo Nexys 2 de la siguiente manera:

1. Implementar la tabla de verdad mediante la declaración When-Else.
2. Implementar la tabla de verdad haciendo uso de operadores lógicos (compuertas).
3. Implementar la tabla de verdad mediante la selección de una señal (With-Select-
When).
51
ENTRADAS SALIDA
A B C X
0 0 0 1
0 0 1 0
0 1 0 1
0 1 1 0
1 0 0 1
1 0 1 0
1 1 0 1
1 1 1 1
Tabla 5.1 Tabla de verdad del ejercicio 5.4
5.2.Programación de estructuras básicas mediante declaraciones

secuenciales
Como ya se mencionó, las declaraciones secuenciales son aquellas en las que el orden que
llevan puede tener un efecto significativo en la lógica descrita. A diferencia de una
declaración concurrente, una secuencial debe ejecutarse en el orden en que aparece y
formar parte de un proceso (process).
5.2.1 Declaración if-then-else (si-entonces-si no)
Esta declaración sirve para seleccionar una condición o condiciones basadas en el resultado
de evaluaciones lógicas (falso o verdadero). Por ejemplo, observemos que en la instrucción:
if la condición es cierta then

realiza la operación 1;
else
realiza la operación 2;
end if;
Si (if) condición se evalúa como verdadera, entonces (then) la instrucción indica que se
ejecutará la operación 1. Por el contrario, si la condición se evalúa como falsa (else) correrá
la operación 2. La instrucción que indica el fin de la declaración es end if (fin del si). Un
ejemplo que ilustra este tipo de declaración se ilustra en la figura 5.4.
52
Figura 5.4 Comparador de igualdad de dos bits
El código correspondiente a esta entidad de diseño se muestra en el listado siguiente:
--Ejemplo de declaración de la entidad comparador

entity comp is
port (a,b: in bit_vector( 1 downto 0);
c: out bit);
end comp ;
architecture behavioral of comp is
begin
process (a,b)
begin
if a = b then
c <='1';
else
c <= ' 0 ' ;
end if;
end process;
end behavioral;
Muchas veces sólo son necesarias dos condiciones por evaluar, pero no en todos los diseños
es así. Por tanto, cuando se requieren más condiciones de control, se utiliza una nueva
estructura llamada elsif (si no-si), la cual permite expandir y especificar prioridades dentro
del proceso. La sintaxis para esta operación es:
if la condición 1 se cumple then

realiza operación 1;
elsif la condición 2 se cumple then
realiza operación 2:
else
realiza operación 3;
end if;
La sintaxis anterior se interpreta como sigue: Si (if) la condición 1 es verdadera, entonces

(then) se ejecuta la operación l, si no-si (elsif) se evalúa la condición 2 y si es verdadera
entonces (then) se ejecuta la operación 2, si no (else) se ejecuta la operación 3.
53
Ejercicio 5.7.- Comparador de 2 bits
Introducir el diseño anterior del comparador en la tarjeta Nexys 2. Utilizar de SW0 a SW1
como la entrada a y SW6 Y SW7 como entrada b. La salida estará dada por el led LD0.
Verificar el correcto funcionamiento.
5.2.2 Operadores relacionales
Los operadores relaciónales se usan para evaluar la igualdad, desigualdad o la magnitud en

una expresión. Los operadores de igualdad y desigualdad ( = y /= ) se definen en todos los
tipos de datos. Los operadores de magnitud (<,<—,> y > = ) lo están sólo dentro del tipo
escalar. En ambos casos debe considerarse que el tamaño de los vectores en que se
aplicarán dichos operadores debe ser igual. En la tabla 5.1 se muestran estos operadores y
su significado.
Tabla 5.1 Operadores relaciónales
5.3.Buffers triestado
Los registros de tres estados (buffers tri-estado) tienen diversas aplicaciones, ya sea como
salidas de sistemas (modo buffer) o como parte integral de un circuito. En VHDL estos
dispositivos son definidos a través de los valores que manejan (0,1 y alta impedancia 'Z').
En la figura 5.5 se observa el diagrama correspondiente a este circuito, y en el listado el
código que describe su funcionamiento.
Figura 5.5 Buffer tri-estado
54
library ieee;
use ieee.std_logic_1164.all ;
entity tri_est is port(
enable, entrada: in std_logic;
salida: out std_logic);
end tri_est;
architecture behavioral of tri_est is
begin
process (enable, entrada) begin
if enable = '0' then
salida <= 'Z';
else
salida <= entrada;
end if;
end process ;
end behavioral;
El listado anterior se basa en un proceso, el cual se utiliza para describir los valores que
tomará la salida del registro (buffer). En este proceso se indica que cuando se confirma el
habilitador del circuito (enable), el valor que se encuentra a la entrada del circuito se asigna
a la salida; si por el contrario no se confirma enable, la salida del buffer tomará un valor de
alta impedancia (Z).
El tipo std_logic soporta este valor —al igual que 0 y 1—. A esto se debe que en el diseño
se prefiera utilizar el estándar std_logic_l164 y no el tipo bit, ya que el primero es más
versátil al proveer valores de alta impedancia y condiciones de no importa, los cuales no
están considerados en el tipo bit.
Ejercicio 5.8.- Buffer triestado
Introducir el diseño anterior en la tarjeta Nexys 2. Utilizar a SW0 para la entrada “enable” y
BTN0 como “entrada”. La salida estará dada por el led LD0. Verificar el correcto
funcionamiento.
5.4.Multiplexores
Los multiplexores se diseñan describiendo su comportamiento mediante la declaración

with-select-when o ecuaciones booleanas.
55
En la figura 5.6 a) se observa que el multiplexor dual tiene como entrada de datos las
variables a, b, c y d, cada una de ellas representadas por dos bits (al, a0), (bl, b0), etc., las
líneas de selección (s) de dos bits (s1 y s0) y la línea de salida z (zl y z0).
En la figura 5.6 b) se muestra un diagrama simplificado que resalta la representación

mediante vectores de bits.
Figura 5.6 a) Multiplexor de 4 bits, b) Multiplexor con vectores
En el listado siguiente se muestra la descripción mediante with-select-when del multiplexor

dual de 2 x 4. En este caso la señal s determina cuál de las cuatro señales se asigna a la
salida Z. Los valores de s están dados como "00", "01" y "10"; el término others (otros)
especifica cualquier combinación adicional que pudiera presentarse (que incluye el "11"),
ya que esta variable se encuentra definida dentro del tipo std_logic_vector, el cual contiene
nueve valores posibles que la herramienta de síntesis reconoce como tipos lógicos
estándares.
library ieee;
entity mux is port(
a,b,c,d: in std_logic_vector(1 downto 0);
s: in std_logic_vector (1 downto 0) ;
Z: out std_logic_vector (1 downto 0) ;
end mux;
architecture behavioral of mux is
begin
with s select
Z <= a when "00",
b when "01",
c when "10",
d when others ;
end behavioral;
56
5.5.Sumadores
Para describir el funcionamiento de los circuitos sumadores es importante recordar las

reglas básicas de la adición.
En el caso de la suma 1 + 1 = 10, el resultado "0" representa el valor de la suma, mientras

que el "1" el valor del acarreo.
Para observar en detalle el funcionamiento de un circuito medio sumador, considere la

suma de los números A y B mostrados en la tabla 5.2.
Tabla 5.2Tabla de verdad de un circuito sumador
La ecuación lógica que corresponde a la expresión es la función lógica or-

exclusiva A B, mientras que la ecuación lógica del acarreo de salida es Cout = AB que
corresponde a la compuerta lógica and.
La realización física de estas ecuaciones se muestra en la figura 5.7a, en ella se presenta el

bloque lógico del medio sumador (MS) y la figura 5.7b representa su implantación
mediante compuertas lógicas.
Figura 5.7 a) Diagrama a bloques de un medio sumador; b) Medio sumador lógico
57
El programa en VHDL que representa este medio sumador se muestra en el listado

siguiente:
library ieee;
entity m_sum is port (
A,B: in std_logic;
SUMA, Cout: out std_logic) ;
end m_sum;
architecture behavioral of m_sum is
begin
SUMA <= A XOR B;
Cout <= A AND B;
end behavioral;
Ejercicio 5.9.- Medio Sumador
Introducir el diseño anterior en la tarjeta Nexys 2. Utilizar a SW0 la entrada “A”, SW1
como la entrada “B”. LDO como la salida “SUMA” y LD1 como la salida “Cout”.
Verificar el correcto funcionamiento.
5.5.1.Diseño de un sumador completo
Un sumador completo (SC) a diferencia del circuito medio sumador considera un acarreo
de entrada (Cin) tal y como se muestra en la figura 5.8a, el comportamiento de este
sumador se describe a través de su tabla de verdad.
Figura 5.8 a) Sumador completo; b) Tabla de verdad del medio sumador
58
Las ecuaciones reducidas mediante un mapa de Karnaugh correspondientes a la salida

Suma y Cout se muestran a continuación
Si se manipulan las ecuaciones anteriores mediante álgebra booleana obtenemos que la

función de Suma y Cout puede expresarse como:
La realización física del circuito se basa en la utilización de compuertas or-exclusiva como

se muestra en la figura 5.9 a). Como puede observarse en la figura 5.9 b), dos circuitos
medio sumadores pueden implementar un sumador completo.
a) Circuito sumador completo implementado por compuertas
b) Circuito sumador completo implementado por medio sumadores
Figura 5.9 Circuitos sumadores
La programación en VHDL del sumador completo se presenta en el listado:
library ieee;
entity sum is port (
A,B,Cin: in std_logic;
Suma, Cout: out std_logic);
59
end sum;
architecture behavioral of sum is
begin
Suma <= A xor B xor Cin;
Cout <= (A and B) or (A xor B) and Cin;
end behavioral;
Ejercicio 5.10.- Sumador completo
Introducir el diseño anterior en la tarjeta Nexys 2. Utilizar a SW0 como la entrada A, SW1
como la entrada B y SW2 como la entrada Cin, LD0 como la salida Suma y LD1 como la
salida Cout. Verificar el correcto funcionamiento.
5.6.Decodificador de BCD a display de siete segmentos
En la figura 5.10 a) se muestra un circuito decodificador, el cual acepta código BCD en sus
entradas y proporciona salidas capaces de excitar un display de siete segmentos que indica
el dígito decimal seleccionado. En la figura 5.10 b) se observa la distribución de los
segmentos dentro del display.
Figura 3.13 a) Decodificador BCD a siete segmentos, b) Configuración del display de siete segmentos.
Como se puede apreciar, la entidad del decodificador cuenta con una entrada llamada A,
formada por cuatro bits (AO, Al, A2, A3), y siete salidas (a, b, c, d, e, f, g) activas en nivel
bajo, las cuales corresponden a los segmentos del display. En la tabla 5.3 se indican los
valores lógicos de salida correspondientes a cada segmento.
60
Tabla 5.3Valores lógicos correspondientes a cada segmento del display
La función del programa cuyo código se exhibe en el listado mostrado más abajo utiliza
declaraciones secuenciales del tipo case-when que, como se puede apreciar, ejecutan un
conjunto de instrucciones basadas en el valor que pueda tomar una señal. En nuestro
ejemplo, se describe de qué manera se maneja el decodificador de acuerdo con el valor que
toma la señal A. Para fines prácticos se declararon todas las salidas como un solo vector de
bits (identificado como d). Por otro lado, la palabra reservada others, como ya se indicó,
define los valores que puede tomar en la síntesis la salida d.
library ieee;
entity deco is port (
A: in std_logic_vector (3 downto 0);
d: out std_logic_vector (6 downto 0);
anodo: out std_logic_vector (3 downto 0));
end deco;
architecture behavioral of deco is
begin
anodo <= “1110”
process (A) begin
case A is
when "0000" => d <= "0000001";
when "0001" => d <= "1001111";
when "0010" => d <= "0010010";
when "0011" => d <= "0000110";
when "0100" => d <= "1001100";
when "0101" => d <= "0100100";
when "0110" => d <= "0100000";
when "0111" => d <= "0001110";
61
when "1000" => d <= "0000000";

when "1001" => d <= "0000100";
when others = > d < = "1111111";
end case;
end process;
end behavioral;
En la instrucción case-when podemos observar el uso de asignaciones dobles (=>d < = ),

las cuales permiten que una señal adopte un determinado valor de acuerdo con el
cumplimiento de una condición especificada. Por ejemplo, en nuestro diseño estas
instrucciones se interpretan dela siguiente manera: cuando la señal A sea "0000", asigna a
la señal d el valor"0000001"; cuando A es "0001", asigna a d el valor "1001111", etc.
La señal ánodo se utiliza en este diseño para especificar cuál es el display que queremos
activar, en este caso es el display que se encuentra más a la derecha de nuestra tarjeta.
Ejercicio 5.11.- Decodificador BCD a siete segmentos
Introducir el diseño anterior en la tarjeta Nexys 2. Utilizar de SW0 a SW3 como entradas y
los valores del display de 7 segmentos como la salida d. Recuerde que los valores de los
displays de 7 segmentos los puede localizar impresos en la tarjeta de desarrollo o en el
manual de usuario. Verificar el correcto funcionamiento del diseño.
62
6 DISEÑO LÓGICO SECUENCIAL EN VHDL
El participante aplicará los principios del diseño secuencial en VHDL mediante diversos
ejercicios prácticos utilizando la tarjeta de desarrollo Nexys 2 de manera adecuada.
Los circuitos digitales que se han manejado fueron del tipo combinacional; es decir, son
circuitos que dependen por completo de los valores que se encuentran en sus entradas en
determinado tiempo. Sin embargo, la mayoría de los sistemas que se encuentran en la
práctica incluyen elementos de memoria, los cuales requieren que el sistema se describa en
términos de lógica secuencial.
En este capítulo se describen algunos de los circuitos secuenciales más utilizados en la

práctica, como flip-flops, contadores, registros, etc.
6.1 Sistema secuencial
Un sistema secuencial está formado por un circuito combinacional y un elemento de

memoria encargado de almacenar de forma temporal la historia del sistema.
En esencia, la salida de un sistema secuencial no sólo depende del valor presente de las
entradas, sino también de la historia del sistema, según se observa en la figura 6.1.
Figura 6.1 Estructura de un sistema secuencial
Básicamente hay dos tipos de sistemas secuenciales: síncronos y asíncronos; el

comportamiento de los primeros se encuentra sincronizado mediante el pulso de reloj del
sistema, mientras que el funcionamiento de los sistemas asíncronos depende del orden y
63
momento en el cual se aplican sus señales de entrada, por lo que no requieren un pulso de
reloj para sincronizar sus acciones.
6.2 Flip-flops
El elemento de memoria utilizado indistintamente en el diseño de los sistemas síncronos o

asíncronos se conoce como flip-flop o celda binaria.
La característica principal de un flip-flop es mantener o almacenar un bit de manera
indefinida hasta que a través de un pulso o una señal cambie de estado.
Los flip-flops más conocidos son los tipos SR, JK, T y D.
6.2.1 Flip-Flop D
Es importante recordar el significado de la notación Q y Q(t+i);
Q = estado presente o actual

Qt+1 = estado futuro o siguiente
Consideremos la tabla de verdad que describe el funcionamiento del flip-flop tipo D,

mostrado en la figura 6.2.
Figura 6.2 a) Diagrama y tabla de verdad del flip-flop D, b) Flujo de información en el dispositivo
Cuando el valor de la entrada D es igual a 1, figura 6.2 b), la salida Qt + i adopta el valor de
1: Qt+i = 1 siempre y cuando se genere un pulso de reloj.
Es importante resaltar que el valor actual en la entrada D es transferido a la salida Qt + i sin

importar cuál sea el valor previo que haya tenido la salida Q en el estado presente.
64
En el diseño secuencial con VHDL las declaraciones If-then-else son las más utilizadas; por
ejemplo, el programa del listado mostrado más abajo usa estas declaraciones.
La ejecución del proceso es sensible a los cambios en clk (pulso de reloj); esto es, cuando
clk cambia de valor de una transición de 0 a 1 (clk = 1), el valor de D se asigna a Q y se
conserva hasta que se genera un nuevo pulso.
1 library ieee;
2 use ieee.std_logic_1164.all ;
3 entity Flip_Flop_D is
4 Port ( D : in STD_LOGIC;
5 CLK : in STD_LOGIC;
6 Q : out STD_LOGIC;
7 Qn: out STD_LOGIC);
8end Flip_Flop_D;
9architecture Behavioral of Flip_Flop_D is
10begin
11process (CLK)
12begin
13if clk'event and clk='1' then
14Q <= D;
15Qn<=not D;
16end if;
17end process;
18end Behavioral;
6.3 Atributo event
En el lenguaje VHDL los atributos sirven para definir características que se pueden asociar
con cualquier tipo de datos, objeto o entidades. El atributo event (evento) se utiliza para
describir un hecho u ocurrencia de una señal en particular.
En el código del listado anterior podemos observar que la condición if clk 'event es cierta
sólo cuando ocurre un cambio de valor; es decir, un suceso (event) de la señal clk. Como se
puede apreciar, la declaración (if-then) no maneja la condición else, debido a que el
compilador mantiene el valor de Q hasta que no exista un cambio de valor en la señal clk.
Ejercicio 6.1.- Implementación del Flip-Flop D
Introducir el diseño anterior en la tarjeta Nexys 2. Utilizar SW0 como entrada D y LD0
como la salida Q. Recuerde que la terminal que corresponde al reloj interno de la tarjeta es
B8. Verificar el correcto funcionamiento del diseño.
65
6.4 Flip-Flop SR
Escriba un programa que describa el funcionamiento de un flip-flop SR con base en la
siguiente tabla de verdad (figura 6.3).
Figura 6.3 Tabla de funcionamiento flip-flop SR
La tabla de verdad del flip-flop SR muestra que cuando la entrada S es igual a 1 y la

entrada R es igual a 0, la salida Qt+i toma valores lógicos de 1. Por otro lado, cuando S = 0
y R = l, la salida Qt+i = 0; en el caso de que S y R sean ambas igual a 1 lógico, la salida
Qt+j queda indeterminada; es decir, no es posible precisar su valor y éste puede adoptar el 0
ó 1 lógico.
Por último, cuando no existe cambio en las entradas S y R, es decir, son igual a 0, el valor
de Qt+i mantiene su estado actual Q.
Con base en el análisis anterior, el programa en VHDL puede realizarse utilizando

instrucciones condicionales y un nuevo tipo de datos: valores no importa ('-'), los cuales
permiten adoptar un valor de 0 o 1 lógico de manera indistinta.
library IEEE;
entity Flip_Flop_SR is
Port ( S : in STD_LOGIC;
R : in STD_LOGIC;
clk : in STD_LOGIC;
Q : out STD_LOGIC;
Qn : out STD_LOGIC);
end Flip_Flop_SR;
architecture Behavioral of Flip_Flop_SR is

begin
process (clk, S, R)
begin
if (clk'event and clk = '1') then
66
if S = '0' and R = '1' then
Q <= '0';
Qn <= '1';
elsif (S = '1' and R = '0') then
Q <= '1';
Qn <= '0';
elsif (S = '0' and R = '0') then
else
Q <= '-';
Qn <= '-';
end if;
end if;
end process;
end Behavioral;
Ejercicio 6.2.- Implementación del Flip-Flop SR
Introducir el diseño anterior en la tarjeta Nexys 2. Utilizar SW0 como entrada S, SW1
como entrada R, LD0 como la salida Q y LD1 como salida Qn. Recuerde que la terminal
que corresponde al reloj interno de la tarjeta es B8. Verificar el correcto funcionamiento del
diseño.
6.5 Registros
En la figura 6.4 se presenta la estructura de un registro de 8 bits con entrada y salida de

datos en paralelo. El diseño es muy similar al flip-flop anterior, la diferencia radica en la
utilización de vectores de bits en lugar de un solo bit, como se observa en el listado
siguiente.
Figura 6.4 Registro paralelo de 8 bits.
library ieee;
entity reg is port (
D: in std_logic_vector(0 to 7);
clk: in std_logic;
67
Q: out std_logic_vector(0 to 7));
end reg ;
architecture behavioral of reg is
begin
process (clk) begin
if (clk'event and clk='1') then
Q <= D;
end if;
end process;
end behavioral;
Ejercicio 6.3.- Registro paralelo de 8 bits
Introducir el diseño anterior en la tarjeta Nexys 2. Utilizar SW0 a SW7 como entrada D y
LD0 A LD7 como la salida Q. Recuerde que la terminal que corresponde al reloj interno de
la tarjeta es B8. Verificar el correcto funcionamiento del diseño.
6.6 Contadores
Los contadores son entidades muy utilizadas en el diseño lógico. La forma usual para
describirlos en VHDL es mediante operaciones de incremento, decremento de datos o
ambas.
Como ejemplo veamos la figura 6.5 que representa un contador ascendente de 4 bits, así
como el diagrama de tiempos que muestra su funcionamiento.
Figura 6.5 Contador binario de cuatro bits.
Cabe mencionar que la presentación del diagrama de tiempos de este circuito tiene la
finalidad de ilustrar el procedimiento que se sigue en la programación, ya que puede
observarse con claridad el incremento que presentan las salidas cuando se aplica un pulso
de reloj a la entrada.
library ieee;
use ieee.std_logic_unsigned.all;
entity cont4 is port (
68
clk: in std_logic;
Q: out std_logic_vector(3 downto 0));
end cont4;
architecture behavioral of cont4 is

begin
process (clk)
variable Qaux: std_logic_vector (3 downto 0);
begin
If (clk'event and clk = '1') then
Qaux := Qaux + 1;
end if;
Q <= Qaux;
end process ;
end behavioral;
Se necesita una señal auxiliar llamada Qaux porque la salida Q no puede usarse dentro del
proceso, la salida no puede emplearse para hacer lógica.
Notemos el uso del paquete std_arith que, como ya se mencionó, permite usar el operador +
con el tipo std_logic_vector.
El funcionamiento del contador se define básicamente en un proceso, en el cual se llevan a

cabo los eventos que determinan el comportamiento del circuito. Al igual que en los otros
programas, una transición de 0 a 1 efectuada por el pulso de reloj provoca que se ejecute el
proceso, lo cual incrementa en 1 el valor asignado a la variable Q. Cuando esta salida tiene
el valor de 15 ("1111") y si el pulso de reloj se sigue aplicando, el programa empieza a
contar nuevamente de 0.
Ejercicio 6.4.- Contador binario de 4 bits
Introducir el diseño anterior en la tarjeta Nexys 2. Utilizar SW0 como entrada D y LD0
como la salida Q. Recuerde que la terminal que corresponde al reloj interno de la tarjeta es
B8. ¿Es correcto el comportamiento de la tarjeta?
Ahora se describirá el funcionamiento de un contador de 4 bits con una señal de control

(Up/Down) que determine el sentido del conteo: ascendente o descendente (Figura 6.6).
69
Figura 6.6 Contador binario de cuatro bits
La señal de control Up/Down permite definir si el conteo se realiza en sentido ascendente o

descendente. En nuestro caso, un cero aplicado a esta señal determina una cuenta
ascendente: del 0 al 15. De esta forma, el funcionamiento del circuito queda determinado
por dos señales: el pulso de reloj (clk) y la señal Up/Down, como se ve en el siguiente
programa.
library ieee;
use ieee.std_logic_unsigned.all;
entity contador is port (
clk: in std_logic;
UP:in std_logic;
Q: inout std_logic_vector(3 downto 0));
end contador;
architecture behavioral of contador is
begin
process (UP, clk)
variable Qaux: std_logic_vector(3 downto 0);
begin
if (clk'event and clk = '1')then
if (UP = '0') then
Qaux := Qaux + 1;
else
Qaux := Qaux - 1;
end if ;
end if ;
Q <= Qaux;
end process ;
end behavioral;
70
7. VHDL ESTRUCTURAL
El participante aplicará el diseño estructural en VHDL mediante ejercicios prácticos

utilizando la tarjeta de desarrollo Nexys 2 de manera adecuada.
Para diseñar un circuito grande es conveniente separarlo en bloques funcionales. Cada uno
de estos bloques se diseña como se ha realizado hasta ahora (entidad y arquitectura). Y
estos bloques se juntan en una arquitectura que hace referencia a estos bloques.
Habitualmente este tipo de arquitectura se denomina Estructural.
7.1.Creación de un diseño estructural
En un diseño grande puede haber varios niveles de jerarquía, donde unas arquitecturas
estructurales contienen a otras. Las ventajas de realizar el diseño de esta manera son varias,
entre ellas se cuentan las siguientes:
 Permite dividir el circuito en partes más sencillas, haciendo que el diseño

sea más manejable y entendible. Esto además facilita el trabajo en equipo.
 Es fácil modificar algún bloque del diseño, mientras que se deja el resto igual.
 Permite la reutilización ya que puede que un bloque de un diseño lo necesitemos par

a otro.
Para explicar cómo se describe una arquitectura estructural en VHDL, en este ejemplo se
asume que se han implementado en un nuevo proyecto el diseño de una compuerta XNOR
y en otro proyecto el diseño de una compuerta AND.
Con los diseños anteriores se pretende implementar el diseño del comparador de 2 bits de la
figura 7.1.
71
Figura 7.1.- Representación esquemática de un comparador de 2 bits
Para iniciar el diseño de una entidad de manera estructural, es necesario la descomposición

lógica del diseño en pequeños submódulos (jerarquizar), los cuales permiten analizar de
manera práctica el circuito, ya que la función de entrada/salida es conocida. En el siguiente
ejemplo se conoce la función de salida de las dos compuertas xnor, por lo que al unirlas a la
compuerta and, la salida c es el resultado de la operación and efectuada en el interior a
través de las señales x0 y xl.
Es importante resaltar que una jerarquía en VHDL se refiere al procedimiento de dividir en

bloques y no a que un bloque tenga mayor jerarquía (peso) que otro.
En el listado siguiente se muestra el código del programa que representa al esquema de la

figura 7.1.
1 library ieee;
2 use ieee.std_logic_1164.all;
3 entity comp is port (
4 a,b: in std_logic_vector (0 to 1);
5 c: out std_logic);
6 end comp;
7 architecture estructural of comp is
8 component xnor
9port (a0,b0: in std_logic;
10salida: out std_logic);
11 end component
12 component and
13 port (a1,b1: in std_logic;
14 salida: out std_logic);
15 end component
16
17 signal x0,x1: std_logic;
18
19 begin
72
20
21 U0: xnor port map (a,b,x0);
22 Ul: xnor port map (a,b,x1);
23 U2: and port map (x0,x1, c);
24 end estructural;
En la línea 7 se inicia la declaración de la arquitectura estructural. El algoritmo propuesto

(líneas 21 a 23) describe la estructura de la siguiente forma: cada compuerta se maneja
como un bloque lógico independiente (componente) del diseño original, al cual se le asigna
una variable temporal (U0, U1 y U2); la salida de cada uno de estos bloques se maneja
como una señal línea 17, signal x0 y xl, las cuales se declaran dentro de la arquitectura y no
en la entidad, debido a que no representan a una terminal (pin) y sólo se utilizan para
conectar bloques de manera interna a la entidad. A esta parte se le denomina “mapeo de las
señales”.
Por último, podemos observar que la compuerta and recibe las dos señales provenientes de
x0 y xl, ejecuta la operación y asigna el resultado a la salida c del circuito.
El mapeo realizado de las líneas 21 a la 23 se le denomina “mapeo de manera ordenada”, y

como su nombre lo indica tiene que realizarse en orden. Existe otro tipo de mapeo
denominado “mapeo de manera explícita”, en el cual se determina con exactitud el origen y
destino de las señales. El siguiente listado muestra el algoritmo del diseño realizado
anteriormente utilizando el mapeo de manera explícita.
21 U0: xnor port map (a0=>a,b0=>b,salida=>x0);

22 Ul: xnor port map (a0=>a,b0=>b,salida=>x1);
23 U2: and port map (a1=>x0,a2=>x1,salida=>c);
Ya sea que se decida utilizar mapeo explícito o mapeo ordenado, el resultado es el mismo.
Ejercicio 7.1 Diseño estructural
Realice el programa correspondiente en VHDL para el circuito mostrado en la figura 7.2.

Utilice descripción estructural. Verificar el correcto funcionamiento del diseño.
7.2.Divisor de frecuencia
Como se ha observado anteriormente con el diseño del contador binario de 4 bits o con los
Flip-Flops, la frecuencia a la que trabaja la tarjeta Nexys 2 es muy alta para poder observar
a detalle los cambios que suceden en este tipo de diseños, por lo que es necesario crear un
diseño denominado “divisor de frecuencia” en el cual nos da como salida una frecuencia
73
más baja y a través de este alimentar nuestros contadores o nuestros Flip-Flops, cosa que se
puede realizar a través de un diseño estructural en VHDL.
Para realizar el divisor de frecuencia se debe considerar primero la frecuencia a la que

trabaja la tarjeta Nexys 2, la cual es 50Mhz, cuyo periodo es de 20 ns, es decir, si queremos
que la frecuencia sea de 1Hz su periodo debe de ser cada nanosegundos o lo que es
lo mismo, cada pulsos a una frecuencia de 50MHz, teniendo esto en mente se puede
realizar un divisor de frecuencia a 1 Hz manteniendo una salida en ‘1’ durante
pulsos de reloj y posteriormente cambiar la salida a un ‘0’ lógico los pulsos de reloj
restantes.
Este divisor de frecuencia se puede observar en el siguiente diseño en VHDL:
library IEEE;
entity Div2 is
PORT (Clk50Mhz: IN STD_LOGIC;
Clk: OUT STD_LOGIC
);
end Div2;
architecture Behavioral of Div2 is
constant max: INTEGER := 50000000;

constant half: INTEGER := max/2;
begin
process (Clk50Mhz)
variable count: integer;
begin
if Clk50Mhz'EVENT and Clk50Mhz = '1' then
if
count < max then count := count + 1;
else count := 0;
end if;
if
count < half then Clk <= '0';
else Clk <= '1';
end if;
end if;
end process;
end Behavioral;
Se pueden observar varios aspectos del diseño anterior, uno de ellos es el uso de la palabra
reservada “constant” en lugar de usar una variable, esto debido a que los valores que se
74
obtengan para max y half se mantienen constantes a lo largo del tiempo, notese también que
las constantes han sido inicializadas. Es cierto que estas constantes bien pudieron colocarse
inmediatamente después del process, sin embargo el hacer esto implicaría que cada vez que
se activara dicho proceso la variable max automáticamente tomaría el valor de 50000000,
con lo cual nunca se llevaría a cabo el correcto funcionamiento del divisor de frecuencia
propuesto.
Dentro del proceso Clk50Mhz se lleva a cabo el conteo de los flancos de subida en la
variable count, la cual se resetea al llegar a los 50000000 pulsos, por otra parte se lleva a
cabo el conteo de los pulsos para variar la salida entre un ‘1’ y un ‘0’ lógico cada 25000000
pulsos de reloj, de esta manera se obtiene como resultado una frecuencia de salida de 1Hz.
Ejercicio 7.2 Implementación de un divisor de frecuencia
Implementar el divisor de frecuencia previamente mostrado en la tarjeta de desarrollo

Nexys 2 utilizando como salida el led LD0 (terminal J14). Verificar el correcto
funcionamiento del diseño.
Ejercicio 7.3 Contador de 4 bits con divisor de frecuencia
Ya que se cuentan con los diseños del divisor de frecuencia a 1Hz y el contador binario de
4 bits, realizar un diseño estructural en el cual la señal de reloj que entra al contador
provenga del divisor de frecuencia en lugar de la tarjeta.
75
8. Simulación de diseños
El participante comprenderá la manera de realizar simulaciones de los diseños realizados en

VHDL mediante el uso adecuado del software ModelSim.
En este capítulo se muestra el manejo básico de ModeISim, el cual permite la simulación de

diseños empleando VHDL, Verilog o ambos, mezclando, en un mismo diseño, bloques
realizados en ambos lenguajes. A través de la simulación de un diseño básico se mostrará el
ciclo de trabajo con ModeISim y algunas de sus características más importantes.
8.1 Creación de un archivo de prueba
Puesto que el objetivo es sobre todo conocer el entorno de Modelsim, se ha seleccionado un

circuito combinacional muy sencillo para introducir las posibilidades de simulación-
verificación de un circuito digital. En la figura 8.1 se presenta el circuito a modelar y
simular:
Figura 8.1 Diseño a simular
Los siguientes diseños se tienen que realizar en el software Xilinx ISE en un mismo
proyecto.
El diseño para la compuerta and es el siguiente:
library ieee;
entity c_and is
port(a,b: in std_logic;
z: out std_logic);
76
end c_and;
architecture beh of c_and is

begin
z<=a and b;
end beh;
El diseño para la compuerta or es el siguiente:
library ieee;
entity c_or is
z: out std_logic);
end c_or;
architecture beh of c_or is

begin
z<=a or b;
end beh;
El diseño para la compuerta xor es el siguiente:
library ieee;
entity c_xor is
z: out std_logic);
end c_xor;
architecture beh of c_xor is

begin
z<=a xor b;
end beh;
El diseño estructural del circuito se muestra a continuación:
library ieee;
entity Circuito is
port (a,b,c: in std_logic;
y: out std_logic);
end Circuito;
77
architecture str of Circuito is
component c_and
z: out std_logic);
end component;
component c_or
z: out std_logic);
end component;
component c_xor
z: out std_logic);
end component;
signal net1,net2: std_logic;
begin
u1: c_and port map (a=>a, b=>b, z=>net1);

u2: c_or port map (a=>c, b=>a, z=> net2);
u3: c_xor port map (a=>net1, b=>net2, z=>y);
end str;
El diseño del archivo de prueba es el siguiente:
library IEEE;
entity Circuito_test is
end Circuito_test;
architecture tst of Circuito_test is
component Circuito
Port (a : in std_logic;
b : in std_logic;
c : in std_logic;
y : out std_logic);
end component;
signal a,b,c,y: std_logic;
78
begin
uut: Circuito port map (a=>a, b=>b, c=>c, y=>y);
a <='0', '1' after 200ns, '0' after 400ns;

b <='1', '0' after 300ns, '1' after 600ns;
c <='1', '0' after 350ns, '1' after 700ns;
end tst;
Nótese que en el diseño del archivo de prueba la entidad se encuentra vacía y que al
principio de la arquitectura se hace referencia solamente a la entidad del diseño estructural.
Así como en la arquitectura de un diseño comportamental y en un diseño estructural se
denota por beh y str, en un diseño de prueba o testbench la arquitectura se denota con las
letras tst.
Después del begin de la arquitectura tenemos la instanciación de señales de manera similar

a como se realiza con un diseño estructural, la diferencia radica en que en este caso la
etiqueta se denota como uut, lo cual significa unit under test.
Por último tenemos la sección en donde deben colocarse las estímulos de las señales de
cada entrada con las que pretendemos probar nuestro diseño digital, algunas de las bases de
tiempo utilizadas son las siguientes:
 ps para picosegundos.
 ns para nanosegundos.
 ms para hacer referencia a los milisegundos.
En ocasiones es necesario que una de las entradas de nuestro diseño tenga una entrada de
reloj (clk), para lo cual puede utilizarse como referencia el siguiente código que simulará la
entrada mencionada anteriormente:
 Primero tiene que inicializarse dicha señal antes de escribir el begin de la

arquitectura, en este ejemplo estamos inicializando la señal a un valor de 0:
signal clk: std_logic:=’0’;
 Posteriormente el estímulo para esta señal sería de la siguiente manera, pudiendo

cambiar la base tiempo a la que mejor se adapte nuestro diseño a probar:
clk <= not clk after 50ns;
79
La figura 8.2 muestra como se ve este proyecto en el software Xilinx ISE en la ventana de
diseño.
Figura 8.2 Diseño a probar
No se debe sintetizar tst, puesto que no es un diseño en sí, sino solamente un archivo de
prueba.
Debe de recordarse que al momento de crear un proyecto en Xilinx ISE, el software nos
pregunta con que programa queremos realizar la simulación de nuestro diseño, es
indispensable elegir el software de simulación ModelSim.
8.2 Arranque de la aplicación ModelSim XE
ModelSim XE es el software que nos permitirá realizar las simulaciones de nuestros

diseños en VHDL, Para poder realizar el enlace entre Xilinx ISE y ModelSim es necesario
indicarle a Xilinx ISE la ruta del simulador, que generalmente se encuentra en
C:\modeltech_6.5b\win32\modelsim.exe.
Para realizar lo anterior se debe ir a Edit > Preferences, ahí se debe escoger el apartado
Integrated Tools. Se debe poner la ruta del simulador en Model Tech Simulator (figura
8.3).
Figura 8.3 Ventana de preferencias de Xilinx ISE
80
Una vez realizado lo anterior damos clic en aceptar y volvemos a la ventana principal de
Xilinx ISE, seleccionando el archivo tst de la ventana de diseño se da clic en Simulation
(figura 8.4).
Figura 8.4 Cambio a modo de simulación
Posteriormente se hace doble clic en Simulate Behavioral Model de la ventana de

procesos (figura 8.5).
Figura 8.5 Inicio de la simulación
Una vez realizado lo anterior aparecerá la ventana de la figura 8.6, en la que debemos elegir
No para poder acceder a la pantalla principal de ModelSim.
Figura 8.6 Pantalla de advertencia
81
8.3 Revisión de la simulación
Al acceder al programa ModelSim podemos observar diversas ventanas de dicha

simulación (figura 8.7), La ventana Objects nos muestra las señales que se están simulando
en el diseño mientras que la ventana Wave nos muestra una gráfica de las señales
simuladas con respecto al tiempo.
Figura 8.7 Pantalla principal de ModelSim
Para poder observar mejor la gráfica se hace uso de la barra de herramientas zoom
y se ajusta hasta que pueda ser leída de mejor manera (figura 8.8).
Figura 8.8 Ajuste de zoom en la gráfica de simulación
82
En la barra de simulación se puede

continuar con la simulación o cambiar la base de tiempo de ps a ns o ms .
Si se desea resetear todas las señales de la gráfica se puede hacer uso del botón Restart ,
el cual al hacer clic sobre este, nos aparece una pantalla en la cual se nos pide seleccionar lo
que deseamos conservar (figura 8.9). Se deja todo como está y se da clic en Ok
Figura 8.9 Ventana de reseteo
Ya que la gráfica con los datos de la simulación se ha borrado, se puede hacer clic en el botón Run
para comenzar con la simulación.
Ejercicio 8.1 Simulación de un Flip-Flop D
Realizar un archivo de prueba para el diseño del Flip-Flop D del ejercicio 6.1 y simúlelo en
ModelSim. Corra la simulación con al menos dos tipos diferentes de estímulos, los cuales quedan a
elección del participante.
Ejercicio 8.2 Simulación de un divisor de frecuencia
Realizar un archivo de prueba para el diseño del divisor de frecuencia del ejercicio 7.2 y simúlelo
en ModelSim.
Ejercicio 8.3 Simulación de un contador de 4 bits con divisor de frecuencia
Realizar un archivo e prueba para el diseño del contador de 4 bits con divisor de frecuencia del
ejercicio 7.3 y simúlelo en ModelSim.
83
9. Máquina de estados en VHDL

El participante comprenderá el diseño e implementación de una máquina de estados en

VHDL haciendo uso de una tarjeta basada en FPGA de acuerdo al procedimiento
establecido.
Se denomina máquina de estados a un modelo de comportamiento de un sistema con

entradas y salidas, en donde las salidas dependen no sólo de las señales de entradas actuales
sino también de las anteriores.
9.1 Definición de máquina de estados
Los diagramas de estados, tablas de estados y otras descripciones de máquina de estados

finitos contienen básicamente la misma información: describen el comportamiento deseado
del circuito en términos de transiciones de estado y cambios de salida en respuesta a todas
las combinaciones posibles de entradas y estados.
Por ejemplo, las figuras 9.1 a, b y c presentan un diagrama de estados, la correspondiente

tabla de estados y la tabla de verdad, respectivamente, de una máquina de estados finitos.
Por lo general, en una descripción de arquitectura VHDL se describe el comportamiento de
un circuito secuencial mediante una o más estructuras de proceso.
Figura 9.1 Descripción del circuito secuencial. (a) Diagrama de estados. (b) Tabla de estados.
(c) Formato de tabla de verdad.
84
Existen dos tipos de máquinas de estados.
Máquina de Mealy: Es la máquina de estado en la cual la salida depende tanto del estado
presente como de las entradas externas. (figura 9.2).
Figura 9.2 Descripción máquina de estados Mealy
Lógica de estado siguiente (F): Una función de las entradas y del estado actual.
 Memoria de estados: Es un conjunto de n flip flops que almacenan el estado
presente de la máquina, que tiene 2n estados diferentes. La señal de reloj controla el
cambio de estado en tales flip flops.
 La señal de reloj: Dispone el funcionamiento de los flip flops ya sea por disparo de
flanco o por disparo de pulso.
 Lógica de salida (G): Una función del estado actual y/o de las entradas.
Máquina de Moore: Es la máquina de estado en la cual las salidas solo dependen del estado
presente (figura 9.3).
Figura 9.3 Descripción máquina de estados Moore
85
9.2 Diseño de una máquina de estados Moore
En la figura 9.4 se muestra una máquina de estados Moore:
Figura 9.4 Máquina de estados Moore
Donde:
x=> Vector de entrada.

Z=> Vector de salida.
y=> Vector de estado actual.
Y=> Vector de estado próximo.
Debido a que es una máquina Moore el vector de estado próximo está en función del vector
de entrada y del vector de estado actual, es decir, Y=g(x,y) y la salida Z se encuentra en
función del estado actual, es decir, Z=f(y).
A continuación se explica por partes la manera de realizar la máquina de estados de la

figura 9.4
library ieee;
entity maquina is
port( x: in std_logic_vector (1 downto 0);

clk: in std_logic;
86
reset: in std_logic;
z: out std_logic);
end maquina;
Esta primer parte del código no muestra nada nuevo, ya que solo se están especificando las
entradas y salidas de la máquina de estados, nótese que se tiene una señal de reset, la cual
se recomienda colocar en cada diseño de máquina de estados para regresar al estado inicial.
architecture beh of maquina is

type estado is (alfa,beta,gama,delta,eta);
signal actual, proximo: estado;
El código anterior muestra el principio de la arquitectura del diseño, aquí se declara un

nuevo tipo de datos. El tipo de datos es un elemento básico en VHDL, ya que delimita que
valores puede tener un objeto y que operaciones podemos realizar con él. Aparte de los
tipos ya existentes en VHDL, podemos crear nuevos tipos y subconjuntos de tipos.
Esta declaración está formada por un identificador que nos permitirá usar el nuevo tipo al
llamarlo y la descripción del conjunto de valores que forman el tipo de datos. Para ello
usamos la palabra reservada type.
Se declaran alfa, beta, gama, delta, eta como estado (son los estados de la máquina referida
en la figura 9.4), así como las señales actual y próximo como pertenecientes al tipo antes
declarado.
begin
combinacional: process (x, actual)
begin
case actual is
when alfa=> if x(1)=’0’
then proximo <= beta;
else proximo <= alfa;
end if;
when beta=> if x(0)=’0’
then proximo <= delta;
else proximo <= gama;
end if;
when gama=> proximo <= eta;
when delta=> próximo <= eta;
when eta=> próximo <= alfa;
end case;
end process;
87
El código anterior muestra las transiciones que debe realizar nuestra máquina de estados
dependiendo de los valores del vector de entrada, posteriormente se debe colocar el diseño
del registro, que se encargará de guardar el valor actual y próximo del estado de nuestra
máquina.
registro: process (clk)
begin
if clk’event and clk=’1’
then if reset = ‘0’
then actual <= alfa;
else actual <= proximo;
end if;
end if;
end process;
Dicho registro se realiza con un proceso sensible a una señal de reloj. Por último queda
definir las salidas del diseño.
salida: process (actual)

begin
case actual is
when alfa => z <=’0’;
when beta => z <=’0’;
when gama => z <=’1’;
when delta => z <=’0’;
when eta => z <=’1’;
end case;
end process;
end beh;
En caso de que se requiera construir una máquina Mealy en lugar de una Moore, la
estructura de este último código es la que cambiaría un poco, agregando las entradas para
los posibles valores de entrada.
A continuación se muestra el diseño completo de esta máquina de estados:
library ieee;
entity maquina is
port( x: in std_logic_vector (1 downto 0);

clk: in std_logic;
reset: in std_logic;
z: out std_logic);
end maquina;
88
architecture beh of maquina is
type estado is (alfa,beta,gama,delta,eta);

signal actual, proximo: estado;
begin
combinacional: process (x, actual)

begin
case actual is
when alfa=> if x(1)=’0’
then proximo <= beta;
else proximo <= alfa;
end if;
when beta=> if x(0)=’0’
then proximo <= delta;
else proximo <= gama;
end if;
when gama=> proximo <= eta;
when delta=> proximo <= eta;
when eta=> proximo <= alfa;
end case;
end process;
registro: process (clk)
begin
if clk’event and clk=’1’
then if reset = ‘0’
then actual <= alfa;
else actual <= proximo;
end if;
end if;
end process;
salida: process (actual)
begin
case actual is
when alfa => z <=’0’;
when beta => z <=’0’;
when gama => z <=’1’;
when delta => z <=’0’;
when eta => z <=’1’;
end case;
end process;
end beh;
89
Ejercicio 9.1 Simulación de una máquina de estados
Diseñe en Xilinx ISE y simule en ModelSim la máquina de estados expuesta anteriormente,

simule las señales de entrada que crea pertinentes para demostrar que el diseño se comporta
de acuerdo a lo esperado.
Ejercicio 9.2 Contador de 3 bits con máquina de estados
Diseñe en Xilinx ISE y simule en ModelSim un contador binario de 3 bits modificando la

señal de salida por medio de una máquina de estados, el cual debe de funcionar al
encontrarse en alto una señal de entrada con una frecuencia de reloj de 1 Hz.
90
BIBLIOGRAFIA
Amado, Oscar Alejandro. “GUÍA DE USO TARJETA NEXYS 2 FPGA SPARTAN-3E”.

Universidad Nacional de Colombia.
Cardenas, Rubén Darío. “CURSO PROGRAMACIÓN FPGA (PROGRAMACIÓN DE

ARREGLO DE COMPUERTAS)”. Universidad Nacional de Colombia.
Departamento de tecnología electrónica. “Diseño avanzado de circuitos digitales con

VHDL”. Universidad Rey Juan Carlos.
López Núñez, Adolfo Rafael: Documento tesis de maestría “Sistema de control digital para
obtención de máxima potencia de celdas fotovoltaicas”. Instituto Tecnológico de Celaya,
2011.
Maxinez,David G."VHDL El arte de programar sistemas digitales". CECSA.
Nexys 2 FPGA Board [Online]. Disponible en

http://www.digilentinc.com/Products/Detail.cfm?NavTop=2&NavSub=451&Prod=NEX
YS2
Pardo Carpio Fernando, “VHDL. Lenguaje para síntesis y modelado de circuitos”, Ra-Ma,
2003.
91

Diseño FPGA VHDL

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

Diseño FPGA VHDL

Cargado por

Copyright:

Formatos disponibles

Diseño básico en FPGA con VHDL

Manual del participante

En el primer capítulo se muestra una introducción a los diferentes dispositivos lógicos

En el segundo capítulo se muestra las características generales de la tarjeta de desarrollo

En el cuarto capítulo se introduce al ambiente de desarrollo del software XILINX ISE

En el quinto capítulo se introduce al diseño lógico combinacional en VHDL, se muestran

Una introducción a VHDL estructural se muestra en el capítulo 7, en la cual se hace énfasis

OBJETIVO DEL CURSO

El participante identificará las características principales de los dispositivos lógicos

En la actualidad el nivel de integración alcanzado con el desarrollo de la microelectrónica

El proceso de miniaturización de los sistemas electrónicos comenzó con la interconexión de

1.1 Dispositivos lógicos programables (PLD)

En la actualidad, el diseño de ASIC (circuitos integrados desarrollados para aplicaciones

Los FPGA (arreglos de compuertas programables en campo) y CPLD (dispositivos lógicos

Tabla 1.1 Dispositivos lógicos programables

1.1.1 Estructura interna de un PLD

La arquitectura básica de un PLD está formada por un arreglo de compuertas AND y OR

Figura 1.1 Arreglos AND: a) no programado y b) programado

b) Arreglo OR. Está formado por un conjunto de compuertas OR conectadas a un arreglo

Figura 1.2 Estructura básica de PLD

Tabla 1.2Dispositivos lógicos programables

• La PROM no se utiliza como un dispositivo lógico, sino como una memoria

1.2 Arreglo Lógico Genérico (GAL)

Figura 1.3Diagrama de bloques del arreglo GAL

1.2.1 Programación de un arreglo GAL

Figura 1.4 Programación del dispositivo GAL

1.3 Macroceldas lógicas de salida

Figura 1.5Arquitectura de una macrocelda OLMC 22V1O

1.4 Dispositivos lógicos programables complejos (CPLD)

Un circuito CPLD consiste en un arreglo de múltiples PLD agrupados como bloques en un

En su estructura básica, cada CPLD contiene múltiples bloques lógicos (similares al

Figura 1.6Arquitectura básica de un CPLD

1.4.1 Arreglos de compuertas programables en campo (FPGA)

Figura 1.7 Arquitectura básica de un FPGA

En la figura 1.8 se puede observar una arquitectura FPGA de la familia XC4000 de la

Figura 1.8 Arquitectura del FPGA XC4000 de Xilinx

Los bloques lógicos (llamados también celdas generadoras de funciones) están

Cuando se aplica alguna combinación en las entradas de la LUT, el circuito la traduce en

Figura 1.9 Arquitectura de un bloque lógico configurable FPGA

En un dispositivo FPGA, los CLB están ordenados en arreglos de matrices programables

En algunas ocasiones se pueden confundir los dispositivos de FPGA y CPLD, ya que

1.5 Metodología de diseño con FPGA's

La metodología de diseño es similar a la cualquier sistema digital, salvo que al final se

La especificación de un circuito se realizaba sólo de una manera: utilizando esquemas

1.6 Configuración y uso del software y hardware FPGA

1.7 Breve historia del lenguaje VHDL

VHDL es el Lenguaje de Descripción de Hardware, que se desarrolló en los años de1980s

La primera versión públicamente disponible de VHDL, versión 7.2, se liberó en 1985.En

2 TARJETA DE DESARROLLO NEXYS 2

El participante identificará las características generales de la tarjeta de desarrollo Nexys 2

2.1 Características generales

Figura 2.1 Tarjeta Nexys2

Sus características principales son:

• FPGA Xilinx Spartan-3E, 500K puertas.

La figura 2.2 muestra el diagrama a bloques de la tarjeta Nexys 2.

Figura 2.2 Diagrama a bloques tarjeta Nexys 2

En la figura 2.3 se muestran las conexiones en la placa de los pulsadores, interruptores

2.2 Verificación de funcionamiento

Para garantizar el funcionamiento de las tarjetas se establece el siguiente protocolo de

Figura 2.3 Verificación del correcto funcionamiento de la tarjeta Nexys 2

El participante reconocerá la organización básica de VHDL identificando las partes

Tal como se había indicado anteriormente, VHDL (Hardware Description Language) es un

3.1 Unidades básicas de diseño