Diseño Digital Utilizando Lógicas Programables

Diseo Digital Utilizando Lgicas
Programables
Versin 0.6
Junio 29, 2005
Guillermo Gichal
Universidad Tecnolgica Nacional
Facultad Regional Baha Blanca
Diseo digital utilizando Lgicas Programables
UTN, Facultad Regional Baha Blanca
ndice
1
2
3
4
Agradecimientos ......................................................................................................... 7
Versiones..................................................................................................................... 8
Introduccin ................................................................................................................ 9
Temas Bsicos de Diseo Digital ............................................................................. 11
4.1
Diseo Combinacional y Secuencial ................................................................ 11
4.1.1
Flip-Flops y Latches ................................................................................. 11
4.2
Diseo Secuencial Asincrnico y Sincrnico ................................................... 11
4.3
Algunas Notas sobre Diseo Secuencial Sincrnico ........................................ 11
4.3.1
Temporizado y Utilizacin de Registros................................................... 11
4.3.2
Distribucin de Reloj ................................................................................ 11
4.3.3
Mxima Frecuencia de Trabajo ................................................................ 11
4.3.4
Pipelines.................................................................................................... 11
4.3.5
Dominios de Reloj .................................................................................... 11
4.3.6
Metaestabilidad en los Flip-Flops............................................................. 11
4.4
Autmatas de Estados Finitos (Mquinas de estados finitos)........................... 11
4.4.1
Mquinas de Mealy................................................................................... 11
4.4.2
Mquinas de Moore .................................................................................. 11
4.4.3
Codificacin de estados. Mnima, One-hot, One-cold, Grey, etc. ............ 11
4.5
Integridad de Seal ........................................................................................... 11
4.5.1
Que afecta la integridad de seal y que es. Como afecta fuera y dentro del
chip (FPGA?) ............................................................................................................ 11
4.5.2
Terminaciones de Seales......................................................................... 12
4.6
Interfaces Elctricas .......................................................................................... 12
4.7
Potencia y Consumo de los Circuitos ............................................................... 12
5
Diseo Digital con FPGAs y HDLs.......................................................................... 13
5.1
Metodologa General de Diseo Digital ........................................................... 15
5.1.1
Especificacin y Diseo............................................................................ 17
5.1.2
Verificacin............................................................................................... 18
5.1.3
Pasos Finales............................................................................................. 18
5.2
Diseo Digital Utilizando Lenguajes de Descripcin de Hardware ................. 18
5.3
Flujo de Diseo para Lgicas Programables .................................................... 19
5.3.1
Flujo de Diseo (Design Flow)................................................................. 19
5.4
Lenguajes de descripcin de hardware ............................................................. 22
5.4.1
VHDL ....................................................................................................... 23
5.4.2
Verilog ...................................................................................................... 23
5.4.3
Otros.......................................................................................................... 23
5.5
Herramientas de Desarrollo .............................................................................. 24
5.5.1
Descripcin del Diseo ............................................................................. 24
5.5.2
Generacin o Traduccin.......................................................................... 24
5.5.3
Simulacin ................................................................................................ 24
5.5.4
Notas Manejo del tiempo en VHDL ......................................................... 24
6
Dispositivos Lgicos Programables.......................................................................... 27
6.1
Evolucin de los Primeros Dispositivos Lgicos Programables ...................... 28
2005 Guillermo Gichal
6.2
CPLDs............................................................................................................... 31
6.3
FPGAs............................................................................................................... 32
6.3.1
Bloque Lgico Programable ..................................................................... 35
6.3.2
Bloque de Entrada / Salida....................................................................... 38
6.3.3
Bloque de Control de Reloj....................................................................... 41
6.3.4
Memoria.................................................................................................... 43
6.3.5
Bloque de Procesamiento de Seal ........................................................... 44
6.3.6
CPUs Embebidas ...................................................................................... 46
6.3.7
Matriz de Interconexin............................................................................ 47
6.4
Granularidad de los Dispositivos Lgicos Programables (PLDs) .................... 48
6.5
Tecnologa de Configuracin de los PLDs ....................................................... 53
6.6
Tendencias Actuales y Futuras ......................................................................... 54
6.7
Notas a Junio 2005............................................................................................ 54
7
Primeros Pasos con VHDL ....................................................................................... 56
7.1
Notas Preliminares Sobre Formato de VHDL y los Ejemplos ......................... 56
7.1.1
Formato del Cdigo de Ejemplo ............................................................... 56
7.1.2
Capitalizacin en VHDL........................................................................... 56
7.1.3
Comentarios en VHDL ............................................................................. 56
7.1.4
Delimitadores de Cdigo en VHDL ......................................................... 56
7.2
Estructura Bsicas de un Modelo en VHDL..................................................... 57
7.2.1
Entidades y Arquitecturas ......................................................................... 57
7.2.2
Modelos de comportamiento..................................................................... 59
7.2.3
Modelos Estructurales............................................................................... 61
7.3
Elementos del Lenguaje VHDL........................................................................ 64
7.3.1
Palabras Reservadas.................................................................................. 64
7.3.2
Smbolos Especiales.................................................................................. 64
7.3.3
Identificadores........................................................................................... 66
7.3.4
Nmeros.................................................................................................... 66
7.3.5
Cadenas de bits ......................................................................................... 66
7.4
Tipos en VHDL................................................................................................. 67
7.4.1
Tipos Comunes ......................................................................................... 67
7.4.2
Declaracin de Tipos ................................................................................ 67
7.4.3
Tipos enumerados ..................................................................................... 68
7.4.4
Subtipos..................................................................................................... 68
7.4.4.1 Tipo Natural y Positivo......................................................................... 68
7.4.5
Tipos Fsicos ............................................................................................. 69
7.4.5.1 Tipo Tiempo.......................................................................................... 69
7.4.6
Tipos compuestos...................................................................................... 69
7.4.6.1 Arreglos................................................................................................. 70
7.4.6.2 Arreglos sin Rangos Predeterminados .................................................. 71
7.4.6.3 Records ................................................................................................. 72
7.4.7
Calificacin y Conversin de Tipos.......................................................... 72
7.5
Objetos en VHDL ............................................................................................. 73
7.5.1
Constantes ................................................................................................. 73
7.5.2
Seales ...................................................................................................... 73
7.5.3
Variables ................................................................................................... 74
7.6
Libreras y Paquetes.......................................................................................... 75
7.6.1
Libreras .................................................................................................... 75
7.6.2
Paquetes (Packages).................................................................................. 75
7.6.3
Paquetes de Lgica Estndar del IEEE..................................................... 77
7.6.3.1 Lgica estndar std_logic y std_ulogic definidos en std_logic_1164 .. 78
7.6.3.2 Deteccin de flancos de seales definidos en std_logic_1164 ............. 79
7.6.4
Aritmtica sobre lgica estndar............................................................... 79
7.7
Construcciones Bsicas de VHDL.................................................................... 81
7.7.1
Declaracin de seales.............................................................................. 82
7.7.2
Operaciones Concurrentes ........................................................................ 83
7.7.2.1 Flujo de datos........................................................................................ 83
7.7.2.2 Palabra reservada AFTER..................................................................... 85
7.7.2.3 Expresin with select ....................................................................... 86
7.7.2.4 Expresin when, else ............................................................................ 87
7.7.3
Operaciones secuenciales.......................................................................... 88
7.7.3.1 Instruccin WAIT ................................................................................. 88
7.7.3.2 Expresin if elsif else.................................................................... 90
7.7.3.3 Expresin null ....................................................................................... 92
7.7.3.4 Expresin case ...................................................................................... 92
7.7.3.5 Procesos (process)................................................................................. 94
7.7.4
Operaciones secuenciales, retardos delta y sntesis .................................. 98
7.7.5
Visibilidad de las declaraciones de objetos en VHDL.............................. 99
8
Ms VHDL.............................................................................................................. 101
8.1
Introduccin .................................................................................................... 101
8.2
Parmetros Genricos ..................................................................................... 101
8.2.1
Declaracin de parmetros genricos ..................................................... 101
8.2.2
Uso de componentes con parmetros genricos ..................................... 104
8.3
Subprogramas: FUNCTION y PROCEDURE ............................................... 108
8.3.1
Procedimientos........................................................................................ 108
8.3.2
Funciones ................................................................................................ 111
8.3.3
Asociacin de parmetros por posicin y por nombre............................ 113
8.4
Instruccin GENERATE ................................................................................ 113
8.5
Componentes Bsicos de Diseo (Primitivas - Primitives) ............................ 114
8.5.1
Utilizacin de Primitivas desde VHDL .................................................. 114
8.5.2
Libreras de Primitivas (componentes) Especficos para Simulacin..... 116
8.5.3
Memoria.................................................................................................. 116
Inferencia de Memorias ...................................................................................... 118
Instancia de Memorias ........................................................................................ 124
8.5.4
Definicin de Nuevos Componentes de Diseo ..................................... 125
8.6
Mquinas de Estado ........................................................................................ 129
8.6.1
Codificacin de Estados.......................................................................... 133
8.6.2
Divisin de la Seal de Reloj (Clock Enable) ........................................ 134
9
VHDL para Simulacin y Verificacin .................................................................. 135
9.1
Introduccin .................................................................................................... 135
9.2
Bancos de Prueba............................................................................................ 135
9.2.1
Vectores de prueba.................................................................................. 136
9.2.2
Diseo de un Banco de Pruebas.............................................................. 136
9.2.3
Manejo de tiempo en simulaciones usando VHDL ................................ 137
9.2.3.1 Uso del WAIT y AFTER .................................................................... 137
9.2.3.2 Funcin NOW..................................................................................... 138
9.3
VHDL (Generalmente) No Sintetizable.......................................................... 139
9.3.1
Instrucciones de lazo FOR, WHILE y LOOP, NEXT y EXIT............... 139
9.3.2
Instrucciones ASSERT y REPORT ........................................................ 142
9.3.3
Manejo de Archivos y Paquete TEXTIO................................................ 143
9.3.4
Palabra reservada ALIAS ....................................................................... 145
9.3.5
Ejemplos de Componentes para Bancos de Prueba ................................ 146
9.3.5.1 Generacin de Seal de Reloj ............................................................. 146
9.3.5.2 Generacin de una Seal de Reset ...................................................... 147
9.3.5.3 Temporizado de la Interfase de un Bus de Microcontrolador............. 148
9.4
Que Falta sobre VHDL ............................................................................... 152
10
Buenas Prcticas de Diseo ................................................................................ 153
10.1 Introduccin .................................................................................................... 153
10.2 Documentacin ............................................................................................... 153
10.3 Gua de estilo para el cdigo HDL ................................................................. 153
10.4 Programacin para Diseos Sintetizables....................................................... 156
10.4.1
Diferencias entre Sntesis y Simulacin ................................................. 156
10.4.2
Divisin de la Frecuencia Mediante Habilitacin del Reloj ................... 156
10.5 Gua de Estilo Para un Buen Diseo de Hardware ......................................... 159
11
SoCs, Cores y Propiedad Intelectual................................................................... 162
11.1 Introduccin .................................................................................................... 162
11.2 Presentacin de un Core.................................................................................. 162
11.3 Diseo para Verificacin (Design For Test)................................................... 162
11.4 Reutilizacin de Propiedad Intelectual ........................................................... 162
12
Notas Sobre Sntesis con FPGAs........................................................................ 163
12.1 Introduccin .................................................................................................... 163
12.2 Diseo y Optimizacin Para Sntesis.............................................................. 163
12.3 Formato Edif ................................................................................................... 163
12.4 Estructuras Recomendadas para Diseos Sintetizables .................................. 163
12.4.1
Estructuras de Decisin Jerrquicas y Concurrentes (IF vs. CASE) ...... 163
12.4.2
Procesos sincrnicos ............................................................................... 163
12.4.3
etc............................................................................................................ 163
12.4.4
etc............................................................................................................ 163
12.4.5
etc............................................................................................................ 163
12.5 Ejemplos de estructuras sintetizadas............................................................... 163
13
Notas sobre Verificacin..................................................................................... 165
13.1 Introduccin .................................................................................................... 165
14
Uso de las Herramientas ..................................................................................... 166
14.1 Manejo Bsico de Xilinx Project Manager..................................................... 166
14.2 Manejo Bsico de Altera Quartus II ............................................................... 166
14.3 Manejo Bsico de Actel Libero (o la que sea gratuita)................................... 166
14.4 Manejo Bsico de ModelSim.......................................................................... 167
15
Referencias.......................................................................................................... 169
15.1 Dispositivos Lgicos Programables................................................................ 169

Bibliografa ............................................................................................................. 169
Links de Inters....................................................................................................... 169
15.2 Diseo Digital con PLDs ................................................................................ 170
Bibliografa ............................................................................................................. 170
Links de Inters....................................................................................................... 170
15.3 VHDL ............................................................................................................. 170
Bibliografa ............................................................................................................. 170
Links de Inters....................................................................................................... 170
15.4 Buenas Prcticas de Diseo ............................................................................ 171
Bibliografa ............................................................................................................. 171
15.5 Sntesis ............................................................................................................ 171
Bibliografa ............................................................................................................. 171
Links de Inters (sntesis) ...................................................................................... 171
16
Ejemplos ............................................................................................................. 172
16.1 Ejemplos de Lgica Combinacional ............................................................... 172
16.2.............................................................................................................................. 172
16.3 Ejemplos de Lgica Secuencial ...................................................................... 172
16.4 Divisor Reloj................................................................................................... 172
16.5 Control display 7 segmentos........................................................................... 172
16.6 ... otros ejemplos de laboratorios hechos en clase... ....................................... 172
16.6.1
Interfase Mouse....................................................................................... 172
16.6.2
Controlador VGA.................................................................................... 172
16.7 Ejemplo Completo: UART ............................................................................. 172
16.8 etc, etc ............................................................................................................. 172
Diseo digital utilizando FPGAs
1 Agradecimientos
Con la versin 0.6 llega el aporte de algunos colaboradores. Me gustara aprovechar
entonces para agregar esta seccin y agradecerles su ayuda.
Julio Amoedo de Invap S.E. (www.invap.com.ar) ley la primer versin y me dio mucha
realimentacin para mejorar estas notas. Se que hay secciones que pueden no estar muy
claras, pero trat de seguir sus sugerencias para que todo sea mas entendible.
Salvador Eduardo Tropea, del Instituto Nacional de Tecnologa Industrial de Argentina
(INTI - www.inti.gov.ar) me dio algunas sugerencias y me hizo notar algunos puntos que
podan mejorarse. Gracias a esas sugerencias y sus ejemplos reescrib la seccin sobre
memorias, agregu algunos comentarios a la seccin de VHDL no sintetizable (que en
muchos casos s es sintetizable) y cambi algunos ejemplos que eran muy especficos de
Xilinx.
2 Versiones
Ver 0.5 (27/06/2005)
Publicacin inicial en www.fpga.com.ar
Ver 0.6 (29/06/2005)
Seccin de Agradecimientos y Versiones.
Fuentes en las figuras y tablas de terceros
Cambios en la implementacin de mquinas de estado (no se si aclaran algo o no:)
Cambios en la descripcin de memorias y su uso en VHDL
Algunas notas sobre VHDL sintetizable y no sintetizable
Cambios en la seccin sobre primitivas
Trat de usar trminos aceptados en castellano en vez de mis "castellanizaciones"
Varias correcciones y cambios menores
3 Introduccin
Estas notas son una introduccin al diseo digital utilizando lgicas programables y
lenguajes de descripcin de hardware. La intencin no es hacer un tratamiento exhaustivo
y completo de este tema, sino presentar el material que permitir comenzar a trabajar lo
ms rpido posible. Esto se intenta hacer limitando el contenido y focalizndolo sobre
aplicaciones y ejemplos para diseos sintetizables sobre FPGAs.
Los ejemplos de aplicaciones fueron desarrollados para la placa de desarrollo D2E, DIO1
y DIO2 de Digilent, Inc (www.digilentinc.com). La placa D2E contiene una FPGA
Spartan IIe 200 y varios conectores. Las otras placas se conectan a la D2E y contienen
perifricos, tales como botones, leds, display, conectores PS2 y VGA, etc. Por ese
motivo, en las secciones o ejemplos que utilicen o presenten herramientas de desarrollo, y
en los ejemplos en donde se presenten dispositivos especficos, se utilizarn herramientas
y dispositivos de Xilinx. En las secciones generales, sin embrago, se intentan presentar
dispositivos y herramientas de varios fabricantes para que el lector tenga una visin ms
amplia de las alternativas existentes.
Se espera que el lector de estas notas tenga una base de diseo digital. Adems se supone
que el lector conoce algn lenguaje de programacin y esta familiarizado con la
utilizacin de herramientas de desarrollo de software. Para el que necesita estudiar los
conceptos bsicos de diseo digital se recomienda el libro de John F. Wakerly detallado
al final de esta seccin. Este libro, adems, contiene una excelente introduccin a los
dispositivos lgicos programables. Para el lector que no est familiarizado con ningn
ambiente de desarrollo de software tambin se da una lista de los documentos y manuales
de Xilinx que permitirn que se entienda rpidamente el uso de las herramientas de
desarrollo. En el futuro se completar una seccin introductoria con un repaso de temas
de diseo, tecnologas y tcnicas digitales.
Algunas caractersticas y limitaciones que deben tenerse en cuenta al leer estas notas son
las siguientes:
Las notas estn principalmente orientadas a sntesis de diseos digitales sobre

FPGAs. Esto debe tenerse en cuenta especialmente en las secciones sobre VHDL,
ya que los temas tratados y los ejemplos presentados se limitan a ese uso del
lenguaje.
Se tratan de presentar los temas con ejemplos que permitan la rpida utilizacin y
aprendizaje. Un estudiante debera poder comenzar a hacer diseos bastante
complejos sobre FPGAs solo copiando y modificando el cdigo presentado en los
apndices y ejemplos, sin realmente tener una base demasiado formal sobre PLDs
y VHDL.
Se trata de ensear a travs de ejemplos funcionales, que puedan usarse como
plantillas bases para un diseo o que puedan copiarse directamente. En las
secciones sobre VHDL, en muchos casos no se presentar formalmente el uso de
una instruccin, operacin o construccin, sino que se darn ejemplos que

muestran su utilizacin.
Al no presentar el lenguaje VHDL con todas sus reglas y posibilidades, en
muchos casos se presentan ejemplos que utilizan construcciones antes de haberlas
explicado formalmente. Como se espera que el lector tenga una base de diseo
digital y programacin, esto no debera presentar problemas.
Se pone bastante nfasis en las formalidades y guas que deberan existir al
escribir cdigo (ya sea en un lenguaje de descripcin de hardware o cualquier otro
lenguaje de programacin). Se presentan los ejemplos con un formato estndar
que se describe en las notas.
Esta es la primera versin de estas notas, y seguramente contiene errores, omisiones o

temas que pueden presentarse de una manera ms didctica. Por favor hacer llegar
cualquier duda, comentario o crtica que ayude a mejorarlas en el foro o wiki del sitio
www.fpga.com.ar.
10
4 Temas Bsicos de Diseo Digital

COMPLETAR CON ALGUNAS NOTAS SOBRE DISEO DIGITAL PARA PODER
METER LAS FPGAS y HDLs EN CONTEXTO.
4.1 Diseo Combinacional y Secuencial

4.1.1 Flip-Flops y Latches
4.2 Diseo Secuencial Asincrnico y Sincrnico

4.3 Algunas Notas sobre Diseo Secuencial Sincrnico
4.3.1 Temporizado y Utilizacin de Registros
4.3.2 Distribucin de Reloj
4.3.3 Mxima Frecuencia de Trabajo
4.3.4 Pipelines
4.3.5 Dominios de Reloj
4.3.6 Metaestabilidad en los Flip-Flops
4.4 Autmatas de Estados Finitos (Mquinas de estados finitos)

4.4.1 Mquinas de Mealy
4.4.2 Mquinas de Moore
4.4.3 Codificacin de estados. Mnima, One-hot, One-cold, Grey, etc.
4.5 Integridad de Seal

4.5.1 Que afecta la integridad de seal y que es. Como afecta fuera y dentro
del chip (FPGA?)
Ver nota Altera de PLD design line. Chip-level concerns include improper I/O buffer
design and inadequate return-current paths. Package-level issues include high package
inductance, mismatched traces, improper routing and inadequate return-current paths,
while board-level issues include crosstalk, reflections, signal attenuation and EMI/EMC.
11
4.5.2 Terminaciones de Seales

Usar terminaciones para evitar rebotes en diseos de alta velocidad. Terminaciones
internas en las FPGAs.
4.6 Interfaces Elctricas

Estndares de interfase posibles con las FPGAs actuales. Resistencias de pull-up/down
internas. Flancos lentos y rpidos. etc.,
4.7 Potencia y Consumo de los Circuitos

Puede ser importante. Potencia esttica vs dinmica. Dificultoso de calcular para las
FPGA. Hay herramientas que analizan y calculan. Hay que analizar los requerimientos de
la aplicacin para ver si la potencia es una limitacin y/o disear las fuentes de
alimentacin (aplicaciones mviles con bateras, etc.).
Las FPGA tienen grandes cantidades de entradas salidas que pueden requerir mucha
corriente. Se deben usar capacitores de desacople y tener en cuenta las especificaciones
de los fabricantes sobre la cantidad de salidas que pueden cambiar al mismo tiempo.
12
5 Diseo Digital con FPGAs y HDLs

Para poder atacar un problema complejo (sistema) la mejor manera que tenemos es
dividirlo. De esta manera se pueden atacar problemas de menor complejidad y mas
fciles de analizar. Este es el camino que generalmente usamos para disear un sistema
digital. Las decisiones que se tomen al principio para dividir el problema pueden afectar
el resultado final. En algunos casos debemos volver al principio y replantear la
arquitectura despus de haber resuelto el problema. La experiencia y conocimientos sobre
el problema, las posibles soluciones y la tecnologas disponibles ayudarn a que la
decisin que se tome sea la mas acertada. Este proceso se esquematiza en la Figura 1.
Figura 1 Esquema del proceso de diseo de un sistema complejo
13
Un sistema puede estar compuesto por varios subsistemas, no todos ellos digitales o
electrnicos. La primer decisin ser entonces que partes del sistema se implementarn
como subsistemas digitales. En el sistema digital, los siguientes pasos se siguen en cada
nivel de la jerarqua del diseo, cada vez con mayor nivel de detalle.
Especificacin - Arquitectura - Diseo lgico - Layout (disposicin y conexionado)
La especificacin es muy importante pare definir bien los lmites de lo que se quiere
fabricar. A partir de la especificacin se puede definir una arquitectura con los diferentes
componentes que implementan cada funcin del sistema. Para el diseo se debe definir el
funcionamiento de cada uno de esos componentes.
Un sistema digital y sus componentes pueden definirse a distintos niveles de abstraccin
y en tres dominios diferentes: Comportamiento, estructural y fsico. En la Figura 2 se
muestra el diagrama "Y" de Gajski y Kahn que representa los niveles de abstraccin y
dominios para un circuito.
Figura 2 Diagrama de Gajski - Kahn
Dominio Comportamiento: Describe lo que hace un sistema (funcionamiento)

Nivel Algoritmo: Describe el comportamiento del sistema como operaciones
sobre las entradas para producir las salidas deseadas sin detallar los cambios en el
tiempo ni las seales internas.
14
Nivel RTL: Describe el comportamiento de todas las seales (entradas, internas y

salidas) en el tiempo (para cada ciclo de reloj en sistemas sincrnicos)
Dominio Estructural: Describe al sistema como una interconexin de componentes
(esquemtico)
Nivel P-M-S (Processor Memory Switch): Describe la estructura como la
interconexin de elementos de procesamiento, memoria e interconexin, sin
mayores detalles de implementacin.
Nivel Registros: Describe la estructura como la interconexin de registros y
lgica de interconexin.
Dominio Fsico: Describe la implementacin fsica del sistema (plano).
Para lograr tiempo ms rpidos de diseo, menos errores, y mayor productividad, lo ideal
sera poder trabajar al mximo nivel de abstraccin posible (algoritmos), sin entrar en los
detalles de bajo nivel. Desafortunadamente, esto no es siempre posible con la tecnologa
existente (pero esta cambia permanentemente). El nivel de abstraccin depender
entonces de la aplicacin y restricciones sobre el diseo. Si se debe disear un integrado
full-custom analgico es probable que se trabaje al nivel de ecuaciones diferenciales, al
nivel de transistores y haciendo el layout manual. Si se disea un integrado digital con
bloques predefinidos (IP, Cores) y adquiridos a terceros se trabajar a un nivel de
abstraccin mucho mayor (floorplanning, RTL). En el ciclo de diseo con FPGAs, gran
parte del aspecto fsico ha sido solucionado por el fabricante. En general se trabaja al
nivel de transferencia de registros con algunas herramientas que ayudan a disear a
niveles de algoritmo.
5.1 Metodologa General de Diseo Digital

Al desarrollar cualquier sistema digital es importante seguir ciertas pautas de trabajo y
tener en cuenta factores muy diversos para que el diseo pueda terminarse a tiempo y
funcione correctamente. A medida que los diseos se hacen ms complejos, la necesidad
de seguir un mtodo ordenado para lograr buenos resultados se hace ms importante. Los
lenguajes de descripcin de hardware, si se utilizan correctamente, pueden utilizarse en
varios pasos del proceso de desarrollo, no solo para disear sino tambin para especificar
y documentar el sistema que se quiere desarrollar.
Las grandes capacidades de los PLDs y herramientas de diseo disponibles permiten que
los diseos implementados sobre FPGAs sean cada vez mas complejos. En muchos casos
varias personas pueden estar trabajando sobre el mismo producto, incluso en localidades
separadas. Para poder atacar el problema del diseo de sistemas digitales complejos (ya
sea para desarrollos sobre FPGAs, ASICs o PCBs) es importante tener una metodologa
de trabajo que permita planificar y ordenar el trabajo.
Como ejemplo, en la Figura 3 se muestra un esquema de un mtodo que permite ordenar
el trabajo de diseo. Segn su autor (ver Referencias), la "Metodologa Universal de
Diseo" define pasos que permiten:
15
Disear un dispositivo libre de defectos de manufactura, que funciona de manera

adecuada y se integra con el sistema.
Disear el dispositivo de manera eficiente, sin malgastar recursos ni tiempo.
Planificar el diseo de manera eficiente, crear un cronograma razonable y asignar
los recursos necesarios para las diferentes tareas de manera ordenada.
En muchos casos el proceso es no lineal. Si se descubren fallas o problemas en las

especificaciones, se debe volver a iterar sobre los pasos anteriores para corregirlos.
El ciclo comienza con un conjunto de requerimientos para la fabricacin de un
dispositivo o sistema. Estos requerimientos pueden venir de un cliente, de otro grupo de
trabajo dentro de la misma empresa o del mismo grupo de trabajo que necesita desarrollar
una parte de un sistema mas grande.
Figura 3 - Metodologa Universal de Diseo
16
5.1.1 Especificacin y Diseo

Una especificacin permite que todas las personas involucradas en un proyecto
comprendan cual es el dispositivo que se va a desarrollar. Las personas que forman parte
de un proyecto incluyen no solo a los desarrolladores, sino tambin a clientes, gerencia,
personal de otras reas de la empresa, etc.
Las especificaciones deberan describir la solucin de manera de cumplir con los
requerimientos que se piden para el dispositivo. Al haber una especificacin formal, las
bases sobre las que trabajar en un diseo quedan preestablecidas y se minimizan los
errores por diferencias de apreciacin o entendimiento entre los participantes.
Una especificacin debera comprender los siguientes puntos:
Diagrama en bloques del sistema externo, que muestra como y donde encaja el
dispositivo dentro del sistema completo.
Diagrama en bloques interno que muestra los principales bloques funcionales.
Descripcin de las entradas/salidas, incluyendo interfaces lgicas, elctricas y
protocolos de comunicacin.
Estimaciones de tiempos que se deben cumplir, incluyendo tiempos de "setup" y
"hold" para las entradas/salidas y frecuencias de reloj.
Estimacin de la complejidad y/o magnitud del dispositivo, dado en nmero de
compuertas equivalentes o nmero de circuitos integrados necesarios.
Especificacin fsica del dispositivo. Tamao, empaquetamiento, conectores, etc.
Estimacin del consumo de potencia del dispositivo.
Precio estimado del dispositivo.
Procedimientos de verificacin y validacin para el dispositivo.
Despus de escribir las especificaciones es importante hacer una revisin con todos los
miembros del equipo. De esta revisin podrn surgir cosas que no se tuvieron en cuenta
individualmente y que produzcan modificaciones. La especificacin tambin incluye la
metodologa de verificacin del dispositivo. Estas muchas veces se dejan para el final del
proyecto y no se definen ni llevan a cabo de manera adecuada.
La especificacin es un documento activo, que se modifica de acuerdo en los cambios de
requerimientos y a medida que se tiene ms informacin sobre el proyecto.
Una vez que se escribe la especificacin se puede utilizar para seleccionar componentes y
tecnologas que se utilizarn para el proyecto. El diseo deber hacerse siguiendo
mtodos aceptados y confiables. El proceso de diseo es en general un ciclo, e incluye
varios pasos intermedios.
17
5.1.2 Verificacin
La verificacin engloba varios pasos menores, y al revisar pueden surgir cosas que
obligan a volver atrs hacia pasos anteriores. Dependiendo del dispositivo y tecnologa
utilizada, pero en general sigue los siguientes pasos:
Simulacin: es en general un proceso continuo, ya que al simular se pueden

encontrar problemas que hacen volver sobre el diseo y hacer cambios. Las
simulaciones se hacen sobre pequeas partes del sistema y sobre el sistema
completo. Se debe llevar a cabo una simulacin funcional, pero tambin puede
incluir simulaciones de temporizado, consumo de potencia y otros parmetros.
Revisin: En este paso se revisan los resultados de la simulacin y se analiza el
comportamiento del dispositivo. Es importante que participen ingenieros externos
al proyecto y personas que conozcan el sistema en su totalidad.
Implementacin Fsica: Una vez que se ha aceptado el diseo se lleva a cabo la
implementacin fsica final del dispositivo.
Verificacin Formal: En este paso se verifica la implementacin fsica para
asegurarse que su funcionamiento coincide con las simulaciones hechas
anteriormente. En este paso se deben tambin evaluar los tiempos, consumo de
potencia y cualquier otro parmetro de importancia.
5.1.3 Pasos Finales

Si todos los pasos se siguieron correctamente la revisin final debera ser solo una
formalidad. Se verifica que el dispositivo est listo para ser entregado o integrado al
sistema.
La integracin y verificacin en el contexto del sistema general es muy importante. Si los
pasos se siguieron correctamente, cualquier modificacin que surja de esta integracin
ser en general pequea y no requerir grandes cambios.
Cualquier problema o falla que se encuentre debe ser documentarse y analizada para
poder corregirla en una prxima versin del dispositivo y evitarla en el futuro.
5.2 Diseo Digital Utilizando Lenguajes de Descripcin de Hardware

Los lenguajes de descripcin de hardware (HDLs) permiten modelar sistemas digitales
completos. Mediante diferentes herramientas de software estos modelos pueden luego
sintetizarse para implementarlos como circuitos reales. La utilizacin de HDLs para
sintetizar sistemas digitales y la utilizacin de PLDs permiten crear prototipos
funcionales en plazos relativamente cortos. Esto hace que todo el proceso de desarrollo
de un sistema digital sea mucho ms simple y rpido en comparacin con metodologas
clsicas (desarrollo con discretos sobre PCBs o el diseo de circuitos integrados).
Los modelos de hardware usando HDLs pueden ser estructurales, de comportamiento o
una mezcla de estos dos. A nivel estructural se describe la interconexin y jerarqua entre
componentes. A nivel de comportamiento de hardware se describe la respuesta
entrada/salida de un componente. El comportamiento de un sistema puede modelarse a
18
distintos niveles de abstraccin o detalle: algoritmos y comportamiento general, nivel de

transferencia de registros, nivel de compuertas, etc. El tipo de modelo ms usado para
sntesis es el denominado RTL (Register Transfer Level), o de nivel de transferencia de
registros. Existen herramientas que permiten sintetizar circuitos a partir de modelos de
abstraccin ms elevados, pero en general lo hacen llevando el diseo a un nivel de
descripcin como RTL antes de sintetizarlo.
La utilizacin de HDLs para sntesis puede tener como objetivo la creacin de un circuito
integrado de propsito especfico (ASIC) o la implementacin del circuito en alguna
lgica programable (PLD). Independientemente del objetivo, no todas las construcciones
posibles de los lenguajes de descripcin de hardware pueden sintetizarse y transformarse
en circuitos. Esto puede deberse a las limitaciones de las herramientas utilizadas o a que
el circuito descrito por el modelo VHDL no puede implementarse fsicamente. En general
el diseador debe seguir ciertas pautas de modelado, que dependern de su objetivo y de
las herramientas que utiliza, para que el modelo pueda sintetizarse. Esto es an ms
importante para lograr implementaciones ptimas sobre la arquitectura para la que se est
diseando el circuito.
5.3 Flujo de Diseo para Lgicas Programables

Cuando se disea con lgicas programables, cualquiera sea el mtodo usado para disear
el circuito (HDLs, esquemticos, etc.), el proceso desde la definicin del circuito por el
desarrollador hasta tenerlo funcionando sobre un PLD implica varios pasos intermedios y
en general utiliza una variedad de herramientas. A este proceso se lo denomina ciclo o
flujo de diseo.
5.3.1 Flujo de Diseo (Design Flow)

Durante el proceso de creacin de un sistema digital desde el cdigo fuente
(esquemticos, VHDL, etc.) a la implementacin en un PLD hay varios pasos
intermedios. Para cada uno de estos pasos se utilizan herramientas de software diferentes
que pueden o no estar integradas bajo un ambiente de desarrollo. En muchos casos las
herramientas utilizadas en cada paso del diseo son provistas por diferentes empresas. La
Figura 4 muestra el ciclo de diseo tpico para lgicas programables. Dependiendo de las
herramientas utilizadas, este ciclo puede tener variaciones o las tareas llamarse con otros
nombres.
A continuacin se describe cada uno de los pasos del ciclo de diseo. Se agrega su
denominacin en ingls entre parntesis, ya que estos son los trminos que se encontrarn
en las herramientas de desarrollo.
Descripcin del Diseo: este es el paso en el que se describe el diseo, muchas

veces usando un lenguaje de descripcin de hardware como el VHDL. Muchas
herramientas permiten ingresar el diseo no solo como HDLs sino tambin como
un diagrama esquemtico o estructural, una representacin grfica de una
mquina de estados o una tabla de entrada-salida. Estas herramientas simplifican
en gran medida el diseo y simplifican mucho la tarea del diseador. El cdigo
HDL puede ingresarse utilizando cualquier editor de texto, pero se recomienda
19
uno que tenga coloreado automtico de sintaxis ("syntax highlighting") ya que

ayuda y hace ms fcil esta etapa.
Figura 4 - Flujo de diseo para lgicas programables
Generacin o Traduccin (Generate, Translate): Este paso tiene sentido

cuando el diseo se hace mediante algunas de los mtodos mencionados
anteriormente en vez de en VHDL. En este paso se traducen todos los mdulos a
VHDL. Para los mdulos ingresados como VHDL, las herramientas generalmente
hacen una copia a una librera interna. En esta etapa se hace un anlisis del VHDL
para verificar la sintaxis y semntica de los mdulos. Tambin se hace una
20
elaboracin de los archivos, que consiste en replicar los componentes que se

utilizan ms de una vez en el diseo para hacer copias nicas y definir un
conexionado adecuado.
Compilado (Compile): Los simuladores actuales compilan el cdigo VHDL a un
formato que permite una simulacin mas rpida y eficaz. Esto se hace en este
paso.
Simulacin y verificacin: En este paso se simula el comportamiento del diseo
y se evala su comportamiento. La simulacin puede hacerse en tres etapas
diferentes del diseo. La primera es sobre el cdigo VHDL original para verificar
el correcto funcionamiento del diseo. La segunda es despus de sintetizar el
circuito, y se simulan la implementacin real sobre el PLD, ya sea con o sin la
anotacin de tiempos. La tercer etapa en la cual se puede simular el diseo es
despus de la Ubicacin e Interconexin. Esta es la ms exacta y la mas engorrosa
y lenta, ya que incluye la informacin final lgica y temporal el diseo sobre el
PLD.
Sntesis (Synthesis): En este paso se traduce el VHDL original a su
implementacin con lgica digital, utilizando los componentes especficos del
PLD que va a utilizarse. Esta traduccin puede llegar hasta el nivel ms bsico de
elementos lgicos (CLBs, LUTs, FFs) o hasta un nivel superior, en el que el
diseo se presenta en mdulos bsicos estndar provistos en una librera por el
proveedor del PLD.
Ubicacin e Interconexin (Place and Route): El PLD est compuesto por
muchos bloques idnticos, como se present en las secciones anteriores. En este
paso, cada componente del diseo sintetizado se ubica dentro del PLD especfico.
Tambin se interconectan los componentes entre s y con los pines de entradasalida.
Tareas Adicionales: Las tareas adicionales dependen del fabricante y las
herramientas. Puede definirse la interconexin de las con los pines fsicos del
PLD ingresar condiciones de entorno fsico para guiar a la herramienta de
Ubicacin e Interconexin, seleccionar reas del PLD para ubicar los bloques
lgicos, etc.
Anotacin de Retardos: Como en todo circuito digital, las seales tendrn un
retardo de propagacin que influir sobre su comportamiento. Con estos retardos
puede anotarse el diseo compilado para una simulacin que incluya informacin
de temporizado mas cercana a la implementacin real. Una vez sintetizado el
diseo, puede hacerse una estimacin de los retardos de propagacin que habr
entre las seales. Despus de la ubicacin e interconexin, el clculo de retardos
es mucho mas exacto.
Generacin de Binarios: Despus de la Ubicacin e Interconexin se genera
algn archivo ya sea para poder utilizar el sistema en un diseo mas complejo o
para programar un PLD.
Configuracin de PLD: Con el archivo binario generado puede configurarse
directamente un PLD a travs de alguna de las opciones de configuracin. Estas
opciones dependern de las herramientas y del PLD que se est utilizando.
Programacin de Memoria (PROM): Muchas FPGA no pueden configurarse de
manera permanente y requieren algn tipo de memoria para leer la configuracin
21
cuando se les aplica tensin de alimentacin. En la etapa de produccin deben

configurarse memorias PROM y conectarlas a la FPGA en el circuito impreso.
Verificacin (automtica): Una vez integrada la FPGA con su programacin al
sistema debe hacerse una verificacin para controlar que el diseo sobre en la
FPGA funciona bien (las FPGAs pueden tener fallas internas) y que la FPGA se
integra bien al sistema en el que est. Pueden usarse tcnicas y herramientas de
verificacin automticas para evaluar si el dispositivo y el diseo estn
funcionando como debieran.
En la figura, las flechas de lneas punteadas que vuelven al comienzo indican las
iteraciones que muchas veces se dan al trabajar en un diseo nuevo. Despus de simularlo
o configurar un PLD, pueden descubrirse fallas o haber cambios de requerimientos que
obligan al diseador a volver y modificar la descripcin del diseo.
5.4 Lenguajes de descripcin de hardware

Los lenguajes de descripcin de hardware (HDLs) permiten modelar sistemas digitales
completos. Al utilizar un HDL para modelar un sistema, es importante recordar que se
est modelando hardware, y no escribiendo software. El software se caracteriza por ser de
secuencial, una CPU ejecutar cada instruccin despus de la anterior. Los efectos de una
instruccin dependen exclusivamente de los efectos de las instrucciones anteriores. En el
hardware, sin embargo, hay muchas tareas que suceden de manera concurrente y la
variable tiempo juega un papel predominante. Un cambio en el tiempo de propagacin
de una compuerta, el retardo de una traza en una plaqueta, o el no cumplir con los
tiempos de establecimiento de un circuito puede cambiar de manera radical el
comportamiento de un sistema electrnico digital. Para poder modelar hardware los
HDLs permiten describir la concurrencia y paralelismo que se observa en un sistema de
hardware (muchas cosas y muchas seales cambian al mismo tiempo).
Usando HDLs, los sistemas digitales pueden describirse de diferentes maneras. Estos
modelos pueden ir desde el nivel abstracto de un algoritmo o el comportamiento general
de un circuito hasta un modelo al nivel de interconexin compuertas lgicas. En una
descripcin estructural, se definen de manera precisa las interfases de cada componente
de un sistema y sus interconexiones. As se arma un jerarqua de componentes, desde los
ms bsicos hasta el nivel superior que describe el sistema completo. Los HDLs tambin
permiten describir el comportamiento de los componentes. Para poder describir los
procesos concurrentes que caracterizan un sistema de hardware. Utilizando un conjunto
de instrucciones secuenciales puede modelarse el comportamiento de un sistema digital y
controlar la variable tiempo en los modelos.
Aunque hay muchos lenguajes de descripcin de hardware, dos predominan actualmente
el mundo del desarrollo de hardware digital: Verilog y VHDL. De los dems lenguajes,
muchos son propietarios, desarrollados por los distintos proveedores de herramientas o
PLD. En la actualidad casi todos los fabricantes de PLD y proveedores de herramientas
de desarrollo proveen soporte para VHDL y Verilog. En la actualidad estn surgiendo
nuevos lenguajes que incorporan mayores facilidades y prestaciones, de acuerdo a las
22
nuevas tecnologas y necesidades de los desarrolladores. A continuacin se presenta una

breve introduccin a cada lenguaje
5.4.1 VHDL
Las siglas VHDL provienen de VHSIC Hardware Description Lenguaje y a su vez
VHSIC quiere decir Very High Speed Integrated Circuit. O sea que VHDL significa
lenguaje de descripcin de hardware para circuitos integrados de alta velocidad. Sus
orgenes datan de la dcada de 1980. El departamento de defensa de Estados Unidos y el
IEEE patrocinaron un programa de desarrollo para un lenguaje con el que se pudieran
modelar circuitos integrados de alta complejidad. Un lenguaje de estas caractersticas
permitira describir los circuitos para su documentacin y adems modelarlos y
evaluarlos mediante simulaciones antes de incurrir en los grandes gastos de fabricacin.
El VHDL naci entonces como un lenguaje de modelado y documentacin de sistemas
electrnicos digitales. El lenguaje se estandariz mediante el estndar 1076 del IEEE en
1987 (VHDL-87). Este estndar fue extendido y modificado en 1993 (VHDL-93) y 2002
(VHDL-2002).
En la actualidad, VHDL se utiliza no solo para modelar circuitos electrnicos sino
tambin para crear, o sintetizar, nuevos circuitos. La capacidad de sintetizar circuitos a
partir de los modelos en VHDL (u otro lenguaje de descripcin de hardware) surgi
despus de la creacin del lenguaje, con la aparicin de herramientas que traducen los
modelos VHDL a circuitos reales.
5.4.2 Verilog
El lenguaje Verilog fue desarrollado por Gateway Design Automation en 1984. En 1988
Synposis present la primera herramienta de sntesis basada en Verilog. Ms tarde
Cadence Design Systems adquiri Gateway Design Automation y luego abri el
lenguaje para que otros proveedores pudieran desarrollar herramientas de simulacin y
sntesis utilizando Verilog. En 1995 el lenguaje Verilog se transform en un estndar del
IEEE. Mientras que la sintaxis del VHDL es parecido a los lenguajes de programacin
Ada y Pascal, el Verilog proviene del C y tiene una sintaxis mas parecida a este.
5.4.3 Otros
En la actualidad los dos lenguajes mencionados, VHDL y Verilog, son los mas utilizados
para la sntesis automtica de hardware. Hay mucho esfuerzo de investigacin y
desarrollo (e incluso algunas herramientas comerciales) que aceptan la descripcin de
algoritmos en otros lenguajes con un mayor nivel de abstraccin.
Muchos vendedores de FPGAs proveen herramientas o "toolboxes" que se integran a
lenguajes de modelado como Matlab y Simulink. Una vez probado un algoritmo con estas
herramientas se genera de manera automtica el hardware necesario para implementarlo.
Una de las lneas de desarrollo principales es la de poder describir los sistemas con un
nivel de abstraccin mayor al RTL en un nico lenguaje Despus se especificaran las
restricciones necesarias para los resultados y las herramientas decidiran que parte
conviene implementar en hardware y que partes en software.
23
En general todas las herramientas actuales, aunque permiten describir o modelar los
sistemas con un lenguaje mas abstracto que el RTL terminan generando alguna versin
de cdigo RTL antes de sintetizar un circuito.
5.5 Herramientas de Desarrollo

La facilidad de desarrollo de sistemas sobre PLDs depende en gran medida del software y
hardware que permite crear y probar los diseos de una manera simple y eficiente. Al
conjunto de estas aplicaciones se los denomina herramientas de desarrollo. A
continuacin se describen algunas caractersticas de estas herramientas para los distintos
pasos del ciclo de diseo.
5.5.1 Descripcin del Diseo

En la creacin de fuentes se usan diferentes herramientas para facilitar el diseo. Algunas
herramientas comunes:
Estas herramientas incluyen: Modelos de comportamiento. Diferentes niveles. Interfases
grficas, etc.
5.5.2 Generacin o Traduccin

Se lleva todos los tipos de fuentes, tales como representaciones grficas de mquinas de
estado o diagramas esquemticos. a un lenguaje de descripcin de hardware. Los ms
comunes son VHDL o Verilog.
5.5.3 Simulacin
La simulacin de un sistema descrito de modelos en HDL merece algunos comentarios.
Los lenguajes de descripcin de hardware modelan o describen, mediante instrucciones
secuenciales, bloques de hardware que funcionarn de manera concurrente, es decir, al
mismo tiempo. Las seales de los bloques pueden afectarse mutuamente. Simular esto
tiene su complejidad, y dentro de los estndares que definen los lenguajes de descripcin
de hardware VHDL y Verilog se especifica como se deben simular los procesos
concurrentes.
5.5.4 Notas Manejo del tiempo en VHDL

La simulacin en VHDL se basa en incrementos finitos de tiempo. El paso de simulacin
estar dado por el tiempo especificado en el cdigo para cambios en las seales o por un
factor denominado retardo delta ("delta delay"). Este retardo delta es un micro-paso de
simulacin que se utiliza cuando no se especifica un retardo en la asignacin del valor de
una seal. Puede haber una cantidad indefinida de retardos delta en un paso de
simulacin. En la descripcin que sigue se mencionan de manera general algunas
caractersticas de VHDL. Aunque todava no se ha presentado ninguna caracterstica
especfica del lenguaje, el lector con una base de diseo de hardware podr seguirla sin
problemas. Un proceso en VHDL es la descripcin de un bloque de hardware que acta
de manera concurrente (al mismo tiempo) con todos los dems procesos.
Es importante tener en cuenta que ninguna asignacin de valores a una seal en hardware
ser inmediata. Es decir, si se utiliza la operacin X <= 1 que indica la asignacin un
24
valor lgico 1 a la seal X, este cambio nunca se producir inmediatamente, sino que
habr un retardo (como mnimo de un retardo delta) para la asignacin. Con esto en
mente, puede analizarse un ciclo de simulacin en VHDL que se comporta de la manera
mostrada en la Figura 5.
Al comenzar la simulacin (tiempo de simulacin cero) se asigna valores iniciales a las
seales. Despus de asignar los valores a las seales, se ejecutan todos los procesos hasta
que estos lleguen a un estado de reposo. En general, los procesos incluirn asignaciones
de nuevos valores para algunas seales. Estos cambios o asignaciones en los valores de
las seales se agendan para un tiempo posterior. Las seales recin se actualizarn
despus de un retardo, nunca inmediatamente.
Figura 5 - Ciclo de simulacin
Cuando los procesos estn en un estado de reposo (todos los procesos en VHDL tienen
un estado de reposo) se incrementa el tiempo de simulacin como para cambiar la seal
que tiene la prxima transicin. Este retardo ser el menor tiempo de todas las
asignaciones de seal hecha por los procesos, y puede ser un retardo delta o un tiempo
especificado por el cdigo. Despus de cambiar la(s) seal(es) se examinan nuevamente
los procesos para ver si esos cambios estimulan o disparan el comportamiento de algn
proceso o puede continuar la simulacin. Si se dispara algn proceso, este se evala
nuevamente de la manera descrita anteriormente. Si no se dispara ningn proceso se
procede a incrementar el tiempo hasta la prxima transicin de seal. Esto se repite hasta
llegar a un tiempo en la que no hay ninguna transicin de seal y todos los procesos estn
en reposo. Este proceso de simulacin permite obtener resultados determinsticos.
A continuacin se presenta un ejemplo para explicar mejor el proceso de simulacin en
VHDL. La Figura 6 muestra un circuito digital y los valores iniciales de las seales A, B,
25
C, X e Y. Todas las compuertas estn definidas para no tener retardo de propagacin, por
lo que el simulador usar el valor de un retardo delta. A los 50 ns de simulacin la
entrada A pasa de 1 a 0.
Figura 6 - Circuito digital combinacional
La siguiente tabla muestra los pasos en la simulacin al cambiar la seal A de 1 a 0 a los

50 ns. Cuando cambia A se evalan los procesos a los que afecta esa seal. El nico
proceso que se dispara es el inversor, y su salida X se agenda para cambiar de 0 a 1. En
delta 2 se cambia la seal X y se observa a que procesos afecta. Se agendan para cambiar
las seales Y y C. En delta 3 se cambian esas seales y se nota que solo se afecta el
proceso AND de salida. Se agenda el cambio de C y en delta 4 se cambia C a su valor
final.
Tabla 1 Ejemplo del pasos de simulacin y cambios en las seales
Tiempo Delta A
0 ns
1
50 ns
0 0
1 0
2 0
3
B X Y
1 0 1
1 0 1
1 1 1
1 1 0
1
C
0
0
0
1
Proceso
Entrada y salidas estables
Cambio en la entrada A. Evaluar inversor
Cambio en X. Evaluar NAND, Evaluar AND
Cambio en Y, C. Evaluar AND
Todos los procesos en reposo (actualizacin

0 de salida definitiva)
El pulso de un delta tiene sentido ya que al estar definidos los retardos sobre las
compuertas al valor por defecto de un retardo delta, el tiempo de propagacin a travs de
dos compuertas (NAND-AND) es mayor que a travs de una sola(AND), generando el
pulso (o glitch) en la salida C.
26
6 Dispositivos Lgicos Programables

Los dispositivos lgicos programables son circuitos integrados digitales que no tienen
una funcin predefinida por el fabricante. Su funcin puede ser definida (o programada)
por el usuario. Permiten reemplazar grandes diseos digitales que antes se
implementaban con componentes discretos (como compuertas y flip-flops) por un solo
integrado. Debido a la gran capacidad lgica que tienen los dispositivos modernos,
sistemas completos pueden desarrollarse sobre un solo circuito integrado. Esto da lugar a
las denominaciones System-on-a-Programmable Chip, o SoPC (sistema sobre un circuito
integrado programable) y System-on-a-Reprogammable Chip (SoRC).
Los dispositivos actuales (CPLD y FPGAs) tienen una capacidad lgica de hasta millones
de compuertas, incluyen interfaces programables para varios estndares de interfase
elctrica y tienen bloques de funciones especiales embebidos entre la lgica programable
tales como memoria, multiplicadores o CPUs completas. Esta gran capacidad y variedad
de los dispositivos los hace sumamente tiles a la hora de crear prototipos, desarrollo
rpido de nuevos productos, para los productos que deben ser reconfigurables por
naturaleza o productos que se producen en bajos volmenes y para los cuales no es
econmicamente viable crear un integrado a medida.
Uno de los factores ms importantes para el auge de las FPGA es el conjunto de
herramientas disponibles. Entre los puntos a destacar de las herramientas de software
disponibles en el mercado pueden nombrarse los siguientes:
La practicidad de usar lenguajes de descripcin de hardware (HDL o Hardware

Description Language) para sintetizar circuitos
La integracin de los flujos de diseo en un solo ambiente que hacen posible el
prototipeado rpido con poco tiempo de uso de las herramientas.
La integracin de los simuladores con el ambiente de desarrollo que permiten una
rpida verificacin de los sistemas diseados
Las interfases cada vez ms amigables, que incluyen interfases grficas, sistemas
de desarrollo integrados, la capacidad de desarrollar sistemas utilizando diversas
metodologas (esquemtico, maquina de estado, HDL, etc.), etc.
El soporte de diseo para FPGA por parte de las herramientas clsicas utilizadas
para el diseo de circuitos electrnicos (Orcad, etc.).
La disponibilidad de herramientas gratuitas o a bajo costo por parte de los
vendedores de PLDs
Las libreras de componentes integradas con las herramientas de software, que
permiten hacer diseos de manera rpida.
Guas y Templates automticos para el diseo de circuitos bsicos.
En resumen, la facilidad de uso de herramientas de desarrollo para PLDs ayudan a que

una gran cantidad de usuarios puedan rpidamente desarrollar un sistema utilizando
PLDs.
27
6.1 Evolucin de los Primeros Dispositivos Lgicos Programables

Los primeros dispositivos lgicos programables fueron las memorias PROM. Para ello se
utilizan como entradas las lneas de direccin a la memoria. De esta manera la memoria
provee una tabla de decodificacin completa de las entradas, y puede utilizarse para
implementar cualquier funcin lgica combinacional.
Los primeros dispositivos diseados especficamente para implementar funciones
digitales programables fueron los PLA, introducidos al mercado en la dcada de 1970 por
Philips.
Figura 7 - Esquema de un PLA
La base terica de estos dispositivos es que cualquier ecuacin lgica puede reducirse a
una suma de productos. El corazn electrnico de estos dispositivos consiste en un
bloque que permite negar las entradas y dos niveles de compuertas: un nivel de
compuertas AND y un nivel OR. Mediante fusibles pueden programarse las
interconexiones entre las entradas y la lgica. As los PLA permiten implementar
cualquier suma de productos de sus entradas. La Figura 7 muestra un esquema bsico de
un tpico dispositivo PLA.
Debido a las limitaciones en la velocidad de las conexiones programables y los
problemas en el proceso de manufactura de las PLA, surgieron dispositivos con un solo
nivel de lgica programable denominados PAL (recordar que los PLA tienen dos niveles
programables: un nivel AND y un nivel OR). Los PAL se basan en el mismo principio
que las PLA, pero tienen un nivel de lgica AND programable mientras el nivel de lgica
OR es fijo. Esto limita la cantidad de funciones que pueden definirse con un dispositivo
28
dado, as que los fabricantes de PAL los ofrecan en una variedad de configuraciones para
adecuarlos a las necesidades del usuario. Muchos PAL adems incorporaron registros
sobre las salidas y realimentacin para implementar circuitos secuenciales. La Figura 8
muestra un esquema de una posible configuracin de un PAL.
Figura 8 - Esquema de un PAL
Los dispositivos denominados GAL son un poco mas complejos que los PAL
mencionados anteriormente. Incluyen un nivel de lgica AND a la entrada y luego un
bloque lgico denominado macrocelda a la salida, en reemplazo del nivel OR. La
denominacin GAL fue utilizada en principio por Lattice, y luego licenciada a otros
fabricantes. Las Figura 9 y Figura 10 muestran el diagrama funcional de una GAL
completa y de una macrocelda de un dispositivo GAL22V10 de Lattice Semiconductors.
La macrocelda de estas GAL se denomina OLMC, por "Output Logic Macro Cell".
29
Figura 9 - Diagrama funcional de una GAL 22V10 de Lattice Semiconductors

(Fuente: hoja de datos de Lattice Semiconductors GAL 22V10 - www.latticesemi.com)
Figura 10 - Diagrama funcional de una macrocelda del GAL 22V10 de Lattice Semiconductors
(Fuente: hoja de datos de Lattice Semiconductors GAL 22V10 - www.latticesemi.com)
30
6.2 CPLDs
Los CPLDs son dispositivos que combinan varios bloques lgicos similares a las PAL o
GAL con una matriz de interconexin programable. Estos dispositivos se fabrican con
distintas capacidades para adaptarlos a las necesidades del usuario. Como ejemplo, la
familia MAX7000 de alto rendimiento de Altera se manufactura en versiones desde 32
hasta 512 macroceldas, con 36 a 212 entradas/salidas segn el dispositivo y
empaquetamiento (packaging) que se elija. Las Figura 11 y Figura 12 muestran la
estructura general y una macrocelda de estos CPLDs. Como se de las figura, estos
dispositivos incluyen adems de las macroceldas, un arreglo de interconexin
programable (PIA), una red de distribucin de reloj dedicada y bloques de entrada salida
que permiten interfases compatibles con diferentes estndares elctricos. Los bloques
lgicos AND y OR estn ambos incluidos en la macrocelda del dispositivo.
Figura 11 - Estructura funcional de los CPLD MAX7000 de Altera

(Fuente: hoja de datos de Altera Familia MAX7000 - www.altera.com)
31
Figura 12 - Esquema de una macrocelda de los CPLD MAX7000 de Altera

(Fuente: hoja de datos de Altera Familia MAX7000 - www.altera.com)
6.3 FPGAs
La arquitectura de una FPGA consiste en arreglos de bloques lgicos que se comunican
entre si a travs de canales de conexin verticales y horizontales. La Figura 13 muestra
un esquema de esta estructura. La principal diferencia entre las FPGA y CPLDs es que en
general los bloques lgicos de las FPGA no implementan la lgica usando compuertas
sino con generadores de funciones. En la siguiente seccin se estudiar en mayor detalle
la arquitectura de una FPGA tpica.
Figura 13 - Esquema bsico de la arquitectura de una FPGA
32
En las Figura 14 se muestra la arquitectura general de una FPGA de la familia Spartan IIe
de Xilinx. Esta FPGA contiene cinco elementos principales:
Bloque de entrada-salida (IOB o Input-Output Block): estos bloques proveen la

interfase entre las patitas o "pines" del integrado y la lgica interna.
Bloque lgico configurable (CLB o Configurable Logic Block): Estos son los
bloques bsicos que se utilizarn en la implementacin de un circuito digital.
Bloque de distribucin y compensacin de reloj (DLL o Delay Locked Loop):
Estos bloques controlan los dominios de reloj dentro del integrado y compensan
por retardos que pueda haber entre el reloj externo y el interno.
Bloque de memoria (BLOCK RAM): Estos bloques son memorias dedicadas
integradas dentro de la lgica programable.
Estructura de interconexin: Es una estructura verstil y multi-nivel de
interconexin entre los otros componentes de la FPGA.
Figura 14 - Diagrama en bloques de una FPGA Spartan IIe de Xilinx

(Fuente: hoja de datos Xilinx Familia Spartan 2e www.xilinx.com)
En las siguientes figuras se muestran algunos ejemplos de la arquitectura general de

algunas FPGAs de distintos fabricantes.
33
Figura 15 - Diagrama en bloques de una FPGA Cyclone II EP2C20 de Altera

(Fuente: hoja de datos Altera Familia Cyclone 2 www.altera.com)
Figura 16 - Arquitectura de una FPGA ProAsicPlus de Actel

(Fuente: hoja de datos Actel Familia ProAsicPlus www.actel.com)
Adems de los bloques lgicos bsicos, que ocupan la mayor parte de las FPGAs (CLBs,
Logic Array, Logic Tile, etc.), estos dispositivos constan de bloques que cumplen ciertas
funciones especficas. En las siguientes subsecciones se presentan en mayor detalle
34
algunos de los bloques o mdulos especficos que pueden conformar una FPGA. No
todos los bloques se encuentran en todas las FPGA, aunque casi todas tienen la
estructura general presentada al principio de esta seccin. La arquitectura especfica de
cada FPGA depender del fabricante y la aplicacin a la que est orientada.
6.3.1 Bloque Lgico Programable

Todas las FPGA tienen algn tipo de bloque lgico programable. Este es el corazn de la
FPGA, y permite implementar las diferentes funciones lgicas. En la Figura 17 se
muestra un esquema del bloque lgico programable (CLB) de una FPGA de la familia
Spartan IIe de Xilinx.
Figura 17 Esquema del bloque lgico configurable de una FPGA Spartan IIe de Xilinx
Cada CLB esta compuesto por dos bloques iguales denominados slices. Cada "slice"
contiene dos generadores de funciones y un multiplexor MUXF5. El multiplexor combina
los resultados de los generadores de funciones dentro de cada "slice" del CLB.
Las dos "slices" estn unidas por un multiplexor MUXF6, que puede seleccionar la salida
de una u otra slice hacia la salida del CLB. Esto permite implementar cualquier funcin
de 6 entradas, un multiplexor de 8:1 o determinadas funciones lgicas de asta 19
entradas. Adems de poder implementarse lgica combinacional, cada slice contiene
35
recursos para implementar circuitos secuenciales y operaciones aritmticas eficientes. La

Figura 18 muestra estos componentes en ms detalle para un slice del CLB.
Figura 18 - Esquema interno de medio bloque lgico configurable de una Spartan 2e de Xilinx
En esta figura se ven los generadores de funciones, compuesto por una tabla de entradasalida (LUT o Look-Up Table) de cuatro entradas y una salida. Estas tablas pueden
implementar cualquier funcin lgica de cuatro entradas y una salida, as como tambin
utilizarse como memorias distribuidas de 16 x 1 bit. Las salidas de las LUT pasan a los
bloques de control, que contiene lgica que permite optimizar funciones aritmticas. Los
36
elementos que permiten implementar lgica secuencial son los elementos de

almacenamiento que se ven sobre las salidas del slice. Estos pueden configurarse como
flip-flops D con reloj o como latches controlado por nivel.
Como ejemplos, y sin entrar en detalles, en la Figura 19 y Figura 20 se muestran dos
ejemplos de bloques lgicos para otras FPGAs. Hay FPGAs que tienen bloques
configurables mas simples y otras (especialmente las de ltima generacin) cuyos
bloques lgicos son bastante ms complejos.
Figura 19 - Esquema del CLB de una FPGA Spartan 3 de Xilinx

(Fuente: hoja de datos Xilinx Familia Spartan 3 www.xilinx.com)
37
Figura 20 - Esquema del Elemento Lgico de una FPGA Cyclone II de Altera

(Fuente: hoja de datos Altera Familia Cyclone II www.altera.com)
6.3.2 Bloque de Entrada / Salida

Las interfaces de entrada-salida son otro de los componentes particulares que tienen las
FPGAs. La familia de FPGAs Spartan IIe de Xilinx, por ejemplo, divide las
entradas/salidas del integrado en bancos que se pueden configurar para tener una interfase
con lgica de diferentes estndares elctricos de manera independiente. Los bancos se
configuran aplicando diferentes tensiones de alimentacin a los pines denominados VccO
y VREF. Al utilizar diferentes valores de VccO para los distintos bancos se podr tener
un sistema con interfase a diferentes familias lgicas dentro de la misma FPGA. Las
entradas de reloj estn asociadas a diferentes bancos de entrada-salida, para permitir que
haya diferentes dominios de reloj con interfases elctricas diferentes. La Figura 21
muestra un esquema de estos bancos de entrada-salida.
38
Figura 21 Distribucin de los bancos de entrada/salida en una FPGA Spartan IIe de Xilinx
La siguiente tabla muestra el valor de VccO para las diferentes interfases lgicas.
Tabla 2 - Tensin VccO para diferentes interfases lgicas de la familia Spartan IIe de Xilinx
Valor de VccO
3.3V
2.5V
1.8V
1.5V
Lgica de interfase
PCI, LVTTL, SSTL3 I, SSTL3 II, CTT, AGP, LVPECL, GTL, GTL+
SSTL2 I, SSTL2 II, LVCMOS2, LVDS, Bus LVDS, GTL, GTL+
LVCMOS18, GTL, GTL+
HSTL I, HSTL III, HSTL IV, GTL, GTL+
Adems de la tensin VccO, para varios de las interfases lgicas debe configurarse la
tensin de referencia VREF y agregarse resistencias de terminacin sobre la plaqueta en
las entradas-salidas de la FPGA. Cada bloque de entrada-salida tiene una resistencia de
pull-up y pull-down configurables que permiten fijar el valor lgico mediante
programacin.
Internamente, cada bloque de entrada-salida de la familia Spartan IIe de Xilinx tiene la
estructura mostrada en la Figura 22. Los elementos de entrada-salida de las FPGAs de
Altera Cyclone II tienen la estructura mostrada en la Figura 23.
39
Figura 22 - Esquema de un bloque de entrada-salida (IOB) de una FPGA Spartan IIe de Xilinx
Figura 23 - Esquema de un bloque de entrada-salida de una FPGA Cyclone II de Altera

(Fuente: hoja de datos Altera Familia Cyclone II www.altera.com)
40
Los bloques de entrada-salida de muchas FPGAs tienen elementos de almacenamiento

integrados que permiten controlar mejor los tiempos de propagacin entre las patitas
(pines) del integrado y la lgica interna. Adems cada bloque de entrada-salida cuenta
con buffers programables que pueden configurarse para tres estados y colocar la salidas
de la FPGA en alta impedancia (estado Z).
6.3.3 Bloque de Control de Reloj

El sistema de control del reloj consiste en bloques de control integrados a la red de
distribucin de reloj. La red de distribucin de reloj en las FPGA asegura retardos parejos
a todos los bloques lgicos de la FPGA. Cada fabricante utiliza una arquitectura diferente
para el control y distribucin de reloj. La siguiente Figura 24 muestra el esquema de
distribucin de reloj para la familia Spartan IIe de Xilinx.
Figura 24 Red global de distribucin de reloj en la FPGA Spartan IIe de Xilinx

A continuacin se presentan dos ejemplos de bloques de control para FPGAs de

diferentes fabricantes.
La familia Spartan IIe de Xilinx tiene bloques especficos para control de reloj
denominados DLL (Delay Locked Loop). La Figura 25 muestra un esquema bsico de la
estructura de un DLL. Estos bloques sincronizan el reloj interno al reloj externo del
sistema, controlan el desplazamiento de fase entre los relojes, sincronizan los diferentes
dominios de reloj y aseguran un retardo de distribucin del reloj pareja para la lgica
interna de la FPGA.
41
Figura 25 Esquema bsico de un bloque de control de reloj de la FPGA Spartan IIe de Xilinx
(Fuente: hoja de datos Xilinx Spartan 2e www.xilinx.com)
La familia Stratix de Altera tiene los bloques de control de reloj que se muestran en la
Figura 26.
Figura 26 Esquema de un bloque de control de reloj de la FPGA Stratix de Altera

(Fuente: hoja de datos Altera Familia Stratix www.altera.com)
42
Estos bloques (Enhanced PLL) permiten controlar la fase y frecuencia del reloj, el
sistema de distribucin de reloj y el estndar elctrico de interfase entre otras cosas.
6.3.4 Memoria
La memoria es un componente muy utilizado en diseos digitales. Varias familias de
FPGA contienen bloques de memoria embebida integrados con la lgica programable. En
general estos bloques bsicos de memoria pueden utilizarse en diferentes configuraciones
para generar RAMs y ROMs de diferentes tamaos. Adems de memorias embebidas, las
FPGAs basadas en memoria SRAM pueden usar las tablas LUT de los bloques lgicos
como memoria.
La Figura 27 muestra un esquema de una celda de memoria bsica de la familia Spartan
IIe de Xilinx. Este bloque se denomina BLOCK RAM y es una memoria de puerto dual
(dual-port), que puede leerse y escribirse al mismo tiempo.
Figura 27 Diagrama de un bloque de memoria de la FPGA Spartan IIe de Xilinx

Estos bloques de memoria pueden usarse como memorias de puerto dual, puerto simple,
RAMs o ROMs. Para entender la versatilidad de estos bloques de memoria, en la
siguiente tabla se muestran las opciones de configuracin. Las interfases de direccin y
datos (ADDRA, ADDRB, DIA, DOB, DOA) se pueden configurar para diferentes
tamaos de memoria.
43
Tabla 3 - Posibles configuraciones de las celdas de BLOCK RAM de la familia Spartan IIe de Xilinx
Ancho de la palabra de
datos (bits)
1
2
4
8
16
Profundidad de
la memoria
4096
2048
1024
512
256
Bus de
direcciones
ADDR<11:0>
ADDR<10:0>
ADDR<9:0>
ADDR<8:0>
ADDR<7:0>
Bus de datos
DATA<0>
DATA<1:0>
DATA<3:0>
DATA<7:0>
DATA<15:0>
Adems de poder configurar cada bloque, varios bloques pueden conectarse utilizando
lgica externa para implementar memorias de otros tamaos y colas FIFO o FILO.
La Figura 28 muestra un bloque de memoria de Actel, que puede configurarse como
memoria de puerto simple, dual o multi-puerto.
Figura 28 -Esquema de un bloque de memoria de Actel configurada como memoria multi-puerto

(Fuente: Nota de Aplicacin de Actel: "Implementing Multi-Port
Memories in Actel ProAsicPlus Devices" - www.actel.com)
6.3.5 Bloque de Procesamiento de Seal

Varias FPGA contienen bloques especficos que optimizan en hardware ciertas funciones
especiales. Las FPGA de la familia Stratix de Altera, por ejemplo, contienen uno o ms
mdulos de procesamiento de seal entre los bloques de lgica programable de propsito
general. Estos bloques permiten desarrollar ciertas funciones especficas tpicas de las
aplicaciones de procesamiento de seal de manera muy eficiente. Pueden configurarse de
varias maneras diferentes segn las necesidades del usuario. Como muestra la Figura 29,
este bloque contiene lgica para implementar operaciones de multiplicacin-acumulacin
que requeriran de muchos recursos y ciclos de reloj si se implementaran utilizando
44
lgica de propsito general. Al igual que los otros bloques, los bloques especficos
pueden interconectarse a los dems bloques utilizando la matriz de intercone3xin
programable de la FPGA.
Figura 29 Bloque de procesamiento de seal de la familia Stratix de Altera

(Fuente: hoja de datos Altera Familia Stratix www.altera.com)
45
6.3.6 CPUs Embebidas

La familia de FPGAs de Xilinx Virtex II-PRO contiene una CPU Power PC 405 de IBM
y lgica de interconexin embebida dentro de lgica programable. Esto permite utilizar
toda la potencia de una CPU integrada con la flexibilidad de los perifricos diseados
mediante lgica programable. Los bloques especficos integrados en el silicio de las
FPGAs se denominan "hardcores". La Figura 30 muestra un esquema de la arquitectura
del Virtex II-PRO.
Figura 30 - CPU PC405 embebida en una Virtex II Pro de Xilinx

(Fuente: hoja de datos Xilinx Familia Virtex 2 Pro www.xilinx.com)
Altera ofrece la FPGA Excalibur que contiene un microcontrolador ARM922T integrado

a un costado de lgica programable. La lgica programable del Excalibur puede ser de
hasta un milln de compuertas. El micro es de arquitectura RISC de 32 bits, y puede
correr a una frecuencia de reloj de hasta 200 MHz.
Por otro lado tambin pueden disearse microcontroladores o procesadores usando
solamente la lgica de configuracin de las FPGAs. Altera ofrece el microcontrolador
Nios, de tecnologa RISC de 16 bits que puede utilizarse sobre varias de las FPGA de
Altera. A este tipo de diseo se lo denomina "softcore", ya que a FPGA no tiene ningn
bloque especfico para la CPU implementado sobre el circuito integrado. Hay muchos
micros "softcore" pblicos y propietarios. Xilinx ofrece el Microblaze y Actel ofrecer un
micro de la familia ARM.
46
6.3.7 Matriz de Interconexin

Para poder implementar circuitos lgicos, los elementos lgicos presentados en las
secciones anteriores no solo deben configurarse adecuadamente sino que tambin deben
conectarse entre si. La estructura de interconexin interna de un PLD consiste en un
conjunto de alambres o trazas que pueden conectarse mediante elementos de conexin
programables. Las herramientas de localizacin e interconexin (place and route) son
las encargadas de decidir en que elementos lgico se implementar la lgica diseada por
el usuario y como deben programarse las interconexiones para que el diseo funcione
segn las especificaciones de tiempo y retardos que se han definido.
A modo de ejemplo, se describir a continuacin la arquitectura de interconexin de las
FPGA Spartan IIe de Xilinx. Estas FPGA tienen dos niveles de interconexin. Por un
lado tienen una interconexin de propsito general a travs de la matriz de
interconexionado general o GRM por sus siglas en ingls. Por otro lado contienen
recursos de interconexin local. Adems de los ya mencionados, las FPGA Spartan IIe
contienen recursos de interconexin dedicados a seales de tres estados, de entrada-salida
y recursos de interconexin global para la distribucin de reloj y seales especficas.
Los recursos de interconexin local, mostrados en la Figura 31, permiten hacer las
conexiones entre los elementos internos de un bloque lgico o CLB, como las tablas de
bsqueda (LUT), los flip-flop y las realimentaciones dentro del CLB. Adems, el
interconexionado a este nivel provee conexiones a la matriz de interconexionado general
y a los CLB adyacentes. Las conexiones a los CLB adyacentes permiten optimizar los
diseos al evitar los retardos y la utilizacin de recursos de la matriz general de
interconexionado.
La mayor parte de las seales se conectarn a travs de la matriz general de
interconexionado (GRM). Los elementos de la GRM se encuentran entre los CLB, en los
canales de interconexin horizontales y verticales de la FPGA. Permiten hacer la
interconexin entre las trazas horizontales y verticales y hacia los CLB. A travs de ellos
se configuran las conexiones entre CLBs no adyacentes y hacia los bloques de
entrada/salida.
Los recursos de interconexionado global que no forman parte de la GRM permiten
distribuir seales con un fan-out grande, como son las seales de reloj y posiblemente las
seales de reset. La Figura 32 muestra un esquema de la red dedicada de distribucin de
seales de alto fan-out. Esta red de distribucin global tiene dos niveles y puede llevar
las seales de reloj a todos los bloques lgicos con poca diferencia de tiempo (skew)
entre ellos.
47
Figura 31 - Caminos de interconexin local en la FPGA Spartan IIe de Xilinx

Figura 32 - Red dedicada de distribucin de reloj en la FPGA Spartan IIe de Xilinx

6.4 Granularidad de los Dispositivos Lgicos Programables (PLDs)

La granularidad de un dispositivo lgico programable est dada por la funcionalidad
bsica que provee cada bloque de configuracin lgica, o la relacin entre las celdas
lgicas y los recursos de interconexionado. Algunos parmetros para definir la
granularidad de un dispositivo programable son:
Nmero de funciones que puede implementar cada celda lgica
Nmero de compuertas NAND de dos entradas equivalente por cada celda
lgica
48
Nmero total de transistores por celda lgica

rea total normalizada de lgica configurable (relacin de rea lgica/rea de
interconexionado)
Nmero de entradas y salidas por celda lgica
Algunos dispositivos tienen arquitecturas con celdas lgicas que pueden implementar
funciones lgicas complejas, de varias entradas/salidas. A estas se las denomina de
granularidad gruesa. Otras arquitecturas estn formadas por celdas bsicas que solo
permiten implementar lgica muy simple. A estas se las denomina de granularidad fina..
La granularidad de un dispositivo lgico influir en la manera que se implemente una
funcin lgica dada, en su frecuencia mxima de funcionamiento y en la utilizacin que
se hace del dispositivo.
Un bloque lgico grande puede implementar lgica ms compleja y por lo tanto se
necesitan menos bloques para una funcin dada. Por otro lado cada bloque consume ms
rea que puede desaprovecharse.
Una arquitectura de granularidad fina ser tpicamente ms densa y tendr menor retardo
de interconexin entre celda y celda. Sin embargo, para una funcin dada, se debern
conectar un mayor nmero de celdas. En general la mejor granularidad depender de la
aplicacin y las restricciones que hay sobre el diseo. Para una FPGA basada en tablas de
bsqueda (Look Up Table o LUT) la mejor relacin entradas salidas del bloque lgico es
4 a 1. Esto es lo que utilizan los dos fabricantes principales de FPGAs basados en
tecnologa SRAM. Para mayor informacin ver la seccin Referencias.
Algunas caractersticas de cada tipo de arquitectura son las siguientes:
Arquitecturas con granularidad fina
Celdas implementan funciones lgicas parciales de n entradas
Relacin de entradas a registros por celda muy baja (2/4 a 1)
Ejemplo: ProAsicPlus de Actel
Figura 33 Bloque Lgico (Logic Tile) de la ProAsicPlus de Actel

(Fuente: hoja de datos Actel Familia ProAsicPlus - www.actel.com)
49
Arquitecturas con granularidad media

Celdas implementan funciones completas de n entradas
Relacin de entradas a registros por celda de 6/8 a 1
Buenas para implementar mquinas de estado y lgica secuencial compleja
Ejemplo: Xilinx Spartan 3:
Figura 34 Slice de Spartan 3 de Xilinx

(Fuente: hoja de datos Xilinx Familia Spartan 3 www.xilinx.com)
50
Arquitecturas con granularidad gruesa

Celdas estilo PLD de arreglos de trminos
Relacin de entradas a registros de 32 a 1
Buenas para lgica combinacional como decodificacin de direcciones,
funciones aritmticas,
Pobres para arquitecturas con colas (pipelines)
Ejemplo: Altera MAX 3000
Figura 35 Macrocelda de un CPLD MAX3000 de Altera

(Fuente: hoja de datos Altera Familia MAX3000 www.altera.com)
Arquitecturas mixtas
Combinan celdas con granularidad fina y gruesa
Muchas veces tienen recursos de interconexin dedicados para cada tipo de
celda
Ejemplo: ispXPGA de Lattice Semiconductors
51
Figura 36 Unidad Funcional Programable PFU del ispXPGA de Lattice

(Fuente: hoja de datos Lattice Semiconductors Familia ispXPGA - www.latticesemi.com)
52
6.5 Tecnologa de Configuracin de los PLDs

La tecnologa .utilizada para configurar los elementos de un PLD, ya sean los bloques
lgicos o las interconexiones, dependen del fabricante y el dispositivo. Entre los
dispositivos reprogramables, se destacan las tecnologas EEPROM, SRAM y Flash. Los
dispositivos que solo pueden configurarse una vez en general utilizan tecnologas de
antifusible. Cada tecnologa tiene sus ventajas y desventajas respecto a las otras. En la
Tabla 4 se resumen algunas de estas caractersticas
Tabla 4 Caractersticas de las Tecnologas de Configuracin de PLDs
Tecnologa
EEPROM
SRAM
Flash
Antifusible
Ventajas
Desventajas
Requiere tensiones altas para configurar y

borrar
Requiere programador
Mayor consumo de potencia
Tolerancia media a la radiacin
Requiere mucha rea para implementarse
(integrados grandes)
Voltil. Se debe reprogramar despus de cortar
la alimentacin
Requiere memoria (PROM) externa
Tiempo de encendido lento (debe
configurarse)
Mayor utilizacin de rea en el integrado
No muy tolerante a la radiacin
No voltil
Puede probarse en un 100%
Software simple
Tecnologa base muy conocida
Reconfigurable. Puede cambiarse el

diseo solo cambiando la PROM de
configuracin en la placa final
No requiere programador
Proceso de manufactura igual que la
lgica
Puede probarse en un 100%
Tecnologa integrada con la lgica
(manufactura fcil, menor costo)
No voltil
Tiempo de encendido rpido
Menor potencia que SRAM
Menor rea que SRAM y antifusible
Programable sobre la placa (no tan
fcil)
No voltil
Mayor densidad
Mucha tolerancia a la radiacin
(aplicaciones espaciales)
Tiempo de encendido muy rpido
Baja potencia
Requiere tensiones altas
La misma velocidad que SRAM
Menor cantidad de reprogramaciones
No pueden reconfigurarse
No puede evaluarse. Si se comete un error, se
pierde el integrado
A continuacin se dan algunos ejemplos de dispositivos que utilizan cada tecnologa.

SRAM: Virtex II, Virtex4, Spartan2e, Spartan 3 de Xilinx. Stratix, Cyclone y Apex de
Altera
Flash: Actel ProAsic, ProAsicPlus
Antifusible: Actel A54SX, Quicklogic pAsic
EEPROM: Altera MAX7000, Cypress Ultra37000
EEPROM + SRAM: Lattice Semiconductor ispXPGA
53
6.6 Tendencias Actuales y Futuras

A continuacin se nombran algunas tendencias que pueden observarse en la industria de
de las lgicas programables, no solo de los dispositivos en s sino de las herramientas y
usos de estos dispositivos.
Desarrollo de FPGAs con mayor capacidad, ms velocidad, menos consumo de

potencia y menor costo.
Integracin en hardware sobre las lgicas programables de bloques especficos
como ALUs, componentes para procesamiento digital de seal, integracin con
uP y uC, memorias, etc.
Integracin y mezcla entre FPGAs y circuitos integrados de propsito especfico
(ASICs). Componentes que pueden pasar directamente de un prototipo sobre una
FPGA a un ASIC sin esfuerzo de diseo adicional.
Enfoque sobre la reutilizacin de propiedad intelectual. Modelo de negocios en el
que no solo se provee el hardware (PLDs) sino tambin propiedad intelectual por
un costo.
Cambios en las herramientas de software para tener mayor integracin entre los
diferentes usuarios y en los distintos pasos del proyecto. Esto incluye el manejo
de grupos de trabajo, el manejo de la propiedad intelectual, la documentacin de
proyectos integrada a las herramientas de diseo, la transferencia de los diseos
para FPGAs a ASICs, etc.
Integracin con herramientas y otros software de desarrollo de mayor nivel, como
son Matlab y herramientas para el diseo integrado de software y hardware. (HWSW co-design).
Integracin del manejo de configuracin de FPGAs con las herramientas de
diseo de plaquetas (PCBs), para poder configurar el interconexionado interno del
SoPC de manera integral con el conexionado hacia los componentes externos.
Instrumentos, tales como analizadores lgicos, que permiten observar la lgica de
interna de las FPGA en tiempo real al mismo tiempo que se observan otras
seales, externas a la FPGA.
Sistemas con aplicaciones que utilicen la reconfiguracin o reprogramacin de las
FPGAs directamente en el producto final segn la necesidad del momento.
Integracin de bloques lgicos programables alrededor de lgica fija en ASICs o
integrados estndar.
etc.
En los primos aos probablemente se ver una mayor incorporacin de las lgicas
programables en los diseos, junto a una mayor variedad, diversidad, nuevas ideas y
diseos basados en lgicas y plataformas programables.
6.7 Notas a Junio 2005

Estas notas se comenzaron a escribir en el 2003, y a Junio del 2005 muchos de los
aspectos tecnolgicos estn des actualizados respecto de los dispositivos actuales, y
algunos comentarios sobre tendencias son una realidad. Parece imposible tratar de
actualizar la informacin para reflejar las ltimas tendencias en estas notas. Para eso se
54
refiere al lector a los sitios web de los fabricantes de FPGAs listados al final de las notas.
La presentacin anterior debera servir para poner en tema al lector y presentarle los
conceptos bsicos sobre estas tecnologas. Para obtener mas detalles referirse a las
pginas web de los fabricantes (Ver referencias).
55
7 Primeros Pasos con VHDL

7.1 Notas Preliminares Sobre Formato de VHDL y los Ejemplos
Antes de continuar se describirn algunos puntos bsicos para poder comprender los
ejemplos y explicaciones que se presentan en las siguientes secciones.
7.1.1 Formato del Cdigo de Ejemplo

En los ejemplos presentados en este texto se tratar de mantener las siguientes reglas para
facilitar su comprensin y el aprendizaje de VHDL.
Las palabras reservadas de VHDL se escribirn en negrita
Se seguir un formato estndar para el cdigo
Solo se presentarn los casos y construcciones ms utilizadas y las orientadas a la
sntesis para FPGAs
7.1.2 Capitalizacin en VHDL

VHDL no es sensible a la capitalizacin y no distinguir las palabras que solo se
diferencian por letras maysculas. Por ejemplo, las palabras begin, BEGIN, Begin y
bEGin sern tratadas de la misma manera por el analizador de VHDL
En general es una buena prctica mantener el mismo formato a travs de todo el diseo y
por todos los miembros del equipo. En este texto se usarn palabras reservadas en
minscula con algunas palabras especiales en mayscula.
7.1.3 Comentarios en VHDL

Los comentarios en VHDL se indican con un doble guin --". Abracan desde --" hasta
el final de la lnea
Ejemplos:
-- A<= 1 Esto es un comentario de una lnea completa. No hace nada
A <= 1; -- Esto es una asignacin de la seal a con un comentario al final
-- Esto es un comentario que me dar error porque
pasa a la otra lnea y el analizador de VHDL no entiende la segunda lnea
En VHDL no existen los comentarios multi-lnea, y debe comentarse lnea por lnea si se
quiere comentar un bloque completo de cdigo
7.1.4 Delimitadores de Cdigo en VHDL

Las instrucciones en VHDL se terminan con ; y aunque se pueden escribir varias
instrucciones por lnea esa prctica no se recomienda y no se usar en este texto.
Ejemplos:
A <= 1; -- Una asignacin a la seal A
56
B <= 0; -- Una asignacin a la seal B

C <= 0; D <= 1; -- Doble asignacin en una lnea NO RECOMENDADO
Los bloques lgicos en VHDL se delimitan por las palabras reservadas begin y end.
Ejemplos:
-- Definicin de una arquitectura
architecture Comportamiento of Contador is
begin
-- Instrucciones que modelan la arquitectura
end architecture Comportamiento;
-- Definicin de un proceso
P_IncrementoCuenta : process(Clock_IN)
begin
-- Instrucciones que definen el proceso
end process; --Se debe cerrar con la palabra reservada process
7.2 Estructura Bsicas de un Modelo en VHDL

Con VHDL, un mdulo o componente de hardware se modela en dos secciones. Una es la
interfase del componente, denominado entidad y la otra es la arquitectura que describe
su funcionamiento interno. Este modelo permite esconder los detalles internos de
implementacin e incluso definir varias implementaciones para un componente sin
afectar la interfase externa.
7.2.1 Entidades y Arquitecturas

La siguiente Figura 37 ilustra el concepto de definicin de un componente en dos
secciones y presenta las palabras clave (en negritas) utilizadas por VHDL para definirlas.
La primer seccin declara el componente o entidad y define las seales de interfase Para
declarar la entidad se utiliza la palabra reservada entity.
57
Figura 37 Declaracin de un componente en VHDL
La estructura bsica mas simple de la declaracin se muestra con el siguiente ejemplo de

la declaracin de un contador de 6 bits.
entity Contador is
port(
Reset_IN
Clock_IN
Cuenta_OUT
);
end Contador;
: IN
: IN
: OUT
std_logic;
std_logic;
std_logic_vector(5 downto 0)
Cuadro 1 Declaracin de Entidad
La palabra reservada entity especifica que comienza con la declaracin de una entidad de
hardware. Esta entidad tendr el nombre Contador.A continuacin se definen las
seales de interfase mediante la palabra port.
Los tipos de seales de interfase o ports pueden tener los siguientes modos:
IN
Seal de entrada al componente
OUT
Seal de salida del componente
INOUT
Seal bidireccional. Usada para interfases de tres estados.
BUFFER
Seal de salida que puede leerse internamente. No recomendada
para diseos sintetizables.
58
En general, los tipos de los ports que se recomiendan para diseos sintetizables son
std_logic y std_logic_vector1, que definen seales de 1 bit o varios bits de ancho
respectivamente.
La entidad termina con la palabra reservada end. Notar el uso del ; para terminar cada
instruccin y su uso en la separacin de la declaracin de las seales de interfase.
La descripcin del funcionamiento del componente se define en la segunda seccin de
definicin del componente, denominada arquitectura. De la misma manera que una
funcin en hardware puede ser diseada de diferentes maneras, el comportamiento de un
componente puede modelarse de muchas maneras diferentes en VHDL.
En general la seccin de arquitectura tendr la estructura mostrada a continuacin.

-- En esta seccin se declaran las seales usadas en
-- el modelo
begin Comienzo de la especificacin del comportamiento
-- En esta seccin se define el comportamiento
-- utilizando las construcciones de VHDL necesarias
-- segn el modelo que se implemente
-- .........
Cuadro 2 Declaracin de arquitectura
El modelado del comportamiento puede ser de muchas maneras diferentes, pero en

general pueden dividirse en dos categoras principales. Los modelos de comportamiento y
los estructurales. Estos modelos se presentan por separado a continuacin, pero debe
tenerse en cuenta que VHDL no impone restricciones a mezclar los tipos de modelo
dentro de una arquitectura, aunque esta no es una prctica recomendada.
7.2.2 Modelos de comportamiento

En los modelos de comportamiento el funcionamiento del componente se modela a travs
del comportamiento de las seales a travs de compuertas y registros internos. Este
modelo de funcionamiento puede ser en la forma de un algoritmo general, al nivel de
transferencia de registros (register transfer level o RTL), flujo de datos o una mezcla de
ellos. El elemento de construccin bsico en el modelo de comportamiento en VHDL es
el proceso (process).
Los tipos std_logic y std_logic_vector estn definidos en libreras estndar de IEEE que se describirn
ms adelante.
59
En el siguiente ejemplo se muestra un proceso y una asignacin concurrente que definen

el comportamiento del contador de 6 bits declarado ms arriba.

-- Declaracin de las seales usadas en la arquitectura
signal Cuenta_REG : std_logic(5 downto 0);
-- Conexin del registro con el puerto de salida
Cuanta_OUT <= Cuenta_REG;
-- Este proceso cuenta los ciclos de reloj en
-- cada flanco ascendente de Clock_IN
P_IncrementaCuenta : process(Reset_IN, Clock_IN)
begin
if Reset_IN = 1 then
Cuenta_REG <= 000000; -- Reset vuelve todo a 0
elsif (Clock_INevent and Clock_IN = 1) then
Cuenta_REG <= Cuenta_REG + 1; -- Incrementa cuenta
end if;
-- Fin if(Reset, Clock)
end process;
-- Fin de Proceso Incrementa Cuenta
Cuadro 3 Modelo de comportamiento para un contador
Para el siguiente ejemplo, se supone que hay una entidad LogicaVaria declarada que
tiene varias entradas y cuya salidas son funciones lgicas AND y OR de las entradas. A
continuacin se muestran dos posibles arquitecturas de comportamiento para este
componente.
En el primer ejemplo se utilizan instrucciones concurrentes para asignar las salidas
directamente. En el segundo ejemplo se utiliza un proceso que se disparar ante un
cambio de cualquiera de las entradas. Este proceso cambia el valor de las seales
internas que actan solo como cables hacia los puertos de salida. El funcionamiento de
ambos modelos es exactamente el mismo y pueden definirse una variedad de modelos
con el mismo comportamiento.
architecture Comportamiento1 of LogicaVaria is

-- No hay seales internas que declarar
SalidaAnd_OUT <= Entrada1_IN and Entrada2_IN;
SalidaOR_OUT <= Entrada1_IN or Entrada2_IN;
60
end architecture Comportamiento1;

-- ----------------------------------------------------------------------------------------------- --- ----------------------------------------------------------------------------------------------- -architecture Comportamiento2 of LogicaVaria is
intSalidaAnd : std_logic; -- Seales internas declaradas
intSalidaOr : std_logic; -- solo para aclarar la lgica
SalidaAnd_OUT <= intSalidaAnd;
SalidaOr_OUT <= intSalidaOr;
ProcesoCalculoLogica : process(Entrada1_IN, Entrada2_IN)
begin
intSalidaOr <= Entrada1_IN or Entrada2_IN;
intSalidaAnd <= Entrada1_IN and Entrada2_IN;
end process; -- Fin de ProcesoCalculoLogica
end architecture Comportamiento2;
Cuadro 4 Modelos de comportamiento
7.2.3 Modelos Estructurales

Como al armar una plaqueta con diferentes componentes e interconectarlos, VHDL
permite armar modelos estructurales y as dar una jerarqua al diseo. En los modelos
estructurales se interconectan diferentes componentes utilizando un mapeo de
componentes bsicos mediante seales que actan como cables de interconexin. Las
interconexiones se hacen mapeando los puertos definidos en las declaraciones de las
entidades de los componentes bsicos.
Para el siguiente ejemplo se supone que existen dos componentes CompuertaAnd y
CompuertaOr predefinidos en la misma librera, ambas con dos entradas y una salida.
Siguiendo el ejemplo anterior para la entidad LogicaVaria, una arquitectura estructural
para este componente se muestra en el Cuadro 5.
architecture Estructura of LogicaVaria is

-- Declaracin de los componentes bsicos utilizados en
-- la arquitectura. Solo es necesario si se utiliza
-- VHDL-87.
component CompuertaAnd
port(EntradaAnd1_IN : IN std_logic;
EntradaAnd2_IN : IN std_logic;
SalidaAnd_OUT : OUT std_logic;
61
);
component CompuertaOr
port(EntradaOr1_IN : IN std_logic;
EntradaOr2_IN : IN std_logic;
SalidaOr_OUT : OUT std_logic;
);
begin Comienzo de la especificacin de estructura
-------
La instruccin port map conecta las seales con los

puertos de los componentes bsicos.
El smbolo => indica conexin. A la izquierda
estn los puertos de los componentes bsicos y
a la derecha seala las seales o puertos de la entidad
superior (en este caso LogicaVaria)
ComponenteBasicoAnd : CompuertaAnd
port map (EntradaAnd1_IN => Entrada1_IN,
EntradaAnd2_IN => Entrada2_IN,
SalidaAnd_OUT => SalidaAnd_OUT
);
ComponenteBasicoAnd : CompuertaOr
port map (EntradaOr1_IN => Entrada1_IN,
EntradaOr2_IN => Entrada2_IN,
SalidaOr_OUT
=> SalidaOr_OUT
);
end architecture Estructura;
Cuadro 5 Modelo estructural
En este ejemplo se conectaron dos componentes bsicos que implementan una compuerta
AND y una OR de dos entradas y una salida para definir el funcionamiento del
componente LogicaVaria. Notar el smbolo de conexin => (diferente al de asignacin
para seales <= ) y el uso de los separadores , entre los diferentes puertos de los
componentes bsicos. Otra cosa que se debe destacar es que no hay ningn problema en
que las seales o puertos de varios componentes en la jerarqua tengan el mismo nombre,
como puede verse en la conexin de las seales de salida.
En el modelo estructural pueden apreciarse dos partes principales. Una es la declaracin
de los componentes antes del comienzo (begin) de la arquitectura utilizando la palabra
component. La otra es crear una "instancia" (instantiation) de los componentes dentro de
la arquitectura. Instancia se refiere a crear una copia de un componente, dndole un
nombre nico dentro del diseo. Puede verse la instancia de un componente como la
creacin de una copia del componente dentro del componente actual. Los puertos del
componente se conectan a diferentes seales mediante el mapeo con las palabras port
map. En el ejemplo todos los puertos de los componentes se interconectan de manera
62
explcita a seales declaradas anteriormente. Tambin pueden dejarse seales abiertas,

por ejemplo cuando no se utilizan algunas salidas. Esto se hace usando la palabra open en
la instancia. Por ejemplo, si no se quiere conectar la salida de la compuerta AND,
puede usarse
ComponenteBasicoAnd : CompuertaAnd
port map (EntradaAnd1_IN => Entrada1_IN,
EntradaAnd2_IN => Entrada2_IN,
SalidaAnd_OUT => open
);
lo que dejar desconectada la salida. No pueden dejarse desconectadas las entradas.

En el ejemplo presentado se interconectan los puertos de los componentes con seales
usando una asociacin por nombre. Una asociacin por nombre es el uso de la expresin
(Puerto => SealALaQueSeConecta) que se utiliza para cada seal del puerto del
componente. Tambin puede hacerse una asociacin por lugar, pero eso no es
recomendable y no se presentarn ejemplos de ello en este texto.
Muchas herramientas de desarrollo permiten armar un componente con una arquitectura
estructural de manera grfica. Esto se hace representando cada componente bsico por un
smbolo grfico que tiene indicadas sus puertos de entrada y salida. Estos puertos se
interconectan con lneas como se hara al disear un circuito con una herramienta de
captura de esquemticos (como Orcad o PowerLogic). La herramienta de diseo traduce
luego el diagrama esquemtico a su representacin en VHDL para el anlisis y
elaboracin. En la Figura 38 se muestra un ejemplo de representacin grafica de un
esquemtico tomado de la herramienta ISE 6.2 de Xilinx.
Figura 38 Representacin grfica de un modelo estructural con las herramientas de Xilinx

(Fuente: Captura de pantalla de Herramienta Esquemtica ECS de Xilinx)
63
7.3 Elementos del Lenguaje VHDL

En esta seccin se presentan los elementos bsicos del lenguaje VHDL para familiarizar
al lector con algunas expresiones y operadores antes de comenzar con los elementos y
construcciones mas complejas del lenguaje.
7.3.1 Palabras Reservadas

Las siguientes son las palabras reservadas en VHDL. No debern utilizarse como
nombres de ningn tipo que no sea como instrucciones de VHDL.
abs, access, alter, alias, all, and, architecture, array, assert, attribute
begin, block, body, buffer, bus
case, component, configuration, constant
disconnect, downto
else, elsif, end, entity, exit
file, for, function
generate, generic, group2, guarded
if, impure2, in, inertial2, inout, in, is
label, library, linkage, literal2, loop
map, mod
nand, new, next, nor, not, null
of, on, open, or, others, out
package, port, postponed2, procedure, process, protected2,3, pure2
range, record, register, reject2, rem, report, return, rol2, ror2
select, severity, shared2, signal, sla2, sll2, sra2, srl2, subtype
then, to, transport, type
unaffected2, units, until, use
variable
wait, when, while, with
xnor2, xor
Cuadro 6 Palabras reservadas de VHDL
7.3.2 Smbolos Especiales

Algunos smbolos especiales usados por VHDL y sus y ejemplos se dan en la siguiente
tabla
Los operadores pueden sobrecargarse y tener diferentes significados para diferentes tipos
en diferentes libreras.
2
3
Estas no son palabras reservadas en VHDL-87

Estas no son palabras reservadas en VHDL-93
64
Tabla 5 Smbolos especiales de VHDL
Smbolo
Significado
Ejemplos de uso
Agrupa valores de bits

Forma cadenas de texto
Divisor para nmeros en base 2 a 16
&
(comilla
simple)
*
+
Operador de concatenacin
Atributos
Calificacin de tipo ambiguo
Caracteres
Valores de dgitos de bit
Subprogramas, para agrupar operadores
y dar prioridad en expresiones, etc.
Multiplicacin
Suma o identidad
Resta o negacin
, (coma)
. (punto)
Separa listas de parmetros

Punto decimal
Jerarqua en libreras
Divisin
Especificacin de tipo
std_logic_vector := 001000
Una cadena
una cadena con comillas.
2#1001000# -- nmero binario
16#af125f# -- nmero hexadecimal
001 & 111 -- equivalente a 001111
Clockevent Aleft
Bhigh
unsigned(10001)
A c
0 1 Z (alta impedancia)
function ()
(A + B) * 4
A := A * 4;
A+B
Cuenta_REG + 1
AB
Cuenta_REG 1
port map(A => A, B => B)
0.5 2#0.100#
use ieee.std_logic_1164.all
A := A / 4;
signal A : std_logic;
constant C : integer;
A_REG <= 1;
if (A < B) then
if (A = 0) then
if (A > 0) then
( )
/
:
;
<
=
>
[ ]
| (barra
vertical)
=>
**
:=
/=
>=
<=
<>
\
_ (Guin
bajo)
Fin de instruccin
Menor en comparaciones
Igual en comparaciones
Mayor en comparaciones
Mltiples opciones en una condicin
when 1 | 2 | 3 => -- Cuando la expresin sea

-- 1 o 2 o 3
Opciones case, when

Mapeo de puertos en arquitecturas
estructurales
Para dar valor a bits no asignados de
vectores
Exponencial
Asignacin para variables
No igual en comparaciones
Mayor o igual en comparaciones
Asignacin para seales
Menor o igual en comparaciones
Usado para indicar rango indefinidos
Usado para definir identificadores
extendidos
Usado para separar nmeros o cadenas
de bits largas
when 000 =>

port map(A => A, B => B)
(others => 0)
VariableA := 1
if (A /= 0) then
if (A >= 2) then
A <= 1; -- A toma el valor 1
if (A <= 3) then
(natural range <>)
\C:\\Xilinx\CarpetaProyecto\
124_321
b0100_0110
2#0110_1100#
X12FD_C46B_4567
65
7.3.3 Identificadores
Los identificadores se utilizan para dar nombre a los elementos de un diseo, ya sea
seales, variables o cualquier otro elemento del diseo.
Los identificadores pueden utilizar los caracteres alfanumricos y el guin bajo _.
Deben comenzar con una letra y no pueden tener mas de dos guiones bajos seguidos ni
terminar con un guin bajo. Recordar que no deben usarse palabras reservadas como
identificadores y que VHDL no diferenciar identificadores solo por las maysculas.
Ejemplos:
constant UTN_CUENTA_MAXIMA : integer := 56;
-- Una constante
signal
CuentaDeReloj_REG
: std_logic_vector(3 downto 0); -- Una seal
variable CuentaModulo1_VAR
: std_logic_vector(3 downto 0); -- Una variable
A partir de VHDL-93 se permite definir identificadores extendidos utilizando el smbolo
\. Estos identificadores extendidos pueden tener cualquier smbolo sin las limitaciones
de los identificadores bsicos de VHDL. Esto se hace para poder comunicarse con
herramientas de desarrollo que aceptan identificadores con formatos diferentes a los de
VHDL.
7.3.4 Nmeros
Los nmeros pueden representarse en diferentes bases y formatos. Hay dos tipos bsicos
de nmeros, los enteros (integer) y reales (real). Se puede usar notacin exponencial con
ambos tipos de nmero. Los nmeros pueden representarse en cualquier base de 2 a 16
usando #.
Los reales son nmeros representan aproximaciones a nmeros fraccionarios y contienen
un punto decimal con al menos un nmero antes y uno despus. En general los reales no
se utilizan en diseos para sntesis.
Ejemplos de nmeros reales:
1.23 1.2e4 1.23e-4 0.5 2#0.10# 8#0.4#
Ejemplos de nmeros enteros:
1 2 3467 2#01110#
16#0AFD24#
7.3.5 Cadenas de bits

Para poder representar los valores bsicos binarios de seales de diferentes anchos VHDL
define las cadenas de bits. Estas pueden estar definidas en base binaria, octal o
hexadecimal
Ejemplos de cadenas de bits
B1100000 (8 bits) b100_000 (7 bits)
xFA (8 bits)
xA3B6C1 (24 bits)
o 530 (9 bits) O54 (6 bits)

XF160_1234 (32 bits)
66
7.4 Tipos en VHDL

VHDL es un lenguaje de tipos fuertes (strong typing) como el Ada o Pascal4. Esto
significa que no pueden asignarse valores a seales o variables que no sean del tipo
declarado para esa seal o variable. Para poder asignar un tipo diferente, el programador
debe llamar explcitamente a una funcin de conversin de tipo.
Hay cuatro clases de objetos en VHDL: constantes, variables, seales y archivos. El tipo
de un objeto es muy importante, ya que no solo define que valores podr tomar, sino
tambin que operaciones se pueden realizar sobre l.
7.4.1 Tipos Comunes

VHDL tiene solo unos cuantos tipos predefinidos. Tambin est diseado para que haya
mucha flexibilidad para definir nuevos tipos. En algunos casos los tipos ms utilizados no
son los predefinidos sino tipos estndares definidos por el usuario. La tabla presenta
algunos de los tipos ms utilizados.
Tabla 6 Tipos ms utilizados en VHDL
Tipo
bolean
carcter
integer
real
time
std_logic
std_logic_vector
Comentario
Tipo buleano, toma los valores TRUE o FALSE
Contiene todos los caracteres ISO de 8 bits
Valores enteros. Como mnimo deben incluir los valores desde
el (- 231 + 1) hasta el (231-1)
Usado para representar valores fraccionarios
Usado para controlar tiempo en los modelos. Especialmente
importante durante las simulaciones.
Usada para seales
Definido a partir de std_logic, permite tener seales de un ancho
de varios bits
7.4.2 Declaracin de Tipos

Como ya se mencion, es muy simple definir nuevos tipos en VHDL. Un tipo que toma
un rango de valores se declara de la siguiente manera
type IdentificadorDeTipo is range MenorValor to MayorValor;

type IdentificadorDeTipo is range MayorValor downto MenorValor;
Cuadro 7 Declaracin de tipos
A diferencia del C que tiene tipos dbiles y en el que pueden asignarse valores de un tipo diferente al
declarado para las variables (tales como asignar a una variable del tipo float un valor int).
67
Ejemplos:
type tdDiaDelMes is range 0 to 31;
type tdHorasDelDia is range 0 to 23;
Mas ejemplos de tipos:
type tdMinutos is range 0 to 59;
type tdUnTipoRaro is range 59355 downto -456;
7.4.3 Tipos enumerados

Tambin pueden declararse tipos que toman un nmero discreto de valores usando la
declaracin:
type IdentificadorDeTipo is (Valor1, Valor2, Valor2, ...);

Cuadro 8 Declaracin de tipo enumerado
Ejemplos:
type tdCPUCycle is (fetch, decode, execute1, execute2);
type tdCicloLectura is (comienzo, lectura, fin);
type tdOctal is (0, 1, 2, 3, 4, 5, 6, 7);
type tdLogica3Estados is (0, 1, Z);
7.4.4 Subtipos
As como se pueden definir nuevos tipos, fcilmente se pueden definir subtipos a partir
de tipos ya declarados. La siguiente expresin permite hacer esto.
subtype Subtipo is Tipo range ValorMenor to ValorMayor;

Cuadro 9 Declaracin de subtipos
7.4.4.1 Tipo Natural y Positivo

El estndar VHDL incluye dos subtipos definidos de la siguiente manera. Un tipo muy
subtype natural is integer range 0 to EnteroMasAlto; -- Los enteros de 0 al mas alto
subtype positive is integer range 1 to EnteroMasAlto; -- Los enteros de 1 al mas alto
68
7.4.5 Tipos Fsicos

VHDL puede definir tipos fsicos para representar valores de cantidades fsicas del
mundo real. Al declarar un tipo fsico se define una unidad primaria y unidades
secundarias. El cuadro muestra algunos ejemplos de declaraciones de tipos fsicos.
-- Declaracin de un tipo para medidas

type tdLongitud is range 0 to 1E9;
units
um;
mm = 1000 um;
cm = 10 mm;
m = 100 cm;
pulgada = 25400 um; -- Multiplicador debe ser entero
-- No puede ser pulgada = 25.4 mm
pie = 12 pulgada;
end units tdLongitud;
Cuadro 10 Declaracin de tipo fsico
7.4.5.1 Tipo Tiempo

El tipo fsico predeterminado tiempo (time) es muy importante ya que es muy usado al
modelar retardos. La declaracin de time es la siguiente.
type time is (rango depende de la implementacin);

units
fs;
ps = 1000 fs;
ns = 1000 ps;
us = 1000 ns;
ms = 1000 us;
sec = 1000 ms;
min = 60 sec;
hour = 60 min;
end units time;
Cuadro 11 Tipo fsico tiempo (time)
7.4.6 Tipos compuestos

VHDL permite declarar tipos compuestos por mas de un valor. Un tipo compuesto es un
conjunto o agrupacin de valores que se trata como una unidad. Los tipos compuestos en
VHDL pueden ser arreglos (array) o records (record).
69
7.4.6.1 Arreglos
Un arreglo (array) es una coleccin de valores todos del mismo tipo. Se describe la
declaracin de tipos arreglos con varios ejemplos. Aunque todava no se han descrito los
objetos variable y constant se usan para ayudar a entender como se accede a los
elementos de un arreglo.
type tdByteC is array (0 to 7) of std_logic;
-- Indice
-- creciente
type tdByteD is array (7 downto 0) of std_logic; -- Indice
-- decreciente
-- Tipo auxiliar para los siguientes ejemplos
type tdEstadosControlador is (Inicial, Espera, Ejecucion,
Abrir, Cerrar, Fin);
-- Tipos arreglos a partir de un tipo enumerado
type tdContadorEstados is array (Inicial to Ejecucion)
of natural;
-- O lo mismo pero especificando el tipo original
type tdContadorEstados is array (tdEstadosControlador range
Inicial to Ejecucion) of natural;
-- Una vez que se ha definido un tipo arreglo se pueden definir
-- objetos de esa clase y se direccionan de la siguiente manera
constant PalabraDeControl : tdByteC := (0, 1, 0, 0,
1, 0, 1, 0);
-- La palabra reservada others se refiere a todos los elementos
-- que no han sido nombrados explicitamente
variable PalabraDeControl : tdByteD;
PalabraDecontrol (1) := 1;
PalabraDeControl := (others => 0); -- Todos los elementos !!!
-- Ahora uso others para definir los elementos 0,2,3,5 y 7
PalabraDecontrol := (1 =>1, 4 =>1, 6 =>1, others => 0);
variable ContadorEstados
ContadorEstados(Inicial)
ContadorEstados(Espera)
ContadorEstados(Inicial)
: tdContadorEstados;
:= 0;
:= 0;
:= ContadorEstados(Inicial) + 1;
variable ContadorPrincipio : tdContadorEstados;

-- Ejemplo de asignacin por posicin
ContadorPrincipio := (0, 0 ,0);
-- Ejemplo de asignaciones nombrada (named)
ContadorPrincipio := (Inicial to Ejecucion => 0);
-- Otro ejemplo
ContadorPrincipio := (Inicial
=> 0,
70
Ejecucion => 0,
others
=> 0); -- Queda solo Espera
Cuadro 12 Arreglos
Del ejemplo pueden destacarse varias cosas.

Un arreglo puede ser ascendente o descendente y eso definir cual es el elemento
que queda ms a la izquierda.
Un arreglo puede definirse a partir de un tipo enumerado.
Los elementos de un arreglo pueden accederse usando el nombre del arreglo
seguido del ndice entre ( ). Ej.: Arreglo(0) :=
Los elementos de un arreglo pueden accederse usando notacin por posicin e
indicando los valores para todos sus elementos entre ( ) Ej.: Arreglo := (3, 2)
Los elementos de un arreglo pueden accederse usando los ndices de manera
explcita con notacin nombrada. Ej.: Arreglo := (0 =>3, 1 => 2)
La palabra reservada others se utiliza para acceder a todos los elementos de de un
arreglo que no hayan sido definidos.
7.4.6.2 Arreglos sin Rangos Predeterminados
VHDL permite definir tipos de arreglos sin rangos predeterminados. Estos arreglos se
denominan unconstrained arrays. El rango se da al declarar un objeto de ese tipo. A
continuacin se muestran dos ejemplos de arreglos de este tipo muy utilizados en VHDL.
type std_logic_vector is array (natural range <> ) of std_logic;

type string is array (natural range <> ) of character;
Cuadro 13 Arreglos sin rango predeterminado
El primero es std_logic_vector, definido en el paquete std_logic_1164 y es el tipo ms

utilizado para seales de ancho de ms de un bit. Los paquetes se presentan ms adelante.
El segundo es un tipo predefinido de VHDL, string, y permite definir cadenas de
caracteres. No se utilizan para diseos sintetizables
El valor de los ndices o rango se dan al declarar un objeto como se muestra en los
ejemplos
Ejemplos:
-- string. No usado en diseos sintetizables
constant Cadena: string (0 to 10); -- Rango definido explicitamente
variable Cadena: string := Cadena de caracteres ; -- Rango definido
-- de manera implcita
71
-- std_logic_vector. Buena prctica siempre definirla como (MSB downto 0)

constant PalabraControl : std_logic_vector (3 downto 0) := 1001;
constant PalabraControl : std_logic_vector (15 downto 0) := XF5D6;
signal PalabraEntrada : std_logic_vector (3 downto 0);
7.4.6.3 Records
Un record es una coleccin de valores que no deben ser todos del mismo tipo. Se
presentarn mediante un ejemplo en el cuadro siguiente.
-- Un record que agrupa varios
-- control de tiempo en horas,
type tdTiempo is record
seg
: integer range 0 to
min
horas
end record tdTiempo;
valores para llevar un

minutos y segundos
59;
59;
23;
-- Declaracin y asignacin para un objeto del tipo tdTiempo

constant Espera : tdTiempo := (seg => 4, min => 21, horas => 0);
Cuadro 14 Declaracin de un record
7.4.7 Calificacin y Conversin de Tipos

Si varios tipos definen el mismo valor posible puede ser que un valor se pueda interpretar
de manera ambigua. Para especificar el tipo explcitamente se usa la comilla simple.
Ejemplos:
unsigned(01001)
tdNivelLogico(high)
-- 01001 puede interpretarse como signed o unsigned

-- Si tdNivelLogico es un subtipo de tdNivelValido que
-- tambin puede tomar el valor high
Como VHDL es un lenguaje con tipos fuertes, cuando se necesita convertir de un tipo a
otro se debe especificar una conversin explcitamente. Esto se hace utilizando el tipo al
que se quiere convertir seguido del valor de otro tipo entre parntesis.
Ejemplos:
real(3)
integer (4.5)
-- Para convertir el entero 3 a real

-- Para redondear el real 4.5 a entero
72
7.5 Objetos en VHDL

Como se mencionara anteriormente, hay cuatro clases de objetos que pueden declararse
en . En esta seccin se presentarn las constantes, variables y seales. Los archivos no
pueden usarse para diseos sintetizables y se describirn en otra seccin.
7.5.1 Constantes
Las constantes son tipos en las que se almacenan datos que no cambian. Como su nombre
lo indica, se mantienen constantes en el tiempo. Las constantes se utilizan para poder
asignar tipos definidos a valores. Se utilizan para parametrizar valores que se repetirn en
distintos lugares del diseo y evitar nmeros mgicos, que aparecen en el cdigo pero
no se entiende bien que significan ni que tipo tienen. En vez de esto, puede definirse un
paquete que contenga todas las constantes usadas en el proyecto, con tipos nombres que
tengan sentido al leer el cdigo.
Las constantes se declaran como se muestra en el cuadro.
-----
Declaracin de constantes
El formato usado en este ejemplo para los
identificadores de constantes es el recomendado
en varias guas de cdigo VHDL
constant ADC_VALOR_MAXIMO : integer := 3000;

constant ADC_VALOR_MINIMO : integer := -3000;
constant CONTADOR_ANCHO_DE_CUENTA : natural := 2;
constant TIEMPO_SIMULACION_MAXIMO : time = 200 ns;
Cuadro 15 Declaracin de constantes
7.5.2 Seales
Las seales son la representacin de las conexiones de hardware que toman valores
lgicos. En general deben utilizarse seales al hacer un diseo que ser sintetizado. Los
tipos de seales mas utilizados son los mostrados en las declaraciones del cuadro. Estos
tipos se han definido por un estndar del IEEE que se describe ms adelante. EL
operador para asignacin de valores a una seal es el smbolo <=.
-- Declaracin de seales usadas en un modelo

signal Reloj
: std_logic;
signal Reset
: std_logic;
signal InterrupcionCPU : std_logic;
73
signal Cuenta_REG : std_logic_vector(5 downto 0);

signal ADCData_REG : std_logic_vector(ADC_MSB downto 0);
-- Asignacin de valores de seales.

Cuenta_REG <= 0111111;
ADCData_REG <= ADCData_IN;
Reloj <= 1;
Reloj <= 0;
BufferSalida <= ZZZZZZZZ;
-- Seal a tres estados
BufferSalida <= (others => Z) -- Seal a tres estados
-- Asignacin de valores de seales con retardo.
Cuenta_REG <= 0111111 after 1 ms;
ADCData_REG <= ADCData_IN after 2 ps;
Reloj <= 1 after 20 ns;
Reloj <= 0 after 20 ns;
BufferSalida <= (others => Z) after 40 ns;
Cuadro 16 Declaracin y uso de seales
En simulacin las seales toman sus valores un delta de tiempo despus de que se ejecuta
la instruccin, como se explicara en la seccin 5.5.3. Al sintetizar un circuito, la
asignacin puede verse como una conexin fsica, o un cable.
7.5.3 Variables
Las constantes pueden almacenar datos para utilizarlos en el modelo. Se asemejan a las
variables de otros lenguajes de programacin. Las variables toman los valores
instantneamente al asignarse en el cdigo. El operador de asignacin para las variables
es :=. Para diseos sintetizables se recomienda utilizar seales, pero las variables son
muy tiles al disear bancos de prueba.
-- Declaraciones de variables
variable A : integer;
variable B : integer := 56;
variable C : natural := 2#100_0111;
variable ValorMaximo_VAR : std_logic_vector(1 downto 0);
variable TiempoDeEspera
: time := 0 ns;
-- Asignacin de valores de variables
A := 45;
-- El tipo de A debe aceptar el valor 45
C := B;
-- Ambas variables del mismo tipo
TiempoViejo := TiempoActual;
Cuadro 17 Declaracin de variables
74
7.6 Libreras y Paquetes

En VHDL los componentes se describen utilizando entidades y definiendo arquitecturas
por separado. Estos bloques se denominarn unidades de diseo. Al analizar el cdigo,
cada unidad se asigna a una librera de una manera dependiente de las herramientas
utilizadas. A esto se lo denominar unidad de librera.
7.6.1 Libreras
Una librera se define como una coleccin de unidades de librera. Dependiendo de la
herramienta y el sistema operativo de la computadora que se utilice una librera puede ser
una carpeta directorio o una base de datos que contenga los nombres de las entidades y
arquitecturas que le pertenecen. Esto significa que una librera es solo una manera de
agrupar diferentes unidades para organizarlas, darles una jerarqua y poder reutilizarlas de
una manera ordenada. VHDL reserva el nombre de librera work para la librera del
diseo actual.
Si se necesita acceder a entidades, declaraciones o funciones de otra librera se debe
utilizar la instruccin library. La librera work se agrega al diseo en el que se est
trabajando de manera implcita. Supongamos que hay un conjunto de componentes que se
quieren reutilizar y han sido asignados a una librera llamada CompuertasBasicas en
algn diseo anterior. Para utilizar esos componentes se debe agregar lo siguiente antes
de la especificacin de una arquitectura.
-- Para usar las compuertas bsicas se debe agregar la

-- librera que las contiene
library CompuertasBasicas;
architecture Estructural of LogicaCompleja is
begin
-- Aqu pueden utilizarse los componentes declarados en
-- la librera CompuertasBasicas
end architecture Estructural;
Cuadro 18 Uso de una librera
La localizacin de la librera no est especificada por VHDL sino por la herramienta que
se est utilizando. Por ejemplo, la herramienta puede tener un men donde se seleccionan
las libreras y se especifica el lugar dentro del disco rgido donde estas se localizan. Esa
informacin luego queda guardado en una base de datos para poder procesarla cuando el
analizador encuentra la directiva library en el VHDL.
7.6.2 Paquetes (Packages)

Un paquete (package) en VHDL es otras unidad de diseo adems de las entidades y
arquitecturas que contiene definiciones de objetos que pueden ser utilizados por otros
75
mdulos. Las clases de objetos que se puede colocarse en un paquete incluyen

declaraciones de seales, tipos, constantes, funciones, procedimientos y componentes.
-- Declaracin de un paquete
package NombrePaquete is
-- Declaraciones de constantes
constant ... ;
-- Declaraciones de tipos
type ...
;
subtype ... ;
-- Declaraciones de seales
signal ...
-- Declaraciones de subprogramas
function F1(...) return ... ;
function F2(...) return ... ;
...
end package NombrePaquete;
-- ----------------------------------------------------- --- Definicin del cuerpo del paquete
package body NombrePaquete is
function F1(...) is
...
function F2(...) is
...
end package body NombrePaquete;
Cuadro 19 Declaracin de paquetes
La estructura de definicin de paquete tiene primero una declaracin en la que se define

la interfase con el paquete. En esta seccin se deben especificar todas las declaraciones
de los tems que luego sern visibles a las unidades en las que se incluya el paquete. La
segunda seccin del paquete es el cuerpo (body) en el cual se implementan los
subprogramas. Esto permite esconder la implementacin del funcionamiento de los tems
del paquete. En el cuadro se muestra el formato general de un paquete.
Las seales que se definen en un paquete sern globales y podrn accederse por cualquier
entidad que utilice el paquete. Lo mismo sucede con los tipos y constantes definidas en el
paquete. Estas podrn ser utilizadas en cualquier archivo en el que se incluya el paquete.
La expresin utilizada para utilizar un paquete de una librera dada redescribe a
continuacin
76
-- Para agregar un item declarado como NombreItem

-- en un paquete NombrePaquete de una librera
-- NombreLibreria debe usarse la instruccin use
library NombreLibreria; -- Declara que se usara la libreria
use NombreLibreria.NombrePaquete.NombreItem; -- Uso del
-- paquete
-- Para agregar todos los tipos y constantes de
-- una libreria
library NombreLibreria; -- Declara que se usara la libreria
use NombreLibreria.NombrePaquete.all; -- Uso del paquete
Cuadro 20 Uso de un paquete
7.6.3 Paquetes de Lgica Estndar del IEEE

Como puede verse de la seccin donde se describen los tipos en VHDL el lenguaje tiene
una gran capacidad para extender los tipos y definir y sobrecargar operadores y
funciones. Para estandarizar el IEEE desarroll un paquete lgico estndar denominado
std_logic_1164. Aunque no es realmente parte de VHDL, este paquetes es tan utilizado
que casi podra considerarse un aparte del lenguaje. Se recomienda siempre usar los tipos
definidos en estos paquetes, como se detallar mas adelante.
Adems de definir el paquete std_logic_1164, el IEEE defini un paquete con
operaciones aritmticas para nmeros representados por vectores de bits. Este paquete se
denomina numeric_std y es el recomendado para diseos sintetizables.
Para utilizar la lgica 1164 del IEEE o los paquetes numricos estndar con las
operaciones aritmticas sobre la lgica estndar se debe agregar el use de los paquetes
adecuados.
-- Utilizacin de los paquetes lgicos estndar del IEEE
library ieee;
use ieee.std_logic_1164.all; -- Lgica estndar
use ieee.numeric_std.all;
-- Operaciones aritmticas
Cuadro 21 Uso de los paquetes estndar IEEE
77
7.6.3.1 Lgica estndar std_logic y std_ulogic definidos en std_logic_1164

El paquete std_logic_1164 dentro de la librera ieee define un tipo std_ulogic con nueve
valores posibles.
Tabla 7 Valores posibles para lgica std_logic
Valor
U
X
0
1
Z
Descripcin
Sin inicializar
Desconocido forzado
0 forzado
1 forzado
alta impedancia
Valor
W
L
H
-
Descripcin
Desconocido dbil
0 dbil
1 dbil
No importa
A partir de esta lgica tambin se define el subtipo std_logic. Este tipo es lo que se
denomina lgica resuelta ya que incluye funciones que definen que pasa cuando varias
salidas se conectan a una seal.
Los valores dbiles y forzados se incluyen para poder modelar hardware que tiene
diferentes capacidades de controlar una seal. Por ejemplo, si una seal tiene un buffer de
tres estados que la maneja (posibles valores 0, 1 y Z) y adems una resistencia de
pull-up a la tensin de alimentacin con un valor alto (valor H). Si la salida del buffer
es alta impedancia (Z) el valor de la seal estar dado por la resistencia, pero si el buffer
tiene una salida lgica, esta forzar el valor de la seal mas all de la resistencia de pullup.
Del tipo std_logic se define el tipo std_logic_vector que es un arreglo (array) de
std_logic. std_logic_vector es un arreglo sin lmites, y el valor de los ndices mximo y
mnimo se dan al declarar el objeto de ese tipo.
Estos tipos se nos permite modelar seales y buses de diferentes anchos. Los tipos
std_logic y std_logic_vector son los recomendados para su uso y son los que se usarn
en los ejemplos de este texto.
Ejemplo de uso del tipo std_logic en la declaracin de una entidad :
entity Contador is
port(
Clock_IN
: IN std_logic;
Reset_IN
: IN std_logic;
Cuenta_OUT : OUT std_logic_vector (31 downto 0)
);
Ejemplo de uso del tipo std_logic en la declaracin de seales en una arquitectura
signal Cuenta_REG
: std_logic_vector (31 downto 0);
signal intFinDeCuenta : std_logic;
78
7.6.3.2 Deteccin de flancos de seales definidos en std_logic_1164

El paquete std_logic_1164 contiene las siguientes funciones que son muy tiles para
simplificar la sintaxis en los procesos para sntesis, como ya se ver mas adelante.
Tabla 8 Funciones de deteccin de flanco de seales
Funcin
rising_edge(S)
Tipo que
devuelve
boolean
falling_edge(S) boolean
Descripcin
Devuelve TRUE si hay un flanco ascendente
sobre S, sino devuelve FALSE.
Devuelve TRUE si hay un flanco descendente
sobre S, sino devuelve FALSE.
7.6.4 Aritmtica sobre lgica estndar

El paquete numeric_std define dos nuevos tipos a partir de la std_logic. Estos son
signed y unsigned, usados para representar nmeros enteros con y sin signo
respectivamente. Adems de esos dos tipos, define las operaciones dadas en la siguiente
tabla. En la tabla se enumeran las operaciones y el resultado de operar sobre los distintos
tipos.
Los paquetes std_logic_arith, std_logic_unsigned y std_logic_signed son paquetes de
Synopsis, Inc. que se distribuyen como parte de la librera IEEE. Estos paquetes cumplen
la misma funcin para cadenas de bits del tipo std_logic_vector. En std_logic_arith se
definen las operaciones sobre tipos del tipo signed y unsigned, mientras que en los otros
dos se definen conversiones para poder usar las funciones aritmticas con tipos
std_logic_vector. Si se desea utilizar estos paquetes, se debe incluir el paquete
std_logic_arith y solo uno de los otros dos paquetes. As las seales del tipo
std_logic_vector sern tratadas como con signo o sin signo segn cual paquete se haya
incluido. Estos paquetes surgieron antes de la librera estandarizada numeric_std. Como
se mencion antes, este paquete numeric_std no define operaciones sobre los vectores
estndar, sino que obliga al programador a declarar explcitamente las cadenas de bits
como del tipo signed o unsigned antes de poder realizar operaciones aritmticas sobre
ellos. Al utilizar los paquetes std_logic_arith junto a std_logic_signed o
std_logic_unsigned se puede operar directamente sobre std_logic_vector, por lo que
resultan ms prcticos.
A continuacin se resumen las opciones de encabezamientos recomendados para usar
diferentes paquetes. Las siguientes lneas deben incluirse de la manera especificada en los
diseos para usar los tipos std_logic_vector.
-- Encabezamiento para usar los tipos std_logic y std_logic_vector sin operaciones
aritmticas
library ieee;
use std_logic_1164.all;
79
-- Encabezamiento para usar los tipos std_logic y std_logic_vector y tratarlos como

-- nmeros con signo (complemento a dos) en las operaciones aritmticas
library ieee;
use std_logic_arith.all;
use std_logic_signed.all;
-- Encabezamiento para usar los tipos std_logic y std_logic_vector y tratarlos como
-- nmeros sin signo en las operaciones aritmticas
library ieee;
use std_logic_arith.all;
use std_logic_unsigned.all;
Tabla 9 Resumen de tipos de las operaciones aritmticas
Oper. Operacin
abs
+
*
/
rem
mod
=
/=
<
<=
>
>=
sll
srl
rol
ror
not
and
or
nand
nor
xor
xnor
valor absoluto
negacin
suma
resta
multiplicacin
divisin
resto
mdulo
igualdad
diferente
menor
menor o igual
mayor
mayor o igual
corrimientos
lgicos
rotaciones
Tipo del
operando
derecho
signed
Tipo del
resultado
Longitud del
resultado
signed
Longitud del operando
unsigned
signed
unsigned
natural
signed
integer
unsigned
signed
unsigned
natural
signed
integer
unsigned
signed
unsigned
signed
natural
unsigned
integer
signed
unsigned
signed
natural
unsigned
integer
signed
integer
integer
unsigned
signed
unsigned
unsigned
signed
signed
boolean
boolean
boolean
boolean
boolean
boolean
unsigned
signed
La mas grande de los

dos operandos
Suma de las longitudes
Longitud del izquierdo
Longitud de operando
derecho
unsigned
signed
unsigned
signed
unsigned
signed
unsigned
signed
unsigned
signed
Tipo del
operando
izquierdo
negacin
operaciones
lgicas

del tipo vector de bits
Longitud de los
operandos.
Ambos deben ser de
igual longitud.
80
7.7 Construcciones Bsicas de VHDL

En esta seccin se presentarn las construcciones bsicas de modelado. Como se ha visto
de las secciones anteriores El VHDL es muy flexible y una misma tarea o funcin puede
modelarse de muchas maneras diferentes. Las descripciones y ejemplos dados estarn
orientados a diseos sintetizables. Los ejemplos se presentarn siguiendo prcticas
recomendadas para el cdigo que facilitan su entendimiento y reutilizacin. Esto no
significa que no haya otras estructuras y maneras diferentes de definir la misma
funcionalidad para un modelo, o que las presentadas sean las nicas estructuras
sintetizables.
Como se ha visto anteriormente, un componente en VHDL se define utilizando dos
unidades de diseo: entity y architecture. Es buena prctica incluir ambas unidades5
para un componente en un solo archivo que tenga el mismo nombre que la entidad,
separadas de otras declaraciones de entidades y arquitecturas. Esto facilita la
comprensin del diseo, ayuda a localizar rpidamente los componentes y ayuda a
reutilizar el cdigo.
En trminos generales, la arquitectura de un componente puede ser un modelo de
comportamiento o estructural. No conviene mezclar ambos modelos y no se har en este
texto. Un modelo estructural incluye todos los componentes bsicos y las seales que los
interconectan. Utiliza las palabras port map para logar esta interconexin, como se
mostr en la seccin 7.2.3. Es importante destacar que en VHDL-87 se deben declarar los
componentes bsicos que se usarn usando la palabra component antes del begin de la
arquitectura. En VHDL-93 pueden usarse componentes directamente destacando
explcitamente a que librera pertenecen. En los apndices pueden consultarse ejemplos
de este tipo de modelo que servirn como gua para nuevos diseos.
La estructura general de un componente en el que se modela su comportamiento es la
mostrada en el cuadro. En este esquema se van las declaraciones de la entidad y
arquitectura, y dentro de la arquitectura varias secciones bsicas.
En la arquitectura, antes de la palabra begin se definen todas las seales internas que se
utilizarn en el modelo. Despus de la palabra begin recin comienza una serie de
operaciones que concurrentes que se ejecutarn en paralelo. Esto permite modelar el
verdadero funcionamiento del hardware ya que en general habr muchas tareas
ejecutando en paralelo e interactuando entre s.
entity Componente is
port(
Declaracin de puertos de entrada salida
);
5
Si existe ms de una arquitectura para una entidad todas deberan estar definidas en el mismo archivo.
81
end Componente;
-- ---------------------------------------------------- -architecture Comportamiento of Componente is
Declaracin de seales internas del componente

-- En esta seccin se define el comportamiento
-- utilizando las construcciones de VHDL necesarias
-- segn el modelo que se implemente
Serie de operaciones concurrentes:
Operacin concurrente 1 (proceso u operacin aislada)
Operacin concurrente 2 (proceso u operacin aislada)
proceso A
Declaracin de variables internas del componente

begin -- Comienzo de las instrucciones secunciales del proceso
operaciones secuenciales
end process;
proceso B
Declaracin de variables internas del componente

begin -- Comienzo de las instrucciones secunciales del proceso
operaciones secuenciales
end process;

Cuadro 22 Esquema bsico de un componente en VHDL
7.7.1 Declaracin de seales

Todas las seales que se utilizan internamente en el componente deben declararse. Los
tipos recomendados de seales para diseos sintetizables son std_logic,
std_logic_vector, signed y unsigned, como se explicara en la descripcin de paquetes en
secciones anteriores. Para diseos sintetizables no se deben asignar valores iniciales a las
seales ya que estos no tienen sentido en una implementacin de hardware real.
82
Ejemplos:
signal intCuenta
signal ADCData_REG
signal Reloj
signal FinDeCuenta_REG
: unsigned(5 downto 0);

: signed(11 downto 0);
: std_logic;
: std_logic;
7.7.2 Operaciones Concurrentes

Las operaciones concurrentes modelan procesos que suceden en paralelo en el hardware.
En VHDL todas las operaciones concurrentes se ejecutan al mismo tiempo. VHDL tienen
varias instrucciones concurrentes y un mecanismo para agrupar instrucciones
secuenciales para que funcionen como una sola instruccin concurrente. Este mecanismo
se denomina proceso (process)
Algo importante a tener en cuanta para diseos sintetizables sobre PLDs es que a una
seal se le debe asignar un valor en solo una operacin concurrente. Es decir, dos
operaciones concurrentes no pueden tratar de asignar un valor a la misma seal. Si se
piense que significara esto en hardware se vera que habra dos o mas componentes o
elementos lgicos con sus salidas conectadas a la misma seal.
7.7.2.1 Flujo de datos
La manera ms simple de modelar una operacin concurrente es usando las asignacin
para seales <=. Este operador indica que el resultado de la expresin a la derecha debe
asignarse a la seal de la izquierda. Obviamente la seal y el resultado de la evaluacin
de la expresin deben ser del mismo tipo. Estas asignaciones se sintetizarn como lgica
combinacional. La expresin de la derecha debe utilizar operadores que estn definidos
para las seales utilizadas y que adems sean sintetizables. Los operadores lgicos
LISTA, de suma + y resta y la multiplicacin y divisin por factores de 2 son en
general sintetizables.
Todas las operaciones mostradas dentro de la arquitectura del siguiente cuadro son
concurrentes, eso significa que no importa en que orden se escriban ya que se evaluarn
todas al mismo tiempo.
library ieee;
entity Logica2Entrdas is
port (
Entrada1_IN
: IN
Entrada2_IN
: IN
SalidaAnd_OUT : OUT
SalidaOr_OUT
: OUT
SalidaNand_OUT : OUT
SalidaNor_OUT : OUT
std_logic;
std_logic;
std_logic;
std_logic;
std_logic;
std_logic -- No hay ; aqu
83
);
end Logica2Entrdas;
architecture Comportamiento of Logica2Entrdas is

-- Seales internas utilizadas
signal intSalidaAnd : std_logic;
signal intSalidaOr : std_logic;
begin
-- Operaciones
SalidaAnd_OUT
SalidaOr_OUT
SalidaNand_OUT
SalidaNor_OUT
concurrentes que modelan flujo de datos

<= intSalidaAnd;
<= intSalidaOr;
<= not intSalidaAnd;
<= not intSalidaOr;

-- ----------------------------------------------------- -library ieee;
use ieee.std_logic_arith.all; -- Lgica estndar
entity Logica2Entrdas is
port (
Entrada1_IN
: IN
Entrada2_IN
: IN
SalidaAnd_OUT : OUT
SalidaOr_OUT
: OUT
SalidaNand_OUT : OUT
SalidaNor_OUT : OUT
);
end Logica2Entrdas;
std_logic;
std_logic;
std_logic;
std_logic;
std_logic;
std_logic -- No hay ; aqu

-- Seales internas utilizadas
signal intSalidaAnd : std_logic;
signal intSalidaOr : std_logic;
begin
-- Operaciones
SalidaAnd_OUT
SalidaOr_OUT
SalidaNand_OUT
SalidaNor_OUT
concurrentes que modelan flujo de datos

<= intSalidaAnd;
<= intSalidaOr;
<= not intSalidaAnd;
<= not intSalidaOr;
84

Cuadro 23 Ejemplo de arquitectura definida como flujo de datos
Otras manera de definir la misma lgica se muestra en el siguiente cuadro. En este

ejemplo no se utilizan seales internas, sino que todas las salidas se definen como
funciones de las entradas. En general las herramientas de sntesis son los suficientemente
inteligentes como para optimizar esta lgica y sintetizar ambas arquitecturas a la misma
implementacin. Esta implementacin depender del PLD que se est utilizando.

begin
-- Operaciones concurrentes que modelan flujo de datos
SalidaAnd_OUT <= Entrada1_IN and Entrada2_IN;
SalidaOr_OUT
<= Entrada1_IN or Entrada2_IN;
SalidaNand_OUT <= not (Entrada1_IN and Entrada2_IN);
SalidaNor_OUT <= not (Entrada1_IN or Entrada2_IN);
Cuadro 24 Otro ejemplo de flujo de datos
7.7.2.2 Palabra reservada AFTER

En los siguientes ejemplos se presentan asignaciones de seal que utilizan la palabra
clave palabra clave after.
-- Operaciones concurrentes que modelan flujo de datos

-- con retardo entre cambios en las entradas y salidas
-- a la lgica
Salida1_OUT <= Entrada1_IN and Entrada2_IN after 20 ns;
Logica1
<= Entrada1_IN or Entrada2_IN after 40 ps;
Registro_REG <= not (Entrada1_IN and Entrada2_IN) after 4 ps;

Salida_OUT
<= not (Entrada1_IN or Entrada2_IN) after 2 ms;
Cuadro 25 Uso de la palabra AFTER
Como VHDL permite modelar el comportamiento eventos en el tiempo, incluye la

palabra reservada after que en el contexto presentado significa despus de luego de.
Esta palabra permite modelar retardos entre el evento que provoca los cambios en una
85
seal y la actualizacin de la seal. Mediante esta palabra se pueden modelar retardos en

compuertas, tiempos de repuesta de componentes, etc. La palabra after no es tenida en
cuanta al sintetizar un diseo, ya que los retardos en un circuito sintetizados dependern
del PLD y de cmo se haya implementado la lgica.
La palabra reservada alter puede ser utilizada en cualquier asignacin de seal, ya sea en
una instruccin concurrente o secuencial.
7.7.2.3 Expresin with select
La expresin with select modela un multiplexor, en el que de acuerdo a alguna seal
de control puede seleccionarse el valor a aplicar a una seal . El formato y algunos
ejemplos se muestran en el cuadro.
-- Formato general de la expresin "with... select"

with SenalDeControl select
SenalDeDestino <= Fuente1 when Condicion1,
Fuente2 when Condicion2,
...
FuenteN when others;
-- Ejemplo 1 Con SenalDeControl de 2 bits
with SenalDeControl select
SenalDeDestino_OUT <= Fuente1_IN when 00,
Fuente2_IN when 01,
Fuente4_IN when 10,
Fuente5 when others;
-- Ejemplo 2 - Operacin concurrente with ... select
with Seleccion_IN select
Salida1_OUT <= Datos1_IN when "001",
Datos2_IN when "010",
010101 when "100",
"XXXXXX" when others;
Cuadro 26 Uso de la expresin WITH SELECT
Deben especificarse todos los casos, y para ello es conveniente usar la palabra others
para asignar los valores que faltan y completar los casos. Se debe tener en cuenta que los
valores posibles de las seales del tipo std_logic no son solo 1 y 0, sino que hay otros
tales como Z, U. Eso hace que haya ms combinaciones posibles en un select que las
esperadas. Como no tiene sentido preguntar por opciones como Z o U ya que esto no
es sintetizable y probablemente ni siquiera tenga sentido durante simulaciones, la palabra
others debe incluirse siempre para el ltimo caso y as evitar problemas.
Otro puno importante es que muchas herramientas aceptan el valor X para las seales
de salida. Esto se muestra en el Ejemplo 2, y permite que se optimice la lgica en el
momento de la sntesis.
86
7.7.2.4 Expresin when, else

La expresin when else es otra operacin concurrente que puede usarse para modelar
lgica con prioridades.
-- Formato de when... else

SenalDeDestino <= Fuente1 when Condicion1 else
Fuente2 when Condicion2 else
...
OtraFuente when Condicion3 else
FuenteN ;
-- Caso por defecto
-- Ejemplo 1 de when... else con la
SenalDeDestino_OUT <= Fuente1 when
Fuente2 when
Fuente3 when
Fuente4 ; --
misma seal de control

SenalDeControl=00 else
Caso por defecto
-- Ejemplo 2 de when... else con condiciones varias

SenalDeDestino_OUT <= Fuente1 when Control = 00 else
Fuente2 when Control /= 01 else
Fuente3 when OtroControl = 101 else
Fuente4 ; -- Caso por defecto
-- Ejemplo 3 de when... con una condicin compleja
SenalDeDestino
<= 1 when X = 0 and Y = 1;
-- Ejemplo 3 de when... con una condicin compleja y ejemplos de
-- la palabra after
OtraSenal
<= 1 after 4 ns when X = 0 and Y = 1
else 0 after 3 ns;
Cuadro 27 Uso de la expresin WHEN ELSE
En el ejemplo 1 se modela una lgica de asignacin que toma decisiones sobre una sola
seal de control. Muchas herramientas reconocern en esto un multiplexor y lo
sintetizarn como tal, pero no es la manera recomendable de modelarlo, ya que las
palabras else indican prioridad. En esta operacin no es necesario especificar todos los
casos, pero debe tenerse en cuanta que al no hacerlo se inferir un match para guardar el
valor de salida anterior.
Las condiciones de asignacin a su vez no deben ser necesariamente sobre la misma seal
de control, y esto se muestra en el ejemplo 2. En este caso no se infiere un multiplexor
sino que se genera lgica combinacional con prioridades para implementar el circuito
modelado. La segunda condicin se prueba solo si no se cumple la primera, la tercera si
no se cumplen ni la primera ni la segunda, y as hasta llegar a la ltima. Si ninguna de las
condiciones se cumple se mantendr el valor anterior utilizando un latch. Para evitar
87
este latch se debe incluir el ltimo else sin condicin final y asignar un valor por
defecto.
7.7.3 Operaciones secuenciales

Antes de presentar los procesos, que son la operacin concurrente clave, se deben
presentar las operaciones secuenciales. Las instrucciones secuenciales se ejecutarn una
tras otra, de manera similar a las instrucciones de un lenguaje de programacin
convencional. La principal diferencia es que el bloque de instrucciones secuenciales
agrupadas por un proceso se ejecutarn en paralelo con los otros procesos y operaciones
concurrentes. En la seccin sobre procesos se explicar este mecanismo en ms detalle.
7.7.3.1 Instruccin WAIT
Adems de la palabra reservada after presentada anteriormente, la otra instruccin que
modela el tiempo en VHDL es la instruccin wait. Esta instruccin es una instruccin
secuencial, y por lo tanto solo se utilizar dentro de un proceso. Permite suspenderlo por
un perodo determinado de tiempo o hasta que se cumpla alguna condicin. Los usos de
la instruccin wait y algunos ejemplos se muestran en el cuadro.
-- Formatos posibles para la instruccin wait

wait;
-- Suspende el proceso para siempre
wait on Seal;
-- Suspende el proceso hasta que ocurra

-- un evento sobre la seal
wait for Tiempo;
-- Suspende el proceso un intervalo

-- fijo de tiempo
wait until (Expresin buleana);

-- Suspende el proceso hasta que se la
-- evaluacin de la expresin devuelva TRUE
-- Ejemplos de uso de la instruccin wait. En general se

-- utiliza para modelos NO SINTATIZABLES
-- --------------------------------------------------------- --- wait on ...

SenalAccion_OUT <= 1;
wait on PulsoRespuesta_IN; -- Espero un cambio en la entrada
-- Instrucciones secuenciales en un proceso de suma de 1 bit

-- con acarreo
Resultado <= A xor B after 20 ns;
88
Carry
<= A and B after 20 ns;
wait on A, B; Suspende hasta que cambie A o B
-- --------------------------------------------------------- --- wait for ...

wait for 10 ns; -- Suspende 10 nanosegundos
wait for 40 ms; -- Suspende 40 milisegundos
-- usando una constante predefinida
wait for ADC_TIEMPO _CONVERSION;
-- --------------------------------------------------------- --- wait for y wait solo

--- Generacin de un pulso de 200 ns
Reset_OUT <= 1; -- Pulso de la seal reset en 1
wait for 230 ns; -- Ancho del pulso es 230 ns
Reset_OUT <= 0; -- Seal reset a 0
wait;
-- Suspende para siempre. El reset queda
-- en el ultimo valor asignado (0)
-- --------------------------------------------------------- --- wait until ...
SenalAccion_OUT <= 1;
wait until (PulsoRespuesta_IN = 1); -- Espero que la entrada
-- se haga 1
-- ... condiciones mas complejas...
wait until (Senal1 = 0 and Entrada2 = 0);
wait until (((Entrada1 and Entrada2) xor Entrada3 )= 0);
Cuadro 28 Uso de la palabra WAIT
Pueden armarse expresiones ms complejas con la instruccin wait utilizando

combinaciones de los tres formatos for, on, until. Como en general la expresin wait no
es sintetizable6 y lo presentado alcanza para armar bancos de prueba simples, estas
expresiones no se presentarn de manera exhaustiva en este texto. Puede consultarse la
bibliografa para una mayor explicacin y ejemplos varios.
La expresin wait es sintetizable solo en procesos sincrnicos que usan el wait para esperar un evento en
la seal de reloj, como se detallar en la seccin 0.
89
7.7.3.2 Expresin if elsif else

La expresin if permite condicionar la ejecucin de instrucciones secuenciales. Cuando la
condicin buleana de la instruccin if se evala a TRUE se ejecutarn las instrucciones
secunciales que la siguen. Sino se saltearn. La instruccin elsif permite anidar
condiciones, generando una lgica de prioridad. Si no se da primer condicin se evala la
segunda, y as sucesivamente. La condicin else permite que se de un caso por defecto,
que se ejecutar solo si no se cumple ninguna de las condiciones anteriores. Siempre se
debe cerrar un lazo if con una instruccin end if. Los cuadros muestran el formato
general y dan ejemplos para la utilizacin de las instrucciones if, elsif, else.
---if
Formato general de la instruccin secuencial if

Solo es necesario que haya una condicin if...los elsif y
else son optativos
(Condicin 1) then
... -- Instrucciones secuenciales que se ejecutan si
-- se cumple la condicin 1
elsif (Condicin 2) then
-- se cumple la condicin 2 (y no se cumpli la
-- condicin 1)
-- se cumple la condicin 3 (y no se cumplieron las
-- condiciones 1 ni 2)
-- se cumple la condicin 4 (y no se cumplieron las
-- condiciones 1, 2 ni 3)
...
...
...
else
... - Instrucciones que se ejecutan solo si no se da
-- ningn caso de las condiciones anteriores
end if;
Cuadro 29 Uso de la expresin IF, ELSIF, ELSE
-- Ejemplos de instrucciones if
-- --------------------------------------------------------- --- Una sola condicin
-- Si la cuenta llega a su valor final volver a cero
90
if (Contador_REG = VALOR_MAXIMO) then

Contador_REG <= (others => 0);
end if;
-- --------------------------------------------------------- --- if, elsif
-- Reset asincrnico y ejecucin sincrnica
if (Reset_IN = 1) then
-- Dar valores iniciales a los registros
Registro_REG <= (others => 0);
elsif (Rising_Edge(Clock_IN)) then
.. -- Instrucciones secuenciales sincrnicas
end if;
-- --------------------------------------------------------- --- if, else
-- Detecto el signo de una entrada y lo guardo a un registro
if (DatoEntrada_IN(MSB) = 0) then
Signo_REG <= 0;
else
Signo_REG <= 1;
end if;
-- --------------------------------------------------------- --- if elsif else
-- Un ejemplo raro que no modela nada
if (Control_IN = 00) then
Salida_REG <= Entrada0_IN;
elsif (Entrada1_IN = 0100) then
Cualquiercosa_REG <= 1100000;
elsif (Cualquiercosa_REG = 1111111) then
TodosUnos_OUT <= 1;
else
Salida_REG <= Entrada3_IN;
end if;
-- --------------------------------------------------------- --- if else anidados
if (Control_IN = CONTROL_LEO_SIGNO) then
if (DatoEntrada_IN(MSB) = 0) then
Salida_REG <= 0;
else
Salida _REG <= 1;
end if;
elsif (Control_IN = CONTROL_LEO_LSB) then
Salida_REG <= DatoEntrada_IN(0);
else
Salida_REG <= 0;
end if;
91
-- --------------------------------------------------------- --- Todos los casos

-- Esto implementa un multiplexor usando if (la instruccin
-- case es la mas recomendada en estos casos)
if (Control_IN = 00) then
Salida_OUT <= Entrada0_IN;
elsif (Control_IN = 01) then
elsif (Control_IN = 10) then
else
end if;
Cuadro 30 Ejemplos de la expresin IF, ELSIF, ELSE
7.7.3.3 Expresin null

En algunos casos es necesario modelar que hay situaciones en las que no se debe tomar
ninguna accin. Esto puede hacerse en VHDL usando la instruccin null. Esta es una
instruccin secuencial y puede usarse en cualquier estructura secuencial. Se utiliza
muchas veces en expresiones como case donde deben explicitarse las acciones para todas
las alternativas posibles. En este caso se usa la palabra null para especificar que en
algunos casos no se debe hacer nada. Se mostrarn ejemplos de su uso en la seccin
donde se describe la expresin case.
7.7.3.4 Expresin case
Cuando las opciones que se desean evaluar son mutuamente excluyentes y no se necesita
una lgica de prioridad, la expresin a usar es case. Esta expresin utiliza la palabra
when para evaluar las diferentes opciones en paralelo y siempre debe terminarse con un
end case. Todas las opciones deben tenerse en cuanta en la expresin. Puede utilizarse la
barra vertical | para agrupar varias opciones y la palabra others para declarar un caso
para las opciones que no se evalan de manera explcita. Las opciones deben ser . En el
cuadro se presenta el formato general de la instruccin case.
-- Formato general de la instruccin secuencial case

case ExpresinSelectora is
when Condicin 1 =>
... -- Instrucciones secuenciales que se ejecutan
-- ExpresinSelectora resulta en la condicin
when Condicin 2 =>
-- ExpresinSelectora resulta en la condicin
when Condicin 3 | Condicin 4 =>
si
1
si
2
si
92
-- ExpresinSelectora resulta en la condicin 3 o 4

...
...
when others =>
-- ExpresinSelectora no resulta ser ninguna de las
-- opciones anteriores
end case;
Cuadro 31 Uso de la Expresin CASE
En el siguiente cuadro se presentan ejemplos que ayudar a entender el uso de la

instruccin case.
-- Ejemplos de instrucciones case

-- --------------------------------------------------------- --- Multiplexor utilizando la expresin case
case Control_IN is
when 00 =>
when 01 =>
when 10 =>
when others =>
end case;
-- --------------------------------------------------------- --- Ejemplo para una mquina de estado
...
-- Declaracin del tipo para estados
type tdEstado is (
EsperarDato,
LachearDato,
PulsoAlADC
);
...
-- Declaracin de estado actual y siguiente
signal EstadoActual
: tdEstado ;
signal EstadoSiguiente : tdEstado ;
...
-- CASE dentro de un proceso combinacional que asigna el
-- prximo estado segn el estado actual y las entradas.
-- El estado inicial y la asignacin de EstadoSiguiente a
-- EstadoActual se hacen en otro proceso sincrnico con reset
case EstadoActual is
when EsperarDato =>
if (ADCDataAvailable_IN = '1') then
93
EstadoSiguiente <= PulsoAlADC;

else
EstadoSiguiente <= EsperarDato;
end if;
when LachearDato =>
when PulsoAlADC =>
EstadoSiguiente <= LachearDato;
when others =>
end case;
-- CASE dentro de un proceso sincrnico que asigna las seales
-- internas y las salidas
...
-- A algunas seales se les da valores por defecto que se
-- sobre escriben en la expresin case
...
when EsperarDato =>
DatosInternos_REG <= DatosADC_IN;
Read_N_REG
<= '0';
NuevaMuestra_REG <= '1';
when PulsoAlADC =>
Read_N_REG
<= '0';
when others =>
null;
end case;
Cuadro 32 Ejemplos de la expresin CASE
El uso de null en la segunda expresin case significa no hacer nada. Se debe tener en
cuanta que no hacer nada significa mantener el valor de salida anterior, y esto implica
generar latches o realimentar seales adicionales. Si lo que realmente sucede es que no
importa que valor tenga la seal se con esa combinacin del case, puede dejarse algn
caso deseado como caso por defecto y as simplificar la lgica generada.
7.7.3.5 Procesos (process)
El tipo fundamental de operacin concurrente es el proceso (process). El proceso es el
bloque clave para modelar la interaccin compleja entre seales. El proceso en si
contiene operaciones secuenciales que se tratarn en bloque como una operacin
concurrente. Esto significa que el proceso se ejecutar en paralelo con otros procesos y
operaciones concurrentes, y que el tiempo de ejecucin de un proceso (es decir, la
ejecucin de todas sus instrucciones secuenciales) ser netamente cero7. Las operaciones
secuenciales utilizadas dentro de los procesos se describen en las siguientes secciones.
7
La asignacin de seales en simulacin siempre tiene un retardo mnimo de al menos un retardo delta,
como se describe en la seccin 5.5.3.
94
En simulacin, los procesos permanecen inactivos hasta que algn evento los hace
ejecutar. Un evento se entiende como un cambio en el valor de una seal. Los procesos se
dicen que son sensibles a las seales que causan su ejecucin, y hay varias maneras de
especificar cuales sern las seales que causan que un proceso ejecute. Al sintetizar el
diseo, los procesos se implementarn como circuitos combinacionales o secuenciales
que efectan la operacin modelada. Los circuitos implementados producirn cambios en
sus salidas ante eventos en las seales a las que son sensibles.
El cuadro muestra el formato bsico de un proceso.
-- Formato general de un proceso

NombreDeProceso : process(Seal1, seal2, ...)
...
Declaracin de tipos internos al proceso...
Declaracin de variables internas al proceso...
Declaracin de constantes internas al proceso...
... ms declaraciones internas al proceso
begin -- Comienzo de las instrucciones secuenciales
...
Instruccin secuencial
Instruccin secuencial
...
...ms instrucciones secuenciales
...
end process NombreDeProceso;
Cuadro 33 Declaracin de un proceso
Del formato bsico mostrado pueden destacarse las secciones principales.

Declaracin del proceso y lista de sensibilidad (seales entre parntesis)
Declaracin de variables, constantes, funciones y procedimientos
Bloque secuencial
Declaracin del proceso: Se recomienda dar un nombre al proceso para ayudar en la
depuracin y mejor comprensin del cdigo. Despus del nombre se utiliza la palabra
clave process.
Lista de sensibilidad: Un proceso debe tener alguna manera de suspender su ejecucin.
La lista de sensibilidad es una de las maneras de definir que seales actan sobre un
proceso. La otra es la utilizacin de la instruccin wait. Cuando se utiliza una lista de
sensibilidad no puede usarse la palabra wait para suspender un proceso.
Declaraciones: Pueden declararse funciones, constantes y variables que se utilizarn en
el proceso.
95
Instrucciones secuenciales: Estas estn entre las palabras begin y end. Todas las
instrucciones secuenciales de un proceso se ejecutarn como un bloque en paralelo con
los otros procesos y dems expresiones concurrentes.
El proceso se ejecutar solo cuando haya un cambio en alguna seal de su lista de
sensibilidad. Si el proceso no tiene lista de sensibilidad se ejecutar cuando se cumpla la
condicin dada en la instruccin wait. Solo puede usarse uno de los mtodos para
suspender un proceso Cuando se utiliza una lista de sensibilidad no puede usarse la
palabra wait entre las instrucciones secuenciales.
Al disear circuitos para sintetizar sobre lgicas programables (FPGAs, CPLDs u otros
PLDs) es mejor que los modelos en VHDL se adapten a la lgica bsica de los PLDs. No
hacerlo significa en muchos casos generar lgica adicional que ocupar mayor cantidad
de recursos del PLD innecesariamente. En algunos casos puede ser que el proceso
directamente no pueda sintetizarse. El cuadro muestra los patrones (templates) de
procesos recomendados para diseos sintetizables.
-- Formatos bsicos de los procesos recomendados para diseos

-- sintetizables
-- --------------------------------------------------------- --- PROCESO 1
-- --------------------------------------------------------- --- Este proceso se sintetiza como flip-flops + lgica
-- combinacional.
-- Contiene un reset asincrnico que puede usarse para dar
-- valores iniciales conocidos a las seales y un bloque
-- sincrnico.
-Proceso1 : process (Clock_IN, Reset_IN) -- Solo reloj y reset
begin
if (Reset_IN = '0') then -- Test active level of
-- asynchronous reset
...
... -- Instrucciones secuenciales asincrnicas
...
elsif Rising_edge(Clock_IN) then -- Evala el flanco de reloj
...
... -- Instrucciones secuenciales sincrnicas
...
end if;
end process Proceso1;
------
--------------------------------------------------------- -PROCESO 2
--------------------------------------------------------- -Este proceso genera solo lgica combinacional
96
Proceso2 : process (Entrada1, ...) - Todas las entradas a la

-- lgica en la lista
begin
... - Se asigna salidas para todas las opciones
... -- combinacionales sin realimentacin para que no
... - se infieran latches
-- --------------------------------------------------------- --- PROCESO 3
-- combinacional.
-Proceso3 : process (Clock_IN) -- Solo el reloj en la
-- lista de sensibilidad
begin
if Rising_edge(Clock_IN) then -- Solo se evala flanco de reloj
...
...
end if;
-- --------------------------------------------------------- --- PROCESO 4
-- combinacional.
-- Contiene solo lgica sincrnica. Es equivalente al Proceso 3
-Proceso4 : process Sin lista de sensibilidad
begin
wait until Rising_edge(Clock_IN); -- Espera un flanco de reloj
...
...
-- --------------------------------------------------------- --- PROCESO 5
-- --------------------------------------------------------- --- Este proceso se sintetiza como un latch transparente +
-lgica combinacional.
-Proceso5 : process (Entrada1, ...) - Todas las entradas a la
-- lgica en la lista
begin
if Enable = '1' then
...
... -- Instrucciones secuenciales con latch
97
...
end if;
Cuadro 34 Declaracin de procesos para sntesis
Como se ver en el prximo captulo, para diseos orientados a FPGAs es recomendable

generar procesos sincrnicos con una seal de reset asincrnica. Tambin es posible que
se necesiten procesos totalmente combinacionales. Estos dos procesos son los procesos 1
y 2 mostrados en el cuadro. A continuacin siguen dos procesos equivalentes. Estos
procesos son sincrnicos sin seal de reset. En general no se recomienda usar sistemas
que utilicen latches como el presentado en el proceso 5.
7.7.4 Operaciones secuenciales, retardos delta y sntesis

Debido a la manera en que VHDL simula y sintetiza las instrucciones secuenciales en un
proceso pueden surgir algunas confusiones al observar su funcionamiento. El cuadro
muestra un ejemplo para explicar esto.
-- Ejemplo para explicar el funcionamiento de instrucciones
-- secuenciales
X <= 1;
if (X = 1) then
Y <= 0;
else
Y <= 1;
end if;
X <= 0;
Cuadro 35 Retardos delta en procesos secuenciales
Si se supone que las instrucciones mostradas en el cuadro son parte de un proceso y se

analizan de manera secuencial, muchos usuarios esperaran que al finalizar, la seal Y
tenga el valor 0. Esto puede no suceder nunca! A continuacin se explicar porque.
Para explicar el procesamiento del proceso, VHDL utiliza retardos-delta. Si se supone
que el valor de X al comenzar el proceso (asignado en algn momento anterior de alguna
manera no descripta) no es 1, al procesar la instruccin X<= 1, no se asignar en ese
instante el valor 1 a X, sino que se agendar como se ha explicado en la seccin 5.5.3.
Luego se analizar la instruccin if (X = 1). La decisin tomada en este momento no
depender del valor asignado en la instruccin anterior a X (que todava no ha sido
asignado, sino que solo agendado), sino del valor actual de X (que no es 1). A Y se le
agendar entonces el valor 1 de la rama else. Luego se procesar la operacin X <= 0.
Otra vez, este valor no se asignar instantneamente sino que se agendar,
sobrescribiendo la asignacin 1 que estaba agendada. Despus de haber procesado todas
las instrucciones secuenciales se asignan los valores agendados a las seales. En este caso
98
0 a X y 1 a Y. Es decir, nunca se asigna el valor 1 a X de la primer instruccin. Por

supuesto el circuito sintetizado de estas instrucciones se comportar de la misma manera.
En el siguiente captulo se presentarn ejemplos de circuitos sintetizados para mostrar
como se implementa en hardware una secuencia de instrucciones como la recin
descriptas.
7.7.5 Visibilidad de las declaraciones de objetos en VHDL

Los objetos declarados en VHDL, ya sean constantes, seales o variables, Podrn ser
usadas solo por las construcciones que las ven. Estos objetos tienen una visibilidad
limitada segn el lugar de su declaracin. En la Figura 39 se muestra un esquema de un
componente. Las lneas a los costados muestran donde es visible cada declaracin de
tipo, seal o variable.
Los tipos, constantes y en general todas las declaraciones dentro de un paquete sern
visibles en todo el componente que los use. Para que sean visibles se deben usar antes de
la declaracin de entidad o arquitectura respectivamente. Una excepcin a esto es cuando
se usan dos paquetes que declaran un objeto con el mismo identificador. Por ejemplo, si
en el ejemplo anterior el usuario declara un tipo std_logic en el paquete Constantes, no
podr usarse ese tipo sin declarar explcitamente a que librera se est haciendo
referencia. Esto se hace usando el nombre de la librera, paquete y tipo separado por .
de la siguiente manera:
signal SenialDePrueba : ieee.std_logic_1164.std_logic;
Las constantes genricas no han sido descriptas todava, pero tienen una visibilidad que
abarca la declaracin de interfase y toda la arquitectura del componente.
Las seales de interfase declaradas en la entidad con port sern visibles dentro de toda la
arquitectura definida para esa entidad.
Las declaraciones de tipos, constantes y seales hechas en una arquitectura sern visibles
para toda la arquitectura. Es decir que estas seales podrn usarse en cualquier proceso o
construccin concurrente dentro de la arquitectura.
Las variables declaradas en cada proceso tendrn una visibilidad local a cada proceso.
Se deben mencionar en esta seccin, aunque no se han presentado, los procedimientos y
funciones. Estas se pueden declarar en las regiones de declaracin de la arquitectura o de
los procesos (antes de la palabra begin). Si se declaran como parte de la declaracin de la
arquitectura sern visibles en toda la arquitectura. Si se declaran dentro de un proceso
solo podrn verse dentro del proceso. A su vez las variables declaradas dentro de los
procesos y funciones tendrn una visibilidad local, y no podrn ser vistas por
construcciones externas.
99
Figura 39 Visibilidad de las declaraciones en VHDL
100
8 Ms VHDL
8.1 Introduccin
En la seccin de introduccin al VHDL se presentaron las estructuras y construcciones
bsicas y se dieron ejemplos para poder comenzar a crear diseos sintetizables. En esta
seccin se dan algunos otros conceptos de VHDL, se ahonda en el tema de optimizacin
para sntesis con ejemplos concretos y se presenta la metodologa de prueba utilizada
para validar un diseo, los bancos de prueba (testbench).
8.2 Parmetros Genricos

VHDL permite escribir modelos parametrizables utilizando una lista de constantes
genricas en la declaracin de una entidad. Esto se hace declarando una interfase genrica
con la palabra generic, de una manera similar a la declaracin de la interfase con la
palabra port. De esta manera se puede disear un componente flexible y reutilizable.
8.2.1 Declaracin de parmetros genricos

Utilizando constantes genricas pueden parametrizarse tanto la estructura como el
comportamiento de un componente. Las constantes genricas son visibles a partir de su
declaracin hasta el final de la declaracin de la entidad y en toda(s) la(s) arquitecturas
del componente. Se tratan como constantes dentro de declaracin de interfase y la
arquitectura de la entidad.
El Cuadro 36 muestra el formato de una declaracin de entidad con parmetros genricos.
-- Formato de una declaracin de entidad con genricos

generic(
ParametroGenerico1 : TipoDelGenerico1 := ValorPorDefecto1;
...
... Declaracin de interfase genrica
...
ParametroGenericoN : TipoDelGenericoN := ValorPorDefectoN
);
port(
.. Declaracin de interfaces
);
end Componente;
Cuadro 36 Formato de declaracin con parmetros genricos
Notar que. Al igual que en la declaracin de la interfase con port, el ltimo parmetro no
tiene un punto y coma ; despus de su declaracin y antes del parntesis que cierra la
declaracin genrica. La declaracin genrica se cierra con un parntesis y un punto y
coma );
101
El Cuadro 37 y Cuadro 38 muestran dos ejemplos de contadores que utilizan parmetros

genricos para parametrizar los lmites del contador. En el primero se define el bit ms
significativo del registro de cuenta como un genrico. Este contador pasar de largo al
llegar a su cuenta mxima (todos los bits en 1) y recomenzar en 0. Para el segundo
contador se define el nmero de bits (ser uno ms que el bit ms significativo) y el valor
mximo de la cuenta para reestablecer el valor del contador a cero.
-- ------------------------------------------------------------ EJEMPLO 1
-- Contador con bit ms significativo dado por un parmetro
-- genrico
entity ContadorRollover is
generic(
MSBContador : positive := 31
);
port(
Reset_IN
: IN std_logic;
Clock_IN
: IN std_logic;
Cuenta_OUT : OUT std_logic_vector(MSBContador downto 0)
);
end ContadorRollover;
architecture Comportamiento of ContadorRollover is
signal Cuenta_REG : std_logic_vector(MSBContador downto 0);
begin
-- La salida esta dada por un registro
Cuenta_OUT <= Cuenta_REG;
-- La cuenta de salida se incrementa y pasa de largo a 0 al
-- llegar al valor mximo
ProcesoCuenta : process(Reset_IN, Clock_IN)
begin
Cuenta_REG <= (others => 0);
elsif Rising_Edge(Clock_IN) then
Cuenta_REG <= Cuenta_REG + 1;
end if; -- Reset, Clock
end process ProcesoCuenta;
end Comportamiento;
Cuadro 37 Ejemplo de declaracin de entidad y arquitectura con parmetros genricos
102
-- ------------------------------------------------------------ EJEMPLO 2
-- Contador con nmero de bits y valor de la cuenta mxima dado
-- por parmetros genricos
entity ContadorConLimite is
generic(
CuentaMaxima : positive := 128;
BitsContador : positive := 8
);
port(
Reset_IN
: IN std_logic;
Clock_IN
: IN std_logic;
Cuenta_OUT : OUT std_logic_vector((BitsContador-1) downto 0)
);
end ContadorConLimite;
architecture Comportamiento of ContadorConLimite is
signal Cuenta_REG : std_logic_vector(BitsContador-1 downto 0);
begin
-- La salida esta dada por un registro
Cuenta_OUT <= Cuenta_REG;
-- La cuenta de salida se incrementa y se vuelve a 0 al llegar
-- a la cuenta mxima
ProcesoCuenta : process(Reset_IN, Clock_IN)
begin
Cuenta_REG <= (others => 0);
Cuenta_REG <= Cuenta_REG + 1;
if (Cuenta_REG = CuentaMaxima) then
end if; -- Cuenta mxima?
end process ProcesoCuenta;
end Comportamiento;
Cuadro 38 Ejemplo de declaracin de entidad y arquitectura con parmetros genricos
El Cuadro 39 muestra un ejemplo de la parametrizacin del comportamiento de un

componente. En este ejemplo adems de parametrizarse la estructura, se utiliza un
parmetro genrico para definir el tiempo de propagacin de una compuerta usando el
tipo predefinido time. Aunque este componente se sintetizar sin problemas, la
especificacin del tiempo de propagacin no ser tenida en cuanta por las herramientas.
El retardo de propagacin en un circuito sintetizado estar dado por la implementacin
real en el dispositivo, pero los retardos en los modelos pueden utilizarse para aproximar
el comportamiento post-sntesis o para visualizar mejor los efectos durante la simulacin.
103
-- ------------------------------------------------------------ EJEMPLO 3
-- Modelo de lgica mltiple con seales de ancho variable y
-- retardo entre entrada y salida
entity LogicaMultiple is
generic(
MSB
: positive := 8;
TPropagacion : time := 25 ns
);
port(
Entrada1_IN
: IN std_logic_vector(MSB downto 0);
Entrada2_IN
SalidaAnd_OUT : OUT std_logic_vector(MSB downto 0);
SalidaOr_OUT
: OUT std_logic_vector(MSB downto 0)
);
end LogicaMultiple;
architecture Comportamiento of LogicaMultiple is
begin
SalidaAnd_OUT <= Entrada1_IN AND Entrada2_IN -- Instruccin en
after TPropagacion;
-- varias lneas
SalidaOr_OUT <= Entrada1_IN OR Entrada2_IN after TPropagacion;
end Comportamiento;
Cuadro 39 Ejemplos de declaracin de entidad y arquitectura con parmetros genrico fsico
8.2.2 Uso de componentes con parmetros genricos

Hasta ahora solo se describi la declaracin de componentes con constantes genricas. La
flexibilidad de diseo la dan esas constantes al usar los componentes en una arquitectura
estructural. El Cuadro 40 muestra un ejemplo del uso de un componente con constantes
genricas en un modelo estructural para crear un componente de mayor complejidad. En
este caso el componente superior utiliza dos instancias del mismo componente base, con
diferentes parmetros genricos en cada instancia. Estos parmetros al igual que las
conexiones de las seales se hacen al usar el generic map y al port map.
104
-- ------------------------------------------------------------ Utilizacin de un componente con constantes genricas en un

-- diseo jerrquico
entity ContadorDualConLimite is
port(
ResetTop_IN
: IN std_logic;
ClockTop_IN
: IN std_logic;
Cuenta1_OUT
: OUT std_logic_vector(3 downto 0);
Cuenta2_OUT
: OUT std_logic_vector(4 downto 0)
);
end ContadorDualConLimite;
architecture Estructura of ContadorDualConLimite is

-- Declaracin del componente para poder usarlo en la
-- arquitectura
component ContadorConLimite
generic(
CuentaMaxima : positive := 128;
BitsContador : positive := 8
);
port(
Reset_IN
: IN std_logic;
Clock_IN
: IN std_logic;
Cuenta_OUT : OUT std_logic_vector(BitsContador-1 downto 0)
);
end component;
begin
-- Se crea una instancia del contador de 4 bits y limite
-- mximo = 12 con la salida a la salida 1 del contador dual
Contador12 : ContadorConLimite
generic map (
CuentaMaxima => 12,
BitsContador => 4
)
port map (
Reset_IN
=> ResetTop_IN,
Clock_IN
=> ClockTop_IN,
Cuenta_OUT => Cuenta1_OUT
);
-- Se crea una instancia del contador de 5 bits y limite
-- mximo = 25 con la salida a la salida 2 del contador dual
Contador25 : ContadorConLimite
generic map (
CuentaMaxima => 25,
BitsContador => 5
)
105
port map (
Reset_IN
Clock_IN
Cuenta_OUT
);
=> ResetTop_IN,
=> ClockTop_IN,
=> Cuenta2_OUT
end Estructura;
Cuadro 40 Ejemplo de modelo estructural usando constantes genricas
En el ejemplo del Cuadro 41 se usa el componente definido en el ltimo ejemplo de la

subseccin anterior. En este caso se genera una AND de tres entradas y con un ancho de
seal parametrizado a partir del componente LogicaMultiple. El componente creado tiene
un parmetro genrico con el mismo nombre que los componentes que utiliza. Esto no es
problema ya que al asociar los puertos siempre se usa GenricoDelComponenteBase =>
GenricoDelComponenteSuperior, y estos dos genricos pueden tener el mismo nombre.
Puede notarse que lo mismo sucede con las seales de los puertos.
-- ------------------------------------------------------------ Utilizacin de un componente con constantes genricas en un

-- diseo jerrquico para generar otro componente con constante
-- genrica
entity CompuertaAnd3Entradas is
generic(
MSB : positive := 3
);
port(
Entrada1_IN
Entrada2_IN
Entrada3_IN
SalidaAnd_OUT : OUT std_logic_vector(MSB downto 0)
);
end CompuertaAnd3Entradas;
architecture Estructura of CompuertaAnd3Entradas is

-- Declaracin del componente para poder usarlo en la
-- arquitectura
component LogicaMultiple
generic(
MSB
: positive := 8;
TPropagacion : time := 25 ns
);
106

port(
Entrada1_IN
Entrada2_IN
SalidaAnd_OUT
SalidaOr_OUT
);
end component;
:
:
:
:
IN
IN
OUT
OUT
std_logic_vector(MSB
downto
downto
downto
downto
0);
0);
0);
0)
-- Declaracin de una seal interna que permite la

-- interconexin de los componente internos
-- El genrico MSB es la definida para CompuertaAnd3Entradas
signal SenialIntermedia : std_logic_vector(MSB downto 0);
begin
-- Comienzo de la arquitectura de AND de 3 entradas
-- Se crea una instancia de la compuerta donde solo se usa

-- la parte AND y la salida a una seal interna
Compuerta1DosEntradas : LogicaMultiple
generic map (
MSB
=> MSB,
TPropagacion => 0 ns
)
port map (
Entrada1_IN
=> Entrada1_IN,
Entrada2_IN
=> Entrada2_IN,
SalidaAnd_OUT => SenialIntermedia,
SalidaOr_OUT
=> open
);
-- Se crea una instancia de la compuerta donde solo se usa
-- la parte AND y una de las entradas es la seal interna
Compuerta2DosEntradas : LogicaMultiple
generic map (
MSB
=> MSB,
TPropagacion => 0 ns
)
port map (
Entrada1_IN
=> SenialIntermedia,
Entrada2_IN
=> Entrada3_IN,
SalidaAnd_OUT => SalidaAnd_OUT,
SalidaOr_OUT
=> open
);
end Estructura;
Cuadro 41 Otro ejemplo de modelo estructural usando constantes genricas
107
Del cuadro pueden verse las diferentes secciones. Por un lado est la declaracin de la
entidad del nuevo componente (de nivel superior en la jerarqua del diseo). En esta
seccin se declaran las constantes genricas y las interfases o puertos.
Despus de esto se declara la arquitectura y dentro de esta los componentes y seales que
se utilizarn. Despus de la palabra begin se instancian o crean las dos instancias de
los componentes bases. Estos componentes se conectan a las entadas y salidas y entre s
mediante los port map. El generic map da valores a las constantes genricas de las
instancias de componentes bases. En este caso se propaga la constante MSB del
componente superior a los componentes base y se da un valor de 0 ns a los retardos. Las
salidas OR de los componentes base se dejan abiertas, y cualquier herramienta de sntesis
optimizar esto deshacindose de cualquier lgica no conectada e innecesaria.
8.3 Subprogramas: FUNCTION y PROCEDURE

VHDL provee dos maneras de definir subprogramas que pueden invocarse desde otras
secciones de cdigo: los procedimientos (procedure) y las funciones (function).
La diferencia entre estas dos estructuras es que el procedimiento es una instruccin
secuencial que se utiliza por su cuenta, mientras que una funcin es parte de una
expresin. En esta seccin se dar una breve descripcin de cada una de ellas, sin
ahondar en demasiados detalles.
En cuanto a sntesis, las funciones se sintetizarn como un bloque de lgica
combinacional independiente para cada llamado. Los procedimientos son sintetizables si
no utilizan instrucciones de deteccin de flancos de reloj o wait y se sintetizarn como
lgica combinacional que depende del uso del procedimiento y las optimizaciones que
implementen las herramientas.
8.3.1 Procedimientos
Los procedimientos se utilizan para agrupar instrucciones secuenciales. Un
procedimiento se declara con un nombre y opcionalmente un conjunto de parmetros.
Puede declararse al comienzo de una arquitectura, proceso o en un paquete. Su
visibilidad depender de donde est declarado. El Cuadro 42 muestra el formato de
declaracin y descripcin de un procedimiento
Un procedimiento termina al llegar la secuencia de ejecucin a la instruccin end
procedure. Es posible forzar el final de la ejecucin en medio del procedimiento usando
la palabra return.
-- Formato de la declaracin de un procedimiento sin parmetros

procedure NombreProcedimiento is
...
...-- Declaracin de variables locales al procedimiento
108
begin
...
... -- Instrucciones secuenciales
...
end procedure NombreProcedimiento;
-- Formato de la declaracin de un procedimiento con parmetros

procedure NombreProcedimiento (-- Lista de parmetros
ClaseDeParametro Identficador1 : Modo Tipo;
... -- Ms parmetros
ClaseDeParametro Identficador N : Modo Tipo
) is
...
...-- Declaracin de variables locales al procedimiento
begin
...
...
end procedure NombreProcedimiento;
Cuadro 42 Formato de declaracin de procedimientos
Un procedimiento se invoca desde un conjunto de instrucciones secuenciales utilizando

su nombre. El Cuadro 43 muestra la declaracin y uso de un procedimiento dentro de un
proceso que satura una seal a un valor mximo.
-- Ejemplo de procedimiento dentro de un proceso sincrnico

ProcesoLecturaADC : process(Reset_IN, Clock_IN)
-- Declaracin del procedimiento
procedure SaturarADC is
begin
if (ADCValue_REG > ADC_SATURACION) then
ADCValue_REG <= ADC_SATURACION;
end if;
end procedure SaturarADC;
begin - Comienzo de la seccin secuencial del proceso

... - Valores de reset
if ... - Si se debe leer un dato para leer del ADC
...- Interfase y lectura del ADC
109
ADCValue_REG <= ADC_IN;

-- Llamado al procedimiento que satura el valor del ADC
SaturarADC;
end if; -- Si se lee ADC
end process;
Cuadro 43 Ejemplo de declaracin y llamado a un procedimiento en un proceso
Los procedimientos sin parmetros actuarn sobre las seales o variables visibles para
ellos. En el ejemplo anterior, el procedimiento acta y modifica directamente la seal
ADCValue_REG. Si se utilizan parmetros para declarar y llamar un procedimiento se
podr utilizar o modificar diferentes variables o seales con cada llamado. Para declarar
un procedimiento con parmetros se utiliza el formato mostrado en el Cuadro 42. Esta es
similar a la declaracin de los puertos de una entidad, con los siguientes elementos:
ClaseDeParmetro : constant : constante, utilizada por defecto si el modo es in
variable : variable, utilizada por defecto si el modo es out
signal : seal, modifica directamente a la seal que representa
Identficador : Nombre con el que se identificar al parmetro en las instrucciones dentro
del procedimiento
Modo
: in
: parmetro de entrada que no se modifica en el procedimiento
out
: parmetro que no se lee pero se modifica en el procedimiento
inout : parmetro que se usa internamente y adems se modifica en el
procedimiento
Tipo
: Tipo del parmetro (ej.: std_logic, boolean, integer, etc.)
Los procedimientos que se declaran al principio de una arquitectura (no dentro de un
proceso especfico) solo pueden modificar seales a las que acceden en su lista de
parmetros. No pueden modificar seales declaradas en la arquitectura directamente
como en el ejemplo del Cuadro 43. El Cuadro 44 muestra un ejemplo de esto, con un
procedimiento que no funcionar y uno que si.
-- Ejemplo 1: NO FUNCIONA, NO SE PUEDE ACCEDER A Dato_REG

-- DIRECTAMENTE CON EL PROCEDIMIENTO SaturarADC
... - Arquitectura de una entidad
architecture Comportamiento of EntradaADC is
-- Declaracin de una seal y el mximo valor aceptado
constant LIMITE_MAX : std_logic_vector...
signal
Dato_REG
: std_logic_vector(15 downto 0);
-- Procedimiento mal hecho que no funcionar
procedure SaturarADC is
begin
if (Dato_REG > LIMITE_MAX) then
Dato_REG <= LIMITE_MAX;
110
end if;
...
-- Ejemplo 2: ESTE SI FUNCIONA, SE DEBE INVOCAR EL PROCEDIMIENTO
-- CON UN PARAMETROS, NO PUEDE ACCEDER A Dato_REG DIRCTAMENTE
...
architecture Comportamiento of EntradaADC is
-- Declaracin de una seal y el mximo valor aceptado
constant LIMITE_MAX : std_logic_vector...
signal
Dato_REG
-- Procedimiento que funciona porque usa un parmetro
procedure SaturarADC(signal Dato : inout
std_logic_vector(15 downto 0)) is
begin
if (Dato > LIMITE_MAX) then
Dato <= LIMITE_MAX;
end if;
...
Cuadro 44 Ejemplos de procedimiento al principio de una arquitectura bien y mal hechos
Un procedimiento puede utilizarse como una instruccin concurrente directamente en la

arquitectura de un componente. El procedimiento se ejecutar con los otras elementos
concurrentes como las asignaciones de seal y los procesos.
Para llamar a un procedimiento se utiliza el nombre del procedimiento seguido de una
lista de asociacin si el procedimiento requiere parmetros. Por ejemplo, para llamar al
procedimiento SaturarADC del ejemplo 2 del cuadro anterior para saturar la seal
Dato_REG se utiliza:
SaturarADC (Dato => Dato_REG); -----
Se asocia el parmetro Dato del

procedimiento con la seal
Dato_REG declarada en la
arquitectura.
Si hay mas de un parmetro deben separarse con comas como al

asociar un componente usando port map.
8.3.2 Funciones
Las funciones pueden verse como la generalizacin de expresiones. Son una manera de
definir nuevas operaciones que luego podrn ser utilizadas en expresiones. Estas
operaciones se describen como un conjunto de instrucciones secunciales que calculan un
resultado. Su declaracin, como se muestra en el Cuadro 45 es muy similar a los
procedimientos. La diferencia es que debe declararse un tipo que devolver el llamado a
la funcin usando return en la declaracin.
111
-- Formato de la declaracin de una funcin

function NombreFuncion (parmetros opcionales) return RTipo is
...
...-- Declaraciones
begin
...
...
end function NombreFuncion;
Cuadro 45 Formato de declaracin de una funcin
A diferencia de los procedimientos las funciones deben devolver un valor del tipo
declarado en la declaracin usando el formato de la instruccin return :
return expresin; -- Esto devuelve el resultado de expresin,
-- que debe ser del tipo declarado para la
-- funcin
La lista de parmetros opcionales de una funcin tiene el mismo formato que el de un

procedimiento con algunas limitaciones y detalles. Los parmetros no pueden ser del tipo
variable, si no especifica la clase del parmetro esta se asume constant y si no se
especifica el modo este se asume in. As, en una funcin que solo devolver un valor a
partir de una serie de seales de entrada puede declararse de manera simple segn el
esquema del ejemplo mostrado en el Cuadro 46. Este formato tiene similitud con las
funciones de otros lenguajes de programacin.
-- Ejemplo de la declaracin de una funcin con parmetros de

-- entrada constantes
function Mayor (
Entrada1 : std_logic_vector;
Entrada2 : std_logic_vector
) return std_logic_vector is
begin
if (Entrada1 > Entrada2) then
return Entrada1;
else
return Entrada2;
end if;
end function Mayor;
...
...
-- Uso de la funcin en una expresin concurrente o secuencial
112
Resultado <= Mayor(Entrada1 => DatoADC_IN,

Entrada2 => LimiteUsuario_IN);
-- Uso de la funcin con asociacin por posicin
Resultado <= Mayor(DatoADC_IN, LimiteUsuario_IN);
Cuadro 46 Ejemplo de declaracin y uso de una funcin con parmetros de entrada solamente
En este ejemplo los parmetros de entrada no tienen un rango prefijado. Los rangos se
asignarn cuando se llame a la funcin con parmetros reales. El tipo de la salida no
puede tener un rango predeterminado. En el ejemplo, el rango estar dado por las seales
DatoADC_IN y LimiteUsuario_IN y la seal que se devuelve tambin depender de la
cantidad de bits de estas dos entradas.
8.3.3 Asociacin de parmetros por posicin y por nombre

Hasta ahora solo se han descrito las listas de asociacin por nombre, como las utilizadas
para los port map y llamados de procedimientos, que utilizan el smbolo =>. En todos
estos casos pueden asociarse parmetros por posicin, como se muestra en el segundo
ejemplo del llamado de la funcin Mayor. Hay que tener mucho cuidado al hacer esto ya
que pueden cometerse errores de orden y no obtener los resultados deseados. Tambin
hace ms difcil la modificacin del cdigo. Para los componentes en arquitecturas
estructurales se recomienda la asociacin por nombre, pero en llamados a funciones hay
veces que es prctico usar la asociacin por posicin. En el caso del ejemplo se asociar
DatoADC_IN con Entrada1 porque este es el primer parmetro en la lista, y
LimiteUsuario_IN con Entrada1 porque es el segundo parmetro. En las
asociaciones por nombre no es necesario mantener el orden de los parmetros igual que
en la declaracin de la funcin o procedimiento.
8.4 Instruccin GENERATE

La instruccin generate permite generar mltiples copias de un componente para no
tener que declararlos uno por uno en un diseo estructural. El muestra el formato y un
ejemplo de esta instruccin.
-- Formato de la instruccin generate

Etiqueta : for Identificador in Rango generate
Instruccin concurrente
end generate;
-- ------------------------------------------------------ --- Ejemplo de la instruccin generarte para crear un inversor
-- de 16 bits a partir de un componente INV de 1 bit
library ieee;
use ieee.std_logic_1164.all;
library unisim;
113
use unisim.vcomponents.all;
entity Inversor16 is
port(Entrada_IN
: in std_logic_vector(15 downto 0);
Salida_N_OUT : out std_logic_vector(15 downto 0));
end Inversor16;
architecture Estructura of Inversor16 is
-- Declaracin del componente primitivo que se usar
component INV
port(I : in std_logic;
O : out std_logic);
end component;
begin
CompGenerado : for ndice in 15 downto 0 generate
CompBasico : INV port map (I => Entrada_IN(Indice),
O => Salida_N_OUT(Indice));
end generate;
end Estructura;
Cuadro 47 Uso de GENERATE
8.5 Componentes Bsicos de Diseo (Primitivas - Primitives)

Al sintetizar un diseo, las herramientas traducen el cdigo VHDL a un conjunto de
componentes bsicos (denominados primitivas) interconectados para proveer la
funcionalidad que se desea. Estas primitivas estn formadas por los elementos bsicos de
las FPGAs, pero los detalles estn escondidos al diseador. Cada fabricante provee un
conjunto libreras de componentes que estn optimizados para su arquitectura en
particular. Estos componentes son ptimos porque hay una relacin directa entre ellos y
la funcionalidad provista por los bloques lgicos bsicos de la arquitectura del dispositivo
Por ejemplo, los fabricantes proveen una primitiva "sumador", que no existe directamente
en las FPGAs. Esta primitiva est formada por los elementos lgicos, lgica de acarreo,
etc., para cada familia de FPGAs en particular. Las herramientas detectan los sumadores
en el cdigo VHDL y lo traducen a una interconexin del componente "sumador" con
otras primitivas.
8.5.1 Utilizacin de Primitivas desde VHDL

Las primitivas pueden usarse desde el VHDL, creando una instancia como cualquier otro
componente en una arquitectura estructural. Para utilizarlos se deben declarar los
componentes con los nombres especificados por los fabricantes. Si se utilizan las
herramientas de diseo esquemtico provistos por los fabricantes esto es muy directo.
Xilinx provee las denominadas libreras unificadas. Con ellas Xilinx unifica los
componentes para todos sus dispositivos programables. Los componentes de las libreras
114
unificadas se describen en el documento Libraries Guide de Xilinx. Las primitivas

incluyen bloques para realizar funciones especiales de entrada/salida, manejo de reloj,
comparadores, contadores, multiplexores, funciones aritmticas, memorias, etc. Cada
fabricante provee esos componentes para su uso de alguna manera.
El Cuadro 48 muestra un ejemplo en que se usa una primitiva de un buffer tipo BUFG.
Ese buffer es el buffer de entrada de las seales de reloj en las FPGA. Cuando se hace un
diseo con las herramientas de Xilinx ISE 5, este componente debe incorporarse como
una instancia explcitamente si se conecta una seal que no es una seal de reloj a uno de
estos pines. En la placa D2E de Digilent Inc, el botn est conectado a uno de estos pines,
y para todos los diseos debe agregarse una instancia de BUFG si se desea utilizar.
library ieee;
use ieee.numeric_std.all;
library unisim;
use unisim.vcomponents.all;
port(
Clock_IN
:
in
std_logic;
Reset_IN
:
in
std_logic;
...
...
- Dems puertos de interfase al componente
);
end Componente;
architecture Estructura of Componente is
signal intReset
: std_logic;
component bufg
port ( I : in std_logic;
o : out std_logic);
end component;
begin
BufferReset : bufg
port map (I => Reset_IN,
O => intReset);
-- Resto de la descripcin structural utiliza intReset
-- como seal de reset
...
Cuadro 48 Utilizacin de una instancia de un componente de librera BUFG en una estructura
115
8.5.2 Libreras de Primitivas (componentes) Especficos para Simulacin

Los componentes bsicos o primitivas son expresiones directas de la arquitectura bsica
de una FPGA. Al crear una instanciar mediante VHDL y sintetizarlos, se transforman
directamente en recursos de la FPGA. Estos estarn configurados de maneras especficas
segn su funcin, fabricante y familia de la FPGA. En general no son compatibles entre
fabricantes, y muchas veces no son compatibles entre distintas familias de FPGAs del
mismo fabricante.
De cualquier manera, un diseo que utilice primitivas debe poder simularse. Para ellos se
necesitan modelos de simulacin de estas primitivas. Cada fabricante provee estos
modelos de simulacin para sus primitivas. Por ejemplo, Xilinx provee estos modelos en
la librera unisim, Altera en la librera altera_mf y Actel tiene una librera para cada
familia de FPGAs. Si en un diseo se utiliza directamente alguna primitiva (componente)
de Xilinx, por ejemplo, se deben agregar a la lista de libreras las siguientes lneas
library unisim;
use unsim.vComponents.all;
En el ejemplo anterior del uso de BUFG estas lneas aparecen al comienzo del archivo,
antes de la declaracin de la entidad.
En el caso de Altera ser
library altera_mf;
use altera_mf.altera_mf_components.all;
En general se recomienda tratar de no utilizar primitivas especficas de un fabricante. De
esa manera el diseo ser mas fcil de portar de una FPGA a otra. En muchos casos, sin
embargo, se desean utilizar recursos especiales provistos por una familia de FPGAs. Para
poder re-utilizar luego el diseo con otras FPGAs se puede envolver las primitivas en
cdigo VHDL genrico (creando un "wrapper"). De esta manera solo habr que cambiar
la implementacin de ese bloque al cambiar de FPGA, haciendo la tarea un poco mas
simple.
8.5.3 Memoria
La memoria es un componente bsico de muchos diseos digitales. Muchas FPGAs
incluyen bloques de memoria entre los elementos lgicos, lo que permite integrarla de
manera rpida y eficiente con los diseos lgicos. Adems de la memoria embebida o en
bloque (la que est integrada en el chip junto a la lgica programable), las FPGAs
basadas en memoria SRAM para su configuracin permiten usar parte de la lgica como
memoria. Dependiendo de las herramientas, su configuracin y el estilo del cdigo HDL,
las memorias pueden . En algunos casos pueden inferirse a partir de la descripcin que se
hace en el HDL. En otros casos, si se desea usar un tipo de memoria con una
configuracin particular, es posible que haya que crear una instancia explcitamente como
una primitiva.
116
A continuacin se describirn algunas configuraciones para las memoria de las FPGA de

Xilinx. Las FPGA de Xilinx pueden implementar dos tipos de memoria RAM que se
incluyen como primitivas. Una es la memoria RAM en bloque (block RAM), que est
formada por los bloques de memoria embebidos en la FPGA. Esta memoria solo puede
configurarse como memoria (RAM o ROM) y no utilizarse como lgica configurable. La
RAM distribuida (distributed RAM) se implementa utilizando las tablas de bsqueda
LUT de los bloques lgicos como.
Para utiliza cualquiera de los dos tipos de memoria deben inferir o crear una instancia de
alguna versin de ellos en una arquitectura estructural. Hay varias posibilidades de uso y
configuracin de las memorias, ya sea con puerto simple, puerto dual, diferentes anchos
de palabra, etc. A continuacin se presentarn algunos ejemplos de estos componentes,
tomados de la gua de libreras unificada de Xilinx.
La Figura 40 muestra una memoria RAM de puerto dual de 16 palabras por 1 bit de
ancho. Esta memoria tiene los siguientes puertos interfase.
Tabla 10 Puertos de interfase de la memoria RAM16x1D
Seal
WE
WCLK
D
A0..A3
DPRA0..DPRA3
SPO
DPO
Descripcin
Habilitacin de escritura (Write Enable)
Reloj de escritura (Write Clock)
Dato escritura
Direccin de escritura
Direccin de lectura
Salida dada por A0..A3
Salida dada por DPRA0..DPRA3
Figura 40 Interfase de memoria de puerto dual 16x1
La Figura 41 muestra un esquema de la interfase de memoria en bloque configurada

como memoria de puerto simple, de 1024 palabras por 4 bits. La Tabla 11 describe
brevemente las seales.
117
Figura 41 Interfase de memoria de bloque de 1024 x 4
Tabla 11 Puertos de interfase de la memoria RAMB4_S4
Seal
WE
EN
RST
CLK
DI3.. DI0
A3..A0
DO3.. DO0
Descripcin
Habilitacin de escritura (Write Enable)
Habilitacin
Reset
Reloj
Datos de entrada
Direccin
Datos de salida
Inferencia de Memorias
Ciertas estructuras en VHDL pueden modelar el comportamiento de memorias RAM o
ROM. Muchas herramientas detectan estas estructuras e infieren el uso de una memoria
interna de la FPGA (ya sea en bloque o distribuida). El tipo de estructura reconocida y las
memorias inferidas dependern de las herramientas. Algunas herramientas infieren bien
ciertos tipos de memoria pero no otros (puerto simple vs. puerto dual) o no permiten
inicializar una memoria inferida. En lo siguientes cuadros y figuras se muestra cdigo
VHDL con el cual se infieren distintos tipos de memoria y los resultados de la sntesis.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH. ALL;
use IEEE.STD_LOGIC_UNSIGNED. ALL;
entity infer_ram is
port (clk : in std_logic;
we : in std_logic;
a
di : in std_logic_vector(3 downto 0);
do : out std_logic_vector(3 downto 0));
end infer_ram;
architecture Comportamiento of infer_ram is
118
type ram_type is array (31 downto 0) of std_logic_vector(3 downto 0);

signal RAM : ram_type;
-- Seal para registrar la direccin de lectura
signal read_a : std_logic_vector(4 downto 0);
begin
process (clk)
begin
if Rising_Edge(clk) then
-- La memoria se escribe con un WE sincronico
if (we = '1') then
RAM(conv_integer(a)) <= di;
end if;
-- La memoria BRAM necesita la direccin de lectura registrada
read_a <= a;
end if;
end process;
-- Datos de salida
do <= RAM(conv_integer(read_a));
end Comportamiento;
Cuadro 49 VHDL para inferir memoria en bloque BRAM en las herramientas de Xilinx
======================================================================
HDL Synthesis Report
Macro Statistics
# Block RAMs
1024x4-bit single-port block RAM
: 1
: 1
======================================================================
Device utilization summary:
--------------------------Selected Device : 2s200epq208-7
Number of bonded IOBs:
Number of BRAMs:
Number of GCLKs:
19
1
1
out of
out of
out of
146
14
4
13%
7%
25%
Cuadro 50 Mensajes de resultado al inferir RAM en bloque en las herramientas de Xilinx
119
Figura 42- Resultados de la sntesis. BRAM inferida.

(Fuente: Captura de pantalla de herramienta Xilinx ECS)
En los siguientes cuadros se muestra el cdigo VHDL y los resultados de sntesis al

inferir memoria RAM distribuida. Notar que hay solo una sutil diferencia en el VHDL
respecto al cdigo que infiere RAM distribuida. Para inferir RAM distribuida la direccin
de lectura no est registrada. El resultado de utilizacin del dispositivo refleja la
diferencia entre usar RAM distribuida o en bloque.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH. ALL;
use IEEE.STD_LOGIC_UNSIGNED. ALL;
entity infer_ram is
port (clk : in std_logic;
we : in std_logic;
a
di : in std_logic_vector(3 downto 0);
end infer_ram;
architecture Comportamiento of infer_ram is
type ram_type is array (31 downto 0) of std_logic_vector(3 downto 0);
signal RAM : ram_type;
begin
process (clk)
120
begin
if Rising_Edge(clk) then
-- La memoria se escribe con un WE sincronico
if (we = '1') then
RAM(conv_integer(a)) <= di;
end if;
end if;
end process;
-- Datos de salida. Direccion de entrada asincrnica directamente
do <= RAM(conv_integer(a));
end Comportamiento;
Cuadro 51 VHDL para inferir memoria distribuida en las herramientas de Xilinx
======================================================================
Macro Statistics
# LUT RAMs
: 1
1024x4-bit single-port distributed RAM: 1
======================================================================
Number
Number
Number
Number
of
of
of
of
Slices:
4 input LUTs:
bonded IOBs:
GCLKs:
341
413
19
1
out
out
out
out
of
of
of
of
2352
4704
146
4
14%
8%
13%
25%
Cuadro 52 Mensajes de resultado al inferir RAM distribuida en las herramientas de Xilinx
En el siguiente ejemplo se infiere una memoria ROM. Notar en la figura que la memoria
ROM se implementa como una RAM con sus entradas de escritura deshabilitadas.
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
-- La interfaz de la ROM no tiene datos de lectura
entity ROM_infer is
port(clk : in std_logic;
we : in std_logic;
addr: in std_logic_vector(3 downto 0);
end entity ROM_infer;
architecture Xilinx of ROM_infer is
121
begin
-- Este proceso solo lee datos
the_rom: process (clk)
begin
if rising_edge(clk) then
case addr is
when "0000" => do <= X"12";
when "0001" => do <= X"34";
when "0010" => do <= X"56";
when "0011" => do <= X"78";
when "0100" => do <= X"9A";
when "0101" => do <= X"BC";
when "0110" => do <= X"DE";
when "0111" => do <= X"F0";
when "1000" => do <= X"77";
when "1001" => do <= X"88";
when "1010" => do <= X"99";
when "1011" => do <= X"AA";
when "1100" => do <= X"BB";
when "1101" => do <= X"CC";
when "1110" => do <= X"DD";
when others => do <= X"EE";
end case;
end if;
end process the_rom;
end architecture Xilinx;
Cuadro 53 VHDL para inferir memoria ROM (usando BRAM) en las herramientas de Xilinx
======================================================================
Macro Statistics
# Block RAMs
16x8-bit single-port block RAM
: 1
: 1
======================================================================
Number of bonded IOBs:
Number of BRAMs:
Number of GCLKs:
12
1
1
out of
out of
out of
146
14
4
8%
7%
25%
Cuadro 54 Mensajes de resultado al inferir una ROM en las herramientas de Xilinx
122
Figura 43 Resultados de la sntesis. ROM implementada como RAM escritura deshabilitada.

(Fuente: Captura de pantalla de herramienta Xilinx ECS)
Altera recomienda estructuras similares para inferir memorias en sus dispositivos desde
los HDLs. en el siguiente cuadro se muestra un ejemplo de VHDL para inferir una
memoria RAM de puerto dual.
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
ENTITY ram_dual IS
PORT (clock1:
clock2:
data:
write_address:
read_address:
we:
q:
);
END ram_dual;
IN
IN
IN
IN
IN
IN
OUT
STD_LOGIC;
STD_LOGIC;
STD_LOGIC_VECTOR (3 DOWNTO 0);
INTEGER RANGE 0 to 31;
INTEGER RANGE 0 to 31;
STD_LOGIC;
STD_LOGIC_VECTOR (3 DOWNTO 0)
ARCHITECTURE rtl OF ram_dual IS

TYPE MEM IS ARRAY(0 TO 31) OF STD_LOGIC_VECTOR(3 DOWNTO 0);
SIGNAL ram_block: MEM;
123
SIGNAL read_address_reg : INTEGER RANGE 0 to 31;

BEGIN
PROCESS (clock1)
BEGIN
IF (clock1'event AND clock1 = '1') THEN
IF (we = '1') THEN
ram_block(write_address) <= data;
END IF;
END IF;
END PROCESS;
PROCESS (clock2)
BEGIN
IF (clock2'event AND clock2 = '1') THEN
q <= ram_block(read_address_reg);
read_address_reg <= read_address;
END IF;
END PROCESS;
END rtl;
Cuadro 55 VHDL recomendado para inferir memoria RAM de puerto dual en FPGAs de Altera
Para entender bien como inferir memorias u otras primitivas desde el cdigo HDL para
una FPGA y herramienta dada, referirse a los manuales de las herramientas y notas de
aplicacin de los fabricantes de FPGAs. Las herramientas provistas por los fabricantes de
FPGAs tienen ayudas y plantillas que permiten generar cdigo HDL de manera rpida.
Instancia de Memorias
Hay muchos casos en los que se desea controlar en detalle el tipo de memoria (u otra
primitiva) a utilizar. En estos casos se debe colocar una instancia (instantiate) del
componente usando port map . Para esto hay que referirse a la documentacin de los
fabricantes y entender las interfaces de las primitivas. Una vez definido el componente se
instancia como cualquier otra primitiva. En el siguiente ejemplos e muestra el uso de una
memoria del tipo ram_32x8_dp en una FPGA de Altera. Para modelar el
comportamiento de la memoria se debe incluir al proyecto el VHDL correspondiente al
componente ram_32x8_dp provisto por Altera. Mas adelante se muestra el uso de
memorias de Xilinx para crear una cola FIFO.
ARCHITECTURE rtl_text OF fifo_1clk_32x8 IS

-- Declaracin del componente
COMPONENT ram_32x8_dp
PORT (
data
: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
wren
: IN STD_LOGIC := '1';
wraddress : IN STD_LOGIC_VECTOR (4 DOWNTO 0);
rdaddress : IN STD_LOGIC_VECTOR (4 DOWNTO 0);
124
clock
: IN STD_LOGIC;
q
: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
END COMPONENT;
BEGIN
-------------------------------------- Altera RAM instantiation for FIFO.
------------------------------------RamFifo : ram_32x8_dp
PORT MAP (
data
=> Writedata_IN,
wren
=> WriteEnable_IN,
wraddress => WriteAddress_REG(4 DOWNTO 0),
rdaddress => ReadAddress_REG(4 DOWNTO 0),
clock
=> Clock_IN,
q
=> Readdata_OUT);
...
END ARCHITECTURE rtl_text;
8.5.4 Definicin de Nuevos Componentes de Diseo

A partir de algunas primitivas de diseo pueden definirse componentes con parmetros
genricos que pueden reutilizarse en distintas aplicaciones. En los siguientes ejemplos se
presenta una memoria de 16 por N y una cola FIFO de 16 x 16, ambas formadas a partir
de la primitiva RAM16x1D.
-- Componente de memoria RAM de 16 x N a partir de primitiva RAM16X1D
entity DRamDual16xN
generic (
MSB_MEMORIA_RAM
);
port (
Clock_IN
WriteEnable_IN
WriteAddress_IN
WriteData_IN
ReadAddress_IN
ReadData_OUT
);
end DRamDual16xN;
is
: positive := 15;
:
:
:
:
:
:
in
in
in
in
in
out
std_logic;
std_logic;
std_logic_vector(3 downto 0);
std_logic_vector(MSB_MEMORIA_RAM downto 0);
std_logic_vector(MSB_MEMORIA_RAM downto 0)
architecture Estructura of DRamDual16xN is

component
port (
WCLK
WE
A0
A1
A2
A3
RAM16X1D
:
:
:
:
:
:
in
in
in
in
in
in
std_logic;
std_logic;
std_logic;
std_logic;
std_logic;
std_logic;
125
D
: in std_logic;
SPO
: out std_logic;
DPRA0 : in std_logic;
DPO
: out std_logic);
end component;
begin
--------------------------------------------- Instancia de RAM
-------------------------------------------G1: for I in MSB_MEMORIA_RAM downto 0 generate
L: RAM16X1D port map (
WCLK => Clock_IN,
WE
=> WriteEnable_IN,
A0
=> WriteAddress_IN(0),
A1
A2
A3
D
=> WriteData_IN(I),
SPO
=> open,
DPRA0 => ReadAddress_IN(0),
DPO
=> ReadData_OUT(I));
end generate G1;
end Estructura;
Cuadro 56 Memoria RAM de 16 x N
En el siguiente ejemplo se define una cola tipo FIFO de 16 palabras por 16 bits. Se utiliza
como bloque bsico para guardar los datos la primitiva RAM16X1D. Este componente
tiene una entrada y una salida de datos y dos seales que indican si se desea leer el dato
de la cola o escribir el dato a la cola. LA salida de lectura siempre tiene el primer dato de
salida disponible, y al leerlo se incrementa un puntero y se pasa al siguiente. El dato de
escritura se escribe sobre la memoria en el lugar indicado por el puntero de escritura. Otra
salida indica el nmero de datos disponibles en la cola. El correcto funcionamiento
depende de que la lgica que se conecta a este componente no acte de manera no
prevista. Es decir, solo se deber leer un dato si hay datos disponibles y solo se deber
escribir un dato si los datos disponibles no llenan la cola.
En la arquitectura de este componente se mezclan las descripciones estructurales y de
comportamiento. Aunque esto no es recomendable en general, en este componente todos
los procesos junto a la memoria como instancia forman un solo componente, y tiene ms
sentido y hace ms entendible el funcionamiento mantener todos los elementos juntos que
separarlos en dos componentes diferentes.
-- Componente FIFO 16 x 16 a partir de primitiva RAM16X1D
126

entity FifoDRam16x16 is
port (
Clock_IN
Reset_IN
WriteEnable_IN
ReadEnable_IN
WriteData_IN
ReadData_OUT
DatosDisponibles_OUT
);
end FifoDRam16x16;
:
:
:
:
:
:
:
in
in
in
in
in
out
out
std_logic;
std_logic;
std_logic;
std_logic;
architecture Mixta of FifoDRam16x16 is

signal ReadAddress_REG
signal WriteAddress_REG
signal DatosDisponibles_REG : std_logic_vector(4 downto 0);
component RAM16X1D
port (
WCLK : in std_logic;
WE
: in std_logic;
A0
: in std_logic;
A1
: in std_logic;
A2
: in std_logic;
A3
: in std_logic;
D
: in std_logic;
SPO
: out std_logic;
DPO
: out std_logic);
end component;
begin
--------------------------------------------- Instancia de RAM 16 x 16
-------------------------------------------G1: for I in 15 downto 0 generate
L: RAM16X1D port map (
WCLK => Clock_IN,
WE
=> WriteEnable_IN,
A0
=> WriteAddress_REG (0),
A1
A2
A3
D
=> WriteData_IN(I),
SPO
=> open,
DPRA0 => ReadAddress_REG (0),
DPO
=> ReadData_OUT(I));
end generate G1;
-- Control de direccin lectura
127
ControlDireccionLectura : process(Reset_IN, Clock_IN)

begin
if (Reset_IN =1) then
ReadAdrress_REG <= (others => 0);
if (ReadEnable_IN = 1) then
ReadAddress_REG <= ReadAddress_REG + 1;
end if;
end if;
end process ControlDireccionLectura;
-- Control de direccin escritura
ControlDireccionEscritura : process(Reset_IN, Clock_IN)
begin
WriteAdrress_REG <= (others => 0);
if (WriteEnable_IN = 1) then
WriteAddress_REG <= ReadAddress_REG + 1;
end if;
end if;
end process ControlDireccionEscritura;
-- Calculo de numero de datos disponibles
CuentaDatosDisponibles : process(Reset_IN, Clock_IN)
begin
DatosDisponibles_REG <= (others => 0);
if (ReadEnable_IN='1') and (WriteEnable_IN='0') then
DatosDisponibles_REG <= DatosDisponibles_REG - 1;
end if;
if (ReadEnable_IN='0') and (WriteEnable_IN='1') then
DatosDisponibles_REG <= DatosDisponibles_REG + 1;
end if;
end process CuentaDatosDisponibles;
DatosDisponibles_OUT <= DatosDisponibles_REG;
end Mixta;
Cuadro 57 Cola FIFO de 16 x 16
128
8.6 Mquinas de Estado

Si el estado de funcionamiento de un diseo, y por ende las salidas, estn dadas por las
entradas al circuito solamente el diseo puede resolverse mediante lgica combinacional.
Un diseo en el que el estado de funcionamiento no est solo dado por las entradas sino
tambin por la historia de funcionamiento anterior no puede resolverse mediante lgica
combinacional. Se est presencia de un circuito secuencial que incluir no solo lgica
combinacional sino tambin una mquina de estados. Si la cantidad de estados es limitada
a se la denomina mquina de estados finita8. Las maneras clsicas de modelar mquinas
de estados son las tablas de transicin y los diagramas de estados de burbujas. En las
tablas de transicin se describen los diferentes estados de funcionamiento en las filas y
las combinaciones de entradas en las columnas. Los datos de las tablas indican el
prximo estado. La Tabla 12 muestra un ejemplo de una tabla de transicin para un
diseo secuencial genrico. El diseo tiene dos entradas de un bit y una salida. Las
entradas se agrupan en la primera fila como un vector de 2 bits.
Tabla 12 Tabla de transicin de estados
Estado
Inicial
Estado1
Estado2
Estado3
Estado4
00
Inicial
Estado4
Estado3
Estado4
Inicial
Entrada1 | Entrada2
01
10
Inicial
Estado1
Estado4
Estado2
Estado3
Estado3
Estado3
Estado4
Inicial
Inicial
Salida
11
Estado1
Estado3
Estado3
Estado3
Inicial
001
010
011
100
111
En los diagramas de burbujas se detallan los estados mediante burbujas y las transiciones
entre ellos con flechas que las unen. Sobre las flechas se especifican las condiciones
necesarias para esas transiciones. Existen muchas herramientas grficas con las que se
pueden disear mquinas de estado. En general se grafican diagramas de burbujas y la
condiciones de transicin y salidas. Estas representaciones grficas son luego traducidas a
VHDL por las herramientas. La Figura 44 muestra esta mquina de estados como un
diagrama de burbujas.
Las mquinas de estado infinitas no tienen sentido prctico para las aplicaciones que se tratan en este
texto
129
Figura 44 Ejemplo de maquina de estado
Siguiendo las recomendaciones para diseos sintetizables sobre FPGAs, se recomienda

utilizar mquinas de estado sincrnicas, con un estado de reset asincrnico. En las
mquinas de estado sincrnicas solo hay cambios de estado y sobre las salidas con un
flanco de reloj. Si la velocidad del reloj es demasiado rpida y se desea hacer ms lenta
una mquina de estados, se puede utilizar una seal de habilitacin de reloj en el proceso
130
sincrnico como se describir ms adelante. La implementacin bsica de una mquina

de estados como la descripta ser la mostrada en la Figura 45.
Figura 45 - Esquema lgico de la maquina de estados del ejemplo
Aunque es muy prctico disear una mquina de estados con una interfase grfica como
la provista por StateCad de Xilinx, HDL Designer de Mentor Graphics, o cualquier otra
herramienta de ese estilo, tambin se puede desarrollar directamente en VHDL9. EL estilo
preferido para describir una mquina de estados en VHDL es mediante dos procesos.
Uno es combinacional y calcula el prximo estado a partir del estado actual y las
entradas. El otro es sincrnico y asigna el estado actual y define las salidas. El ejemplo
presentado es una manera de modelar mquinas de estado, pero existen una variedad de
combinaciones de procesos y lgica concurrente que pueden ser utilizadas.
El Cuadro 58 muestra el la mquina de estados de la figura anterior a modo de ejemplo.
La implementacin ser como la de la Figura 45, con la asignacin del estado actual y las
salidas hecha a travs de elementos sincrnicos (registros). La asignacin de salidas en el
proceso sincrnico puede prestarse a confusin. Debe recordarse que, al haber un flanco
de reloj y ejecutarse la instruccin de asignacin del prximo estado, este valor se
agenda, pero no se actualiza inmediatamente. Por eso, al evaluarse el case de asignacin
de las salidas, se tomar el valor del estado actual y no el agendado. La consecuencia es
que las salidas estarn en realidad retrasadas un ciclo de reloj respecto al estado actual
(debido a los registros antes de las salidas). Si eso no es aceptable puede usarse lgica
combinacional para las salidas o replantearse la mquina de estados para obtener las
salidas necesarias.
Las herramientas traducen los diseos grficos a VHDL o Verilog antes de sintetizarlos.
131
-- Declaracin de la arquitectura de la mquina de estados

-- La entidad se declara como en cualquier otro caso para
-- describir las interfases (port)
architecture ComportamientoFSM of EjemploFSM is
-- Declaracin de seales internas de ser necesarias
signal Salida_REG : std_logic_vector (2 downto 0);
-- Utilizacin de un tipo enumerado para describir los estados
type tdEstado is (
Inicial,
Estado1,
Estado2,
Estado3,
Estado4
);
signal EstadoActual
: tdEstado ;
signal EstadoSiguiente : tdEstado ;
begin
-- -------------------------------------------------------- --- Asignaciones e instrucciones concurrentes
-- -------------------------------------------------------- -Salida <= Salida_REG;
-- -------------------------------------------------------- --- Proceso sincrnico de asignacin de estado actual y seales
-- -------------------------------------------------------- -ProcesoSincronico : process(Clock_IN, Reset_IN)
begin
if (Reset_IN = '1') then
EstadoActual <= Inicial;
-- Valores de reset
Salida_REG <= 001;
elsif (Rising_Edge(Clock_IN) then
-- Paso al prximo estado de manera sincrnica
EstadoActual <= EstadoSiguiente;
-- Acciones para la asignacin de seales y salidas
when Inicial =>
Salida_REG <= 001;
when Estado1 =>
Salida_REG <= 010;
when Estado2 =>
Salida_REG <= 011;
when Estado3 =>
Salida_REG <= 100;
when Estado4 =>
Salida_REG <= 111;
when others =>
null; -- Mantiene las salidas actuales con un registro
end case;
end if;
end process ProcesoSincronico;
132
-- -------------------------------------------------------- --- Proceso combinacional de asignacin de estados

-- -------------------------------------------------------- -AsignacionProximoEstado : process (Entrada1,
Entrada2,
EstadoActual
)
begin
-- Acciones combinadas de asignacin de estado siguiente
when Inicial =>
if (Entrada1_IN = 1) then
EstadoSiguiente <= Estado1;
else
EstadoSiguiente <= Inicial;
end if;
when Estado1 =>
- Entrada1= 1, Entrada2= X
elsif (Entrada2_IN=0) then - Entrada1= 1, Entrada2= 0
else
-- Entrada1= 1, Entrada2= 1
end if;
when Estado2 =>
when Estado3 =>
else
end if;
when others => -- Estado4
EstadoSiguiente <= Inicial;
end case;
end process AsignacionProximoEstado;
end ComportamientoFSM;
Cuadro 58 Ejemplo de mquina de estados en VHDL
En el proceso combinacional todas las seales que producen cambios deben estar en la
lista de sensibilidad. Adems, al evaluar las entradas para el prximo estado en las
instrucciones if.. else deben evaluarse todos los casos de combinaciones de entradas para
evitar que se infieran latches.
8.6.1 Codificacin de Estados

En el ejemplo se utiliza un tipo enumerado para describir los estados y as hacer el cdigo
ms fcil de entender. Al sintetizar este cdigo las herramientas usarn registros y
asignarn un valor a cada estado. Si se describe la mquina de estados en VHDL el
diseador puede optar por utilizar un registro del tipo std_logic_vector directamente. Con
133
un registro de n bits pueden codificarse 2n estados, pero muchas veces es ms eficiente

utilizar codificacin one-hot o one-cold. En este tipo de codificacin se usan tantos
bits como estados haya y un solo bit est en 1 (one hot) o 0 (one cold) en un momento
dado. Esto permite simplificar la lgica combinacional que determina en que estado se
encuentra la mquina para asignar las salidas y el prximo estado.
8.6.2 Divisin de la Seal de Reloj (Clock Enable)

Al disear para sntesis lo ideal es utilizar una sola seal de reloj que se distribuye a todos
los bloques del diseo. En una FPGA esta seal se conecta y distribuye a los bloques
lgicos por una red de conexiones global dedicada a ese fin. Si se desea hacer funcionar
parte del diseo, como puede ser una mquina de estados finita, a una frecuencia
diferente de la del reloj principal no debe proveerse una seal de reloj ms lenta. Lo que
se utiliza es una seal de habilitacin de reloj. Esta es una seal con la que se habilita el
reloj por un ciclo solo cada N ciclos. Esto hace que un proceso sincrnico se ejecute
solamente cada N ciclos de reloj en vez de con cada flanco del reloj. En VHDL esto debe
describirse como se muestra en el Cuadro 59. En general este mtodo puede sintetizarse
de manera eficiente utilizando las seales de habilitacin de los flip-flops de salida en los
bloques lgicos de las FPGA, y no agrega lgica combinacional adicional. La seal de
habilitacin se debe generar en un bloque aparte dividiendo el reloj principal.
-- Formato de un proceso con seal de habilitacin de reloj
ProcesoConHabilitacionClock : process(Clock_IN, Reset_IN)
begin
-- Valores de reset
-- Solo ejecutar las instrucciones secuenciales si el reloj
-- est habilitado
if (HabilitacionDeReloj_IN = 1) then
...
...-- Instrucciones secuenciales del proceso
...
end if; -- Habilitacin de reloj
end process ProcesoConHabilitacionClock;
Cuadro 59 Utilizacin de la seal de habilitacin de reloj
Este mtodo de habilitacin de reloj es til y recomendado para cualquier diseo

secuencial y no solo para mquinas de estado.
134
9 VHDL para Simulacin y Verificacin

9.1 Introduccin
El lenguaje VHDL no solo puede usarse para sintetizar circuitos sino que tambin pueden
crearse modelos de simulacin para verificar el diseo en sus distintas etapas mediante
simulaciones. Esto se hace creando lo que se denomina un "testbench", o banco de
pruebas.
Las prximas secciones describen VHDL que muchas veces no es sintetizable. La
realidad es que eso depende de las herramientas y del uso que se le da a ese VHDL. Los
lazos sern sintetizables si pueden resolverse para un instante dado y modelan lgica
combinacional. Los accesos a archivos no son sintetizables sobre la lgica de las FPGAs,
pero algunas herramientas (Ej.: Quartus II de Altera) permiten usar cdigo de acceso a
archivos para inicializar valores de memoria o realizar tareas similares.
9.2 Bancos de Prueba

En el proceso de diseo de un circuito sintetizable se deben probar primero los
componentes o bloques y luego el diseo completo. Esto se hace mediante simulaciones
utilizando los llamados bancos de prueba. El trmino banco de prueba proviene de las
pruebas que se hacen a diseos mecnicos o elctricos convencionales en que el
dispositivo que se quiere probar se coloca en un banco donde tambin estn los
generadores de seales y los analizadores para medir las respuestas. En el ambiente de
VHDL todo esto se hace de manera virtual utilizando cdigo VHDL para generar seales
de prueba y analizando las respuestas mediante simulaciones.
La utilizacin de bancos de prueba y simulaciones no elimina por completo la necesidad
de probar luego el circuito sintetizado y colocado sobre una placa, pero s simplifica
muchsimo todo el proceso de depuracin.
En general hay dos niveles de interfase que se desean probar. Por un lado se quiere ver si
las formas de onda de la interfase responden a lo esperado. A un nivel superior se desea
probar si los datos de entrada/salida cumplen con lo esperado. Es decir si el diseo hace
lo que debera con los datos de entrada y responde con los datos de salida adecuados. En
el primer caso una observacin de las formas de onda en general alcanza para analizar la
interfase. Para el anlisis de funcionamiento a nivel datos probablemente se requerir una
metodologa mas estructurada, con algn algoritmo de prueba ms sofisticado y
posiblemente leer y guardar datos de y a un archivo para su posterior anlisis.
La manera de probar un componente y la complejidad del banco de pruebas depender
por supuesto de la funcionalidad y complejidad que tenga el dispositivo a probar. Si el
componente solo genera una forma de onda fija quizs no sea necesario hacer un anlisis
a nivel de datos, si el componente es muy complejo quizs puede llevar ms esfuerzo el
diseo del banco de pruebas que el del componente en s. Como en cualquier circuito
digital, es importante probar los casos lmite. Esto es ms fcil de hacer en VHDL que
135
con hardware real ya que podemos generar cualquier combinacin de seales solo
cambiando un poco de cdigo. Algunos de estos casos son que sucede cuando los
contadores llegan a sus valores finales, que sucede cuando se sobrepasan los lmites
esperados para las entradas, que sucede con combinaciones de entradas no esperadas,
utilizar un nmero significativo de datos de entrada, usar nmeros aleatorios para ver el
funcionamiento, etc.
9.2.1 Vectores de prueba

Se denominan vectores de prueba (test vectors) a una secuencia de seales utilizadas para
estimular y probar un diseo. Por ejemplo, si un diseo tiene la siguiente interfase.
port (
Reset_IN
Clock_IN
Enable_IN
Mode_IN
Dato_OUT
);
:
:
:
:
:
IN
IN
IN
IN
IN
std_logic;
std_logic;
std_logic;
los vectores de prueba serian el conjunto de seales que prueban diferentes

combinaciones de las entradas Reset_IN, Clock_IN, Enable_IN, Mode_IN para que se
permita evaluar, mediante observaciones de la salida Dato_OUT si el diseo est
funcionando bien.
Estos vectores pueden generarse mediante VHDL secuencial que explcitamente genera
la secuencia de seales deseadas, usando ciclos y arreglos de valores o leyendo los datos
de un archivo. Este ltimo mtodo es recomendable porque es muy flexible y permite
redefinir fcilmente los vectores de prueba sin tocar el cdigo VHDL.
9.2.2 Diseo de un Banco de Pruebas

Al disear un banco de pruebas no se deben seguir las reglas estrictas que se necesitan
para sntesis, pero es buen seguir buenas prcticas de programacin y estructura del
banco de pruebas.
Algunas pautas y guas para hacer un buen banco de pruebas son las siguientes:
Englobar todo el banco de pruebas en un modelo estructural de nivel superior.

Luego conectar este modelo al diseo que se desea probar. Es bueno dar siempre
el mismo nombre de DUT o UUT (de Device Under Test o Unit Under Test) al
diseo bajo prueba. La Figura 46 muestra el esquema sugerido para un banco de
pruebas. La estructura superior contiene el diseo bajo prueba (DUT) y el
componente que genera las pruebas y analiza los resultados.
Se recomienda separar e independizar la generacin de datos de la generacin de
temporizados. Esto tambin se mostr en la figura en el interior del Probador
Utilizar el prefijo tb para todos los componentes del banco de pruebas. As es
fcil diferenciar que elementos pertenecen al diseo y cuales al banco de pruebas.
Algunas organizaciones requieren que todos los elementos del banco de pruebas
se separen en una librera completamente diferente a la de diseo.
136
No se necesitan seguir las estructuras presentadas para sntesis: como los bancos
de prueba no sern sintetizados, sino que solo sirven para las simulaciones, no es
necesario seguir las estructuras presentadas para diseos sintetizables.
Usar las mismas guas en el cdigo, nombres, etc. Es bueno seguir las mismas
pautas de cdigo y nombres ya que eso hace que el banco de pruebas sea mas fcil
de entender, modificar e incluso reutilizar.
Los procesos de prueba debern tener un valor de reposo ya que esto es lo que
indica que se termin la simulacin y facilita la tarea al simulador (ayuda a
ejecutar la simulacin ms rpido).
Figura 46 Esquema de banco de pruebas para DUT
9.2.3 Manejo de tiempo en simulaciones usando VHDL

En las simulaciones se debe controlar y medir la variable tiempo. De esta manera se
pueden crear las situaciones necesarias para probar el diseo y se puede evaluar la
respuesta temporal del mismo. El manejo del tiempo se hace a travs de la instruccin
wait y la palabra after. Ambas se han presentado en secciones anteriores, y en esta
seccin solo se darn ejemplos de su utilizacin.
9.2.3.1 Uso del WAIT y AFTER
La instruccin wait es la que permite esperar una cierta cantidad de tiempo o a que
suceda un evento. En el Cuadro 60 se muestran algunos de sus usos mediante un proceso
que prueba la lectura de un dato usando un protocolo.
P_PruebaReadEnable : process
variable Dato1_VAR, Dato2_VAR : std_logic_vector(7 downto 0);
137

begin
-- Comienzo de la simulacin
ReadEnable_N_OUT <= 1;
wait for 1 ms;
-- Comienzo sin lectura

-- Espero x transitorio
-- Comienzo del primer ciclo de lectura

-- Primer ciclo de lectura
wait until ReadAck_IN = 1;
-- Espero aviso
Dato1_VAR := Dato_IN;
-- Leo el dato
-- Fin del primer ciclo de lectura
ReadEnable_N_OUT <= 1 after 12 ns; -- Mantengo seal x Thold
wait for 400 ns;
-- Espera para generar 2do

-- ciclo de lectura
-- Comienzo del segundo ciclo de lectura

-- Ciclo de lectura
wait until ReadAck_IN = 1;
-- Espero aviso
Dato2_VAR := Dato_IN;
-- Leo el dato
ReadEnable_N_OUT <= 1 after 12 ns; -- Mantengo seal x Thold
wait;
-- Fin de la simulacin
end process P_ReadEnable;

Cuadro 60 Ejemplo del uso de wait y alter en un proceso de prueba
9.2.3.2 Funcin NOW

La palabra NOW se utiliza para leer el tiempo actual de simulacin. Esto es muy til
cuando se quieren medir los tiempos de respuesta de un diseo. Puede esperarse un
evento, tal como el cambio de un dato de salida del DUT (componente que se est
probando) y usando la palabra NOW guardar el tiempo de respuesta a un archivo.
En el Cuadro 61 se muestra un ejemplo en el que se verifica que el tiempo entre cambios
de una seal no sea menor que 4 ns;
-- Ver si cambia el dato. Si lo hace calcular el tiempo de cambio

if (DatoAnterior_VAR /= DatoActual_VAR) then
-- Guardo el dato y el tiempo de cambio de dato anterior
-- Leo el tiempo de cambio actual
DatoAnterior_VAR
:= DatoActual_VAR;
TCambioAnterior
:= TCambioActual;
TCambioActual
:= now;
...
-- Verifico si hay suficiente tiempo entre cambios
138
if (TCambioActual - TCambioAnterior) < 4 ns then

-- Error! Hay un cambio antes de los 4 ns
...
end if;
...
end if;
Cuadro 61 Ejemplo del uso de NOW para leer el tiempo de un evento
9.3 VHDL (Generalmente) No Sintetizable

Hay muchas instrucciones y estructuras de VHDL que no se pueden sintetizarse. A
continuaciones presentan algunas instrucciones de VHDL que en muchos casos no
pueden sintetizarse pero que son muy tiles para modelar ciertos procesos de hardware y
para generar las pruebas de los diseos sintetizables como se ver ms adelante en la
seccin sobre bancos de prueba.
9.3.1 Instrucciones de lazo FOR, WHILE y LOOP, NEXT y EXIT

Las instrucciones de lazo son instrucciones secuenciales que permiten realizar una tarea
ms de una vez, hasta que se cumpla alguna condicin. En general, estas instrucciones
solo son sintetizables si el resultado final puede modelarse como lgica y no contienen
instrucciones de manejo de tiempo (WAIT) dentro de los lazos. La sntesis o no de estos
lazos depende de las herramientas.
En el Cuadro 62 se dan ejemplos de lazos for . El lazo for puede usar un ndice que se
incrementa o reduce segn se usa la palabra to o downto. Esto depender de la tarea que
deba llevar a cabo el lazo. El lazo se termina con end loop y en el cuerpo se describen las
tareas que se deben realizar usando instrucciones secunciales.
-- Formato de la instruccin FOR

for Indice in Primero to/downto Ultimo loop
... -- Instruccin secuencial
... -- Tareas que se hacen con cada ndice
end loop;
-- Ejemplo de la instruccin FOR para inicializar un arreglo
-- cero
for Indice in 31 downto 0 loop
ArregloBits(Indice) = 0;
end loop;
-- Ejemplo de la instruccin FOR para verificar la diferencia
-- entre elementos de un arreglo con elementos de tipo time
...
-- Se guarda el tiempo de lectura e incrementa el ndice
TiemposLectura(UltimoIndice) := now;
UltimoIndice := UltimoIndice + 1;
139
...
-- Se verifican los tiempos ledos para ver si cumplan la
-- condicin especificada
for Idx in 2 to UltimoIndice loop
if (TiemposLectura(Idx) - TiemposLectura(Idx-1) > 5 ns) then
...
... -- Escribir a un archivo que hay error en los tiempos
...
end if; -- Si hubo un deltaT > Limite
end loop; -- Para todos los elementos del arreglo
...
Cuadro 62 Formato y ejemplo de lazo FOR
El Cuadro 63 muestra el uso de la instruccin while. En esta expresin se especifica una

condicin buleana al comienzo. Mientras esa condicin se evale como verdadera (true)
se seguir ejecutando el cuerpo secuencial del lazo.
-- Formato de la instruccin WHILE

while Indice in Primero to/downto Ultimo loop
... -- Tareas que se hacen con cada Indice
end loop;
-- Ejemplo de la instruccin FOR para inicializar un arreglo
-- cero
for Indice in 31 downto 0 loop
ArregloBits(Indice) = 0;
end loop;
-- Ejemplo de la instruccin FOR para verificar la diferencia

-- entre elementos de un arreglo con elementos de tipo time
...
-- Se guarda el tiempo de lectura e incrementa el ndice
TiemposLectura(UltimoIndice) := now;
UltimoIndice := UltimoIndice + 1;
...
...
-- Se verifican los tiempos ledos para ver si cumplan la
-- condicin especificada
for Idx in 2 to UltimoIndice loop
if (TiemposLectura(Idx) - TiemposLectura(Idx-1) > 5 ns) then
...
... -- Escribir a un archivo que hay error en los tiempos
...
end if; -- Si hubo un deltaT > Limite
140
end loop; -- Para todos los elementos del arreglo

...
Cuadro 63 Formato del lazo WHILE
En el Cuadro 64 se muestra el formato del lazo utilizando la instruccin loop. En este

lazo se usan las instrucciones next y exit para manejar los saltos a la prxima ejecucin
del lazo o para salir. Hay varias maneras de usar las instrucciones next y exit. La ms
simple es como instrucciones por su cuenta, generalmente utilizado despus de una
comparacin if.. para salir del lazo si l condicin se cumple. Tambin se puede usar la
palabra when para especificar la condicin en la misma lnea de instruccin
-- --------------------------------------------------------- --- Formato de la instruccin LOOP, NEXT y EXIT

loop
next (when Condicin); -- Reinicia el lazo
exit (when Condicin); -- Sale del lazo (salta despus
-- del end loop)
end loop;
-- --------------------------------------------------------- --- Ejemplo de lazo loop con condiciones de salida
-Indice := 0;
-- Inicializacin del ndice
loop
-- Comienzo del lazo
Indice := Indice + 1; -- Incremento del ndice
...
... -- Instrucciones secuenciales que se ejecutarn
... para todos los valores de Indice
...
next when Indice <= 5; -- Reinicia el lazo si Indice < 5
...
... -- Instrucciones secuenciales que se ejecutan solo si
... -Indice es mayor que 5
...
exit when Indice = 10; -- Sale del lazo con Indice = 10
end loop;
...
Cuadro 64 Formato del lazo LOOP
Ejemplos de formatos de uso de next y exit en un lazo:

exit;
141
next;
if (Condicin buleana) then
exit;
end if;
if (Condicin buleana) then
next;
end if;
exit when (Condicin buleana);
next when (Condicin buleana);
9.3.2 Instrucciones ASSERT y REPORT

Estas instrucciones se utilizan durante simulacin para dar mensajes sobre el estado de
funcionamiento de un modelo al usuario. Son instrucciones secuenciales que pueden
utilizarse en cualquier punto del cuerpo de un proceso. El formato para esta instruccin es
assert ExpresinDeCondicin report Mensaje severity NivelDeFalla;
ExpresinDeCondicin: expresin buleana que provocar una falla si se evala como
false
Mensaje: Cadena de caracteres que da un mensaje al usuario sobre la falla.
NivelDeFalla: Usado para informar el nivel de severidad de la falla. En general el
simulador detendr la simulacin si la falla es muy grave. El lmite para
esto puede ser fijado por el usuario. A continuacin se dan los posibles
niveles de falla y un comentario sobre el uso de cada uno
note
: Mensaje para informar al usuario
warning : Hay algo mal en el modelo y pueden producirse resultaos
inesperados.
error
: Error en el modelo que no
failure : Falla muy grave que no puede suceder nunca. Detendr al
simulador.
Ejemplos de uso de assert, report:
-- Nota al usuario sobre el funcionamiento del modelo
assert MemoriaLibre >= MEM_LIMITE_MINIMO
report Memoria baja, se sobrescribirn primeros valores
severity note;
-- Mal funcionamiento dentro del modelo
assert NumeroBytes = 0
report Se recibi paquete sin datos
severity warning;
-- Error en una seal que no generar el efecto esperado
142
assert AnchoDePulso >= 2 ns

report Pulso demasiado chico. No generar interrupcin.
severity error;
-- Error en el modelado de un componente
assert NumeroDeEntradas = NumeroDeSalidas
report Error en el modelo. No se puede simular
severity failure;
La instruccin report puede usarse por si sola para generar mensajes que ayuden en la
depuracin del cdigo. La expresin tiene la forma
Uso y ejemplos de report
report Mensaje;
-- Formato de la instruccin report
report Nuevo dato de entrada;
9.3.3 Manejo de Archivos y Paquete TEXTIO

Adems de los tipos predefinidos nombrados anteriormente, VHDL contiene el tipo file
para poder manejar archivos. Adems provee varias instrucciones para el manejo de
archivos. Estas operaciones se muestran en la Tabla 13. Los archivos pueden abrirse en
tres modos: read_mode para lectura, write_mode para escritura a un archivo nuevo y
append_mode para agregar datos al final de un archivo existente. Los archivos en VHDL
pueden contener un solo tipo de datos, incluyendo escalares, arreglos de una dimensin o
datos de tipo record.
Tabla 13 Operaciones con archivos provistas por VHDL
file_open
file_close
read
write
endfile
Descripcin
Procedimiento utilizado para abrir de manera explcita un archivo
Procedimiento utilizado para cerrar de manera explcita un archivo
Procedimiento utilizado para leer un dato de un archivo
Procedimiento utilizado para escribir un dato a un archivo
Funcin que verifica si se ha llegado al final de un archivo y
devuelve true o false
Un archivo puede declararse en cualquier seccin de declaracin, ya sea de una

arquitectura, un proceso o un subprograma. Al hacer la declaracin puede asociarse un
archivo fsico, o esto puede hacerse ms adelante utilizando la instruccin open.
Al escribir datos a un archivo estos se guardarn con un formato binarios que depender
del sistema sobre el que se est trabajando. En general estos no pueden ser analizados
directamente por el desarrollador. En muchos casos es importante que se puedan escribir
o leer los datos directamente de los archivos. De esta manera se hace fcil especificar los
datos de entrada a un modelo o verificar sus resultados. Para simplificar la escritura y
lectura de archivos en un formato entendible para el usuario, la librera std provee el
143
paquete textio. Este paquete permite acceder a archivos que contienen cadenas de
caracteres. As, todos los datos sern cadenas de texto. Pueden usarse funciones de
conversin para guardar o escribir cualquier tipo de dato en estos archivos. En lo que
resta de esta seccin se presentar el paquete textio y su utilizacin para leer y guardar
datos de simulacin. El lector puede referirse a la bibliografa para estudiar el uso de
otros tipos de archivo.
Para utilizar archivos de texto en un banco de pruebas (el manejo de archivos no es
sintetizable), se deben agregar las siguientes lneas en el cdigo
library std;
use std.textio.all;
Esto hace accesible el paquete textio que incluye los tipos y procedimientos mostrados en
la Tabla 14. Tambin incluye los archivos que pueden utilizarse directamente "input" y
"output" asociados a los archivos fsicos "std_input" y "std_output". Estos se proveen
para poder acceder a los dispositivos estndar de entrada / salida, que en general estn
definidos como la pantalla y el teclado en casi todos los sistemas.
Tabla 14 Tipos y procedimientos en textio
Tipo
line
text
side
Descripcin
Tipo declarado como cadena de caracteres "string"
Tipo declarado como archivo de tipos line
Tipo enumerado que toma los valores left o right (izquierda o
derecha)
Tipo definido como natural (nmeros de 0 al mximo entero)
width
Procedimiento
Procedimiento que permite copiar (leer) una lnea de un archivo a
readline
una variable del tipo "line" (cadena de caracteres)
Procedimiento que permite copiar (escribir) una variable del tipo
writeline
"line" a un archivo
Serie de procedimientos sobrecargados para diferentes tipos de
read
parmetro que permiten leer diferentes datos de una variable tipo line
Serie de procedimientos sobrecargados para diferentes tipos de
write
parmetro que permiten escribir diferentes datos a una variable tipo
line
Las operaciones de entrada salida sobre los archivos utilizando textio se hacen lnea a
lnea. Esto permite que varios procesos accedan a un mismo archivo. Como la secuencia
de escritura a un archivo de varios procesos concurrentes es impredecible, al escribir
lneas completas no se entremezclarn los datos sino que a lo sumo se alternan lneas de
un proceso y otro. Si cada proceso marca de alguna manera las lneas que escribe es fcil
descifrar el funcionamiento del modelo en su conjunto al analizar el archivo.
144
Para leer datos usando textio se debe declarar una variable del tipo line y abrir un
archivo de subtipo text. Mediante una instruccin secuencial readline se lee una lnea del
archivo. Esa lnea luego se procesa usado las diferentes variantes de read para extraer los
datos.
Para escribir una lnea a un archivo primero se escriben los datos a una variable del tipo
line utilizando las diferentes variantes de write y luego se escribe la lnea al archivo
usando writeline.
9.3.4 Palabra reservada ALIAS

Como se mencion anteriormente, el lenguaje VHDL da mucha flexibilidad para la
definicin de nuevos tipos y subtipos. Esto permite ordenar y organizar los modelos para
que sean fciles de entender y se adecuen a los componentes que se quieren modelar.
Otra instruccin que es muy til para poder hacer que los modelos sean ms claros de
entender es la palabra reservada alias.
Esta palabra permite definir nuevos nombres para datos y otros objetos. En el caso ms
simple un alias se refiere a un dato con otro nombre. El Cuadro 65 muestra algunos
ejemplos. La capacidad de sintetizar o no diseos que utilizan alias depende de las
herramientas, y se recomienda no utilizarlas para diseos que se sintetizarn para FPGAs.
-- Ejemplo de alias para nombrar los registros y bits

-- del conjunto de registros de una CPU
subtype tdCPURegistro is std_logic_vector(15 downto 0);
type tdCPUSetRegistros is record
ContadorPrograma : tdCPURegistro;
RegistroGeneral
: tdCPURegistro;
RegistroControl
: tdCPURegistro;
RegistroEstado
: tdCPURegistro;
RegistroAuxiliar1 : tdCPURegistro;
RegistroAuxiliar2 : tdCPURegistro;
end record;
-- Se declara una seal con el nuevo tipo
signal CPURegisterSet_REG : tdCPUSetRegistros;
-- Se
alias
alias
alias
alias
alias
alias
definen alias para los registros de la seal declarada

CpuPC_REG
is CPURegisterSet_REG.ContadorPrograma;
CpuGPR_REG
is CPURegisterSet_REG.RegistroGeneral;
CpuState_REG
is CPURegisterSet_REG.RegistroEstado;
CpuControl_REG is CPURegisterSet_REG.RegistroControl;
CpuA1_REG
is CPURegisterSet_REG.RegistroAuxiliar1;
CpuA2_REG
is CPURegisterSet_REG.RegistroAuxiliar1;
-- Se definen alias para algunos bits de algunos registros

alias CpuPCHigh_REG is CpuPC_REG(15 downto 8);
alias CpuPCHigh_REG is CpuPC_REG(7 downto 0);
145
-- Estado de las interrupciones

-- Vector de interrupciones que incluye todos los bits
alias CpuInterrupcion_REG is CpuState_REG(4 downto 0);
-- Bits de interrupcion uno a
alias CpuInterrupcion1_REG is
uno
CpuState_REG(0);
CpuState_REG(1);
CpuState_REG(2);
CpuState_REG(3);
Cuadro 65 Ejemplos declaracin de alias
9.3.5 Ejemplos de Componentes para Bancos de Prueba

A continuacin se dan algunos ejemplos de componentes para pruebas que usan manejo
del tiempo y otras estructuras no sintetizables. Los primeros dos sern utilizados para
probar casi todos los diseos, ya que describen una generacin de reloj y generacin de
una seal de reset. El ltimo ejemplo muestra como puede simularse un ciclo de bus de
CPU.
9.3.5.1 Generacin de Seal de Reloj
En el Cuadro 66 se muestra un componente que genera una seal de reloj con el perodo
dado por una constante genrica.
library ieee;
entity tbGeneradorReloj is
generic (
PERIODO_NS : time := 20 ns
);
port (
SimmulacionActiva_IN : IN
Reloj_OUT
: OUT
);
std_logic;
std_logic
end tbGeneradorReloj ;
architecture Comportamiento of tbGeneradorReloj is
begin
P_Reloj : process
begin
wait for 1 ns;
while (SimmulacionActiva_IN = '1') loop
146
Reloj_OUT <= '0';

wait for PERIODO_NS / 2;
Reloj_OUT <= '1';
wait for PERIODO_NS / 2;
end loop;
-- Simulacin activa
Reloj_OUT <= '0';
wait;
-- Proceso en espera permanente
end process P_Reloj;
end Comportamiento;
Cuadro 66 Generacin de una seal de reloj para pruebas
9.3.5.2 Generacin de una Seal de Reset

En el Cuadro 67 se muestra un componente que genera una seal de Reset con el
tiempo de reset activo dado por una constante genrica.
library ieee;
entity tbGeneradorReset is
generic (
TIEMPO_RESET : time := 250 ns
);
port (
Reset_OUT
: OUT
std_logic
);
end tbGeneradorReset ;
architecture Comportamiento of tbGeneradorReset is
begin
P_Reset : process
begin
Reset_OUT <= 1;
wait for TIEMPO_RESET;
Reset_OUT <= 0;
wait;
end process P_Reset;
------
Reset activo
Se mantiene reset activo
Reset baja. Comienza a funcionar
el circuito
Proceso en espera permanente
end Comportamiento;
Cuadro 67 Generacin de una seal de reset para pruebas
147
9.3.5.3 Temporizado de la Interfase de un Bus de Microcontrolador

En este ejemplo la FPGA tendr una interfase con un microcontrolador (uC) genrico
muy simple. Para probar el diseo se debe crear un banco de pruebas que simule la
interfase de ese uC. El banco de pruebas tendr dos niveles. Por un lado se generarn y
leern datos para verificar el funcionamiento del diseo a alto nivel. Por otro esos datos
se transferirn desde y hacia la FPGA simulando el temporizado del bus del uC (ya que
esa es la manera en la que los dos dispositivos irn conectados en el hardware final). En
la Figura 47 se muestra el temporizado de este bus sincrnico. La Tabla 15 y Tabla 16
dan los valores de tiempo correspondientes y el Cuadro 68 muestra el VHDL que simula
la interfase.
Ciclo de lectura
Ciclo de escritura
Clock
tClock
tSRData
tSWData
tHWData
tHRData
Data
tHAddress
tSAddress
tHAddress
tSAddress
Address
tSRead
tHRead
ReadEnable
tHWrite
tSWrite
WriteEnable
Figura 47 Temporizado de uC a simular en el banco de pruebas
Tabla 15 Tiempos para ciclo de lectura de uC
Parmetro
tClock
tSAddress
tHAddress
tSRead
tHRead
tSRData
tHRData
Descripcin
Perodo del reloj (48 - 52% duty cycle)
Tiempo de setup de direcciones antes del primer flanco
positivo de reloj
Tiempo de mantenimiento o hold de la direccin despus
del flanco positivo de reloj
Tiempo de setup de seal ReadEnable en 0 antes del
flanco positivo de reloj
Tiempo de mantenimiento o hold de la seal ReadEnable
despus del flanco positivo de reloj
Tiempo de setup del dato necesario antes del flanco
positivo de reloj
Tiempo de mantenimiento o hold del dato necesario
Mnimo
100 ns
50 ns
Mximo
1 us
8 ns
14 ns
54 ns
4 ns
8 ns
15 ns
1 ns
148
Tabla 16 Tiempos para ciclo de escritura de uC
Parmetro
tClock
tSAddress
tHAddress
tSWrite
tHWrite
tSWData
tHWData
Descripcin
Perodo del reloj (48 - 52% duty cycle)
Tiempo de setup de direcciones antes del primer flanco
positivo de reloj
Tiempo de mantenimiento o hold de la direccin despus
del flanco positivo de reloj
Tiempo de setup de seal WriteEnable en 0 antes del
Tiempo de mantenimiento o hold de la seal WriteEnable
Tiempo de setup de datos antes del flanco positivo de
reloj
Tiempo de mantenimiento o hold del dato despus del
Mnimo
100 ns
50 ns
Mximo
1 us
8 ns
14 ns
62 ns
4 ns
8 ns
58 ns
6 ns
15 ns
-- ------------------------------------------------------- --- Ejemplo de ciclo de temporizado de un bus de uC

...
... -- Declaracin de libreras y uso de paquetes.
...
-- Entidad para banco de pruebas que simula el micocontrolador
entity tbMicroControlador is
generic(
T_CLOCK : time := 200 ns
);
port(
Reset_IN
: in
std_logic;
Clock_IN
: in
std_logic;
ReadEnable_OUT : out
std_logic;
WriteEnable_OUT : out
std_logic;
Address_OUT
: out
std_logic_vector(19 downto 0) ;
Data_IO
: inout std_logic_vector(15 downto 0)
);
end tbMicroControlador;
architecture Comportamiento of tbMicroControlador is

-- Constantes de parmetros de temporizado del bus
constant T_SETUP_ADDRESS
: time := 50 ns;
constant T_HOLD_ADDRESS
: time := 8 ns;
constant T_SETUP_READENABLE
: time := 54 ns;
constant T_HOLD_READENABLE
: time := 4 ns;
constant T_SETUP_R_DATA
: time := 15 ns;
constant T_HOLD_R_DATA
: time := 1 ns;
constant T_SETUP_WRITEENABLE
: time := 62 ns;
constant T_HOLD_WRITEENABLE
: time := 4 ns;
constant T_SETUP_W_DATA
: time := 58 ns;
constant T_HOLD_W_DATA
: time := 6 ns;
...
... -- Declaracin de tipos, seales internas, etc.
...
149
begin
----------
En el proceso de control se leen las operaciones y datos

de los ciclos del uC de un archivo de comandos.
Los ciclos del bus y los datos se guardan a un archivo
junto a una etiqueta de tiempo, mensajes de error, etc.
para ser revisados despus y analizar el funcionamiento
del diseo
Cada vez que se debe acceder al bus se usan los
procedimientos de LeerDato, EscribirDato definidos
antes del begin del proceso
SimulacionDeMicro : process
variable FinDeSimulacion
: boolean := false;
... - Otras variables auxiliares para controlar simulacin
variable
variable
variable
variable
variable
DatoAEscribir_VAR
DatoEnTiempoSetup_VAR
DatoEnTiempoHold_VAR
DireccionWrite_VAR
DireccionRead_VAR
:
:
:
:
:
std_logic_vector(15
std_logic_vector(15
std_logic_vector(15
std_logic_vector(19
std_logic_vector(19
downto
downto
downto
downto
downto
0);
0);
0);
0);
0);
-- Procedimientos de acceso al bus que controlan los

-- temporizados y se usan en los procesos de simulacin
-- de las operaciones a nivel dato para leer y escribir
-- el bus
procedure LeerDato is
begin
wait until Rising_Edge(Clock_IN);
ReadEnable_OUT <= 0 after (T_CLOCK T_SETUP_READENABLE);
Address_OUT
<= DireccionRead_VAR after T_CLOCK
T_SETUP_ADDRESS;
wait for (T_CLOCK T_SETUP_R_DATA);
DatoEnTiempoSetup_VAR := Data_IO;
wait for T_HOLD_R_DATA;
DatoEnTiempoHold_VAR := Data_IO;
ReadEnable_OUT <= 1 after (T_HOLD_READENABLET_HOLD_R_DATA);
Address_OUT
<= (others => 0) after (T_HOLD_ADDRESS

T_HOLD_R_DATA);
end LeerDato;
procedure EscribirDato is
begin
WriteEnable_OUT <= 0 after (T_CLOCK
T_SETUP_WRITEENABLE);
150
Address_OUT
<= DireccionWrite_VAR after (T_CLOCK

T_SETUP_ADDRESS);
Data_IO
<= DatoWrite_VAR after (T_CLOCK
T_SETUP_W_DATA);
WriteEnable_OUT <= 1 after T_HOLD_WRITEENABLE;
Address_OUT
<= (others => 0) after T_HOLD_ADDRESS;
Data_IO
<= (others => Z) after T_HOLD_W_DATA;
end EscribirDato;
-- Comienzo del proceso de simulacin del uC
begin
-- Valores iniciales
ReadEnable_OUT <= '1';
WriteEnable_OUT <= '1';
Address_OUT
<= (others => '0');
Data_IO
<= (others => 'Z');
-- Esperar a salir del estado de reset. NO es mala idea probar
-- a ver que pasa durante el re3set, pero aqu no se hace
wait until Reset_IN = '0';
-- Lazo de simulacin de X operaciones, o hasta que se acabe
-- el archivo
while (FinDeSimulacion = false) loop
...
-- Leer operacin y datos de un archivo
...
case OperacionDeCPU is
when OP_CPU_LECTURA =>
...
LeerDato;
...
-- Escribir resultados a un archivo
...
when OP_CPU_ESCRITURA =>
...
EscribirDato;
...
... -- Escribir resultados a un archivo
...
when ...
...
-- Otros comandos y procesamiento de los datos ledos, etc.
...
...
...
Cuadro 68 Simulacin de la interfase de un microcontrolador
151
9.4 Que Falta sobre VHDL

El objetivo de estas notas en cuanto a VHDL es presentarlo en el contexto de los diseos
sintetizables para FPGAs y dar una gua rpida y ejemplos para que el lector pueda
utilizarlo lo ms rpido posible. Hay varias instrucciones, estructuras, e infinitas
posibilidades de uso de VHDL que no han sida descriptas. Algunas de estos temas no se
usan en circuitos sintetizables y otros no se incluyeron para no hacer estas notas
demasiado largas y pesadas. Para ahondar ms en estos temas se recomiendan los textos
mencionados en la seccin Bibliografa o utilizar Internet para buscar la informacin
deseada.
Algunos temas que no se han tratado son:
Diferencias entre las diferentes versiones de VHDL
Modo BUFFER para puertos de entidades (no se presentan ya que no son
recomendados para sntesis)
Atributos de tipos escalares y seales (attributes)
Arreglos multidimensionales
Mecanismos de retardo inerciales y de transporte (inertial and transport
delay mechanisms)
Subprogramas: Procedimientos y funciones no se explicaron de manera
exhaustiva
Mltiples arquitecturas y uso de configuraciones (configure)
Bloques y guardas (guards, blocks)
Manejo de archivos de otro tipo que el definido en textio
etc., etc., etc.
152
10 Buenas Prcticas de Diseo

10.1 Introduccin
Al disear hardware utilizando VHDL no debe olvidarse que el producto es parte de un
sistema ms grande y que interactuar con componentes y seales externas sobre las que
no hay control. En este sentido el diseador debe estar al tanto de los requerimientos,
tolerancias, frecuencias etc. de estas seales y componentes para poder proveer una
interfase que se adecue a la funcionalidad prevista.
Por otro lado, las FPGAs permiten el desarrollo de sistemas muy complejos en un solo
componente. Estos diseos pueden llegar a ser bastante sofisticados y tener una jerarqua
que utilice componentes desarrollados por diferentes personas. Para poder manejar esto
de manera controlada es bueno tener pautas o guas de diseo que ayuden a la interaccin
y reutilizacin de la propiedad intelectual. En esta seccin se presentarn de manera
bsica una serie de puntos y recomendaciones relacionadas con estos temas.
10.2 Documentacin
Si se pretende tener un producto (re)utilizable, vendible, o que pueda entenderse despus
de tenerlo archivado unos meses es imprescindible crear buena documentacin.
COMPLETAR CON PAUTAS SOBRE DOCUMENTACIN.
10.3 Gua de estilo para el cdigo HDL

Ya se ha planteado la importancia de crear diseos que puedan ser entendidos facilmente,
ya sea otros desarrolladores, clientes, auditores o el mismo desarrollador un tiempo ms
tarde. Para facilitar esto, una organizacin debera tener una gua documentada que pueda
ser consultada por todos los desarrolladores. De esta manera se evitan las confusiones y
se acelera el aprendizaje de nuevos integrantes del equipo. En esta seccin se presenta un
ejemplo de documento de este tipo. Este es solo un ejemplo, y no debe tomarse como el
nico modelo que puede ser utilizado. Lo ms importante es ser consistente a travs del
tiempo y con el resto de la organizacin al escribir cdigo (ya sea VHDL o en cualquier
otro lenguaje de programacin).
Lenguaje de programacin en general

o En los lenguajes que no son sensibles a las maysculas ser consistente en el
uso de la capitalizacin para las palabras reservadas.
o En los lenguajes que son sensibles a las maysculas no se deben diferenciar
los nombres de funciones, entidades, procesos, etc. solo por las maysculas
o Colocar las instrucciones begin y end en su propia lnea de programa
o En general, cada instruccin independiente del programa deber estar en su
propia lnea
o No usar constantes mgicas. Definir todas las constantes con palabras que las
identifiquen inequvocamente.
o Dar un nombre a todos los procesos para aclarar su funcionalidad.
153
o Usar un prefijo td para los tipos definidos en el programa

o Usar parntesis aunque no sean necesarios si ayudan a entender la prioridad y
sentido de la lgica que se est describiendo.
Programacin en VHDL
o No mezclar estndares de programacin. Usar sintaxis VHDL 87 o 93
exclusivamente)
o Usar un archivo por entidad (entity) que defina su interfase y arquitectura.
El nombre del archivo deber ser igual al de la entidad.
o Usar tipos std_logic para todas los puertos de interfase externa
o Nunca asignar un valor desconocido X o verificar un dont care -
(producen resultados inesperados en la sntesis y las simulaciones)
o No usar los valores por defecto para seales y variables. Asignarles un valor
inicial durante el estado de Reset.
o Tratar de usar el mismo nombre para las seales a travs de toda la jerarqua
de diseo, quizs agregando prefijos o sufijos.
o Definir todas las constantes para un diseo en un solo package
o Usar constantes y parmetros genricos para definir el tamao de los buffers y
buses. (Ayuda a reutilizar el cdigo)
o No utilizar puertos del tipo BUFFER para leer un valor de salida. En vez de
eso usar tipos OUT y agregar otra seal interna a la que se le asigna el
mismo valor.
Nombres de las seales, variables y constantes

o Usar nombres que den una clara idea de los datos que contiene la seal o
constante. Usar palabras completas y no abreviaturas que son difciles de
descifrar y recordar.
o Para los nombres de las seales usar maysculas solo para identificar las
palabras del nombre. (Ej.: NombreDelProceso)
o Usar todas maysculas separadas con _ para definir constantes. Dar un
prefijo especifico a todas las constantes de acuerdo al proyecto. Usar una
secuencia jerrquica de palabras clave para especificar a que valor se est
refiriendo una constante (Ej.: UTN_ADC_MAXIMO, UTN_ADC_MINIMO).
o Usar nombres que den una idea clara de la funcin de los mdulos, procesos o
procedimientos.
o Usar los siguientes sufijos para las seales en VHDL
sin sufijo :
cable
_N
:
lgica negada (active low)
_REG
:
seal almacenada en un registro
_LATCH :
seal almacenada en un match
_DLY
:
seal retrasada a travs de un registro
_IN
:
puerto (port) de entrada a una de una entidad (entity)
_OUT
:
puerto (port) de salida de una de una entidad (entity)
_IO
:
puerto (port) de entrada/salida de una entidad (entity)
154
o Usar los siguientes prefijos para las seales en VHDL

sin prefijo :
cable
int
:
representacin interna de un puerto de una entity
Nombres de mdulos procesos, procedimientos

o Usar nombres que den una idea clara de la funcin de los mdulos, procesos o
procedimientos.
o Ser sistemtico en el formato de los nombres.
o Usar maysculas para dividir las palabras de un nombre. Dejar _ para las
nombres de las variables.
Indentacin, espacios y lneas en blanco

o Hacer un consistente y buen uso de los espacios, indentacin y lneas en
blanco para que el cdigo sea mas entendible y claro.
o La indentacin debe ser fija y consistente para todo proyecto. Dos espacios es
un valor razonable. Los TABs debern estar definidos como 2 espacios.
o No escribir lneas de cdigo de mas de 80 caracteres. Partir la lnea larga entre
varias y alinearla para que se comprenda mejor.
o Usar lneas en blanco para separar las declaraciones de las funciones, los
bloques funcionales de cdigo, etc.
o Indentar la primer lnea de cdigo despus de la declaracin de un proceso o
procedimiento. Todo el cdigo que implementa el proceso quedar as
indentado debajo de la declaracin.
Comentarios
o Usar los comentarios para describir la lgica y el motivo del programa. No
comentar lo obvio.
o Usar lneas completas comentadas para dividir grandes bloques lgicos del
programa
o Usar comentarios para especificar que condicin est cerrando un comando
END
o Siempre debe agregarse un comentario para describir lgica que no es obvia o
tiene particularidades que son difciles de entender a simple vista.
Ejemplos:
Comentarios, espacios y nombres
-- ------------------------------------------------------------------------------ LIMITES PARA LOS DATOS LEIDOS DEL ADC

-- ----------------------------------------------------------------------------constant UTN_ADC_VALOR_MAXIMO : std_logic_vector(12 downto 0) := 0010000000000;
constant UTN_ADC_VALOR_MINIMO : std_logic_vector(12 downto 0) := 1110000000000;
-- ------------------------------------------------------------------------------ SEALES
-- ----------------------------------------------------------------------------signal
ADCdataBus
signal
ADCReady
: std_logic;
signal
ADCRead
: std_logic;
155
Capitalizacin, comentarios nombres, espacios e indentacin

Usar:
-- Proceso que suma las dos entradas ledas de los puertos serie
P_SumaDatosSerie : process (Clock_IN, Reset_IN)
begin
...
elsif (Clock_INevent and Clock_IN = 1) then
...
end; -- if Reset, Clock
end process; -- Proceso Suma Datos Serie
y no
ProcesoX1 : process (Clock_IN, Reset_IN) -- No hay una descripcin del proceso
BEGIN
-- la indentacin esta mal
if (Reset_IN = 0) THEN -- Si el Reset es cero Obvio
elsif (Clock_INEVENT And Clock_IN = 1) then -- si hay un flanco de reloj Obvio
-- suma los datos Esto debera estar describiendo el proceso, no aqu
...
end; end PROCESS; -- Cada end en su propia lnea
Usar:
signal DatoDeEntrada_N_REG : std_logic_vector(2 downto 0);
signal DatoDeSalida_REG
...
P_umaDeEntradas : PROCESS(Clock_IN, Reset_IN)
P_RestaDeEntradas : PROCESS(Clock_IN, Reset_IN)
y no:
signal datodeentrada_N_REG : std_logic_vector(2 downto 0); -- No hay un estndar
-- para los nombres
signal salida : std_logic_vector(2 downto 0);
-- alinear los espacios
...
SumaDeEntradas : PROCESS(Clock_IN, Reset_IN)
-- no hay consistencia en
Proceso_Entradas_Resta : PROCESS(Clock_IN, Reset_IN) -- el formato de los nombres
10.4 Programacin para Diseos Sintetizables

Al hacer cdigo VHDL para diseos sintetizables conviene utilizar las normas de cdigo
para sntesis recomendadas. Segn la herramienta que se use la implementacin puede
depender ms o menos del cdigo que se escriba. Las recomendaciones de VHDL para
sntesis generales (estndar 1076.x) y de los fabricantes ensean que esperan las
herramientas para indicar las caractersticas que se desean en un diseo.
10.4.1 Diferencias entre Sntesis y Simulacin

Diferencias que pueden existir entre diseo simulado y sintetizado. Tiempos no exactos
en simulacin. Hay que hacer sntesis y anotar con SDF. Puede haber diferencias,
especialmente con lgica combinacional y latches.
10.4.2 Divisin de la Frecuencia Mediante Habilitacin del Reloj

Al disear para sntesis lo ideal es utilizar una sola seal de reloj que se distribuye a todos
los bloques del diseo. En una FPGA esta seal se conecta y distribuye a los bloques
lgicos por una red de conexiones global dedicada a ese fin. Si se desea hacer funcionar
parte del diseo a una frecuencia diferente de la del reloj principal no debe proveerse una
seal de reloj ms lenta. Esto es, para diseos con FPGAs no se recomienda dividir el
reloj y generar una seal de menor frecuencia y duty cycle del 50%, sino que se
156
recomienda generar una seal de habilitacin de reloj. Esta es una seal con la que se
habilita el reloj por un ciclo solo cada N ciclos. Esto hace que un proceso sincrnico se
ejecute solamente a la frecuencia deseada (cada N flancos de reloj) en vez de con cada
flanco del reloj. La Figura 48 muestra el mtodo de divisin de frecuencia recomendado
para diseos sobre FPGAs.
Figura 48 Divisin de frecuencia recomendada para FPGAs usando habilitacin de reloj (CE)
La Figura 49 muestra como NO debe implementarse una divisin de reloj en un diseo

con FPGAs. Aunque este mtodo es muy utilizado en diseos digitales convencionales,
no aprovecha los recursos de la FPGA y puede causar problemas de temporizado y
sincronizacin en el circuito implementado. En general, solo se recomienda manejar las
seales de reloj de los flip-flops a partir de las redes de distribucin global de reloj y
nunca desde lgica combinacional.
157
Figura 49 Divisin de frecuencia mediante divisor de reloj (No utilizar en FPGAs)
Usando VHDL, el mtodo recomendado para implementar la divisin de frecuencia se

muestra en el Cuadro 69. Esta manera de dividir el reloj se sintetiza de manera muy
eficiente utilizando las seales de habilitacin de los flip-flops en los bloques lgicos de
las FPGA. La seal de habilitacin se debe generar en un bloque aparte dividiendo el
reloj principal.
-- Formato de un proceso con seal de habilitacin de reloj
ProcesoConHabilitacionClock : process(Clock_IN, Reset_IN)
begin
-- Valores de reset
elsif (Rising_Edge(Clock_IN) then
-- Solo ejecutar las instrucciones secuenciales si el reloj
-- est habilitado
if (HabilitacionDeReloj_IN = 1) then
...
...-- Instrucciones secuenciales del proceso
...
end if; -- Habilitacin de reloj
end process ProcesoConHabilitacionClock;
Cuadro 69 Utilizacin de la seal de habilitacin de reloj
158
10.5 Gua de Estilo Para un Buen Diseo de Hardware

As como una organizacin debera tener una gua para la estructura y formato del cdigo
para que sea entendible y reutilizable, lo mismo es vlido a nivel de componentes para
que estos puedan interconectarse sin mayores esfuerzos a otros bloques y reutilizarse en
otros proyectos. Es una buena idea que se tengan estas normas o guas para el desarrollo
de hardware centralizadas en un documento que puede ser consultado por los
desarrolladores. En este documento deberan volcarse las normas preferidas de interfase y
estructuras de desarrollo as como tambin la experiencia y aprendizajes de la
organizacin. De esta manera se ayuda a que luego la propiedad intelectual sea ms fcil
de comprender y reutilizar por otros o incluso por la misma persona despus de un
tiempo, se evita repetir errores y los nuevos desarrolladores pueden aprender de la
experiencia de otros.
Hay muchos errores comunes que pueden evitarse facilmente siguiendo este tipo de
pautas Por ejemplo, si algunos desarrolladores utilizan una seal de reset positiva y otros
negativa, o si algunos no proveen un estado de reset conocido o si algunos nombran los
buses del bit ms significativo al menor y otros al revs, esto puede causar errores al
integrarlos en un diseo. A continuacin se da como ejemplo una lista de algunas
recomendaciones para diseos utilizando VHDL tomado de guas de desarrollo de
organizaciones reales. Estos son las pautas que se ha tratado de utilizar a travs de este
texto para todos los ejemplos.
Seal de Reset
Proveer una seal de Reset porque hace que un diseo sea determinstico y evita
que se llegue a estados prohibidos
o Todos los Flip-Flop debern tener un Reset de lgica positiva, asincrnico.
Este Reset deber estar conectado a la pata de Reset global de la FPGA o
CPLD de ser posible.
o El Reset asincrnico se usar a nivel local en todos los mdulos. Este se
sincronizar con el reloj al nivel lgico mas alto de la jerarqua de diseo.
(Evita des-sincronizacin por caminos de diferente longitud de la seal de
Reset).
o Durante el estado de Reset todos los puertos bidireccionales debern colocarse
en el estado de entrada. (Esto es lo que espera el boundary scan y evita tener
valores )
Reloj
o Todas las seales que cruzan dominios de reloj debern muestrearse antes y
despus de cruzar dominios (previene estados meta-estables).
o Se debern usar la mnima cantidad de dominios de reloj posibles.
o No usar seales de reloj o Reset como Enable o dato. No usar un dato como
reloj o Reset. (los resultados durante simulaciones pueden diferir del circuito
sintetizado y causar problemas de temporizado)
159
o Las seales de reloj debern estar conectadas a un "pad" global de reloj en la

FPGA o CPLD. (estos pines tienen canales de distribucin especiales con baja
diferencia de retardo en la distribucin, o bajo skew)
Buses
o Comenzar los buses en el bit 0. (Algunas herramientas no aceptan buses que
no comienzan en 0)
o Usar (MSB downto LSB) para todos los buses. (para evitar interpretaciones
diferentes y provocar malos conexionados)
Recomendaciones para Sntesis

o Usar solo diseos sincrnicos. (evita problemas durante la sntesis, de
temporizado y en las simulaciones)
o Tratar de no utilizar Flip-Flops con flanco de reloj descendente (dificulta la
verificacin y puede crear problemas durante la sntesis)
o No usar latches. (crea problemas de sntesis y de verificacin de tiempos)
o Usar procesos con lista de sensibilidad a las seales de Reset y Reloj
solamente con el siguiente formato
PROCESS (Clock, Reset)

BEGIN
IF (Reset = '1') THEN
...
ELSIF (Clock'event AND Clock = '1') THEN
...
END IF;
END IF;
END PROCESS;
o Para lgica sincrnica con enable, tratar de definirla en un proceso solo con
el siguiente formato
PROCESS (Clock, Reset)
BEGIN
IF (Reset = '1') THEN
intOutSignal <= '0';
ELSIF (Clock'event AND Clock = '1') THEN
IF (CE = '1') THEN -- Seal de enable
intOutSignal <= '1';
END IF;
END IF;
END PROCESS;
(as las herramientas de sntesis utilizarn as la seal de enable interna de los

bloques lgicos de la FPGA y no generarn lgica externa)
o No utilizar largas cadenas de if.. else sino que utilizar una instruccin
case. (esto evita que se genere lgica de prioridad grande, lenta e
innecesaria)
160
o En un proceso combinacional incluir todas las seales en la lista de

sensibilidad. (evita que se generen latches no deseados)
o En mquinas de estado, usar dos procesos separados. Uno para la asignacin
sincrnica de los estados y uno asincrnico para las salidas. (Ayuda a entender
el cdigo y predecir el tamao de la lgica combinacional)
Recomendaciones Generales de Diseo

o No usar buffers de tres estados internamente en los diseos.
o No usar elementos de retardo.
o Todas las seales de interfase externa debern tener registros
Bancos de Prueba (testbenches) y Depuracin

o Tratar de crear el banco de pruebas en dos partes. Uno para generacin y
verificacin de datos y otro para la generacin del temporizado de las seales.
(Esto facilita la verificacin de los datos por un lado y el temporizado por
otro. Adems facilita la modificacin del protocolo de comunicacin o
handshaking con el mdulo a probar).
o Definir los tiempos para los ciclos de comunicacin con el mdulo a probar
como constantes que pueden ser modificadas fcilmente.
161
11 SoCs, Cores y Propiedad Intelectual

11.1 Introduccin
Que es un SoC, SoPC. Que es un "core". Papel que juegan en el rpido desarrollo de un
SoC y "time to market" de un producto (tiempos hace unos aos: 2 aos, ahora 6-8 meses
para tener un chip). Cores para FPGAs, cada vez mas los proveen los fabricantes (no solo
chips). Modelo de negocios basado en proveer cores y servicios de integracin de los
cores.
11.2 Presentacin de un Core

TBD. Como se debe presentar un Core: Documentacin, interfaces, modelos, bancos de
prueba, etc. Hay una nota interesante en EETimes o FPGAJournal que guard sobre estos
temas. Buscar en carpeta Research
11.3 Diseo para Verificacin (Design For Test)

Puntos intermedios para poder evaluar funcionamiento, etc.
11.4 Reutilizacin de Propiedad Intelectual

Disear bien los cores para hacerlos reutilizables.
162
12 Notas Sobre Sntesis con FPGAs

12.1 Introduccin
Introduccin al proceso de sntesis. RTL a . Alto nivel (comportamiento) a fsico.
Physical Synthesis.
12.2 Diseo y Optimizacin Para Sntesis

De la nota de aplicacin.: Aunque muchas herramientas pueden optimizar el cdigo, la
implementacin de un circuito en una FPGA muchas veces depende del estilo usado por
el diseador en la descripcin del hardware.
12.3 Formato Edif
12.4 Estructuras Recomendadas para Diseos Sintetizables

Los procesos YA ESTAN EN LA PRIMERA (3) SECCION? Nombrarlos, hacer
referencias y presentar cosas nuevas.
12.4.1 Estructuras de Decisin Jerrquicas y Concurrentes (IF vs. CASE)

Ver nota de aplicacin
12.4.2 Procesos sincrnicos

12.4.3 etc.
12.4.4 etc.
12.4.5 etc.
12.5 Ejemplos de estructuras sintetizadas

Multiplexores
-- with (Seleccion_IN & Datos3_IN(0)) select
with Seleccion_IN select
Salida1_OUT <= Datos1_IN when "00",
Datos2_IN when "01",
"010101" when others;
-"XXXXXX" when others;
163
Ver diferencias cuando se asigna 0000 o XXX
Las herramientas infieren decodificadores para with select, when else, process if, else if y case
Que pasa con if (if else) elsif
Mquina de estados. Mostrar Flip-Flops, quizs con diferentes encoding
164
13 Notas sobre Verificacin

13.1 Introduccin
Qu es verificacin, simulacin. Filosofas de prueba. Herramientas para verificar. Etc.,
etc.
165
14 Uso de las Herramientas

14.1 Manejo Bsico de Xilinx Project Manager
14.2 Manejo Bsico de Altera Quartus II

14.3 Manejo Bsico de Actel Libero (o la que sea gratuita)
166
14.4 Manejo Bsico de ModelSim

Nota Importante de Instalacin
Para poder instalar y ejecutar Xilinx Project Navigator y Modelsim la PC debe tener
instalados el sistema operativo Windows 2000 o Windows XP
Se recomienda seguir el proceso dado en el ISE QuickStart para entender el proceso de
diseo y simulacin completo
En Xilinx Project Navigator
Para poder invocar a ModelSim desde Project Navigator debe estar bien definido
el path al ejecutable. Para el ModelSim versin XE gratuito es
Edit/Preferences/Partner Tools/ C:\Modeltech_xe-starter\win32xoem
o el path adecuado incluyendo el directorio win32xoem
Para crear un banco de pruebas

1. Project/New Source/Testbench Waveform (para diagramas de forma de
onda) o
Project/New Source/VHDL Testbench (para banco de prueba en VHDL)
2. Ponerle un nombre y presionar OK
3. Seleccionar el mdulo al que se desea asociar (que mdulo va a probar)
4. Editar el testbench o formas de onda como se desee y grabarlo.
5. Seleccionar el archivo del banco de pruebas (*.tbw o *.vhd)
Para enviar un proyecto a ModelSim y simularlo

6. Seleccionar el testbench o archivo de forma de onda que se desea simular
7. En la ventana Processes for Current Source seleccionar ModelSim
Simulator
8. Hacer doble clock en la opcin Simulate Behavioral Testbench para
abrir el proyecto y su banco de pruebas en ModelSim
9. Si el test es un archivo de forma de onda se ver el testbench en VHDL
usando View Behavioral Testbench
Mens de ModelSim
Para ver las formas de onda ir al men

View/Wave
Para ver la estructura del diseo cargado en ModelSim

View/Structure
Para agregar seales a la ventana ver las formas de onda ir al men
167
1. View/Signals. Esto abrir la ventana de seales

2. Seleccionar el componente deseado en la jerarqua de la ventana
principal o en la ventana Structure
3. De la ventana de seales, arrastrar la/las seal deseada/s a la ventana
Wave (forma de onda)
Comandos de lnea
Tarea
Recomenzar simulacin
Comando
restart all
Correr simulacin
run TIEMPO
Ayuda sobre comandos
help commands
help run
Salir del programa
quit
Ejemplo/Comentario
Apretar Restart en la ventana que
aparece al apretar Enter
run 1000 ns
run 1 ms
Da una lista de los comandos
disponibles o ayuda sobre un
comando especfico
Presionar YES cuando pregunta si

quiere salir
Mens de la ventana de forma de onda (waveform)
Para ver solo los nombres de las seales (sin path) poner 1 en la casilla:
Tools/Windows Preferences/ Display Signal Path [] # of elements
Para guardar/abrir una configuracin de formas de onda
(Los archivos tienen una extensin .do)
File/Load Format o Save Format
Para insertar una lnea divisoria entre grupos de seales

Botn derecho (o men Insert) / Divider
Para guardar/abrir una simulacin

File/Save Dataset o Open Dataset
Para hacer zoom en la ventana de seales

Lupa negra: muestra toda la simulacin
Lupa + y : hacen zoom
Cuadraditos con flecha hacia abajo y a la derecha: seleccionan un rea
168
15 Referencias
15.1 Dispositivos Lgicos Programables
Bibliografa
Spartan IIe Device Family, Hoja de datos de Xilinx DS077, www.xilinx.com, 2002.
Virtex II Pro Data Sheet, Hoja de datos de Xilinx DS083, www.xilinx.com, 2002
MAX 7000 Programmable Device Family, Hoja de datos de Altera DS-MAX7000-6.5,
www.altera.com.
Stratix FPGA Family Data Sheet, Hoja de datos de Altera DS-STXFAMLY-3.0,
www.altera.com, 2002
Excalibur Device Overview Data Sheet, Hoja de datos de Altera DS-EXCARM-2.0,
www.altera.com.
GAL22V10 Data Sheet, Hoja de datos de Lattice Semiconductors, www.vantis.com,
Junio 2000
Using Delay Locked Loops in Spartan II Devices, Nota de aplicacin de Xilinx XAPP174,
www.xilinx.com, 2000
Introduction to GAL Devices, Nota de aplicacin de Lattice Semiconductors,
www.vantis.com, 2002
CPLD Package and I/O Matriz, Gua de seleccin de Altera SA-CPLDMTRX-1.0,
www.altera.com, 2002
FPGA and CPLD Architectures: A Tutorial, Stephen Brown & Jonathan Rose, IEEE
Design and Test of Computers, 1996.
Diseo Digital Principios y Prcticas Tercera Edicin, John F. Wakerly, Editorial Prentice
Hall, 2001.
Sntesis y Descripcin de Circuitos Digitales Utilizando VHDL, IEC Francisco Javier
Torres Valle, Universidad Autnoma de Guadalajara, 2001.
Low-cost programmable logic: How low should you go?, Brian Dipert, EDN, 16/3/2001
Programmable Logic Device Review. Lattice Introduces FPGA, Murray Disman,
www.chipcenter.com, 2002.
The Effect of LUT and Cluster Size on Deep-Submicron FPGA Performance and Density,
Elias Ahmed a& Jonathan Rose, IEEE Transactions on VLSI Systems, March 2004
FPGA Performance vs Cell Granularity, Jack Kouloheris & Abbas El Gamal, IEEE
Custom Integrated Circuits Conference, 1991
Links de Inters
Sitio web de Altera: www.altera.com

Sitio web de Xilinx: www.xilinx.com
Sitio web de Actel: www.actel.com
Sitio web de Cypress Semiconductor: www.cypress.com
Sitio web de Quicklogic: www.quicklogic.com
Sitio web de Atmel: www.atmel.com
169
15.2 Diseo Digital con PLDs

Bibliografa
Artculo de Embedded Systems Programming: "The Universal Design Methodology", Bob

Zeidman, Nov 4, 2003
Artculo de Embedded Systems Programming: "Tools are not Enough", Lindsey Vereen,
Enero 27, 2004
"Algorithmic C Synthesis Optimizes ESL Design Flows", XCell Journal Fall 2004, Shawn
McCloud, Mentor Graphic Corporation
Links de Inters
What is Behavioral Synthesis? http://www.forteds.com/pub/bd/whatisbd.asp
15.3 VHDL
Bibliografa
The Designers Guide to VHDL 2nd Edition, Peter J. Ashenden, Editorial Morgan Kaufman,
2002
Diseo Digital Principios y Prcticas Tercera Edicin, John F. Wakerly, Editorial Prentice
Hall, 2001
Synthesis and Simulation Design Guide, Xilinx
Development System Reference Guide ISE 5 , Xilinx
The VHDL Golden Reference Guide version 1.1, Doulos, 1995
In Search of the Origins of VHDLs Delta Delays, Sumit Gosh, Proceedings of the IEEE
International Symposium on Quality Electronic Design, 2002.
Cdigo VHDL de los paquetes.de lgica estndar IEEE: std_logic_1164.vhd,
std_logic_arith.vhd, std_logic_signed.vhd y std_logic_unsigned.vhd.
Synthesis and Simulation Design Guide, Xilinx
Libraries Guide, Xilinx
Rapid Prototyping of Digital Systems, James O. Hamlen Michael D. Furman, Kluwer
Academic Publishers, 2000
The VHDL Golden Reference Guide version 1.1, Doulos, 1995
VHDL Style Guidelines for Performance, Model Technology, Oct 1999.
Links de Inters
www.vol.webnexus.com Curso de introduccin al lenguaje Verilog (en ingls)

www.eda.ei.tum.de/forschung/vhdl/ Lista de recursos sobre VHDL
Buscando en Google (www.google.com) las palabras clave VHDL o VHDL
tutorial se hallarn cientos de sitios de inters.
Sitio de vhdl.org: www.vhdl.org
Preguntas frecuentes (FAQ) sobre VHDL: vhdl.org/vi/comp.lang.vhdl
Tutorial de VHDL de Jan Van der Spiegel en University of Pennsylvania
http://www.seas.upenn.edu/~ee201/vhdl/vhdl_primer.html
170
15.4 Buenas Prcticas de Diseo

Bibliografa
Code Complete, Steve McConell, Microsoft Press, 2002.

ESD Coding Standards Rev 1.0, Embedded Systems Design, Inc., 2001
ESD VHDL Coding Guidelines Rev 1.0, Embedded Systems Design, Inc., 2001
15.5 Sntesis
Bibliografa
Xilinx Synthesis Technology (XST) User Guide, Xilinx
Links de Inters (sntesis)
http://www.vhdl.org/vi/vhdlsynth/vhdlsynth.html
171
16 Ejemplos
Los ejemplos se describen en este apndice pero el cdigo est en un CD o archivos
adjuntos
16.1 Ejemplos de Lgica Combinacional

16.2
16.3 Ejemplos de Lgica Secuencial
16.4 Divisor Reloj
16.5 Control display 7 segmentos
16.6 ... otros ejemplos de laboratorios hechos en clase...
16.6.1 Interfase Mouse

16.6.2 Controlador VGA
16.7 Ejemplo Completo: UART

16.8 etc, etc
172

Diseño Digital Utilizando Lógicas Programables

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Diseño Digital Utilizando Lógicas Programables

Cargado por

Copyright:

Formatos disponibles

Diseo Digital Utilizando Lgicas

Diseo digital utilizando Lgicas Programables

UTN, Facultad Regional Baha Blanca

Diseo digital utilizando Lgicas Programables

UTN, Facultad Regional Baha Blanca

2005 Guillermo Gichal

Diseo digital utilizando Lgicas Programables

UTN, Facultad Regional Baha Blanca

2005 Guillermo Gichal

Diseo digital utilizando Lgicas Programables

UTN, Facultad Regional Baha Blanca

2005 Guillermo Gichal

Diseo digital utilizando Lgicas Programables

UTN, Facultad Regional Baha Blanca

15.1 Dispositivos Lgicos Programables................................................................ 169

2005 Guillermo Gichal

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

2003 Guillermo Gichal

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

2003 Guillermo Gichal

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

Las notas estn principalmente orientadas a sntesis de diseos digitales sobre

2003 Guillermo Gichal

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

una instruccin, operacin o construccin, sino que se darn ejemplos que

Esta es la primera versin de estas notas, y seguramente contiene errores, omisiones o

2003 Guillermo Gichal

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

4 Temas Bsicos de Diseo Digital

4.1 Diseo Combinacional y Secuencial

4.2 Diseo Secuencial Asincrnico y Sincrnico

4.4 Autmatas de Estados Finitos (Mquinas de estados finitos)

4.5 Integridad de Seal

2003 Guillermo Gichal

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

4.5.2 Terminaciones de Seales

4.6 Interfaces Elctricas

4.7 Potencia y Consumo de los Circuitos

2003 Guillermo Gichal

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

5 Diseo Digital con FPGAs y HDLs

Figura 1 Esquema del proceso de diseo de un sistema complejo

2003 Guillermo Gichal

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

Figura 2 Diagrama de Gajski - Kahn

Dominio Comportamiento: Describe lo que hace un sistema (funcionamiento)

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

Nivel RTL: Describe el comportamiento de todas las seales (entradas, internas y

5.1 Metodologa General de Diseo Digital

2003 Guillermo Gichal

Diseo digital utilizando FPGAs

UTN, Facultad Regional Baha Blanca

Disear un dispositivo libre de defectos de manufactura, que funciona de manera

En muchos casos el proceso es no lineal. Si se descubren fallas o problemas en las