Manual Del Participante FPGA RV 3

Diseo bsico en FPGA con VHDL
1
Al Servicio del Sistema Nacional de Educacin Superior Tecnolgica
CRO-GT-PO-OO2-04 REV. 1

Contenido
PRESENTACIN .............................................................................................................................. 4
OBJETIVO DEL CURSO .................................................................................................................... 5
1 INTRODUCCIN ...................................................................................................................... 6
1.1 Dispositivos lgicos programables (PLD) ......................................................................... 6
1.1.1 Estructura interna de un PLD ...................................................................................... 8
1.2 Arreglo Lgico Genrico (GAL) ...................................................................................... 10
1.2.1 Programacin de un arreglo GAL ............................................................................... 11
1.3 Macroceldas lgicas de salida ....................................................................................... 12
1.4 Dispositivos lgicos programables complejos (CPLD)..................................................... 12
1.4.1 Arreglos de compuertas programables en campo (FPGA) .......................................... 13
1.5 Metodologa de diseo con FPGA's ............................................................................... 15
1.6 Configuracin 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 Caractersticas generales .............................................................................................. 18
2.2 Verificacin de funcionamiento .................................................................................... 20
3 ORGANIZACIN DE VHDL ..................................................................................................... 22
3.1 Unidades bsicas de diseo .......................................................................................... 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 Declaracin de entidades .......................................................................................... 25
3.2.5 Identificadores .......................................................................................................... 26
3.2.6 Diseo de entidades mediante vectores.................................................................... 26
3.2.7 Declaracin de entidades mediante libreras y paquetes ........................................... 28
3.3 Paquetes ...................................................................................................................... 28
3.4 Arquitecturas ................................................................................................................ 29
3.4.1 Descripcin funcional ................................................................................................ 29

2
3.4.2 Descripcin por flujo de datos................................................................................... 31
4 AMBIENTE DE TRABAJO XILINX ISE DESIGN SUITE 12.1 ......................................................... 33
4.1 Arranque del programa ................................................................................................ 33
4.2 Creacin de proyecto .................................................................................................... 35
4.3 Creacin de un archivo fuente HDL ............................................................................... 38
4.4 Implementacin en la tarjeta Nexys2 ............................................................................ 44
Ejercicio 4.1.- Creacin de un proyecto ................................................................................. 46
5. DISEO LGICO COMBINACIONAL EN VHDL ......................................................................... 47
5.1. Programacin de estructuras bsicas mediante declaraciones concurrentes ................. 47
5.1.1. Declaraciones condicionales asignadas a una seal (when-else) ................................ 47
Ejercicio 5.1.-Primer ejercicio con declaracin When-Else. ................................................... 48
Ejercicio 5.2.-Segundo ejercicio con declaracin When-Else ................................................. 49
5.1.2. Operadores lgicos ................................................................................................... 49
5.1.3. Declaraciones concurrentes asignadas a seales ....................................................... 49
Ejercicio 5.3.- Circuito lgico con compuertas ....................................................................... 50
Ejercicio 5.4.- Segundo circuito lgico con compuertas ......................................................... 50
5.1.4. Seleccin de una seal (with-select-when) ................................................................ 50
Ejercicio 5.5. - Declaracin With-Select-When ...................................................................... 51
Ejercicio 5.6.- Implementacin de tabla de verdad ............................................................... 51
5.2. Programacin de estructuras bsicas mediante declaraciones secuenciales .................. 52
5.2.1 Declaracin 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. Diseo 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

3
6 DISEO LGICO 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.- Implementacin del Flip-Flop D ...................................................................... 65
6.4 Flip-Flop SR ........................................................................................................................ 66
Ejercicio 6.2.- Implementacin 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. Creacin de un diseo estructural................................................................................. 71
Ejercicio 7.1 Diseo estructural ............................................................................................ 73
7.2. Divisor de frecuencia .................................................................................................... 73
Ejercicio 7.2 Implementacin de un divisor de frecuencia ..................................................... 75
Ejercicio 7.3 Contador de 4 bits con divisor de frecuencia ..................................................... 75
8. Simulacin de diseos .............................................................................................................. 76
8.1 Creacin de un archivo de prueba ...................................................................................... 76
8.2 Arranque de la aplicacin ModelSim XE .............................................................................. 80
8.3 Revisin de la simulacin .................................................................................................... 82
Ejercicio 8.1 Simulacin de un Flip-Flop D ............................................................................. 83
Ejercicio 8.2 Simulacin de un divisor de frecuencia ............................................................. 83
Ejercicio 8.3 Simulacin de un contador de 4 bits con divisor de frecuencia .......................... 83
9. Mquina de estados en VHDL ................................................................................................... 84
9.1 Definicin de mquina de estados ...................................................................................... 84
9.2 Diseo de una mquina de estados Moore ......................................................................... 86
Ejercicio 9.1 Simulacin de una mquina de estados ............................................................ 90
Ejercicio 9.2 Contador de 3 bits con mquina de estados ...................................................... 90
BIBLIOGRAFIA .............................................................................................................................. 91


4
PRESENTACIN

El lenguaje de descripcin de hardware VHDL es considerado como una de las mximas
herramienta de diseo por las industrias y universidades de todo el mundo, pues
proporciona a los usuarios muchas ventajas de la planeacin y diseo de los sistemas
electrnicos digitales.

Este curso abarca los conocimientos bsicos para comenzar a disear en VHDL haciendo
uso de la tarjeta de desarrollo Nexys 2, sin embargo, dichos conocimientos son aplicables
tambin 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 ubicacin
de los pines de entrada y de salida del FPGA.

En el primer captulo se muestra una introduccin a los diferentes dispositivos lgicos
programables (PLDs), una breve introduccin al software utilizado para programar las
FPGAs Spartan 3 y Spartan 3E, as como una breve historia del lenguaje VHDL.

En el segundo captulo se muestra las caractersticas generales de la tarjeta de desarrollo
Nexys 2.
El tercer captulo trata acerca de las partes que conforman un diseo en VHDL, la entidad y
la arquitectura, as como las libreras que se utilizan.
En el cuarto captulo se introduce al ambiente de desarrollo del software XILINX ISE
DESIGN SUITE 12.1, tambin se muestra como crear un proyecto y como implementarlo
en la tarjeta Nexys 2.
En el quinto captulo se introduce al diseo lgico combinacional en VHDL, se muestran
los operadores lgicos, declaraciones concurrentes asignadas a seales y se realizan los
diseos de buffers, multiplexores, sumadores y un decodificador.
El uso del reloj interno de la tarjeta para el diseo lgico secuencial se muestra en el
captulo 6, en el cual se muestra el diseo de flip-flops, registros y contadores.
Una introduccin a VHDL estructural se muestra en el captulo 7, en la cual se hace nfasis
en la importancia de esta metodologa para reducir el tiempo de diseo de algn proyecto
entre otras ventajas.
El captulo ocho muestra la manera de simular nuestros diseos desarrollados haciendo uso
del software ModelSIM.
Por ltimo en el captulo nueve se muestra los elementos bsicos que conforman una
mquina de estados en VHDL.

5
OBJETIVO DEL CURSO

El participante comprender y aplicar los principios bsicos del lenguaje VHDL haciendo
uso de una tarjeta de desarrollo basada en un FPGA de manera adecuada.


6
1 INTRODUCCIN

Objetivo de la unidad

El participante identificar las caractersticas principales de los dispositivos lgicos
programables y del lenguaje VHDL mediante la presentacin de dichos temas de acuerdo al
plan de sesin.

En la actualidad el nivel de integracin alcanzado con el desarrollo de la microelectrnica
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 caractersticas como
velocidad, confiabilidad, consumo de potencia y sobre todo el rea de diseo. Esta ltima
caracterstica nos ha permitido observar da a da cmo los sistemas de uso industrial,
militar y de consumo han minimizado el tamao de sus desarrollos.

El proceso de miniaturizacin de los sistemas electrnicos comenz con la interconexin de
elementos discretos como resistencias, capacitores, resistores, bobinas, etc., todos
colocados en un chasis reducido y una escasa separacin entre ellos. Posteriormente se
disearon y construyeron los primeros circuitos impresos, que relacionan e interconectan
los elementos mencionados a travs de cintas delgadas de cobre adheridas a un soporte
aislante (por lo general baquelita) que permite el montaje de estos elementos.

Ms tarde, el desarrollo del transistor de difusin planar, construido durante 1947 y 1948,
permiti en 1960 la fabricacin del primer circuito integrado monoltico. Este integra
cientos de transistores, resistencias, diodos y capacitores, todos fabricados sobre una
pastilla de silicio. Como es del conocimiento general, el trmino monoltico se deriva de las
races griegas "mono" y "lithos" que significan uno y piedra, respectivamente; por tanto,
dentro de la tecnologa de los circuitos integrados un circuito monoltico 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 lgicos programables (PLD)

Los dispositivos lgicos programables (o PLD, por sus siglas en ingls) favorecen la
integracin de aplicaciones y desarrollos lgicos mediante el empaquetamiento de
soluciones en un circuito integrado. El resultado es la reduccin de espacio fsico dentro de
la aplicacin; es decir, se trata de dispositivos fabricados y revisados que se pueden
personalizar desde el exterior mediante diversas tcnicas de programacin. El diseo se
basa en bibliotecas y mecanismos especficos de mapeado de funciones, mientras que su

7
implementacin tan slo requiere una fase de programacin del dispositivo que el diseador
suele realizar en unos segundos.

En la actualidad, el diseo de ASIC (circuitos integrados desarrollados para aplicaciones
especficas) domina las tendencias en el desarrollo de aplicaciones a nivel de
microelectrnica. Este diseo presenta varias opciones de desarrollo, sin embargo, su
diseo ahora slo es adecuado en aplicaciones que requieren un alto volumen de
produccin; por ejemplo, sistemas de telefona celular, computadoras porttiles, cmaras de
video, etctera.

Los FPGA (arreglos de compuertas programables en campo) y CPLD (dispositivos lgicos
programables complejos) ofrecen las mismas ventajas de un ASIC, slo que a un menor
costo; es decir, el costo por desarrollar un ASIC es mucho ms alto que el que precisara un
FPGA o un CPLD, con la ventaja de que ambos son circuitos reprogramables, en los cuales
es posible modificar o borrar una funcin programada sin alterar el funcionamiento del
circuito.

En la actualidad existe una gran variedad de dispositivos lgicos programables, los cuales
se usan para reemplazar circuitos SSI (pequea escala de integracin), MSI (mediana escala
de integracin) e incluso circuitos VLSI (muy alta escala de integracin), ya que ahorran
espacio y reducen de manera significativa el nmero y el costo de los diseos. 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 caractersticas.

Tabla 1.1 Dispositivos lgicos programables


8
1.1.1 Estructura interna de un PLD

Los dispositivos PROM, PLA, PAL y GAL estn formados por arreglos o matrices que
pueden ser fijos o programables, mientras que los CPLD y FPGA se encuentran
estructurados mediante bloques lgicos configurables y celdas lgicas de alta densidad,
respectivamente.

La arquitectura bsica 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 continuacin.

a) Arreglo AND. Est formado por varias compuertas AND interconectadas a travs de
alambres, los cuales cuentan con un fusible en cada punto de interseccin (Figura 1.1a). En
esencia, la programacin del arreglo consiste en fundir o apagar los fusibles para eliminar
las variables que no sern utilizadas (Figura 1.1b). Obsrvese cmo 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


9
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 interseccin. 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 bsica de PLD

De acuerdo con lo anterior, observemos en la tabla 1.2 la estructura de los dispositivos
lgicos programables bsicos.


10

Tabla 1.2Dispositivos lgicos programables

La PROM no se utiliza como un dispositivo lgico, 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 tambin FPLA (arreglo lgico 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 implementacin de fusibles adicionales, que resultan de la utilizacin de
dos arreglos programables y de la complejidad del circuito. Un ejemplo tpico de estos
dispositivos es la familia PAL16R8, la cual fue desarrollada por la compaa 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 Lgico Genrico (GAL)

El arreglo lgico genrico (GAL) es similar al PAL, ya que se forma con arreglos AND
programable y OR fijo, con una salida lgica programable. Las dos principales diferencias
entre los dispositivos GAL y PAL radican en que el primero es reprogramable y contiene
configuraciones de salida programables.


11
Los dispositivos GAL se pueden programar una y otra vez, ya que usan la tecnologa E2
CMOS (Ellectrically Erasable CMOS: CMOS borrable elctricamente), en lugar de
tecnologa bipolar y fusibles (Fig. 1.3).

Figura 1.3Diagrama de bloques del arreglo GAL

1.2.1 Programacin 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
sus complementos. Cuando se programa una celda, sta se activa mediante la aplicacin de
cualquier combinacin de las variables de entrada o sus complementos a la compuerta
AND. Esto permite la implementacin de cualquier funcin (producto de trminos)
requerida.

Figura 1.4 Programacin del dispositivo GAL


12
1.3 Macroceldas lgicas de salida

Una macrocelda lgica de salida (u OLMC, de output logic macrocell) est formada por
circuitos lgicos que se pueden programar como lgica combinacional o secuencial. Las
configuraciones combinacionales se implementan por medio de programacin, 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

Puede haber de ocho a diecisis 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 lneas de entrada al buffer triestado de salida, en funcin de las lneas de
seleccin 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 lneas de seleccin se programa mediante un grupo de celdas especiales que se
encuentran en el arreglo AND.

1.4 Dispositivos lgicos programables complejos (CPLD)

Un circuito CPLD consiste en un arreglo de mltiples PLD agrupados como bloques en un
chip. En algunas ocasiones estos dispositivos tambin se conocen como EPLD (Enhanced
PLD: PLD mejorado), Super PAL, Mega PAL, etc. Se califican como de alto nivel de
integracin, ya que tienen una gran capacidad equivalente a unos 50 PLD sencillos.


13
En su estructura bsica, cada CPLD contiene mltiples bloques lgicos (similares al
GAL22V10) conectados por medio de seales canalizadas desde la interconexin
programable (PI). Esta unidad PI se encarga de interconectar los bloques lgicos y los
bloques de entrada/salida del dispositivo sobre las redes apropiadas (Fig. 1.6).

Figura 1.6Arquitectura bsica de un CPLD

Los bloques lgicos, tambin conocidos como celdas generadoras de funciones, estn
formados por un arreglo de productos de trminos que implementa los productos efectuados
en las compuertas AND, un esquema de distribucin de trminos 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 tamao de los bloques lgicos es
importante, ya que determina cunta lgica se puede implementar dentro del CPLD; esto
es, fija la capacidad del dispositivo.

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 lgicos configurables (CLB), bloques de entrada y de salida (IOB) y canales de
comunicacin. A diferencia de los CPLD, la densidad de los FPGA se establece en
cantidades equivalentes a cierto nmero de compuertas.

Por adentro, un FPGA est formado por arreglos de bloques lgicos configurables (CLB),
que se comunican entre ellos y con las terminales de entrada/ salida (E/S) por medio de
alambrados llamados canales de comunicacin. Cada FPGA contiene una matriz de bloques
lgicos idnticos, por lo general de forma cuadrada, conectados por medio de lneas
metlicas que corren vertical y horizontalmente entre cada bloque (Fig. 1.7).


14

Figura 1.7 Arquitectura bsica de un FPGA

En la figura 1.8 se puede observar una arquitectura FPGA de la familia XC4000 de la
compaa Xilinx. Este circuito muestra a detalle la configuracin interna de cada uno de los
componentes principales que conforman este dispositivo.

Figura 1.8 Arquitectura del FPGA XC4000 de Xilinx

Los bloques lgicos (llamados tambin celdas generadoras de funciones) estn
configurados para procesar cualquier aplicacin lgica. Estos bloques tienen la
caracterstica de ser funcionalmente completos; es decir, permiten la implementacin de
cualquier funcin booleana representada en la forma de suma de productos. El diseo
lgico se implementa mediante bloques conocidos como generadores de funciones o LUT
(Look Up Table: tabla de bsqueda), los cuales permiten almacenar la lgica requerida, ya
que cuentan con una pequea memoria interna, por lo general de 16 bits.

Cuando se aplica alguna combinacin en las entradas de la LUT, el circuito la traduce en
una direccin de memoria y enva fuera del bloque el dato almacenado en esa direccin. En

15
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 lgico configurable FPGA

En un dispositivo FPGA, los CLB estn 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 vas o canales de
comunicacin.

En algunas ocasiones se pueden confundir los dispositivos de FPGA y CPLD, ya que
ambos utilizan bloques lgicos en su fabricacin. La diferencia entre ellos radica en el
nmero de flip-flops utilizados, mientras la arquitectura del FPGA es rica en registros.

1.5 Metodologa de diseo con FPGA's

La metodologa de diseo 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 diseo esperado.

Primero hay que tener una descripcin del circuito a realizar. Tradicionalmente en las
ingenieras se realizan planos o esquemas para esta descripcin, de forma similar a como
un arquitecto disea un edificio. Sin embargo es posible realizar una descripcin del
hardware utilizando algn lenguaje de descripcin de hardware, como VHDL o Verilog
Con esta descripcin se pueden realizar simulaciones del circuito, para comprobar que lo
diseado trabaja correctamente de lo contrario se volver a modificar la descripcin
(esquemas programa) hasta que la simulacin sea satisfactoria. Hasta aqu slo se ha

16
utilizado la computadora y no se tocado hardware. Sin embargo en el caso del software, la
propia simulacin es la ejecucin del programa. Se observa directamente el resultado del
programa y se modifican el cdigo 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 especificacin hardware y utilizando un compilador especial,
obtenemos un archivo binario, llamado bitstream que contiene toda la informacin
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 queramos 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 diseo se pueden hacer igual de rpidos que en el caso
de software. Slo hay que cambiar la especificacin del diseo, volver a compilar y
reconfigurar la FPGA con el nuevo bitstream generado.

La especificacin de un circuito se realizaba slo de una manera: utilizando esquemas
grficos, en los que cada smbolo representa un componente o elemento lgico:
multiplexores, puertas lgicas, etc. Existe otra manera de describir un circuito: utilizando
los llamados lenguajes de descripcin hardware. Existen varios: VHDL, Verilog, Handle
C, JBits. La ventaja de estos lenguajes es que adems de permitir describir el circuito,
permiten definir bancos de pruebas (testbench), que son muy tiles para la simulacin y la
depuracin.

1.6 Configuracin y uso del software y hardware FPGA

El software de diseo programacin y simulacin INTEGRATED SOFTWARE
ENVI ROMENT (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 programacin grfico o usando lenguaje VHDL y realizar la
simulacin de su funcionamiento sin el riesgo de ocasionar daos a los circuitos.

1.7 Breve historia del lenguaje VHDL

VHDL es el Lenguaje de Descripcin de Hardware, que se desarroll en los aos de1980s
como un proyecto de investigacin de circuito integrado de gran velocidad el cual fue
consolidado por el Departamento Americano de Defensa. Un equipo de ingenieros de tres
compaas - IBM, Texas Instruments e Intermetrics fue contratado por el Departamento de
Defensa para completar la especificacin y aplicacin de un nuevo idioma basado en
mtodo de descripcin de diseos digitales ideado por ellos.


17
La primera versin pblicamente disponible de VHDL, versin 7.2, se liber en 1985.En
1986, el Instituto de Ingenieros Elctricos y Electrnicos (IEEE) se present con una
propuesta para estandarizar el idioma que hizo en 1987, despus de que las mejoras
sustanciales y modificaciones fueron hechas por un equipo de gobierno y representantes
acadmicos. La norma resultante, IEEE 1076-1987, es la base virtual para cada simulacin
y el producto de la sntesis vendido hoy. Una nueva versin 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 difcil la descripcin completamente porttil del diseo (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 seales diferentes o las condiciones de la
simulacin normalmente usadas como los desconocidos y alta-impedancia.

Poco despus IEEE 1076-1987 fue adoptada, las compaas de simuladores empezaron
reforzando VHDL con los nuevos tipos no estandarizados y permitirles a sus clientes
simular los circuitos electrnicos complejos con precisin. Esto caus problemas porque las
descripciones de un diseo entraron en un simulador donde a menudo eran incompatibles
con otros ambientes de simulacin. VHDL estaba volvindose no estandarizable
rpidamente creando un problema. Otra norma se desarroll por un comit de IEEE. Esta
norma, numerada 1164, define un paquete estndar (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
Lgica estndar.

Las normas IEEE 1076-1987 e IEEE 1164 completan el estndar VHDL siendo elms
usado hoy.


18
2 TARJETA DE DESARROLLO NEXYS 2

El participante identificar las caractersticas generales de la tarjeta de desarrollo Nexys 2
mediante la presentacin de dicho tema de acuerdo al plan de sesin.

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 Xilinxs MicroBlaze.

2.1 Caractersticas generales

La Nexys2 contiene una FPGA de Xilinx modelo Spartan3E XC3S500E o XC3S1200E con
encapsulado FG320 (figura 2.1). Estas FPGA tienen respectivamente 500 000 o 1 200 000
puertas lgicas equivalentes.

Figura 2.1 Tarjeta Nexys2


19

Sus caractersticas principales son:

FPGA Xilinx Spartan-3E, 500K puertas.
Puerto USB2 para alimentacin de la placa, configuracin 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 alimentacin conmutadas de alta eficiencia (adecuadas para aplicaciones
alimentadas por batera).
Oscilador de 50MHz, adems de un socket para la posible adicin de un segundo
oscilador.
75 entradas/salidas de la FPGA enrutadas hacia los conectores de expansin (un conector
de alta velocidad Hirose FX2 con 43 seales y cuatro conectores Pmod 26).
Todas las seales de entrada/salida son ESD y protegidas por circuito, asegurando una
larga vida de operacin en cualquier tipo de ambiente de uso.
Las entradas/salidas de la placa incluyen 8 LEDs, un display de cuatro dgitos 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 y
LEDS. Analizando la figura podemos observar que al pulsar o conectar un interruptor
enviamos un 1 al pin de la FPGA, y de manera anloga, 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
lgica directa con los pulsadores, interruptores y LED.

20

Como se puede apreciar, los pulsadores tampoco tienen circuitera de anulacin de rebotes.
En la figura tambin se indican los pines de la FPGA que se conectan a stos.

Figura 2.3Conexiones de los pulsadores, interruptores y LED de propsito general en la tarjeta Nexys2
2.2 Verificacin de funcionamiento

Para garantizar el funcionamiento de las tarjetas se establece el siguiente protocolo de
revisin que permitir conocer el estado del dispositivo. Descargar de la siguiente pgina
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)

21

Figura 2.3 Verificacin del correcto funcionamiento de la tarjeta Nexys 2


22
3 ORGANIZACIN DE VHDL


El participante reconocer la organizacin bsica de VHDL identificando las partes
principales de dicho lenguaje de acuerdo al plan de sesin.

Tal como se haba indicado anteriormente, VHDL (Hardware Description Language) es un
lenguaje orientado a la descripcin 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 electrnico digital.

3.1 Unidades bsicas de diseo

La estructura general de un programa en VHDL est formada por mdulos o unidades de
diseo, cada uno de ellos compuesto por un conjunto de declaraciones e instrucciones que
definen, describen, estructuran, analizan y evalan el comportamiento de un sistema digital.
Existen cuatro tipos de unidades de diseo en VHDL: declaracin de entidad (entity
declaration), arquitectura (architecture), declaracin 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 mdulos, pero dos de ellos (entidad y arquitectura) son
indispensables en la estructuracin de un programa.
3.2 Entidad

Una entidad (entity) es el bloque elemental de diseo en VHDL, Las entidades son todos
los elementos electrnicos (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 slo las entradas (Cin, A y B) y salidas
(SUMA y Cout) del circuito: figura 3.1b). De igual forma, la integracin 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.


23

Figura 3.1 a) Descripcin a nivel de compuertas, b) Smbolo funcional de la entidad; c) Diagrama a
bloques representativo de la entidad.

3.2.1 Puertos de entrada y salida

Cada una de las seales de entrada y salida en una entidad son referidas como puerto, el
cual es similar a una terminal (pin) de un smbolo esquemtico.
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 direccin
que tomar la informacin y el tipo define qu clase de informacin 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


24
3.2.2 Modos

Un modo permite definir la direccin en la cual el dato es transferido a travs 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 seales de entrada a la entidad. Este slo es unidireccional y
nada ms permite el flujo de datos hacia dentro de la entidad.
Modo out. Indica las seales de salida de la entidad.
Modo inout. Permite declarar a un puerto de forma bidireccional es decir, de
entrada/salida; adems permite la retroalimentacin de seales 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 seales
3.2.3 Tipos de datos

Los tipos son los valores (datos) que el diseador establece para los puertos de entrada y
salida dentro de una entidad; se asignan de acuerdo con las caractersticas de un diseo en
particular. Algunos de los tipos ms utilizados en VHDL son:
Bit El cual tiene valores de 0 y 1 lgico.
Boolean (Booleano) que define valores de verdadero o falso en una expresin
Bit_vector (Vectores de bits) que representa un conjunto de bits para cada variable de
entrada o salida.
Integer (Entero) que representa un nmero 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

25
Z --Alta impedancia
L -- 0 Debil
H -- 1 Debil
- -- Sin importancia (dont care)
Std_logic_vector Vectores del std_logic

3.2.4 Declaracin de entidades

Como se mencion anteriormente, los mdulos elementales en el desarrollo de un programa
dentro del lenguaje de descripcin en hardware (VHDL) son la entidad y la arquitectura.

La declaracin de una entidad consiste en la descripcin de las entradas y salidas de un
circuito de diseo identificado como entity (entidad); es decir, la declaracin seala las
terminales o pines de entrada y salida con que cuenta la entidad de diseo.

Por ejemplo, la forma de declarar la entidad correspondiente al circuito sumador de la
figura 3.1 se muestra a continuacin:

1 --Declaracin 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 Declaracin de la entidad sumador de la figura 2.1b).

Los nmeros de las lneas (1, 2, 3, 4, 5) no son parte del cdigo; se usan como referencia
para explicar alguna seccin en particular. Las palabras en negritas estn reservadas para el
lenguaje de programacin VHDL; esto es, tienen un significado especial para el programa;
el diseador asigna los otros trminos.

Ahora comencemos a analizar el cdigo lnea por lnea. Observemos que la lnea 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 lnea 2 se inicia la declaracin 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 lneas 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

26
que slo pueden manejarse valores de '0' y '1' lgicos. Por ltimo, en la lnea 5 termina la
declaracin de entidad con la palabra reservada end, seguida del nombre de la entidad
(sumador).

Debemos notar que como cualquier lenguaje de programacin, VHDL sigue una sintaxis y
una semntica dentro del cdigo, mismas que hay que respetar. En esta entidad conviene
hacer notar el uso de punto y coma (;) al finalizar una declaracin 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, seales, procesos, etc. Pueden ser nmeros, letras del alfabeto y
guiones bajos ( _ ) que separen caracteres y no tienen una restriccin 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 Diseo de entidades mediante vectores

La entidad sumador realizada en el circuito del listado 3.1, usa bits individuales, los cuales
slo pueden representar dos valores lgicos (0 o 1). De manera general, en la prctica 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 considrense los vectores de 4 bits que se muestran a continuacin:

vector_A = [A3, A2, Al, AO]
vector_B = [B3, B2, Bl, BO]
vector_SUMA = [S3, S2, SI, SO]


27
En la figura 3.4 se observa la entidad del sumador analizado antes, slo que ahora las
entradas A, B y la salida SUMA incorporan vectores de 4 bits en sus puertos. Obsrvese
cmo 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 configuracin que utilice vectores consiste en la
utilizacin de la sentencia bit_vector, mediante la cual se especifican los componentes de
cada uno de los vectores utilizados. La parte del cdigo 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 declaracin 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 agruparan 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 continuacin se describe en VHDL la entidad del circuito sumador representado en la
figura 2.4. Observe cmo 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;


28
3.2.7 Declaracin de entidades mediante libreras y paquetes

Una parte importante en la programacin con VHDL radica en el uso de libreras y
paquetes que permiten declarar y almacenar estructuras lgicas, seccionadas o completas
que facilitan el diseo.

Una librera o biblioteca es un lugar al que se tiene acceso para utilizar las unidades de
diseo predeterminadas por el fabricante de la herramienta (paquete) y su funcin es
agilizar el diseo. En VHDL se encuentran definidas dos libreras llamadas ieee y work.

Cuando en el diseo se utiliza algn paquete es necesario llamar a la librera que lo
contiene. Para esto se utiliza la siguiente declaracin:

library ieee;

Lo anterior permite el uso de todos los componentes incluidos en la librera ieee. En el caso
de la librera de trabajo (work), su uso no requiere la declaracin library, dado que la
carpeta work siempre est presente al desarrollar un diseo.

3.3 Paquetes

El paquete std_logic_1164 (estndar lgico_1164) que se encuentra en la librera ieee
contiene todos los tipos de datos que suelen emplearse en VHDL (std_logic_vector,
std_logic, entre otros).

El acceso a la informacin contenida en un paquete es por medio de la sentencia use,
seguida del nombre de la librera y del paquete, respectivamente:

use nombre_librera.nombre_paquete.all;

por ejemplo:

use IEEE.STD_LOGIC_1164.ALL;

El paquete use IEEE.STD_LOGIC_ARITH.ALL; define funciones y operadores
aritmticos, como igual (=), mayor que (>), menor que (<), entre otros.


29
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 llevarn
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 diseos; es decir, mediante el algoritmo de programacin
empleado se puede describir desde el nivel de compuertas hasta sistemas complejos.
3.4.1 Descripcin funcional

En la figura 3.5 se describe funcionalmente el circuito comparador. Se trata de una
descripcin funcional porque expone la forma en que trabaja el sistema; es decir, las
descripciones consideran la relacin que hay entre las entradas y las salidas del circuito, sin
importar cmo est organizado en su interior. Para este caso:

Figura 3.5Descripcin funcional de un comparador de igualdad de dos bits

El cdigo que representa el circuito de la figura 3.5 se muestra en el listado 3.2:


30

Listado 3.2 Arquitectura funcional de un comparador de igualdad de 2 bits

Nte cmo la declaracin de la entidad (entity) se describe en las lneas de la 1 a la 7; el
cdigo ocupa de la lnea 8 a la 18, donde se desarrolla el algoritmo (architecture) que
describe el funcionamiento del comparador. Para iniciar la declaracin de la arquitectura
(lnea 8), es necesario definir un nombre arbitrario con que se pueda identificar en
nuestro caso el nombre asignado fue funcional adems de incluir la entidad con que se
relaciona (comp). En la lnea 9 se puede observar el inicio (begin) de la seccin donde se
comienzan a declarar los procesos que rigen el comportamiento del sistema.

La declaracin del proceso (lnea 10) se utiliza para la definicin 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 seales que
determinan el funcionamiento del proceso. Al seguir el anlisis, puede notarse que de la
lnea 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 (lnea 12): si el valor de la seal a es
igual al valor de la seal b, entonces '1' se asigna a c, si no (else)se asigna un '0' (el
smbolo < = 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 aade la etiqueta (funcional) al terminar la arquitectura en la
lnea 18.


31
3.4.2 Descripcin por flujo de datos

La descripcin por flujo datos indica la forma en que los datos se pueden transferir de una
seal a otra sin necesidad de declaraciones secuenciales (if-then-else). Este tipo de
descripciones permite definir el flujo que tomarn los datos entre mdulos encargados de
realizar operaciones. En este tipo de descripcin se pueden utilizar dos formatos: mediante
instrucciones when else (cuando-si no) o por medio de ecuaciones booleanas.

a) Descripcin por flujo de datos mediante when-else

A continuacin se muestra el cdigo del comparador de igualdad de dos bits descrito antes
(figura 3.6) Ntese que la diferencia entre los listados 3.2 y 3.3 radica en la eliminacin del
proceso y en la descripcin sin declaraciones secuenciales (if-then-else).

Listado 3.3 Arquitectura por flujo de datos

b) Descripcin 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 obtencin de sus
ecuaciones booleanas. En el listado 3.4 se observa este desarrollo. El interior del circuito

32
comparador de la figura 3.6a) puede representarse por medio de compuertas bsicas [Fig.
3.7b)] y este circuito puede describirse mediante la obtencin 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
seal de salida c.


33
4 AMBIENTE DE TRABAJO XILINX ISE DESIGN SUITE 12.1


El participante identificar las caractersticas principales del ambiente de trabajo del
software Xilinx ISE mediante una prctica demostrativa de acuerdo al plan de sesin.

En este captulo se describe la manera de utilizar el programa Xilinx ISE Design Suite,
como se encuentra constituido as como la creacin de un nuevo proyecto y la creacin 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.1Project 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

34

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. Descripcin 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 diseo, es as como aqu aparecen las advertencias, los errores
detectados en la revisin de sintaxis, compilacin y simulacin de un diseo electrnico.

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.


35

Figura 4.3. cono del programa Xilinx ISE Design Suite 12.1

4.2 Creacin 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 Creacin de proyecto

La pgina de creacin de nuevo proyecto aparece, aqu damos la informacin general del
proyecto de la siguiente manera:

Project Name: Especifique el nombre del proyecto.

Project Location: Especifique la localizacin 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 botn ubicado al lado del campo Project Location y de la ruta
deseada.

NOTA: Cada proyecto debe tener su propia carpeta. Si mltiples proyectos quedan en la
misma carpeta pueden ocurrir conflictos.

Description: Permite escribir una descripcin del proyecto.

36
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 configuracin de los parmetros en un nuevo proyecto puede obtener ayuda para las
diferentes ventanas dando clic en el botn de More Info.

B.- Clic Next para moverse a la pgina de propiedades del dispositivo.

Use esta pgina (figura 4.6) para seleccionar el dispositivo y otra informacin del diseo de
su proyecto, seleccionar la herramienta de sntesis y lenguaje, y el simulador.

Product Category: Especfica la categora del producto segn su aplicacin. Esta seleccin
filtra las familias de dispositivos y dispositivos disponibles en los dos siguientes campos,
seleccionar All en este campo.

Family: Especfica la familia de dispositivos, o arquitectura Xilinx, dentro del cual se
implementara su diseo, seleccionar Spartan 3E para la tarjeta Nexys 2.


37
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 nmeros que se muestran despus de la S
muestran el nmero de compuertas del FPGA Spartan 3E.

Package: Especfica la presentacin del dispositivo con respecto al nmero de entradas y
salidas. Escoja el FG320 para la tarjeta Nexys 2.

Speed: Especifca la velocidad del dispositivo seleccionado. Para este caso escoja -4.

Top-Level Source Type: Especifica el tipo de fuente para el nivel de diseo.

Synthesis Tool: Especifca la herramienta de sntesis y lenguaje de sntesis usado para su
diseo en este caso Xilinx Synthesis Technology (XST) es suministrado con ISE. Escoja
XST (VHDL/Verilog).

Simulator Especifica la herramienta usada para simulacin.

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).


38

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 Creacin de un archivo fuente HDL

En esta seccin, se muestra la creacin del archivo fuente HDL para el diseo, para lo cual
se procede como sigue:

39

A. Clic en New Source de la pestaa 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 diseo
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 alfanumricos (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 informacin y ayuda detallada dar clic en
botn More Info

Figura 4.10 Seleccin tipo de fuente

40

D. Clic en Next.

E. Declare los puertos para el diseo de la compuerta con cuatro entradas y una salida, esta
se define seleccionando out, llenando la informacin 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

41

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 slo se ha creado la entidad, sino que se han
incluido unas cabeceras, bibliotecas y la declaracin 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 descripcin del diseo, entre otra informacin.

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 comn olvidarse de lo que se hace una vez que ha
transcurrido cierto tiempo.

Despus 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 realizacin de procesos matemticos.


42

a) b)
Figura 4.14 Bibliotecas ms usadas en VHDL

Despus de las referencias a las bibliotecas hay unos comentarios que puedes quitar. A
continuacin 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 cdigo de la estructura, se guarda el fichero y se
comprueba si se ha tenido algn error de sintaxis haciendo clic en Synthesize - XSTCheck
Syntax. Esto est en la subventana de Processes (figura 4.15).

Figura 4.15 Comprobacin de sintaxis

Si se tiene algn 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 terminacin 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

43
da clic en Next (Figura 4.16). Despus aparece una pantalla de confirmacin en la que se
debe dar clic en Finish.

Figura 4.16 Creacin 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 localizacin de los pines del proyecto en
cuestin (Figura 4.17).

Figura 4.17 Edicin 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

44
terminal H18 y finalmente a la C le corresponde la J14, esa es la sintaxis que debe llevar
para una correcta configuracin 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 sntesis e implementacin, viendo si hay algn
error o advertencia de importancia (warning).

4.4 Implementacin 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 ms cmoda. El nico inconveniente es que hay
que instalar el programa gratuito Adept.

Se debe asegurar que los jumpers de POWER SELECT (jumpers de seleccin alimentacin)
se encuentren en la posicin USB.

A continuacin se explica cmo se programa la tarjeta Nexys2 con la versin 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 ningn dispositivo conectado. Esto
se puede ver en la parte derecha de la ventana.


45

Figura 4.18 Pantalla inicial del Adept sin dispositivos conectados

Posteriormente se conecta la tarjeta Nexys2 a la computadora mediante el cable USB y
ponemos el interruptor de alimentacin en la posicin 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 volvindolo
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 instalacin 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, aparecern dos
componentes: uno es la FPGA y otro la memoria (PROM). Indicar tambin el modelo de
FPGA, que en este caso es la XC3S500E.


46

Figura 4.19 Pantalla del Adept que ha detectado la cadena J TAG de dispositivos (FPGA y PROM)

A continuacin se da clic en el botn browse correspondiente a la FPGA, y buscamos el
fichero con extensin 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
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, slo tenemos que hacer clic en Program y se programar la FPGA.
Ahora solo queda verificar el correcto funcionamiento de nuestro diseo en la tarjeta de
desarrollo.
Ejercicio 4.1.- Creacin de un proyecto

Crear e implementar en la tarjeta Nexys 2 el diseo explicado del subtema 4.1 al 4.4.


47
5. DISEO LGICO COMBINACIONAL EN VHDL


El participante aplicar los principios del diseo combinacional en VHDL mediante
diversos ejercicios prcticos utilizando la tarjeta de desarrollo Nexys 2 de manera
adecuada.

En este captulo se disean los circuitos combinacionales ms utilizados en el diseo lgico
a travs del lenguaje de descripcin en hardware. Esto permite introducir nuevos conceptos,
palabras reservadas, reglas, algoritmos, etc., que muestran la potencia y profundidad del
lenguaje VHDL.

5.1. Programacin de estructuras bsicas mediante declaraciones
concurrentes

Las declaraciones concurrentes suelen usarse en las descripciones de flujo de datos. Esto se
debe a que en una declaracin concurrente no importa el orden en que se escriban las
seales, ya que el resultado para determinada funcin sera el mismo.

En VHDL existen tres tipos de declaraciones concurrentes:

Declaraciones condicionales asignadas a una seal (when-else)
Declaraciones concurrentes asignadas a seales
Seleccin de una seal (with-select-when)

5.1.1. Declaraciones condicionales asignadas a una seal (when-else)

La declaracin when-else se utiliza para asignar valores a una seal, determinando as la
ejecucin de una condicin propia del diseo. Para ejemplificar, consideremos la entidad
mostrada en la figura 5.1, cuyo funcionamiento se define en la tabla de verdad.

48

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, segn se
muestra a continuacin:
1 -- Ejemplo combinacional bsico
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;

Ntese que la funcin de salida f (lnea 10) depende directamente de las condiciones que
presentan las variables de entrada, adems y dado que la ejecucin inicial de una u otra
condicin no afecta la lgica del programa, el resultado es el mismo; es decir, la condicin
de entrada "111", visualizada en la tabla de verdad, puede ejecutarse antes que la condicin
"000" sin alterar el resultado final.
Ejercicio 5.1.-Primer ejercicio con declaracin When-Else.

En base a lo visto en el captulo 4, introducir el diseo 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 diseo
realizado.

49
Ejercicio 5.2.-Segundo ejercicio con declaracin When-Else

Realizar haciendo uso de la declaracin When-Else un diseo lgico 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 diseo realizado.

5.1.2. Operadores lgicos

Los operadores lgicos ms utilizados en la descripcin 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 efecten 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 lgicos presentan el siguiente orden y
prioridad:

1) Expresiones entre parntesis
2) Complementos
3) Funcin AND
4) Funcin OR
Las operaciones xor y xnor son transparentes al compilador y las interpreta mediante la
suma de productos correspondiente a su funcin.

5.1.3.Declaraciones concurrentes asignadas a seales

En este tipo de declaracin encontraremos las funciones de salida mediante la ecuacin
booleana que describe el comportamiento de cada una de las compuertas. Obsrvese 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 lgico realizado con compuertas

El programa correspondiente al circuito de la figura 5.2 se muestra en el listado siguiente:


50
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 lgico con compuertas

Utilizar de SW0 a SW5 como entradas. Las salidas estarn dadas por los leds LD0, LD1 Y
LD2. Verificar el correcto funcionamiento del diseo realizado obteniendo su tabla de la
verdad.

Ejercicio 5.4.- Segundo circuito lgico con compuertas

Realizar un diseo lgico 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 diseo realizado.

5.1.4.Seleccin de una seal (with-select-when)

La declaracin with select - when se utiliza para asignar un valor a una seal con base en
el valor de otra seal previamente seleccionada. Por ejemplo, en el listado correspondiente
a la figura 5.3 se muestra el cdigo que representa a este tipo de declaracin. Como puede
observarse, el valor de la salida c depende de las seales de entrada seleccionadas a(0) y
a(1), de acuerdo con la tabla de verdad correspondiente.


51

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. - Declaracin 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 diseo.

Ejercicio 5.6.- Implementacin 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 declaracin When-Else.
2. Implementar la tabla de verdad haciendo uso de operadores lgicos (compuertas).
3. Implementar la tabla de verdad mediante la seleccin de una seal (With-Select-
When).


52
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. Programacin de estructuras bsicas 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 lgica descrita. A diferencia de una
declaracin concurrente, una secuencial debe ejecutarse en el orden en que aparece y
formar parte de un proceso (process).

5.2.1 Declaracin if-then-else (si-entonces-si no)

Esta declaracin sirve para seleccionar una condicin o condiciones basadas en el resultado
de evaluaciones lgicas (falso o verdadero). Por ejemplo, observemos que en la instruccin:

if la condicin es cierta then
realiza la operacin 1;
else
realiza la operacin 2;
end if;

Si (if) condicin se evala como verdadera, entonces (then) la instruccin indica que se
ejecutar la operacin 1. Por el contrario, si la condicin se evala como falsa (else) correr
la operacin 2. La instruccin que indica el fin de la declaracin es end if (fin del si). Un
ejemplo que ilustra este tipo de declaracin se ilustra en la figura 5.4.


53

Figura 5.4 Comparador de igualdad de dos bits

El cdigo correspondiente a esta entidad de diseo se muestra en el listado siguiente:

--Ejemplo de declaracin 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 slo son necesarias dos condiciones por evaluar, pero no en todos los diseos
es as. Por tanto, cuando se requieren ms 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 operacin es:

if la condicin 1 se cumple then
realiza operacin 1;
elsif la condicin 2 se cumple then
realiza operacin 2:
else
realiza operacin 3;
end if;

La sintaxis anterior se interpreta como sigue: Si (if) la condicin 1 es verdadera, entonces
(then) se ejecuta la operacin l, si no-si (elsif) se evala la condicin 2 y si es verdadera
entonces (then) se ejecuta la operacin 2, si no (else) se ejecuta la operacin 3.


54
Ejercicio 5.7.- Comparador de 2 bits

Introducir el diseo 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 relacinales se usan para evaluar la igualdad, desigualdad o la magnitud en
una expresin. Los operadores de igualdad y desigualdad ( = y /= ) se definen en todos los
tipos de datos. Los operadores de magnitud (<,<,> y > = ) lo estn slo dentro del tipo
escalar. En ambos casos debe considerarse que el tamao de los vectores en que se
aplicarn dichos operadores debe ser igual. En la tabla 5.1 se muestran estos operadores y
su significado.

Tabla 5.1 Operadores relacinales
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 travs 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
cdigo que describe su funcionamiento.

Figura 5.5 Buffer tri-estado

55

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 diseo
se prefiera utilizar el estndar std_logic_l164 y no el tipo bit, ya que el primero es ms
verstil al proveer valores de alta impedancia y condiciones de no importa, los cuales no
estn considerados en el tipo bit.

Ejercicio 5.8.- Buffer triestado

Introducir el diseo 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 disean describiendo su comportamiento mediante la declaracin
with-select-when o ecuaciones booleanas.


56
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
lneas de seleccin (s) de dos bits (s1 y s0) y la lnea de salida z (zl y z0).

En la figura 5.6 b) se muestra un diagrama simplificado que resalta la representacin
mediante vectores de bits.

Figura 5.6 a) Multiplexor de 4 bits, b) Multiplexor con vectores

En el listado siguiente se muestra la descripcin mediante with-select-when del multiplexor
dual de 2 x 4. En este caso la seal s determina cul de las cuatro seales se asigna a la
salida Z. Los valores de s estn dados como "00", "01" y "10"; el trmino others (otros)
especifica cualquier combinacin 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 sntesis reconoce como tipos lgicos
estndares.

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;

57
5.5. Sumadores

Para describir el funcionamiento de los circuitos sumadores es importante recordar las
reglas bsicas de la adicin.

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 nmeros A y B mostrados en la tabla 5.2.

Tabla 5.2Tabla de verdad de un circuito sumador

La ecuacin lgica que corresponde a la expresin es la funcin lgica or-
exclusiva A B, mientras que la ecuacin lgica del acarreo de salida es Cout = AB que
corresponde a la compuerta lgica and.

La realizacin fsica de estas ecuaciones se muestra en la figura 5.7a, en ella se presenta el
bloque lgico del medio sumador (MS) y la figura 5.7b representa su implantacin
mediante compuertas lgicas.

Figura 5.7 a) Diagrama a bloques de un medio sumador; b) Medio sumador lgico


58
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 diseo 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.Diseo 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 travs de su tabla de verdad.

Figura 5.8 a) Sumador completo; b) Tabla de verdad del medio sumador


59
Las ecuaciones reducidas mediante un mapa de Karnaugh correspondientes a la salida
Suma y Cout se muestran a continuacin

Si se manipulan las ecuaciones anteriores mediante lgebra booleana obtenemos que la
funcin de Suma y Cout puede expresarse como:

La realizacin fsica del circuito se basa en la utilizacin 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 programacin 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);

60
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 diseo 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 cdigo BCD en sus
entradas y proporciona salidas capaces de excitar un display de siete segmentos que indica
el dgito decimal seleccionado. En la figura 5.10 b) se observa la distribucin de los
segmentos dentro del display.

Figura 3.13 a) Decodificador BCD a siete segmentos, b) Configuracin 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 lgicos de salida correspondientes a cada segmento.


61

Tabla 5.3Valores lgicos correspondientes a cada segmento del display

La funcin del programa cuyo cdigo se exhibe en el listado mostrado ms 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 seal. En nuestro
ejemplo, se describe de qu manera se maneja el decodificador de acuerdo con el valor que
toma la seal A. Para fines prcticos 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 sntesis 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";
when "1000" => d <= "0000000";

62
when "1001" => d <= "0000100";
when others = > d < = "1111111";
end case;
end process;
end behavioral;

En la instruccin case-when podemos observar el uso de asignaciones dobles (=>d < = ),
las cuales permiten que una seal adopte un determinado valor de acuerdo con el
cumplimiento de una condicin especificada. Por ejemplo, en nuestro diseo estas
instrucciones se interpretan dela siguiente manera: cuando la seal A sea "0000", asigna a
la seal d el valor"0000001"; cuando A es "0001", asigna a d el valor "1001111", etc.

La seal nodo se utiliza en este diseo para especificar cul es el display que queremos
activar, en este caso es el display que se encuentra ms a la derecha de nuestra tarjeta.
Ejercicio 5.11.- Decodificador BCD a siete segmentos

Introducir el diseo 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 diseo.


63
6 DISEO LGICO SECUENCIAL EN VHDL


El participante aplicar los principios del diseo secuencial en VHDL mediante diversos
ejercicios prcticos 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 mayora de los sistemas que se encuentran en la
prctica incluyen elementos de memoria, los cuales requieren que el sistema se describa en
trminos de lgica secuencial.

En este captulo se describen algunos de los circuitos secuenciales ms utilizados en la
prctica, 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 slo depende del valor presente de las
entradas, sino tambin de la historia del sistema, segn se observa en la figura 6.1.

Figura 6.1 Estructura de un sistema secuencial

Bsicamente hay dos tipos de sistemas secuenciales: sncronos y asncronos; el
comportamiento de los primeros se encuentra sincronizado mediante el pulso de reloj del
sistema, mientras que el funcionamiento de los sistemas asncronos depende del orden y
momento en el cual se aplican sus seales de entrada, por lo que no requieren un pulso de
reloj para sincronizar sus acciones.

64
6.2 Flip-flops

El elemento de memoria utilizado indistintamente en el diseo de los sistemas sncronos o
asncronos se conoce como flip-flop o celda binaria.
La caracterstica principal de un flip-flop es mantener o almacenar un bit de manera
indefinida hasta que a travs de un pulso o una seal cambie de estado.

Los flip-flops ms conocidos son los tipos SR, JK, T y D.

6.2.1 Flip-Flop D

Es importante recordar el significado de la notacin 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 informacin 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 cul sea el valor previo que haya tenido la salida Q en el estado presente.

En el diseo secuencial con VHDL las declaraciones If-then-else son las ms utilizadas; por
ejemplo, el programa del listado mostrado ms abajo usa estas declaraciones.

65
La ejecucin del proceso es sensible a los cambios en clk (pulso de reloj); esto es, cuando
clk cambia de valor de una transicin 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 caractersticas 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 seal en particular.

En el cdigo del listado anterior podemos observar que la condicin if clk 'event es cierta
slo cuando ocurre un cambio de valor; es decir, un suceso (event) de la seal clk. Como se
puede apreciar, la declaracin (if-then) no maneja la condicin else, debido a que el
compilador mantiene el valor de Q hasta que no exista un cambio de valor en la seal clk.

Ejercicio 6.1.- Implementacin del Flip-Flop D

Introducir el diseo 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 diseo.


66
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 lgicos 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 lgico, la salida
Qt+j queda indeterminada; es decir, no es posible precisar su valor y ste puede adoptar el 0
1 lgico.

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 anlisis 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 lgico 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


67
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.- Implementacin del Flip-Flop SR

Introducir el diseo 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
diseo.
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 diseo es muy similar al flip-flop anterior, la diferencia radica en la
utilizacin 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;

68
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 diseo 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 diseo.

6.6 Contadores

Los contadores son entidades muy utilizadas en el diseo lgico. 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 presentacin del diagrama de tiempos de este circuito tiene la
finalidad de ilustrar el procedimiento que se sigue en la programacin, 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 (

69
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 seal auxiliar llamada Qaux porque la salida Q no puede usarse dentro del
proceso, la salida no puede emplearse para hacer lgica.

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 bsicamente 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 transicin 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 diseo 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 seal de control
(Up/Down) que determine el sentido del conteo: ascendente o descendente (Figura 6.6).


70

Figura 6.6 Contador binario de cuatro bits

La seal de control Up/Down permite definir si el conteo se realiza en sentido ascendente o
descendente. En nuestro caso, un cero aplicado a esta seal determina una cuenta
ascendente: del 0 al 15. De esta forma, el funcionamiento del circuito queda determinado
por dos seales: el pulso de reloj (clk) y la seal 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;


71
7. VHDL ESTRUCTURAL


El participante aplicar el diseo estructural en VHDL mediante ejercicios prcticos
utilizando la tarjeta de desarrollo Nexys 2 de manera adecuada.

Para disear un circuito grande es conveniente separarlo en bloques funcionales. Cada uno
de estos bloques se disea 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. Creacin de un diseo estructural

En un diseo grande puede haber varios niveles de jerarqua, donde unas arquitecturas
estructurales contienen a otras. Las ventajas de realizar el diseo de esta manera son varias,
entre ellas se cuentan las siguientes:

Permite dividir el circuito en partes ms sencillas, haciendo que el diseo
sea ms manejable y entendible. Esto adems facilita el trabajo en equipo.

Es fcil modificar algn bloque del diseo, mientras que se deja el resto igual.

Permite la reutilizacin ya que puede que un bloque de un diseo lo necesitemos par
a otro.

Para explicar cmo se describe una arquitectura estructural en VHDL, en este ejemplo se
asume que se han implementado en un nuevo proyecto el diseo de una compuerta XNOR
y en otro proyecto el diseo de una compuerta AND.

Con los diseos anteriores se pretende implementar el diseo del comparador de 2 bits de la
figura 7.1.


72

Figura 7.1.- Representacin esquemtica de un comparador de 2 bits

Para iniciar el diseo de una entidad de manera estructural, es necesario la descomposicin
lgica del diseo en pequeos submdulos (jerarquizar), los cuales permiten analizar de
manera prctica el circuito, ya que la funcin de entrada/salida es conocida. En el siguiente
ejemplo se conoce la funcin de salida de las dos compuertas xnor, por lo que al unirlas a la
compuerta and, la salida c es el resultado de la operacin and efectuada en el interior a
travs de las seales x0 y xl.

Es importante resaltar que una jerarqua en VHDL se refiere al procedimiento de dividir en
bloques y no a que un bloque tenga mayor jerarqua (peso) que otro.

En el listado siguiente se muestra el cdigo 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

73
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 lnea 7 se inicia la declaracin de la arquitectura estructural. El algoritmo propuesto
(lneas 21 a 23) describe la estructura de la siguiente forma: cada compuerta se maneja
como un bloque lgico independiente (componente) del diseo 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 seal lnea 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 slo se utilizan para
conectar bloques de manera interna a la entidad. A esta parte se le denomina mapeo de las
seales.

Por ltimo, podemos observar que la compuerta and recibe las dos seales provenientes de
x0 y xl, ejecuta la operacin y asigna el resultado a la salida c del circuito.

El mapeo realizado de las lneas 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 explcita, en el cual se determina con exactitud el origen y
destino de las seales. El siguiente listado muestra el algoritmo del diseo realizado
anteriormente utilizando el mapeo de manera explcita.

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 explcito o mapeo ordenado, el resultado es el mismo.
Ejercicio 7.1 Diseo estructural

Realice el programa correspondiente en VHDL para el circuito mostrado en la figura 7.2.
Utilice descripcin estructural. Verificar el correcto funcionamiento del diseo.

7.2. Divisor de frecuencia

Como se ha observado anteriormente con el diseo 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 diseos, por lo que es necesario crear un
diseo denominado divisor de frecuencia en el cual nos da como salida una frecuencia

74
ms baja y a travs de este alimentar nuestros contadores o nuestros Flip-Flops, cosa que se
puede realizar a travs de un diseo 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 lgico los pulsos
de reloj restantes.
Este divisor de frecuencia se puede observar en el siguiente diseo 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 diseo 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
obtengan para max y half se mantienen constantes a lo largo del tiempo, notese tambin que

75
las constantes han sido inicializadas. Es cierto que estas constantes bien pudieron colocarse
inmediatamente despus del process, sin embargo el hacer esto implicara que cada vez que
se activara dicho proceso la variable max automticamente tomara el valor de 50000000,
con lo cual nunca se llevara 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 lgico cada 25000000
pulsos de reloj, de esta manera se obtiene como resultado una frecuencia de salida de 1Hz.
Ejercicio 7.2 Implementacin 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 diseo.

Ejercicio 7.3 Contador de 4 bits con divisor de frecuencia

Ya que se cuentan con los diseos del divisor de frecuencia a 1Hz y el contador binario de
4 bits, realizar un diseo estructural en el cual la seal de reloj que entra al contador
provenga del divisor de frecuencia en lugar de la tarjeta.


76
8. Simulacin de diseos


El participante comprender la manera de realizar simulaciones de los diseos realizados en
VHDL mediante el uso adecuado del software ModelSim.

En este captulo se muestra el manejo bsico de ModeISim, el cual permite la simulacin de
diseos empleando VHDL, Verilog o ambos, mezclando, en un mismo diseo, bloques
realizados en ambos lenguajes. A travs de la simulacin de un diseo bsico se mostrar el
ciclo de trabajo con ModeISim y algunas de sus caractersticas ms importantes.

8.1 Creacin 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 simulacin-
verificacin de un circuito digital. En la figura 8.1 se presenta el circuito a modelar y
simular:

Figura 8.1 Diseo a simular

Los siguientes diseos se tienen que realizar en el software Xilinx ISE en un mismo
proyecto.

El diseo para la compuerta and es el siguiente:

library ieee;

entity c_and is
port(a,b: in std_logic;
z: out std_logic);

77
end c_and;

architecture beh of c_and is
begin
z<=a and b;
end beh;

El diseo 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 diseo 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 diseo estructural del circuito se muestra a continuacin:

library ieee;

entity Circuito is
port (a,b,c: in std_logic;
y: out std_logic);
end Circuito;

78

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 diseo 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;

79

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;

Ntese que en el diseo del archivo de prueba la entidad se encuentra vaca y que al
principio de la arquitectura se hace referencia solamente a la entidad del diseo estructural.
As como en la arquitectura de un diseo comportamental y en un diseo estructural se
denota por beh y str, en un diseo de prueba o testbench la arquitectura se denota con las
letras tst.

Despus del begin de la arquitectura tenemos la instanciacin de seales de manera similar
a como se realiza con un diseo 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 seccin en donde deben colocarse las estmulos de las seales de
cada entrada con las que pretendemos probar nuestro diseo 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 diseo tenga una entrada de
reloj (clk), para lo cual puede utilizarse como referencia el siguiente cdigo que simular la
entrada mencionada anteriormente:

Primero tiene que inicializarse dicha seal antes de escribir el begin de la
arquitectura, en este ejemplo estamos inicializando la seal a un valor de 0:
signal clk: std_logic:=0;

Posteriormente el estmulo para esta seal sera de la siguiente manera, pudiendo
cambiar la base tiempo a la que mejor se adapte nuestro diseo a probar:
clk <= not clk after 50ns;


80
La figura 8.2 muestra como se ve este proyecto en el software Xilinx ISE en la ventana de
diseo.

Figura 8.2 Diseo a probar

No se debe sintetizar tst, puesto que no es un diseo 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 simulacin de nuestro diseo, es
indispensable elegir el software de simulacin ModelSim.

8.2 Arranque de la aplicacin ModelSim XE

ModelSim XE es el software que nos permitir realizar las simulaciones de nuestros
diseos 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


81
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 diseo se da clic en Simulation
(figura 8.4).

Figura 8.4 Cambio a modo de simulacin

Posteriormente se hace doble clic en Simulate Behavioral Model de la ventana de
procesos (figura 8.5).

Figura 8.5 Inicio de la simulacin

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


82
8.3 Revisin de la simulacin

Al acceder al programa ModelSim podemos observar diversas ventanas de dicha
simulacin (figura 8.7), La ventana Objects nos muestra las seales que se estn simulando
en el diseo mientras que la ventana Wave nos muestra una grfica de las seales
simuladas con respecto al tiempo.

Figura 8.7 Pantalla principal de ModelSim

Para poder observar mejor la grfica se hace uso de la barra de herramientas zoom
y se ajusta hasta que pueda ser leda de mejor manera (figura 8.8).

Figura 8.8 Ajuste de zoom en la grfica de simulacin


83
En la barra de simulacin se puede
continuar con la simulacin o cambiar la base de tiempo de ps a ns o ms .

Si se desea resetear todas las seales de la grfica se puede hacer uso del botn 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 grfica con los datos de la simulacin se ha borrado, se puede hacer clic en el botn Run
para comenzar con la simulacin.

Ejercicio 8.1 Simulacin de un Flip-Flop D

Realizar un archivo de prueba para el diseo del Flip-Flop D del ejercicio 6.1 y simlelo en
ModelSim. Corra la simulacin con al menos dos tipos diferentes de estmulos, los cuales quedan a
eleccin del participante.

Ejercicio 8.2 Simulacin de un divisor de frecuencia

Realizar un archivo de prueba para el diseo del divisor de frecuencia del ejercicio 7.2 y simlelo
en ModelSim.

Ejercicio 8.3 Simulacin de un contador de 4 bits con divisor de frecuencia

Realizar un archivo e prueba para el diseo del contador de 4 bits con divisor de frecuencia del
ejercicio 7.3 y simlelo en ModelSim.


84
9. Mquina de estados en VHDL


El participante comprender el diseo e implementacin de una mquina de estados en
VHDL haciendo uso de una tarjeta basada en FPGA de acuerdo al procedimiento
establecido.

Se denomina mquina de estados a un modelo de comportamiento de un sistema con
entradas y salidas, en donde las salidas dependen no slo de las seales de entradas actuales
sino tambin de las anteriores.

9.1 Definicin de mquina de estados

Los diagramas de estados, tablas de estados y otras descripciones de mquina de estados
finitos contienen bsicamente la misma informacin: describen el comportamiento deseado
del circuito en trminos 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 mquina de estados finitos.
Por lo general, en una descripcin de arquitectura VHDL se describe el comportamiento de
un circuito secuencial mediante una o ms estructuras de proceso.

Figura 9.1 Descripcin del circuito secuencial. (a) Diagrama de estados. (b) Tabla de estados.
(c) Formato de tabla de verdad.

85
Existen dos tipos de mquinas de estados.

Mquina de Mealy: Es la mquina de estado en la cual la salida depende tanto del estado
presente como de las entradas externas. (figura 9.2).

Figura 9.2 Descripcin mquina de estados Mealy

Lgica de estado siguiente (F): Una funcin de las entradas y del estado actual.
Memoria de estados: Es un conjunto de n flip flops que almacenan el estado
presente de la mquina, que tiene 2n estados diferentes. La seal de reloj controla el
cambio de estado en tales flip flops.
La seal de reloj: Dispone el funcionamiento de los flip flops ya sea por disparo de
flanco o por disparo de pulso.
Lgica de salida (G): Una funcin del estado actual y/o de las entradas.

Mquina de Moore: Es la mquina de estado en la cual las salidas solo dependen del estado
presente (figura 9.3).

Figura 9.3 Descripcin mquina de estados Moore


86
9.2 Diseo de una mquina de estados Moore

En la figura 9.4 se muestra una mquina de estados Moore:

Figura 9.4 Mquina de estados Moore

Donde:

x=> Vector de entrada.
Z=> Vector de salida.
y=> Vector de estado actual.
Y=> Vector de estado prximo.

Debido a que es una mquina Moore el vector de estado prximo est en funcin del vector
de entrada y del vector de estado actual, es decir, Y=g(x,y) y la salida Z se encuentra en
funcin del estado actual, es decir, Z=f(y).

A continuacin se explica por partes la manera de realizar la mquina 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;

87
reset: in std_logic;
z: out std_logic);
end maquina;

Esta primer parte del cdigo no muestra nada nuevo, ya que solo se estn especificando las
entradas y salidas de la mquina de estados, ntese que se tiene una seal de reset, la cual
se recomienda colocar en cada diseo de mquina 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 cdigo anterior muestra el principio de la arquitectura del diseo, aqu se declara un
nuevo tipo de datos. El tipo de datos es un elemento bsico 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 declaracin est formada por un identificador que nos permitir usar el nuevo tipo al
llamarlo y la descripcin 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 mquina referida
en la figura 9.4), as como las seales actual y prximo 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=> prximo <= eta;
when eta=> prximo <= alfa;
end case;
end process;

88
El cdigo anterior muestra las transiciones que debe realizar nuestra mquina de estados
dependiendo de los valores del vector de entrada, posteriormente se debe colocar el diseo
del registro, que se encargar de guardar el valor actual y prximo del estado de nuestra
mquina.

registro: process (clk)

begin
if clkevent 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 seal de reloj. Por ltimo queda
definir las salidas del diseo.

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 mquina Mealy en lugar de una Moore, la
estructura de este ltimo cdigo es la que cambiara un poco, agregando las entradas para
los posibles valores de entrada.

A continuacin se muestra el diseo completo de esta mquina de estados:

library ieee;

89

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;

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 clkevent and clk=1
then if reset = 0
then actual <= alfa;
else actual <= proximo;
end if;
end if;
end process;
salida: process (actual)
begin

90
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;

Ejercicio 9.1 Simulacin de una mquina de estados

Disee en Xilinx ISE y simule en ModelSim la mquina de estados expuesta anteriormente,
simule las seales de entrada que crea pertinentes para demostrar que el diseo se comporta
de acuerdo a lo esperado.
Ejercicio 9.2 Contador de 3 bits con mquina de estados

Disee en Xilinx ISE y simule en ModelSim un contador binario de 3 bits modificando la
seal de salida por medio de una mquina de estados, el cual debe de funcionar al
encontrarse en alto una seal de entrada con una frecuencia de reloj de 1 Hz.

91
BIBLIOGRAFIA

Amado, Oscar Alejandro. GUA DE USO TARJETA NEXYS 2 FPGA SPARTAN-3E.
Universidad Nacional de Colombia.

Cardenas, Rubn Daro. CURSO PROGRAMACIN FPGA (PROGRAMACIN DE
ARREGLO DE COMPUERTAS). Universidad Nacional de Colombia.

Departamento de tecnologa electrnica. Diseo avanzado de circuitos digitales con
VHDL. Universidad Rey Juan Carlos.

Lpez Nez, Adolfo Rafael: Documento tesis de maestra Sistema de control digital para
obtencin de mxima potencia de celdas fotovoltaicas. Instituto Tecnolgico 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 sntesis y modelado de circuitos, Ra-Ma,
2003.

Manual Del Participante FPGA RV 3

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual Del Participante FPGA RV 3

Uploaded by

Copyright:

Available Formats

Diseo bsico en FPGA con VHDL

You might also like