Diseño Digital Utilizando Lógicas Programables

Versión 0.6
Junio 29, 2005

Guillermo Güichal
Universidad Tecnológica Nacional Facultad Regional Bahía Blanca

Diseño digital utilizando Lógicas Programables

UTN, Facultad Regional Bahía Blanca

Índice
1 2 3 4 Agradecimientos ......................................................................................................... 7 Versiones..................................................................................................................... 8 Introducción ................................................................................................................ 9 Temas Básicos de Diseño Digital ............................................................................. 11 4.1 Diseño Combinacional y Secuencial ................................................................ 11 4.1.1 Flip-Flops y Latches ................................................................................. 11 4.2 Diseño Secuencial Asincrónico y Sincrónico ................................................... 11 4.3 Algunas Notas sobre Diseño Secuencial Sincrónico ........................................ 11 4.3.1 Temporizado y Utilización de Registros................................................... 11 4.3.2 Distribución de Reloj ................................................................................ 11 4.3.3 Máxima 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 Autómatas de Estados Finitos (Máquinas de estados finitos)........................... 11 4.4.1 Máquinas de Mealy................................................................................... 11 4.4.2 Máquinas de Moore .................................................................................. 11 4.4.3 Codificación de estados. Mínima, One-hot, One-cold, Grey, etc. ............ 11 4.5 Integridad de Señal ........................................................................................... 11 4.5.1 Que afecta la integridad de señal y que es. Como afecta fuera y dentro del chip (FPGA?) ............................................................................................................ 11 4.5.2 Terminaciones de Señales......................................................................... 12 4.6 Interfaces Eléctricas .......................................................................................... 12 4.7 Potencia y Consumo de los Circuitos ............................................................... 12 5 Diseño Digital con FPGAs y HDLs.......................................................................... 13 5.1 Metodología General de Diseño Digital ........................................................... 15 5.1.1 Especificación y Diseño............................................................................ 17 5.1.2 Verificación............................................................................................... 18 5.1.3 Pasos Finales............................................................................................. 18 5.2 Diseño Digital Utilizando Lenguajes de Descripción de Hardware ................. 18 5.3 Flujo de Diseño para Lógicas Programables .................................................... 19 5.3.1 Flujo de Diseño (Design Flow)................................................................. 19 5.4 Lenguajes de descripción 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 Descripción del Diseño ............................................................................. 24 5.5.2 Generación o Traducción.......................................................................... 24 5.5.3 Simulación ................................................................................................ 24 5.5.4 Notas Manejo del tiempo en VHDL ......................................................... 24 6 Dispositivos Lógicos Programables.......................................................................... 27 6.1 Evolución de los Primeros Dispositivos Lógicos Programables ...................... 28 ©2005 Guillermo Güichal

Diseño digital utilizando Lógicas Programables

UTN, Facultad Regional Bahía Blanca

6.2 CPLDs............................................................................................................... 31 6.3 FPGAs............................................................................................................... 32 6.3.1 Bloque Lógico 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 Señal ........................................................... 44 6.3.6 CPUs Embebidas ...................................................................................... 46 6.3.7 Matriz de Interconexión............................................................................ 47 6.4 Granularidad de los Dispositivos Lógicos Programables (PLDs) .................... 48 6.5 Tecnología de Configuración 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 Código de Ejemplo ............................................................... 56 7.1.2 Capitalización en VHDL........................................................................... 56 7.1.3 Comentarios en VHDL ............................................................................. 56 7.1.4 Delimitadores de Código en VHDL ......................................................... 56 7.2 Estructura Básicas 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 Símbolos Especiales.................................................................................. 64 7.3.3 Identificadores........................................................................................... 66 7.3.4 Números.................................................................................................... 66 7.3.5 Cadenas de bits ......................................................................................... 66 7.4 Tipos en VHDL................................................................................................. 67 7.4.1 Tipos Comunes ......................................................................................... 67 7.4.2 Declaración 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 Físicos ............................................................................................. 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 Calificación y Conversión de Tipos.......................................................... 72 7.5 Objetos en VHDL ............................................................................................. 73 7.5.1 Constantes ................................................................................................. 73 7.5.2 Señales ...................................................................................................... 73 7.5.3 Variables ................................................................................................... 74

©2005 Guillermo Güichal

......3............1 Declaración de parámetros genéricos ...1 Instrucción WAIT ..................6...........Primitives) ............ 87 7............................................ 79 7...........2........6..4 Expresión case .................................................................. Facultad Regional Bahía Blanca 7....... 82 7......................................................7.....7............4 Expresión when............................ 83 7.........3.....2 Operaciones Concurrentes .....1 Librerías ..............................7..................................... 94 7.............. retardos delta y síntesis ..................6 Máquinas de Estado .......................................................................................................................... 114 8..1 Flujo de datos..............1 Procedimientos.....................1 Introducción .................... 124 8.........................2.............................................................................7......3..........1 Codificación de Estados. 101 8..........2 Librerías de Primitivas (componentes) Específicos para Simulación................................... 113 8.................................................. 101 8...3....... 135 9..... 92 7..........................................7........................Diseño digital utilizando Lógicas Programables UTN...................... 101 8...................... 104 8......... 101 8........................................................7.............. 75 7..... 125 8.. 129 8.... 108 8..........................6............................ 81 7............................................2 Funciones ........5......................... 75 7...............................2 Parámetros Genéricos ...........2.2 Expresión if… elsif… else............7.............................................. 88 7........................................6...........1 Vectores de prueba.6..2 Bancos de Prueba...7......................................................................................................3.................3 Asociación de parámetros por posición y por nombre.... 133 8..6......4 Instrucción GENERATE ........7...............................1 Declaración de señales....4 Aritmética sobre lógica estándar..................2.....................................................................................2 División de la Señal de Reloj (Clock Enable) ............................3 Subprogramas: FUNCTION y PROCEDURE ................4 Operaciones secuenciales.................................................... else ........... 98 7......... 78 7......... 77 7...............7 Construcciones Básicas de VHDL...................... 108 8................4 Definición de Nuevos Componentes de Diseño ................. 135 9...........................................................................3.........................3 Expresión with … select .....................................................................3............................ 135 9............ 88 7..............2 Detección de flancos de señales definidos en std_logic_1164 ............ 85 7..2........................... 79 7.......3........................ 134 9 VHDL para Simulación y Verificación .......6...............................................................3 Memoria.............................................................7...........................5 Visibilidad de las declaraciones de objetos en VHDL....... 90 7..........................................................2 Uso de componentes con parámetros genéricos ...... 114 8......................2 Paquetes (Packages)....... 113 8..7......5 Procesos (process)...............3 Paquetes de Lógica Estándar del IEEE................2.......7........................... 75 7................................... 116 Inferencia de Memorias ........................... 111 8..............................2.......7............. 99 8 Más VHDL......1 Lógica estándar std_logic y std_ulogic definidos en std_logic_1164 ........................................6...............................3................................................6 Librerías y Paquetes............1 Introducción .3.....................................5.............3 Operaciones secuenciales...................1 Utilización de Primitivas desde VHDL ................... 136 ©2005 Guillermo Güichal ........... 118 Instancia de Memorias ...................7............ 86 7............ 92 7....................................................................................................................................................5.................................................5 Componentes Básicos de Diseño (Primitivas .......... 116 8.............3 Expresión null ..........................................................................................5..........................2 Palabra reservada AFTER............................................................ 83 7..............

............................4 Estructuras Recomendadas para Diseños Sintetizables .................................2 Diseño de un Banco de Pruebas................................... 162 11................ 153 10.................5...............................................................................................3..... 153 10.....................................4 Manejo Básico de ModelSim................... 166 14.................4................1 Manejo Básico de Xilinx Project Manager.......................5................................2 Manejo Básico de Altera Quartus II ...........................................Diseño digital utilizando Lógicas Programables UTN..............................2.................3.................... 159 11 SoCs..............4............................... 146 9..................................................................................................3 VHDL (Generalmente) No Sintetizable............... 166 14..........3..........................2.......................3 Diseño para Verificación (Design For Test)...................2 División de la Frecuencia Mediante Habilitación del Reloj .....................1 Generación de Señal de Reloj ............... 169 ©2005 Guillermo Güichal ........................................... 162 11...................... 156 10................4........5 Ejemplos de Componentes para Bancos de Prueba ...... 137 9..........................................4 Reutilización de Propiedad Intelectual .........4.......... 136 9................................4 etc... 153 10....................................................................................4.................. 153 10........................ 163 12.......................................................................... Cores y Propiedad Intelectual................... 156 10.2 Procesos sincrónicos .......... 166 14.... 163 12.......................................... 163 12.................................................................................................................1 Estructuras de Decisión Jerárquicas y Concurrentes (IF vs........................... 147 9..4 Palabra reservada ALIAS ................................... 163 12...............................4.....2 Función NOW................................................ NEXT y EXIT.............4 Que Falta sobre VHDL… ....................................................................... 145 9.4 Programación para Diseños Sintetizables.... 139 9...................................................... 152 10 Buenas Prácticas de Diseño ............ 165 13... 142 9................ 162 12 Notas Sobre Síntesis con FPGAs.............2 Diseño y Optimización Para Síntesis............3..................................................................2 Presentación de un Core........ CASE) ................................................... 166 14.................. 163 12................................. 163 12..................2............... 163 12..................5.........3..................... 163 12.......3 Manejo de Archivos y Paquete TEXTIO....................................................................................5 Guía de Estilo Para un Buen Diseño de Hardware ...........................3 Temporizado de la Interfase de un Bus de Microcontrolador................................1 Introducción ..........................................3 Manejo Básico de Actel Libero (o la que sea gratuita)........................ 156 10...............3...3...........................................................3 Formato Edif ........ 167 15 Referencias.... 148 9................. 163 12.......... 162 11................................................ 163 12...................................................3 etc...............3................................................................................. 163 13 Notas sobre Verificación.........................................5 etc............ 162 11.....................................................................3.....3............1 Uso del WAIT y AFTER ....................2 Instrucciones ASSERT y REPORT ........................2........................................................5 Ejemplos de estructuras sintetizadas.........................................................1 Instrucciones de lazo FOR................ WHILE y LOOP............3 Guía de estilo para el código HDL .............. 146 9.................................................. 138 9......................1 Introducción . 139 9.........1 Introducción ....1 Introducción ........ 165 14 Uso de las Herramientas ................................................................. 143 9.........................................2 Documentación ...............................3 Manejo de tiempo en simulaciones usando VHDL ................4.................................. Facultad Regional Bahía Blanca 9...1 Diferencias entre Síntesis y Simulación .........2 Generación de una Señal de Reset . 137 9.........

.............................................................................................................8 etc............................................................................................................................................................ ......................................6............................1 Interfase Mouse........... 172 16........................................ 172 16..................................................................................................................................................................... 171 16 Ejemplos .......... 169 15..................................................................................................................................................................................................................................................................................................... 172 ©2005 Guillermo Güichal .... 170 15......................Diseño digital utilizando Lógicas Programables UTN......................................................................................................................... 172 16....................................... 170 Bibliografía ................................................................................................................................................. 170 15.............6 .......................................... 172 16...........................................................2........................5 Síntesis ........... 172 16.............................................................3 VHDL .........4 Divisor Reloj......................................2 Diseño Digital con PLDs ........................................................... 171 Links de Interés (síntesis) .........................1 Dispositivos Lógicos Programables...............5 Control display 7 segmentos........... 172 16...................................................................................................................................................................................................................... 170 Links de Interés....................... otros ejemplos de laboratorios hechos en clase...................... 172 16. 170 Links de Interés.... 169 Bibliografía .......................... 171 Bibliografía .................... 172 16.........1 Ejemplos de Lógica Combinacional ...................7 Ejemplo Completo: UART .....................................................................................................2 Controlador VGA..................................................................................... 171 15...............3 Ejemplos de Lógica Secuencial .................. 172 16.......... 170 Bibliografía ................ etc .................................. 171 Bibliografía ....... 169 Links de Interés..... Facultad Regional Bahía Blanca 15................................................6.................. 172 16........................................................................4 Buenas Prácticas de Diseño ..........................

Se que hay secciones que pueden no estar muy claras.E.ar) leyó la primer versión y me dio mucha realimentación para mejorar estas notas.invap. del Instituto Nacional de Tecnología Industrial de Argentina (INTI . (www. agregué algunos comentarios a la sección de VHDL no sintetizable (que en muchos casos sí es sintetizable) y cambié algunos ejemplos que eran muy específicos de Xilinx. Facultad Regional Bahía Blanca 1 Agradecimientos Con la versión 0. Gracias a esas sugerencias y sus ejemplos reescribí la sección sobre memorias.www. Salvador Eduardo Tropea.ar) me dio algunas sugerencias y me hizo notar algunos puntos que podían mejorarse.inti. ©2003 Guillermo Güichal 7 .Diseño digital utilizando FPGAs UTN. Me gustaría aprovechar entonces para agregar esta sección y agradecerles su ayuda.gov. pero traté de seguir sus sugerencias para que todo sea mas entendible.com.6 llega el aporte de algunos colaboradores. Julio Amoedo de Invap S.

Facultad Regional Bahía Blanca 2 Versiones Ver 0.5 (27/06/2005) Publicación inicial en www.Diseño digital utilizando FPGAs UTN.ar Ver 0.com.6 (29/06/2005) Sección de Agradecimientos y Versiones. Fuentes en las figuras y tablas de terceros Cambios en la implementación de máquinas de estado (no se si aclaran algo o no:) Cambios en la descripción de memorias y su uso en VHDL Algunas notas sobre VHDL sintetizable y no sintetizable Cambios en la sección sobre primitivas Traté de usar términos aceptados en castellano en vez de mis "castellanizaciones" Varias correcciones y cambios menores ©2003 Guillermo Güichal 8 .fpga.

En el futuro se completará una sección introductoria con un repaso de temas de diseño. etc. Se trata de enseñar a través de ejemplos funcionales. Esto debe tenerse en cuenta especialmente en las secciones sobre VHDL.digilentinc. Este libro. En las secciones sobre VHDL. Los ejemplos de aplicaciones fueron desarrollados para la placa de desarrollo D2E. leds. y en los ejemplos en donde se presenten dispositivos específicos. Para el lector que no está familiarizado con ningún ambiente de desarrollo de software también se da una lista de los documentos y manuales de Xilinx que permitirán que se entienda rápidamente el uso de las herramientas de desarrollo. Para el que necesita estudiar los conceptos básicos de diseño digital se recomienda el libro de John F. Esto se intenta hacer limitando el contenido y focalizándolo sobre aplicaciones y ejemplos para diseños sintetizables sobre FPGAs. sino presentar el material que permitirá comenzar a trabajar lo más rápido posible.com). DIO1 y DIO2 de Digilent. además. se utilizarán herramientas y dispositivos de Xilinx. Las otras placas se conectan a la D2E y contienen periféricos. tecnologías y técnicas digitales. conectores PS2 y VGA. En las secciones generales. Inc (www. Un estudiante debería poder comenzar a hacer diseños bastante complejos sobre FPGAs solo copiando y modificando el código presentado en los apéndices y ejemplos. Algunas características y limitaciones que deben tenerse en cuenta al leer estas notas son las siguientes: • Las notas están principalmente orientadas a síntesis de diseños digitales sobre FPGAs. se intentan presentar dispositivos y herramientas de varios fabricantes para que el lector tenga una visión más amplia de las alternativas existentes. La intención no es hacer un tratamiento exhaustivo y completo de este tema. Facultad Regional Bahía Blanca 3 Introducción Estas notas son una introducción al diseño digital utilizando lógicas programables y lenguajes de descripción de hardware. en las secciones o ejemplos que utilicen o presenten herramientas de desarrollo. Además se supone que el lector conoce algún lenguaje de programación y esta familiarizado con la utilización de herramientas de desarrollo de software. Se tratan de presentar los temas con ejemplos que permitan la rápida utilización y aprendizaje. sin realmente tener una base demasiado formal sobre PLDs y VHDL. Por ese motivo. tales como botones. sin embrago. Wakerly detallado al final de esta sección. en muchos casos no se presentará formalmente el uso de • • ©2003 Guillermo Güichal 9 .Diseño digital utilizando FPGAs UTN. display. La placa D2E contiene una FPGA Spartan IIe 200 y varios conectores. contiene una excelente introducción a los dispositivos lógicos programables. que puedan usarse como plantillas bases para un diseño o que puedan copiarse directamente. Se espera que el lector de estas notas tenga una base de diseño digital. ya que los temas tratados y los ejemplos presentados se limitan a ese uso del lenguaje.

en muchos casos se presentan ejemplos que utilizan construcciones antes de haberlas explicado formalmente. y seguramente contiene errores.fpga.Diseño digital utilizando FPGAs UTN. Al no presentar el lenguaje VHDL con todas sus reglas y posibilidades. esto no debería presentar problemas.com. operación o construcción. Por favor hacer llegar cualquier duda. omisiones o temas que pueden presentarse de una manera más didáctica.ar. ©2003 Guillermo Güichal 10 . Esta es la primera versión de estas notas. Facultad Regional Bahía Blanca • • una instrucción. comentario o crítica que ayude a mejorarlas en el foro o wiki del sitio www. Se pone bastante énfasis en las formalidades y guías que deberían existir al escribir código (ya sea en un lenguaje de descripción de hardware o cualquier otro lenguaje de programación). Se presentan los ejemplos con un formato estándar que se describe en las notas. sino que se darán ejemplos que muestran su utilización. Como se espera que el lector tenga una base de diseño digital y programación.

mismatched traces. ©2003 Guillermo Güichal 11 .3 Codificación de estados. Grey. 4.2 Diseño Secuencial Asincrónico y Sincrónico 4.5.1 Diseño Combinacional y Secuencial 4. Package-level issues include high package inductance.1 Máquinas de Mealy 4.1 Temporizado y Utilización de Registros 4.4.1 Flip-Flops y Latches 4. 4.3 Algunas Notas sobre Diseño Secuencial Sincrónico 4. Mínima.3.1 Que afecta la integridad de señal y que es. reflections.3. Chip-level concerns include improper I/O buffer design and inadequate return-current paths.5 Dominios de Reloj 4.3 Máxima Frecuencia de Trabajo 4.4.4.3.3.1. improper routing and inadequate return-current paths.4 Autómatas de Estados Finitos (Máquinas de estados finitos) 4.2 Distribución de Reloj 4. One-hot.3.5 Integridad de Señal 4. etc. while board-level issues include crosstalk. Facultad Regional Bahía Blanca 4 Temas Básicos de Diseño Digital COMPLETAR CON ALGUNAS NOTAS SOBRE DISEÑO DIGITAL PARA PODER METER LAS FPGAS y HDLs EN CONTEXTO.Diseño digital utilizando FPGAs UTN. Como afecta fuera y dentro del chip (FPGA?) Ver nota Altera de PLD design line.4 Pipelines 4. signal attenuation and EMI/EMC. One-cold.3.2 Máquinas de Moore 4.6 Metaestabilidad en los Flip-Flops 4.

. Hay que analizar los requerimientos de la aplicación para ver si la potencia es una limitación y/o diseñar las fuentes de alimentación (aplicaciones móviles con baterías.7 Potencia y Consumo de los Circuitos Puede ser importante. Las FPGA tienen grandes cantidades de entradas salidas que pueden requerir mucha corriente. 4. etc.5.2 Terminaciones de Señales Usar terminaciones para evitar rebotes en diseños de alta velocidad. Flancos lentos y rápidos. ©2003 Guillermo Güichal 12 .). Terminaciones internas en las FPGAs.6 Interfaces Eléctricas Estándares de interfase posibles con las FPGAs actuales. etc. 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.Diseño digital utilizando FPGAs UTN. Potencia estática vs dinámica. 4. Facultad Regional Bahía Blanca 4. Dificultoso de calcular para las FPGA. Hay herramientas que analizan y calculan. Resistencias de pull-up/down internas.

La experiencia y conocimientos sobre el problema.Diseño digital utilizando FPGAs UTN. Figura 1 Esquema del proceso de diseño de un sistema complejo ©2003 Guillermo Güichal 13 . Facultad Regional Bahía Blanca 5 Diseño Digital con FPGAs y HDLs Para poder atacar un problema complejo (sistema) la mejor manera que tenemos es dividirlo. Este es el camino que generalmente usamos para diseñar un sistema digital. Las decisiones que se tomen al principio para dividir el problema pueden afectar el resultado final. las posibles soluciones y la tecnologías disponibles ayudarán a que la decisión que se tome sea la mas acertada. En algunos casos debemos volver al principio y replantear la arquitectura después de haber resuelto el problema. Este proceso se esquematiza en la Figura 1. De esta manera se pueden atacar problemas de menor complejidad y mas fáciles de analizar.

©2003 Guillermo Güichal 14 . los siguientes pasos se siguen en cada nivel de la jerarquía del diseño. Figura 2 Diagrama de Gajski . Especificación . no todos ellos digitales o electrónicos. A partir de la especificación se puede definir una arquitectura con los diferentes componentes que implementan cada función del sistema. estructural y físico. Un sistema digital y sus componentes pueden definirse a distintos niveles de abstracción y en tres dominios diferentes: Comportamiento.Diseño lógico . La primer decisión será entonces que partes del sistema se implementarán como subsistemas digitales.Diseño digital utilizando FPGAs UTN. En el sistema digital.Layout (disposición y conexionado) La especificación es muy importante pare definir bien los límites de lo que se quiere fabricar. En la Figura 2 se muestra el diagrama "Y" de Gajski y Kahn que representa los niveles de abstracción y dominios para un circuito. cada vez con mayor nivel de detalle.Arquitectura . Para el diseño se debe definir el funcionamiento de cada uno de esos componentes.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 señales internas. Facultad Regional Bahía Blanca Un sistema puede estar compuesto por varios subsistemas.

la "Metodología Universal de Diseño" define pasos que permiten: ©2003 Guillermo Güichal 15 . Si se diseña un integrado digital con bloques predefinidos (IP. gran parte del aspecto físico ha sido solucionado por el fabricante. sin mayores detalles de implementación. Dominio Físico: Describe la implementación física del sistema (plano). pueden utilizarse en varios pasos del proceso de desarrollo. Como ejemplo. Nivel Registros: Describe la estructura como la interconexión de registros y lógica de interconexión. RTL). incluso en localidades separadas. Desafortunadamente. Las grandes capacidades de los PLDs y herramientas de diseño disponibles permiten que los diseños implementados sobre FPGAs sean cada vez mas complejos.Diseño digital utilizando FPGAs UTN. En general se trabaja al nivel de transferencia de registros con algunas herramientas que ayudan a diseñar a niveles de algoritmo. Facultad Regional Bahía Blanca Nivel RTL: Describe el comportamiento de todas las señales (entradas. Según su autor (ver Referencias). lo ideal sería poder trabajar al máximo nivel de abstracción posible (algoritmos). esto no es siempre posible con la tecnología existente (pero esta cambia permanentemente). en la Figura 3 se muestra un esquema de un método que permite ordenar el trabajo de diseño. no solo para diseñar sino también para especificar y documentar el sistema que se quiere desarrollar. al nivel de transistores y haciendo el layout manual. Los lenguajes de descripción de hardware. sin entrar en los detalles de bajo nivel. Cores) y adquiridos a terceros se trabajará a un nivel de abstracción mucho mayor (floorplanning. A medida que los diseños se hacen más complejos. ASICs o PCBs) es importante tener una metodología de trabajo que permita planificar y ordenar el trabajo. Para poder atacar el problema del diseño de sistemas digitales complejos (ya sea para desarrollos sobre FPGAs. Si se debe diseñar un integrado full-custom analógico es probable que se trabaje al nivel de ecuaciones diferenciales. Para lograr tiempo más rápidos de diseño. y mayor productividad. El nivel de abstracción dependerá entonces de la aplicación y restricciones sobre el diseño. En muchos casos varias personas pueden estar trabajando sobre el mismo producto. menos errores. 5.1 Metodología General de Diseño Digital Al desarrollar cualquier sistema digital es importante seguir ciertas pautas de trabajo y tener en cuenta factores muy diversos para que el diseño pueda terminarse a tiempo y funcione correctamente. internas y salidas) en el tiempo (para cada ciclo de reloj en sistemas sincrónicos) Dominio Estructural: Describe al sistema como una interconexión de componentes (esquemático) Nivel P-M-S (Processor Memory Switch): Describe la estructura como la interconexión de elementos de procesamiento. En el ciclo de diseño con FPGAs. memoria e interconexión. si se utilizan correctamente. la necesidad de seguir un método ordenado para lograr buenos resultados se hace más importante.

se debe volver a iterar sobre los pasos anteriores para corregirlos. Figura 3 .Diseño digital utilizando FPGAs • • • UTN. Si se descubren fallas o problemas en las especificaciones. crear un cronograma razonable y asignar los recursos necesarios para las diferentes tareas de manera ordenada. Estos requerimientos pueden venir de un cliente. Planificar el diseño de manera eficiente. Facultad Regional Bahía Blanca Diseñar un dispositivo libre de defectos de manufactura. En muchos casos el proceso es no lineal.Metodología Universal de Diseño ©2003 Guillermo Güichal 16 . 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. Diseñar el dispositivo de manera eficiente. El ciclo comienza con un conjunto de requerimientos para la fabricación de un dispositivo o sistema. sin malgastar recursos ni tiempo. que funciona de manera adecuada y se integra con el sistema.

Facultad Regional Bahía Blanca 5. Tamaño. De esta revisión podrán surgir cosas que no se tuvieron en cuenta individualmente y que produzcan modificaciones. e incluye varios pasos intermedios. Las personas que forman parte de un proyecto incluyen no solo a los desarrolladores. Estimación de la complejidad y/o magnitud del dispositivo. ©2003 Guillermo Güichal 17 . las bases sobre las que trabajar en un diseño quedan preestablecidas y se minimizan los errores por diferencias de apreciación o entendimiento entre los participantes. Las especificaciones deberían describir la solución de manera de cumplir con los requerimientos que se piden para el dispositivo. Una vez que se escribe la especificación se puede utilizar para seleccionar componentes y tecnologías que se utilizarán para el proyecto. que muestra como y donde encaja el dispositivo dentro del sistema completo. Procedimientos de verificación y validación para el dispositivo.1 Especificación y Diseño Una especificación permite que todas las personas involucradas en un proyecto comprendan cual es el dispositivo que se va a desarrollar. incluyendo tiempos de "setup" y "hold" para las entradas/salidas y frecuencias de reloj. eléctricas y protocolos de comunicación. Especificación física del dispositivo. que se modifica de acuerdo en los cambios de requerimientos y a medida que se tiene más información sobre el proyecto. empaquetamiento.1. etc. El diseño deberá hacerse siguiendo métodos aceptados y confiables. dado en número de compuertas equivalentes o número de circuitos integrados necesarios. incluyendo interfaces lógicas. gerencia. Al haber una especificación formal. etc. Estimación del consumo de potencia del dispositivo. La especificación es un documento activo. sino también a clientes. El proceso de diseño es en general un ciclo. La especificación también incluye la metodología de verificación del dispositivo. Una especificación debería comprender los siguientes puntos: • • • • • • • • • Diagrama en bloques del sistema externo. Estimaciones de tiempos que se deben cumplir.Diseño digital utilizando FPGAs UTN. personal de otras áreas de la empresa. Diagrama en bloques interno que muestra los principales bloques funcionales. Descripción de las entradas/salidas. Precio estimado del dispositivo. Después de escribir las especificaciones es importante hacer una revisión con todos los miembros del equipo. Estas muchas veces se dejan para el final del proyecto y no se definen ni llevan a cabo de manera adecuada. conectores.

2 Verificación La verificación engloba varios pasos menores. En este paso se deben también evaluar los tiempos.1. Los modelos de hardware usando HDLs pueden ser estructurales. pero en general sigue los siguientes pasos: • Simulación: es en general un proceso continuo. A nivel de comportamiento de hardware se describe la respuesta entrada/salida de un componente. El comportamiento de un sistema puede modelarse a ©2003 Guillermo Güichal 18 . ya que al simular se pueden encontrar problemas que hacen volver sobre el diseño y hacer cambios. cualquier modificación que surja de esta integración será en general pequeña y no requerirá grandes cambios.Diseño digital utilizando FPGAs UTN. Se verifica que el dispositivo está listo para ser entregado o integrado al sistema. • • • 5.3 Pasos Finales Si todos los pasos se siguieron correctamente la revisión final debería ser solo una formalidad. Se debe llevar a cabo una simulación funcional. 5. Esto hace que todo el proceso de desarrollo de un sistema digital sea mucho más simple y rápido en comparación con metodologías clásicas (desarrollo con discretos sobre PCBs o el diseño de circuitos integrados). La integración y verificación en el contexto del sistema general es muy importante. A nivel estructural se describe la interconexión y jerarquía entre componentes. Revisión: En este paso se revisan los resultados de la simulación y se analiza el comportamiento del dispositivo. Cualquier problema o falla que se encuentre debe ser documentarse y analizada para poder corregirla en una próxima versión del dispositivo y evitarla en el futuro. La utilización de HDLs para sintetizar sistemas digitales y la utilización de PLDs permiten crear prototipos funcionales en plazos relativamente cortos. pero también puede incluir simulaciones de temporizado. Implementación Física: Una vez que se ha aceptado el diseño se lleva a cabo la implementación física final del dispositivo. de comportamiento o una mezcla de estos dos. Facultad Regional Bahía Blanca 5. Las simulaciones se hacen sobre pequeñas partes del sistema y sobre el sistema completo. Dependiendo del dispositivo y tecnología utilizada.2 Diseño Digital Utilizando Lenguajes de Descripción de Hardware Los lenguajes de descripción de hardware (HDLs) permiten modelar sistemas digitales completos. Si los pasos se siguieron correctamente. consumo de potencia y cualquier otro parámetro de importancia. Es importante que participen ingenieros externos al proyecto y personas que conozcan el sistema en su totalidad. consumo de potencia y otros parámetros.1. Mediante diferentes herramientas de software estos modelos pueden luego sintetizarse para implementarlos como circuitos reales. y al revisar pueden surgir cosas que obligan a volver atrás hacia pasos anteriores. Verificación Formal: En este paso se verifica la implementación física para asegurarse que su funcionamiento coincide con las simulaciones hechas anteriormente.

pero se recomienda ©2003 Guillermo Güichal 19 . Estas herramientas simplifican en gran medida el diseño y simplifican mucho la tarea del diseñador. no todas las construcciones posibles de los lenguajes de descripción de hardware pueden sintetizarse y transformarse en circuitos.). una representación gráfica de una máquina de estados o una tabla de entrada-salida.1 Flujo de Diseño (Design Flow) Durante el proceso de creación de un sistema digital desde el código fuente (esquemáticos. VHDL. etc. En general el diseñador debe seguir ciertas pautas de modelado. cualquiera sea el método usado para diseñar el circuito (HDLs. nivel de transferencia de registros. etc. La Figura 4 muestra el ciclo de diseño típico para lógicas programables.) a la implementación en un PLD hay varios pasos intermedios. A este proceso se lo denomina ciclo o flujo de diseño. El tipo de modelo más usado para síntesis es el denominado RTL (Register Transfer Level). Esto es aún más importante para lograr implementaciones óptimas sobre la arquitectura para la que se está diseñando el circuito. este ciclo puede tener variaciones o las tareas llamarse con otros nombres. muchas veces usando un lenguaje de descripción de hardware como el VHDL. pero en general lo hacen llevando el diseño a un nivel de descripción como RTL antes de sintetizarlo.3 Flujo de Diseño para Lógicas Programables Cuando se diseña con lógicas programables. ya que estos son los términos que se encontrarán en las herramientas de desarrollo. La utilización de HDLs para síntesis puede tener como objetivo la creación de un circuito integrado de propósito específico (ASIC) o la implementación del circuito en alguna lógica programable (PLD). 5. Esto puede deberse a las limitaciones de las herramientas utilizadas o a que el circuito descrito por el modelo VHDL no puede implementarse físicamente. Dependiendo de las herramientas utilizadas. Muchas herramientas permiten ingresar el diseño no solo como HDLs sino también como un diagrama esquemático o estructural. para que el modelo pueda sintetizarse. Existen herramientas que permiten sintetizar circuitos a partir de modelos de abstracción más elevados. o de nivel de transferencia de registros.Diseño digital utilizando FPGAs UTN. En muchos casos las herramientas utilizadas en cada paso del diseño son provistas por diferentes empresas. Para cada uno de estos pasos se utilizan herramientas de software diferentes que pueden o no estar integradas bajo un ambiente de desarrollo. Se agrega su denominación en inglés entre paréntesis.3. Independientemente del objetivo. esquemáticos. nivel de compuertas. Facultad Regional Bahía Blanca distintos niveles de abstracción o detalle: algoritmos y comportamiento general. El código HDL puede ingresarse utilizando cualquier editor de texto. • Descripción del Diseño: este es el paso en el que se describe el diseño. el proceso desde la definición del circuito por el desarrollador hasta tenerlo funcionando sobre un PLD implica varios pasos intermedios y en general utiliza una variedad de herramientas. etc. que dependerán de su objetivo y de las herramientas que utiliza. 5. A continuación se describe cada uno de los pasos del ciclo de diseño.

En este paso se traducen todos los módulos a VHDL. Para los módulos ingresados como VHDL. También se hace una ©2003 Guillermo Güichal 20 .Flujo de diseño para lógicas programables • Generación o Traducción (Generate. En esta etapa se hace un análisis del VHDL para verificar la sintaxis y semántica de los módulos. las herramientas generalmente hacen una copia a una librería interna.Diseño digital utilizando FPGAs UTN. Translate): Este paso tiene sentido cuando el diseño se hace mediante algunas de los métodos mencionados anteriormente en vez de en VHDL. Figura 4 . Facultad Regional Bahía Blanca uno que tenga coloreado automático de sintaxis ("syntax highlighting") ya que ayuda y hace más fácil esta etapa.

como se presentó en las secciones anteriores. Una vez sintetizado el diseño. En este paso. cada componente del diseño sintetizado se ubica dentro del PLD específico. seleccionar áreas del PLD para ubicar los bloques lógicos. Esta traducción puede llegar hasta el nivel más básico de elementos lógicos (CLBs. Generación de Binarios: Después de la Ubicación e Interconexión se genera algún archivo ya sea para poder utilizar el sistema en un diseño mas complejo o para programar un PLD. La primera es sobre el código VHDL original para verificar el correcto funcionamiento del diseño. La segunda es después de sintetizar el circuito. Simulación y verificación: En este paso se simula el comportamiento del diseño y se evalúa su comportamiento. LUTs. Anotación de Retardos: Como en todo circuito digital. puede hacerse una estimación de los retardos de propagación que habrá entre las señales. etc. La tercer etapa en la cual se puede simular el diseño es después de la Ubicación e Interconexión. Después de la ubicación e interconexión. Con estos retardos puede anotarse el diseño compilado para una simulación que incluya información de temporizado mas cercana a la implementación real. ya que incluye la información final lógica y temporal el diseño sobre el PLD. Puede definirse la interconexión de las con los pines físicos del PLD ingresar condiciones de entorno físico para guiar a la herramienta de Ubicación e Interconexión. Esta es la más exacta y la mas engorrosa y lenta. Síntesis (Synthesis): En este paso se traduce el VHDL original a su implementación con lógica digital. ya sea con o sin la anotación de tiempos. Estas opciones dependerán de las herramientas y del PLD que se esté utilizando.Diseño digital utilizando FPGAs UTN. FFs) o hasta un nivel superior. el cálculo de retardos es mucho mas exacto. Esto se hace en este paso. También se interconectan los componentes entre sí y con los pines de entradasalida. en el que el diseño se presenta en módulos básicos estándar provistos en una librería por el proveedor del PLD. Programación de Memoria (PROM): Muchas FPGA no pueden configurarse de manera permanente y requieren algún tipo de memoria para leer la configuración ©2003 Guillermo Güichal 21 . La simulación puede hacerse en tres etapas diferentes del diseño. Compilado (Compile): Los simuladores actuales compilan el código VHDL a un formato que permite una simulación mas rápida y eficaz. que consiste en replicar los componentes que se utilizan más de una vez en el diseño para hacer copias únicas y definir un conexionado adecuado. Ubicación e Interconexión (Place and Route): El PLD está compuesto por muchos bloques idénticos. Tareas Adicionales: Las tareas adicionales dependen del fabricante y las herramientas. Facultad Regional Bahía Blanca • • • • • • • • • elaboración de los archivos. y se simulan la implementación real sobre el PLD. las señales tendrán un retardo de propagación que influirá sobre su comportamiento. utilizando los componentes específicos del PLD que va a utilizarse. Configuración de PLD: Con el archivo binario generado puede configurarse directamente un PLD a través de alguna de las opciones de configuración.

y no escribiendo software. hay muchas tareas que suceden de manera concurrente y la variable tiempo juega un papel predominante. o el no cumplir con los tiempos de establecimiento de un circuito puede cambiar de manera radical el comportamiento de un sistema electrónico digital. En la etapa de producción deben configurarse memorias PROM y conectarlas a la FPGA en el circuito impreso. Los efectos de una instrucción dependen exclusivamente de los efectos de las instrucciones anteriores. Después de simularlo o configurar un PLD. desde los más básicos hasta el nivel superior que describe el sistema completo. desarrollados por los distintos proveedores de herramientas o PLD. una CPU ejecutará cada instrucción después de la anterior. de acuerdo a las ©2003 Guillermo Güichal 22 . Utilizando un conjunto de instrucciones secuenciales puede modelarse el comportamiento de un sistema digital y controlar la variable tiempo en los modelos. sin embargo. De los demás lenguajes. se definen de manera precisa las interfases de cada componente de un sistema y sus interconexiones. dos predominan actualmente el mundo del desarrollo de hardware digital: Verilog y VHDL. En una descripción estructural. Para poder describir los procesos concurrentes que caracterizan un sistema de hardware. es importante recordar que se está modelando hardware. Verificación (automática): Una vez integrada la FPGA con su programación al sistema debe hacerse una verificación para controlar que el diseño 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á. En la figura. los sistemas digitales pueden describirse de diferentes maneras. Usando HDLs. Estos modelos pueden ir desde el nivel abstracto de un algoritmo o el comportamiento general de un circuito hasta un modelo al nivel de interconexión compuertas lógicas. Al utilizar un HDL para modelar un sistema. Aunque hay muchos lenguajes de descripción de hardware.Diseño digital utilizando FPGAs UTN. Así se arma un jerarquía de componentes. En la actualidad casi todos los fabricantes de PLD y proveedores de herramientas de desarrollo proveen soporte para VHDL y Verilog. 5. Facultad Regional Bahía Blanca • cuando se les aplica tensión de alimentación. En la actualidad están surgiendo nuevos lenguajes que incorporan mayores facilidades y prestaciones. Un cambio en el tiempo de propagación de una compuerta. Los HDLs también permiten describir el comportamiento de los componentes. Pueden usarse técnicas y herramientas de verificación automáticas para evaluar si el dispositivo y el diseño están funcionando como debieran.4 Lenguajes de descripción de hardware Los lenguajes de descripción de hardware (HDLs) permiten modelar sistemas digitales completos. el retardo de una traza en una plaqueta. las flechas de líneas punteadas que vuelven al comienzo indican las iteraciones que muchas veces se dan al trabajar en un diseño nuevo. Para poder modelar hardware los HDLs permiten describir la concurrencia y paralelismo que se observa en un sistema de hardware (muchas cosas y muchas señales cambian al mismo tiempo). El software se caracteriza por ser de secuencial. En el hardware. pueden descubrirse fallas o haber cambios de requerimientos que obligan al diseñador a volver y modificar la descripción del diseño. muchos son propietarios.

El lenguaje se estandarizó mediante el estándar 1076 del IEEE en 1987 (VHDL-87).Diseño digital utilizando FPGAs UTN. 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. Muchos vendedores de FPGAs proveen herramientas o "toolboxes" que se integran a lenguajes de modelado como Matlab y Simulink. Un lenguaje de estas características permitiría describir los circuitos para su documentación y además modelarlos y evaluarlos mediante simulaciones antes de incurrir en los grandes gastos de fabricación. Sus orígenes datan de la década de 1980. VHDL se utiliza no solo para modelar circuitos electrónicos sino también para crear. son los mas utilizados para la síntesis automática de hardware.4. VHDL y Verilog.2 Verilog El lenguaje Verilog fue desarrollado por Gateway Design Automation en 1984. Una vez probado un algoritmo con estas herramientas se genera de manera automática el hardware necesario para implementarlo. O sea que VHDL significa lenguaje de descripción de hardware para circuitos integrados de alta velocidad. En 1988 Synposis presentó la primera herramienta de síntesis basada en Verilog. Facultad Regional Bahía Blanca nuevas tecnologías y necesidades de los desarrolladores.4. El VHDL nació entonces como un lenguaje de modelado y documentación de sistemas electrónicos digitales. Mientras que la sintaxis del VHDL es parecido a los lenguajes de programación Ada y Pascal. Más tarde Cadence Design Systems adquirió Gateway Design Automation y luego “abrió” el lenguaje para que otros proveedores pudieran desarrollar herramientas de simulación y síntesis utilizando Verilog. 5. ©2003 Guillermo Güichal 23 . La capacidad de sintetizar circuitos a partir de los modelos en VHDL (u otro lenguaje de descripción de hardware) surgió después de la creación del lenguaje. En la actualidad.1 VHDL Las siglas VHDL provienen de “VHSIC Hardware Description Lenguaje” y a su vez VHSIC quiere decir “Very High Speed Integrated Circuit”. A continuación se presenta una breve introducción a cada lenguaje 5. Hay mucho esfuerzo de investigación y desarrollo (e incluso algunas herramientas comerciales) que aceptan la descripción de algoritmos en otros lenguajes con un mayor nivel de abstracción. Una de las líneas de desarrollo principales es la de poder describir los sistemas con un nivel de abstracción mayor al RTL en un único lenguaje Después se especificarían las restricciones necesarias para los resultados y las herramientas decidirían que parte conviene implementar en hardware y que partes en software.4. el Verilog proviene del C y tiene una sintaxis mas parecida a este. o sintetizar. con la aparición de herramientas que traducen los modelos VHDL a circuitos reales. Este estándar fue extendido y modificado en 1993 (VHDL-93) y 2002 (VHDL-2002). nuevos circuitos. En 1995 el lenguaje Verilog se transformó en un estándar del IEEE.3 Otros En la actualidad los dos lenguajes mencionados. 5.

Diferentes niveles. Este retardo delta es un micro-paso de simulación que se utiliza cuando no se especifica un retardo en la asignación del valor de una señal. etc. Facultad Regional Bahía Blanca En general todas las herramientas actuales. mediante instrucciones secuenciales. En la descripción que sigue se mencionan de manera general algunas características de VHDL. Interfases gráficas. Es decir.5. El paso de simulación estará dado por el tiempo especificado en el código para cambios en las señales o por un factor denominado retardo delta ("delta delay"). a un lenguaje de descripción de hardware.Diseño digital utilizando FPGAs UTN.5. tales como representaciones gráficas de máquinas de estado o diagramas esquemáticos. Los lenguajes de descripción de hardware modelan o describen. Simular esto tiene su complejidad. es decir. Aunque todavía no se ha presentado ninguna característica específica del lenguaje. A continuación se describen algunas características de estas herramientas para los distintos pasos del ciclo de diseño.1 Descripción del Diseño En la creación de fuentes se usan diferentes herramientas para facilitar el diseño. Algunas herramientas comunes: Estas herramientas incluyen: Modelos de comportamiento.3 Simulación La simulación de un sistema descrito de modelos en HDL merece algunos comentarios. 5. aunque permiten describir o modelar los sistemas con un lenguaje mas abstracto que el RTL terminan generando alguna versión de código RTL antes de sintetizar un circuito.2 Generación o Traducción Se lleva todos los tipos de fuentes. Puede haber una cantidad indefinida de retardos delta en un paso de simulación. 5.5. Las señales de los bloques pueden afectarse mutuamente.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 diseños de una manera simple y eficiente.5. 5. Al conjunto de estas aplicaciones se los denomina herramientas de desarrollo. el lector con una base de diseño de hardware podrá seguirla sin problemas. Los más comunes son VHDL o Verilog. al mismo tiempo. 5. y dentro de los estándares que definen los lenguajes de descripción de hardware VHDL y Verilog se especifica como se deben simular los procesos concurrentes. Es importante tener en cuenta que ninguna asignación de valores a una señal en hardware será inmediata. Un proceso en VHDL es la descripción de un bloque de hardware que actúa de manera concurrente (al mismo tiempo) con todos los demás procesos. 5. bloques de hardware que funcionarán de manera concurrente.4 Notas Manejo del tiempo en VHDL La simulación en VHDL se basa en incrementos finitos de tiempo. si se utiliza la operación X <= ‘1’ que indica la asignación un ©2003 Guillermo Güichal 24 .

Facultad Regional Bahía Blanca valor lógico ‘1’ a la señal X. Esto se repite hasta llegar a un tiempo en la que no hay ninguna transición de señal y todos los procesos están en reposo. Con esto en mente. A continuación se presenta un ejemplo para explicar mejor el proceso de simulación en VHDL. Estos cambios o asignaciones en los valores de las señales se agendan para un tiempo posterior. La Figura 6 muestra un circuito digital y los valores iniciales de las señales A. B. Al comenzar la simulación (tiempo de simulación cero) se asigna valores iniciales a las señales. se ejecutan todos los procesos hasta que estos lleguen a un estado de reposo. Después de asignar los valores a las señales.Ciclo de simulación Cuando los procesos están en un estado de reposo (todos los procesos en VHDL tienen un estado de reposo) se incrementa el tiempo de simulación como para cambiar la señal que tiene la próxima transición. este cambio nunca se producirá inmediatamente. puede analizarse un ciclo de simulación en VHDL que se comporta de la manera mostrada en la Figura 5. Este retardo será el menor tiempo de todas las asignaciones de señal hecha por los procesos. En general. sino que habrá un retardo (como mínimo de un retardo delta) para la asignación. Las señales recién se actualizarán después de un retardo. este se evalúa nuevamente de la manera descrita anteriormente. Después de cambiar la(s) señal(es) se examinan nuevamente los procesos para ver si esos cambios estimulan o disparan el comportamiento de algún proceso o puede continuar la simulación. Si se dispara algún proceso. nunca inmediatamente. y puede ser un retardo delta o un tiempo especificado por el código.Diseño digital utilizando FPGAs UTN. los procesos incluirán asignaciones de nuevos valores para algunas señales. Si no se dispara ningún proceso se procede a incrementar el tiempo hasta la próxima transición de señal. Figura 5 . Este proceso de simulación permite obtener resultados determinísticos. ©2003 Guillermo Güichal 25 .

Diseño digital utilizando FPGAs UTN. por lo que el simulador usará el valor de un retardo delta. Facultad Regional Bahía Blanca C. Figura 6 . Evaluar NAND. Evaluar AND Todos los procesos en reposo (actualización 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 único proceso que se dispara es el inversor. A los 50 ns de simulación la entrada A pasa de ‘1’ a ‘0’.Circuito digital combinacional La siguiente tabla muestra los pasos en la simulación al cambiar la señal A de 1 a 0 a los 50 ns. En delta 3 se cambian esas señales y se nota que solo se afecta el proceso AND de salida. y su salida X se agenda para cambiar de 0 a 1. Tabla 1 Ejemplo del pasos de simulación y cambios en las señales Tiempo Delta A 0 ns 1 50 ns 0 0 1 0 2 0 3 0 B X Y 1 0 1 1 0 1 1 1 1 1 1 0 1 1 0 C 0 0 0 1 Proceso Entrada y salidas estables Cambio en la entrada A. Evaluar AND Cambio en Y. C. Cuando cambia A se evalúan los procesos a los que afecta esa señal. el tiempo de propagación a través de dos compuertas (NAND-AND) es mayor que a través de una sola(AND). Se agenda el cambio de C y en delta 4 se cambia C a su valor final. Evaluar inversor Cambio en X. X e Y. Todas las compuertas están definidas para no tener retardo de propagación. generando el pulso (o “glitch”) en la salida C. En delta 2 se cambia la señal X y se observa a que procesos afecta. ©2003 Guillermo Güichal 26 . Se agendan para cambiar las señales Y y C.

desarrollo rápido de nuevos productos. Facultad Regional Bahía Blanca 6 Dispositivos Lógicos Programables Los dispositivos lógicos programables son circuitos integrados digitales que no tienen una función predefinida por el fabricante. Su función puede ser definida (o programada) por el usuario.). Guías y “Templates” automáticos para el diseño de circuitos básicos. que incluyen interfases gráficas. o SoPC (sistema sobre un circuito integrado programable) y System-on-a-Reprogammable Chip (SoRC). etc. Esta gran capacidad y variedad de los dispositivos los hace sumamente útiles a la hora de crear prototipos. Los dispositivos actuales (CPLD y FPGAs) tienen una capacidad lógica de hasta millones de compuertas. multiplicadores o CPUs completas. Debido a la gran capacidad lógica que tienen los dispositivos modernos. para los productos que deben ser reconfigurables por naturaleza o productos que se producen en bajos volúmenes y para los cuales no es económicamente viable crear un integrado a medida. Uno de los factores más importantes para el auge de las FPGA es el conjunto de herramientas disponibles. En resumen. La disponibilidad de herramientas gratuitas o a bajo costo por parte de los vendedores de PLDs Las librerías de componentes integradas con las herramientas de software. que permiten hacer diseños de manera rápida. sistemas completos pueden desarrollarse sobre un solo circuito integrado. Esto da lugar a las denominaciones System-on-a-Programmable Chip. incluyen interfaces programables para varios estándares de interfase eléctrica y tienen bloques de funciones especiales embebidos entre la lógica programable tales como memoria. Permiten reemplazar grandes diseños digitales que antes se implementaban con componentes discretos (como compuertas y flip-flops) por un solo integrado. Entre los puntos a destacar de las herramientas de software disponibles en el mercado pueden nombrarse los siguientes: • • • • • • • • La practicidad de usar lenguajes de descripción de hardware (HDL o Hardware Description Language) para sintetizar circuitos La integración de los flujos de diseño en un solo ambiente que hacen posible el prototipeado rápido con poco tiempo de uso de las herramientas. HDL. ©2003 Guillermo Güichal 27 . la facilidad de uso de herramientas de desarrollo para PLDs ayudan a que una gran cantidad de usuarios puedan rápidamente desarrollar un sistema utilizando PLDs. La integración de los simuladores con el ambiente de desarrollo que permiten una rápida verificación de los sistemas diseñados Las interfases cada vez más amigables.Diseño digital utilizando FPGAs UTN. maquina de estado.). etc. El soporte de diseño para FPGA por parte de las herramientas clásicas utilizadas para el diseño de circuitos electrónicos (Orcad. etc. sistemas de desarrollo integrados. la capacidad de desarrollar sistemas utilizando diversas metodologías (esquemático.

Debido a las limitaciones en la velocidad de las conexiones programables y los problemas en el proceso de manufactura de las PLA.1 Evolución de los Primeros Dispositivos Lógicos Programables Los primeros dispositivos lógicos programables fueron las memorias PROM.Esquema de un PLA La base teórica de estos dispositivos es que cualquier ecuación lógica puede reducirse a una suma de productos. pero tienen un nivel de lógica AND programable mientras el nivel de lógica OR es fijo. Para ello se utilizan como entradas las líneas de dirección a la memoria.Diseño digital utilizando FPGAs UTN. y puede utilizarse para implementar cualquier función lógica combinacional. De esta manera la memoria provee una tabla de decodificación completa de las entradas. introducidos al mercado en la década de 1970 por Philips. Figura 7 . Facultad Regional Bahía Blanca 6. Esto limita la cantidad de funciones que pueden definirse con un dispositivo ©2003 Guillermo Güichal 28 . Los PAL se basan en el mismo principio que las PLA. Mediante fusibles pueden programarse las interconexiones entre las entradas y la lógica. La Figura 7 muestra un esquema básico de un típico dispositivo PLA. El corazón electrónico 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. Así los PLA permiten implementar cualquier suma de productos de sus entradas. Los primeros dispositivos diseñados específicamente para implementar funciones digitales programables fueron los PLA. surgieron dispositivos con un solo nivel de lógica programable denominados PAL (recordar que los PLA tienen dos niveles programables: un nivel AND y un nivel OR).

por "Output Logic Macro Cell". La denominación GAL fue utilizada en principio por Lattice. ©2003 Guillermo Güichal 29 . Figura 8 . La macrocelda de estas GAL se denomina OLMC. Incluyen un nivel de lógica AND a la entrada y luego un bloque lógico denominado macrocelda a la salida. en reemplazo del nivel OR. así que los fabricantes de PAL los ofrecían en una variedad de configuraciones para adecuarlos a las necesidades del usuario. y luego licenciada a otros fabricantes. La Figura 8 muestra un esquema de una posible configuración de un PAL. 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.Diseño digital utilizando FPGAs UTN.Esquema de un PAL Los dispositivos denominados GAL son un poco mas complejos que los PAL mencionados anteriormente. Facultad Regional Bahía Blanca dado. Muchos PAL además incorporaron registros sobre las salidas y realimentación para implementar circuitos secuenciales.

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

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)

©2003 Guillermo Güichal

30

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

6.2 CPLDs
Los CPLDs son dispositivos que combinan varios bloques lógicos similares a las PAL o GAL con una matriz de interconexión 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 según 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 además de las macroceldas, un arreglo de interconexión programable (PIA), una red de distribución de reloj dedicada y bloques de entrada salida que permiten interfases compatibles con diferentes estándares eléctricos. Los bloques lógicos AND y OR están 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)

©2003 Guillermo Güichal

31

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

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 lógicos que se comunican entre si a través de canales de conexión 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 lógicos de las FPGA no implementan la lógica usando compuertas sino con generadores de funciones. En la siguiente sección se estudiará en mayor detalle la arquitectura de una FPGA típica.

Figura 13 - Esquema básico de la arquitectura de una FPGA

©2003 Guillermo Güichal

32

Bloque de distribución y compensación 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.Diagrama en bloques de una FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www.com) En las siguientes figuras se muestran algunos ejemplos de la arquitectura general de algunas FPGAs de distintos fabricantes. Bloque de memoria (BLOCK RAM): Estos bloques son memorias dedicadas integradas dentro de la lógica programable. Figura 14 . ©2003 Guillermo Güichal 33 . 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 lógica interna. Estructura de interconexión: Es una estructura versátil y multi-nivel de interconexión entre los otros componentes de la FPGA.Diseño digital utilizando FPGAs UTN. Facultad Regional Bahía Blanca En las Figura 14 se muestra la arquitectura general de una FPGA de la familia Spartan IIe de Xilinx. Bloque lógico configurable (CLB o Configurable Logic Block): Estos son los bloques básicos que se utilizarán en la implementación de un circuito digital.xilinx.

que ocupan la mayor parte de las FPGAs (CLBs. En las siguientes subsecciones se presentan en mayor detalle ©2003 Guillermo Güichal 34 .).Diagrama en bloques de una FPGA Cyclone II EP2C20 de Altera (Fuente: hoja de datos Altera Familia Cyclone 2 www. estos dispositivos constan de bloques que cumplen ciertas funciones específicas.com) Además de los bloques lógicos básicos. Logic Array. etc.actel. Logic Tile. Facultad Regional Bahía Blanca Figura 15 .Diseño digital utilizando FPGAs UTN.Arquitectura de una FPGA ProAsicPlus de Actel (Fuente: hoja de datos Actel Familia ProAsicPlus www.com) Figura 16 .altera.

Diseño digital utilizando FPGAs UTN. No todos los bloques se encuentran en todas las FPGA. Este es el corazón de la FPGA. cada “slice” contiene ©2003 Guillermo Güichal 35 . Facultad Regional Bahía Blanca algunos de los bloques o módulos específicos que pueden conformar una FPGA.com) Cada CLB esta compuesto por dos bloques iguales denominados “slices”. Figura 17 –Esquema del bloque lógico configurable de una FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www.1 Bloque Lógico Programable Todas las FPGA tienen algún tipo de bloque lógico programable. El multiplexor combina los resultados de los generadores de funciones dentro de cada "slice" del CLB. 6. Las dos "slices" están unidas por un multiplexor MUXF6. Además de poder implementarse lógica combinacional.xilinx. aunque casi todas tienen la estructura general presentada al principio de esta sección. Cada "slice" contiene dos generadores de funciones y un multiplexor MUXF5. y permite implementar las diferentes funciones lógicas. En la Figura 17 se muestra un esquema del bloque lógico programable (CLB) de una FPGA de la familia Spartan IIe de Xilinx. un multiplexor de 8:1 o determinadas funciones lógicas de asta 19 entradas.3. La arquitectura específica de cada FPGA dependerá del fabricante y la aplicación a la que está orientada. que puede seleccionar la salida de una u otra “slice” hacia la salida del CLB. Esto permite implementar cualquier función de 6 entradas.

Los ©2003 Guillermo Güichal 36 . Estas tablas pueden implementar cualquier función lógica de cuatro entradas y una salida. Facultad Regional Bahía Blanca recursos para implementar circuitos secuenciales y operaciones aritméticas eficientes. Figura 18 . Las salidas de las LUT pasan a los bloques de control.Esquema interno de medio bloque lógico configurable de una Spartan 2e de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www.com) En esta figura se ven los generadores de funciones. La Figura 18 muestra estos componentes en más detalle para un ‘slice” del CLB. que contiene lógica que permite optimizar funciones aritméticas. así como también utilizarse como memorias distribuidas de 16 x 1 bit. compuesto por una tabla de entradasalida (LUT o Look-Up Table) de cuatro entradas y una salida.xilinx.Diseño digital utilizando FPGAs UTN.

Figura 19 .Esquema del CLB de una FPGA Spartan 3 de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 3 www.Diseño digital utilizando FPGAs UTN. en la Figura 19 y Figura 20 se muestran dos ejemplos de bloques lógicos para otras FPGAs.com) ©2003 Guillermo Güichal 37 . Hay FPGAs que tienen bloques configurables mas simples y otras (especialmente las de última generación) cuyos bloques lógicos son bastante más complejos. Como ejemplos. y sin entrar en detalles.xilinx. Facultad Regional Bahía Blanca elementos que permiten implementar lógica 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.

La Figura 21 muestra un esquema de estos bancos de entrada-salida.Esquema del Elemento Lógico de una FPGA Cyclone II de Altera (Fuente: hoja de datos Altera Familia Cyclone II www. La familia de FPGAs Spartan IIe de Xilinx. Al utilizar diferentes valores de VccO para los distintos bancos se podrá tener un sistema con interfase a diferentes familias lógicas dentro de la misma FPGA.altera. ©2003 Guillermo Güichal 38 . para permitir que haya diferentes dominios de reloj con interfases eléctricas diferentes.com) 6. divide las entradas/salidas del integrado en bancos que se pueden configurar para tener una interfase con lógica de diferentes estándares eléctricos de manera independiente.3. Las entradas de reloj están asociadas a diferentes bancos de entrada-salida. Los bancos se configuran aplicando diferentes tensiones de alimentación a los pines denominados VccO y VREF. Facultad Regional Bahía Blanca Figura 20 .Diseño digital utilizando FPGAs UTN.2 Bloque de Entrada / Salida Las interfaces de entrada-salida son otro de los componentes particulares que tienen las FPGAs. por ejemplo.

para varios de las interfases lógicas debe configurarse la tensión de referencia VREF y agregarse resistencias de terminación sobre la plaqueta en las entradas-salidas de la FPGA.com) La siguiente tabla muestra el valor de VccO para las diferentes interfases lógicas. HSTL IV.3V 2. Cada bloque de entrada-salida tiene una resistencia de “pull-up” y “pull-down” configurables que permiten fijar el valor lógico mediante programación. AGP. HSTL III. GTL+ LVCMOS18. LVTTL. SSTL3 II. cada bloque de entrada-salida de la familia Spartan IIe de Xilinx tiene la estructura mostrada en la Figura 22. Internamente. GTL. SSTL3 I. CTT.5V 1. Tabla 2 . GTL+ HSTL I. GTL. GTL. LVDS. LVPECL. GTL+ SSTL2 I. Bus LVDS.5V Lógica de interfase PCI.8V 1. GTL+ Además de la tensión VccO. LVCMOS2. ©2003 Guillermo Güichal 39 .Tensión VccO para diferentes interfases lógicas de la familia Spartan IIe de Xilinx Valor de VccO 3.xilinx. Facultad Regional Bahía Blanca Figura 21 –Distribución de los bancos de entrada/salida en una FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www. GTL. Los elementos de entrada-salida de las FPGAs de Altera Cyclone II tienen la estructura mostrada en la Figura 23.Diseño digital utilizando FPGAs UTN. SSTL2 II.

xilinx.altera. Facultad Regional Bahía Blanca Figura 22 .com) Figura 23 .Esquema de un bloque de entrada-salida (IOB) de una FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www.com) ©2003 Guillermo Güichal 40 .Diseño digital utilizando FPGAs UTN.Esquema de un bloque de entrada-salida de una FPGA Cyclone II de Altera (Fuente: hoja de datos Altera Familia Cyclone II www.

La familia Spartan IIe de Xilinx tiene bloques específicos para control de reloj denominados DLL (Delay Locked Loop). La red de distribución de reloj en las FPGA asegura retardos parejos a todos los bloques lógicos de la FPGA. sincronizan los diferentes dominios de reloj y aseguran un retardo de distribución del reloj pareja para la lógica interna de la FPGA. Facultad Regional Bahía Blanca Los bloques de entrada-salida de muchas FPGAs tienen elementos de almacenamiento integrados que permiten controlar mejor los tiempos de propagación entre las patitas (pines) del integrado y la lógica interna. controlan el desplazamiento de fase entre los relojes.3. Cada fabricante utiliza una arquitectura diferente para el control y distribución de reloj. 6.com) A continuación se presentan dos ejemplos de bloques de control para FPGAs de diferentes fabricantes.3 Bloque de Control de Reloj El sistema de control del reloj consiste en bloques de control integrados a la red de distribución de reloj. Además 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’). Figura 24 – Red global de distribución de reloj en la FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www. La siguiente Figura 24 muestra el esquema de distribución de reloj para la familia Spartan IIe de Xilinx. La Figura 25 muestra un esquema básico de la estructura de un DLL. Estos bloques sincronizan el reloj interno al reloj externo del sistema.xilinx. ©2003 Guillermo Güichal 41 .Diseño digital utilizando FPGAs UTN.

Diseño digital utilizando FPGAs UTN. Facultad Regional Bahía Blanca Figura 25 –Esquema básico de un bloque de control de reloj de la FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Spartan 2e www.com) La familia Stratix de Altera tiene los bloques de control de reloj que se muestran en la Figura 26.altera. Figura 26 –Esquema de un bloque de control de reloj de la FPGA Stratix de Altera (Fuente: hoja de datos Altera Familia Stratix www.xilinx.com) ©2003 Guillermo Güichal 42 .

DIA.xilinx. DOB. Facultad Regional Bahía Blanca Estos bloques (Enhanced PLL) permiten controlar la fase y frecuencia del reloj. Para entender la versatilidad de estos bloques de memoria. 6. Además de memorias embebidas. 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 (Fuente: hoja de datos Xilinx Familia Spartan 2e www. ADDRB. puerto simple.4 Memoria La memoria es un componente muy utilizado en diseños digitales.3.Diseño digital utilizando FPGAs UTN. En general estos bloques básicos de memoria pueden utilizarse en diferentes configuraciones para generar RAMs y ROMs de diferentes tamaños. en la siguiente tabla se muestran las opciones de configuración. RAMs o ROMs. Las interfases de dirección y datos (ADDRA. La Figura 27 muestra un esquema de una celda de memoria básica de la familia Spartan IIe de Xilinx. DOA) se pueden configurar para diferentes tamaños de memoria. ©2003 Guillermo Güichal 43 . el sistema de distribución de reloj y el estándar eléctrico de interfase entre otras cosas. Varias familias de FPGA contienen bloques de memoria embebida integrados con la lógica programable.com) Estos bloques de memoria pueden usarse como memorias de puerto dual. las FPGAs basadas en memoria SRAM pueden usar las tablas LUT de los bloques lógicos como memoria.

Como muestra la Figura 29.actel. Figura 28 -Esquema de un bloque de memoria de Actel configurada como memoria multi-puerto (Fuente: Nota de Aplicación de Actel: "Implementing Multi-Port Memories in Actel ProAsicPlus Devices" . Facultad Regional Bahía Blanca Tabla 3 . por ejemplo.com) 6. que puede configurarse como memoria de puerto simple. Pueden configurarse de varias maneras diferentes según las necesidades del usuario.5 Bloque de Procesamiento de Señal Varias FPGA contienen bloques específicos que optimizan en hardware ciertas funciones especiales.Diseño digital utilizando FPGAs UTN.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> Además de poder configurar cada bloque.www. dual o multi-puerto. contienen uno o más módulos de procesamiento de señal entre los bloques de lógica programable de propósito general. varios bloques pueden conectarse utilizando lógica externa para implementar memorias de otros tamaños y colas FIFO o FILO. La Figura 28 muestra un bloque de memoria de Actel.3. Las FPGA de la familia Stratix de Altera. Estos bloques permiten desarrollar ciertas funciones específicas típicas de las aplicaciones de procesamiento de señal de manera muy eficiente. este bloque contiene lógica para implementar operaciones de multiplicación-acumulación que requerirían de muchos recursos y ciclos de reloj si se implementaran utilizando ©2003 Guillermo Güichal 44 .

com) ©2003 Guillermo Güichal 45 . Figura 29 – Bloque de procesamiento de señal de la familia Stratix de Altera (Fuente: hoja de datos Altera Familia Stratix www. Al igual que los otros bloques. Facultad Regional Bahía Blanca lógica de propósito general. los bloques específicos pueden interconectarse a los demás bloques utilizando la matriz de intercone3xión programable de la FPGA.Diseño digital utilizando FPGAs UTN.altera.

Figura 30 . Altera ofrece el microcontrolador Nios. de tecnología RISC de 16 bits que puede utilizarse sobre varias de las FPGA de Altera. A este tipo de diseño se lo denomina "softcore".xilinx. Esto permite utilizar toda la potencia de una CPU integrada con la flexibilidad de los periféricos diseñados mediante lógica programable.3. ya que a FPGA no tiene ningún bloque específico para la CPU implementado sobre el circuito integrado. Facultad Regional Bahía Blanca 6.Diseño digital utilizando FPGAs UTN. La lógica programable del Excalibur puede ser de hasta un millón de compuertas. Hay muchos micros "softcore" públicos y propietarios. ©2003 Guillermo Güichal 46 .CPU PC405 embebida en una Virtex II Pro de Xilinx (Fuente: hoja de datos Xilinx Familia Virtex 2 Pro www.com) Altera ofrece la FPGA Excalibur que contiene un microcontrolador ARM922T integrado a un costado de lógica programable. Por otro lado también pueden diseñarse microcontroladores o procesadores usando solamente la lógica de configuración de las FPGAs. Xilinx ofrece el Microblaze y Actel ofrecerá un micro de la familia ARM. La Figura 30 muestra un esquema de la arquitectura del Virtex II-PRO.6 CPUs Embebidas La familia de FPGAs de Xilinx Virtex II-PRO contiene una CPU Power PC 405 de IBM y lógica de interconexión embebida dentro de lógica programable. y puede correr a una frecuencia de reloj de hasta 200 MHz. El micro es de arquitectura RISC de 32 bits. Los bloques específicos integrados en el silicio de las FPGAs se denominan "hardcores".

los elementos lógicos presentados en las secciones anteriores no solo deben configurarse adecuadamente sino que también deben conectarse entre si. como son las señales de reloj y posiblemente las señales de reset. permiten hacer las conexiones entre los elementos internos de un bloque lógico o CLB. Los elementos de la GRM se encuentran entre los CLB. de entrada-salida y recursos de interconexión global para la distribución de reloj y señales específicas. Facultad Regional Bahía Blanca 6. La estructura de interconexión interna de un PLD consiste en un conjunto de alambres o trazas que pueden conectarse mediante elementos de conexión programables.7 Matriz de Interconexión Para poder implementar circuitos lógicos. el interconexionado a este nivel provee conexiones a la matriz de interconexionado general y a los CLB adyacentes. mostrados en la Figura 31. los flip-flop y las realimentaciones dentro del CLB. como las tablas de búsqueda (LUT). Permiten hacer la interconexión entre las trazas horizontales y verticales y hacia los CLB. se describirá a continuación la arquitectura de interconexión de las FPGA Spartan IIe de Xilinx. Estas FPGA tienen dos niveles de interconexión. A través de ellos se configuran las conexiones entre CLBs no adyacentes y hacia los bloques de entrada/salida. Las conexiones a los CLB adyacentes permiten optimizar los diseños al evitar los retardos y la utilización de recursos de la matriz general de interconexionado. Esta red de distribución global tiene dos niveles y puede llevar las señales de reloj a todos los bloques lógicos con poca diferencia de tiempo (skew) entre ellos.3. La Figura 32 muestra un esquema de la red dedicada de distribución de señales de alto “fan-out”. Además de los ya mencionados. ©2003 Guillermo Güichal 47 .Diseño digital utilizando FPGAs UTN. las FPGA Spartan IIe contienen recursos de interconexión dedicados a señales de tres estados. Los recursos de interconexión local. Por otro lado contienen recursos de interconexión local. Por un lado tienen una interconexión de propósito general a través de la matriz de interconexionado general o GRM por sus siglas en inglés. Los recursos de interconexionado global que no forman parte de la GRM permiten distribuir señales con un fan-out grande. en los canales de interconexión horizontales y verticales de la FPGA. La mayor parte de las señales se conectarán a través de la matriz general de interconexionado (GRM). A modo de ejemplo. Además. Las herramientas de “localización e interconexión” (place and route) son las encargadas de decidir en que elementos lógico se implementará la lógica diseñada por el usuario y como deben programarse las interconexiones para que el diseño funcione según las especificaciones de tiempo y retardos que se han definido.

4 Granularidad de los Dispositivos Lógicos Programables (PLDs) La granularidad de un dispositivo lógico programable está dada por la funcionalidad básica que provee cada bloque de configuración lógica.xilinx.Diseño digital utilizando FPGAs UTN.com) Figura 32 .Caminos de interconexión local en la FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www.com) 6. Algunos parámetros para definir la granularidad de un dispositivo programable son: • Número de funciones que puede implementar cada celda lógica • Número de compuertas NAND de dos entradas equivalente por cada celda lógica ©2003 Guillermo Güichal 48 .Red dedicada de distribución de reloj en la FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www. Facultad Regional Bahía Blanca Figura 31 . o la relación entre las celdas lógicas y los recursos de interconexionado.xilinx.

Por otro lado cada bloque consume más área que puede desaprovecharse. Esto es lo que utilizan los dos fabricantes principales de FPGAs basados en tecnología SRAM.. Una arquitectura de granularidad fina será típicamente más densa y tendrá menor retardo de interconexión entre celda y celda. Un bloque lógico grande puede implementar lógica más compleja y por lo tanto se necesitan menos bloques para una función dada.Diseño digital utilizando FPGAs UTN. A estas se las denomina de granularidad gruesa. se deberán conectar un mayor número de celdas.www. Para una FPGA basada en tablas de búsqueda (Look Up Table o LUT) la mejor relación entradas salidas del bloque lógico es 4 a 1. Otras arquitecturas están formadas por celdas básicas que solo permiten implementar lógica muy simple. Sin embargo. en su frecuencia máxima de funcionamiento y en la utilización que se hace del dispositivo. La granularidad de un dispositivo lógico influirá en la manera que se implemente una función lógica dada. de varias entradas/salidas. para una función dada. Facultad Regional Bahía Blanca • Número total de transistores por celda lógica • Área total normalizada de lógica configurable (relación de área lógica/área de interconexionado) • Número de entradas y salidas por celda lógica Algunos dispositivos tienen arquitecturas con celdas lógicas que pueden implementar funciones lógicas complejas.com) ©2003 Guillermo Güichal 49 . En general la mejor granularidad dependerá de la aplicación y las restricciones que hay sobre el diseño.actel. Para mayor información ver la sección Referencias. Algunas características de cada tipo de arquitectura son las siguientes: Arquitecturas con granularidad fina • Celdas implementan funciones lógicas parciales de n entradas • Relación de entradas a registros por celda muy baja (2/4 a 1) • Ejemplo: ProAsicPlus de Actel Figura 33 Bloque Lógico (Logic Tile) de la ProAsicPlus de Actel (Fuente: hoja de datos Actel Familia ProAsicPlus . A estas se las denomina de granularidad fina.

Facultad Regional Bahía Blanca Arquitecturas con granularidad media • Celdas implementan funciones completas de n entradas • Relación de entradas a registros por celda de 6/8 a 1 • Buenas para implementar máquinas de estado y lógica secuencial compleja • Ejemplo: Xilinx Spartan 3: Figura 34 Slice de Spartan 3 de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 3 www.com) ©2003 Guillermo Güichal 50 .xilinx.Diseño digital utilizando FPGAs UTN.

altera. • 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.com) Arquitecturas mixtas • Combinan celdas con granularidad fina y gruesa • Muchas veces tienen recursos de interconexión dedicados para cada tipo de celda • Ejemplo: ispXPGA de Lattice Semiconductors ©2003 Guillermo Güichal 51 .Diseño digital utilizando FPGAs UTN. Facultad Regional Bahía Blanca Arquitecturas con granularidad gruesa • Celdas estilo PLD de arreglos de términos • Relación de entradas a registros de 32 a 1 • Buenas para lógica combinacional como decodificación de direcciones. funciones aritméticas.

www.latticesemi.Diseño digital utilizando FPGAs UTN. Facultad Regional Bahía Blanca Figura 36 Unidad Funcional Programable PFU del ispXPGA de Lattice (Fuente: hoja de datos Lattice Semiconductors Familia ispXPGA .com) ©2003 Guillermo Güichal 52 .

se destacan las tecnologías EEPROM.Diseño digital utilizando FPGAs UTN. Puede cambiarse el diseño solo cambiando la PROM de configuración en la placa final • No requiere programador • Proceso de manufactura igual que la lógica • Puede probarse en un 100% • Tecnología integrada con la lógica (manufactura fácil. Stratix. Spartan 3 de Xilinx. dependen del fabricante y el dispositivo. Se debe reprogramar después de cortar la alimentación • Requiere memoria (PROM) externa • Tiempo de encendido “lento” (debe configurarse) • Mayor utilización de área en el integrado • No muy tolerante a la radiación • • • • SRAM Flash Antifusible • Reconfigurable. Entre los dispositivos reprogramables. Cypress Ultra37000 EEPROM + SRAM: Lattice Semiconductor ispXPGA ©2003 Guillermo Güichal 53 . SRAM y Flash. ProAsicPlus Antifusible: Actel A54SX. Si se comete un error. Los dispositivos que solo pueden configurarse una vez en general utilizan tecnologías de antifusible. Quicklogic pAsic EEPROM: Altera MAX7000. ya sean los bloques lógicos o las interconexiones. Spartan2e. Virtex4. En la Tabla 4 se resumen algunas de estas características Tabla 4 Características de las Tecnologías de Configuración de PLDs Tecnología EEPROM Ventajas • • • • No volátil Puede probarse en un 100% Software simple Tecnología base muy conocida Desventajas • Requiere tensiones altas para configurar y borrar • Requiere programador • Mayor consumo de potencia • Tolerancia media a la radiación • Requiere mucha área para implementarse (integrados grandes) • Volátil. menor costo) • No volátil • Tiempo de encendido rápido • Menor potencia que SRAM • Menor área que SRAM y antifusible • Programable sobre la placa (no tan fácil) • No volátil • Mayor densidad • Mucha tolerancia a la radiación (aplicaciones espaciales) • Tiempo de encendido muy rápido • Baja potencia Requiere programador Requiere tensiones altas La misma velocidad que SRAM Menor cantidad de reprogramaciones • No pueden reconfigurarse • Requiere programador • No puede evaluarse.utilizada para configurar los elementos de un PLD. SRAM: Virtex II.5 Tecnología de Configuración de los PLDs La tecnología . Facultad Regional Bahía Blanca 6. Cyclone y Apex de Altera Flash: Actel ProAsic. se pierde el integrado A continuación se dan algunos ejemplos de dispositivos que utilizan cada tecnología. Cada tecnología tiene sus ventajas y desventajas respecto a las otras.

Modelo de negocios en el que no solo se provee el hardware (PLDs) sino también propiedad intelectual por un costo. Integración de bloques lógicos programables alrededor de lógica fija en ASICs o integrados estándar. memorias. no solo de los dispositivos en sí sino de las herramientas y usos de estos dispositivos. para poder configurar el interconexionado interno del SoPC de manera integral con el conexionado hacia los componentes externos. • • • • • Desarrollo de FPGAs con mayor capacidad. menos consumo de potencia y menor costo. Integración en hardware sobre las lógicas programables de bloques específicos como ALUs. etc. la documentación de proyectos integrada a las herramientas de diseño. nuevas ideas y diseños basados en lógicas y plataformas programables. Integración del manejo de configuración de FPGAs con las herramientas de diseño de plaquetas (PCBs). Facultad Regional Bahía Blanca 6. el manejo de la propiedad intelectual.7 Notas a Junio 2005 Estas notas se comenzaron a escribir en el 2003. Componentes que pueden pasar directamente de un prototipo sobre una FPGA a un ASIC sin esfuerzo de diseño adicional. Parece imposible tratar de actualizar la información para reflejar las últimas tendencias en estas notas. externas a la FPGA. que permiten observar la lógica de interna de las FPGA en tiempo real al mismo tiempo que se observan otras señales.Diseño digital utilizando FPGAs UTN. Integración con herramientas y otros software de desarrollo de mayor nivel. • • • • • • En los primos años probablemente se verá una mayor incorporación de las lógicas programables en los diseños. tales como analizadores lógicos. junto a una mayor variedad. y algunos comentarios sobre tendencias son una realidad. etc. Enfoque sobre la reutilización de propiedad intelectual.6 Tendencias Actuales y Futuras A continuación se nombran algunas tendencias que pueden observarse en la industria de de las lógicas programables. Integración y mezcla entre FPGAs y circuitos integrados de propósito específico (ASICs). Para eso se ©2003 Guillermo Güichal 54 . Esto incluye el manejo de grupos de trabajo. componentes para procesamiento digital de señal. Cambios en las herramientas de software para tener mayor integración entre los diferentes usuarios y en los distintos pasos del proyecto. la transferencia de los diseños para FPGAs a ASICs. integración con uP y uC. etc. como son Matlab y herramientas para el diseño integrado de software y hardware. más velocidad. (HWSW co-design). Sistemas con aplicaciones que utilicen la reconfiguración o reprogramación de las FPGAs directamente en el producto final según la necesidad del momento. y a Junio del 2005 muchos de los aspectos tecnológicos están des actualizados respecto de los dispositivos actuales. Instrumentos. 6. diversidad.

©2003 Guillermo Güichal 55 .Diseño digital utilizando FPGAs UTN. Para obtener mas detalles referirse a las páginas web de los fabricantes (Ver referencias). La presentación anterior debería servir para poner en tema al lector y presentarle los conceptos básicos sobre estas tecnologías. Facultad Regional Bahía Blanca refiere al lector a los sitios web de los fabricantes de FPGAs listados al final de las notas.

-. 7. Por ejemplo. BEGIN.Esto es una asignación de la señal a con un comentario al final -.3 Comentarios en VHDL Los comentarios en VHDL se indican con un doble guión “--".Una asignación a la señal A ©2003 Guillermo Güichal 56 . y debe comentarse línea por línea si se quiere comentar un bloque completo de código 7. -. Facultad Regional Bahía Blanca 7 Primeros Pasos con VHDL 7. Abracan desde “--" hasta el final de la línea Ejemplos: -.Diseño digital utilizando FPGAs UTN.A<= ‘1’ Esto es un comentario de una línea completa. No hace nada A <= ‘1’.1 Notas Preliminares Sobre Formato de VHDL y los Ejemplos Antes de continuar se describirán algunos puntos básicos para poder comprender los ejemplos y explicaciones que se presentan en las siguientes secciones.1. Ejemplos: A <= ‘1’. las palabras begin. 7. • Las palabras reservadas de VHDL se escribirán en negrita • Se seguirá un formato estándar para el código • Solo se presentarán los casos y construcciones más utilizadas y las orientadas a la síntesis para FPGAs 7.” y aunque se pueden escribir varias instrucciones por línea esa práctica no se recomienda y no se usará en este texto.1.Esto es un comentario que me dará error porque pasa a la otra línea y el analizador de VHDL no entiende la segunda línea En VHDL no existen los comentarios multi-línea. Begin y bEGin serán tratadas de la misma manera por el analizador de VHDL En general es una buena práctica mantener el mismo formato a través de todo el diseño y por todos los miembros del equipo.1.4 Delimitadores de Código en VHDL Las instrucciones en VHDL se terminan con “.1.2 Capitalización en VHDL VHDL no es sensible a la capitalización y no distinguirá las palabras que solo se diferencian por letras mayúsculas.1 Formato del Código de Ejemplo En los ejemplos presentados en este texto se tratará de mantener las siguientes reglas para facilitar su comprensión y el aprendizaje de VHDL. En este texto se usarán palabras reservadas en minúscula con algunas palabras especiales en mayúscula.

Instrucciones que modelan la arquitectura end architecture Comportamiento.Doble asignación en una línea NO RECOMENDADO Los bloques lógicos en VHDL se delimitan por las palabras reservadas begin y end.2. ©2003 Guillermo Güichal 57 .Definición de un proceso P_IncrementoCuenta : process(Clock_IN) begin -. Ejemplos: -. Facultad Regional Bahía Blanca B <= ‘0’. -. Una es la interfase del componente. Este modelo permite esconder los detalles internos de implementación e incluso definir varias implementaciones para un componente sin afectar la interfase externa.1 Entidades y Arquitecturas La siguiente Figura 37 ilustra el concepto de definición de un componente en dos secciones y presenta las palabras clave (en negritas) utilizadas por VHDL para definirlas. -.Definición de una arquitectura architecture Comportamiento of Contador is begin -. --Se debe cerrar con la palabra reservada process 7. La primer sección declara el componente o entidad y define las señales de interfase Para declarar la entidad se utiliza la palabra reservada entity.Una asignación a la señal B C <= ‘0’.2 Estructura Básicas de un Modelo en VHDL Con VHDL. D <= ‘1’.Diseño digital utilizando FPGAs UTN.Instrucciones que definen el proceso end process. un módulo o componente de hardware se modela en dos secciones. -. 7. denominado entidad y la otra es la arquitectura que describe su funcionamiento interno.

Diseño digital utilizando FPGAs UTN. : IN : IN : OUT std_logic. std_logic. end Contador. Usada para interfases de tres estados. Facultad Regional Bahía Blanca Figura 37 Declaración de un componente en VHDL La estructura básica mas simple de la declaración se muestra con el siguiente ejemplo de la declaración de un contador de 6 bits. std_logic_vector(5 downto 0) Cuadro 1 Declaración de Entidad La palabra reservada entity especifica que comienza con la declaración de una entidad de hardware. ©2003 Guillermo Güichal 58 . Esta entidad tendrá el nombre “Contador”. No recomendada para diseños sintetizables. • BUFFER Señal de salida que puede leerse internamente.A continuación se definen las señales de interfase mediante la palabra port. Los tipos de señales de interfase o “ports” pueden tener los siguientes modos: • IN Señal de entrada al componente • OUT Señal de salida del componente • INOUT Señal bidireccional. entity Contador is port( Reset_IN Clock_IN Cuenta_OUT ).

Cuadro 2 Declaración de arquitectura El modelado del comportamiento puede ser de muchas maneras diferentes. De la misma manera que una función en hardware puede ser diseñada de diferentes maneras.. que definen señales de 1 bit o varios bits de ancho respectivamente... end architecture Comportamiento. La descripción del funcionamiento del componente se define en la segunda sección de definición del componente. pero debe tenerse en cuenta que VHDL no impone restricciones a mezclar los tipos de modelo dentro de una arquitectura. El elemento de construcción básico en el modelo de comportamiento en VHDL es el proceso (process).utilizando las construcciones de VHDL necesarias -. aunque esta no es una práctica recomendada.En esta sección se define el comportamiento -...” para terminar cada instrucción y su uso en la separación de la declaración de las señales de interfase.. Los modelos de comportamiento y los estructurales. los tipos de los “ports” que se recomiendan para diseños sintetizables son std_logic y std_logic_vector1.. pero en general pueden dividirse en dos categorías principales.En esta sección se declaran las señales usadas en -. flujo de datos o una mezcla de ellos. Estos modelos se presentan por separado a continuación. al nivel de transferencia de registros (register transfer level o RTL).según el modelo que se implemente -. Este modelo de funcionamiento puede ser en la forma de un algoritmo general.2 Modelos de comportamiento En los modelos de comportamiento el funcionamiento del componente se modela a través del comportamiento de las señales a través de compuertas y registros internos..el modelo begin – Comienzo de la especificación del comportamiento -. En general la sección de arquitectura tendrá la estructura mostrada a continuación.. el comportamiento de un componente puede modelarse de muchas maneras diferentes en VHDL.2. 7. La entidad termina con la palabra reservada end. Los tipos std_logic y std_logic_vector están definidos en librerías estándar de IEEE que se describirán más adelante. Notar el uso del “. architecture Comportamiento of Contador is -.Diseño digital utilizando FPGAs UTN. denominada arquitectura. 1 ©2003 Guillermo Güichal 59 . Facultad Regional Bahía Blanca En general.

Conexión del registro con el puerto de salida Cuanta_OUT <= Cuenta_REG.Incrementa cuenta end if.Fin if(Reset.cada flanco ascendente de Clock_IN P_IncrementaCuenta : process(Reset_IN. se supone que hay una entidad “LogicaVaria” declarada que tiene varias entradas y cuya salidas son funciones lógicas AND y OR de las entradas. Clock_IN) begin if Reset_IN = ‘1’ then Cuenta_REG <= “000000”. -.Reset vuelve todo a 0 elsif (Clock_IN’event and Clock_IN = ‘1’) then Cuenta_REG <= Cuenta_REG + 1. begin – Comienzo de la especificación del comportamiento -. El funcionamiento de ambos modelos es exactamente el mismo y pueden definirse una variedad de modelos con el mismo comportamiento. Clock) end process.Diseño digital utilizando FPGAs UTN.No hay señales internas que declarar begin – Comienzo de la especificación del comportamiento SalidaAnd_OUT <= Entrada1_IN and Entrada2_IN. ©2003 Guillermo Güichal 60 . -. A continuación se muestran dos posibles arquitecturas de comportamiento para este componente. -.Este proceso cuenta los ciclos de reloj en -. -. architecture Comportamiento1 of LogicaVaria is -.Fin de Proceso Incrementa Cuenta end architecture Comportamiento. -. En el segundo ejemplo se utiliza un proceso que se disparará ante un cambio de cualquiera de las entradas. Facultad Regional Bahía Blanca En el siguiente ejemplo se muestra un proceso y una asignación concurrente que definen el comportamiento del contador de 6 bits declarado más arriba. SalidaOR_OUT <= Entrada1_IN or Entrada2_IN. Cuadro 3 Modelo de comportamiento para un contador Para el siguiente ejemplo. En el primer ejemplo se utilizan instrucciones concurrentes para asignar las salidas directamente.Declaración de las señales usadas en la arquitectura signal Cuenta_REG : std_logic(5 downto 0). Este proceso cambia el valor de las señales internas que actúan solo como cables hacia los puertos de salida. architecture Comportamiento of Contador is -.

Cuadro 4 Modelos de comportamiento 7. end process. ©2003 Guillermo Güichal 61 . Las interconexiones se hacen “mapeando” los puertos definidos en las declaraciones de las entidades de los componentes básicos.solo para aclarar la lógica begin – Comienzo de la especificación del comportamiento SalidaAnd_OUT <= intSalidaAnd.3 Modelos Estructurales Como al armar una plaqueta con diferentes componentes e interconectarlos. Solo es necesario si se utiliza -.VHDL-87. Siguiendo el ejemplo anterior para la entidad “LogicaVaria”. -.la arquitectura. VHDL permite armar modelos estructurales y así dar una jerarquía al diseño.----------------------------------------------------------------------------------------------.Diseño digital utilizando FPGAs UTN. ProcesoCalculoLogica : process(Entrada1_IN. Entrada2_IN) begin intSalidaOr <= Entrada1_IN or Entrada2_IN. -. -.2. -. Facultad Regional Bahía Blanca end architecture Comportamiento1.--. SalidaAnd_OUT : OUT std_logic.Declaración de los componentes básicos utilizados en -. En los modelos estructurales se interconectan diferentes componentes utilizando un mapeo de componentes básicos mediante señales que actúan como cables de interconexión. EntradaAnd2_IN : IN std_logic.Señales internas declaradas intSalidaOr : std_logic. SalidaOr_OUT <= intSalidaOr. architecture Estructura of LogicaVaria is -. ambas con dos entradas y una salida.Fin de ProcesoCalculoLogica end architecture Comportamiento2.-architecture Comportamiento2 of LogicaVaria is intSalidaAnd : std_logic. component CompuertaAnd port(EntradaAnd1_IN : IN std_logic.----------------------------------------------------------------------------------------------. una arquitectura estructural para este componente se muestra en el Cuadro 5. Para el siguiente ejemplo se supone que existen dos componentes CompuertaAnd y CompuertaOr predefinidos en la misma librería. intSalidaAnd <= Entrada1_IN and Entrada2_IN.

Diseño digital utilizando FPGAs UTN. A la izquierda están los puertos de los componentes básicos y a la derecha señala las señales o puertos de la entidad superior (en este caso LogicaVaria) ComponenteBasicoAnd : CompuertaAnd port map (EntradaAnd1_IN => Entrada1_IN. Una es la declaración de los componentes antes del comienzo (begin) de la arquitectura utilizando la palabra component. Otra cosa que se debe destacar es que no hay ningún problema en que las señales o puertos de varios componentes en la jerarquía tengan el mismo nombre. SalidaOr_OUT : OUT std_logic. begin – Comienzo de la especificación de estructura ------La instrucción “port map” conecta las señales con los puertos de los componentes básicos. ComponenteBasicoAnd : CompuertaOr port map (EntradaOr1_IN => Entrada1_IN. component CompuertaOr port(EntradaOr1_IN : IN std_logic. como puede verse en la conexión de las señales de salida. ). En el ejemplo todos los puertos de los componentes se interconectan de manera ©2003 Guillermo Güichal 62 .” entre los diferentes puertos de los componentes básicos. Cuadro 5 Modelo estructural En este ejemplo se conectaron dos componentes básicos que implementan una compuerta AND y una OR de dos entradas y una salida para definir el funcionamiento del componente LogicaVaria. EntradaAnd2_IN => Entrada2_IN. Los puertos del componente se conectan a diferentes señales mediante el mapeo con las palabras port map. EntradaOr2_IN => Entrada2_IN. end architecture Estructura. dándole un nombre único dentro del diseño. Instancia se refiere a crear una copia de un componente. Facultad Regional Bahía Blanca ). SalidaOr_OUT => SalidaOr_OUT ). SalidaAnd_OUT => SalidaAnd_OUT ). Notar el símbolo de conexión “=>” (diferente al de asignación para señales “<=” ) y el uso de los separadores “. En el modelo estructural pueden apreciarse dos partes principales. El símbolo => indica conexión. La otra es crear una "instancia" (instantiation) de los componentes dentro de la arquitectura. Puede verse la instancia de un componente como la creación de una copia del componente dentro del componente actual. EntradaOr2_IN : IN std_logic.

pero eso no es recomendable y no se presentarán ejemplos de ello en este texto. También puede hacerse una asociación por lugar. si no se quiere conectar la salida de la compuerta AND. SalidaAnd_OUT => open ). En la Figura 38 se muestra un ejemplo de representación grafica de un esquemático tomado de la herramienta ISE 6. Esto se hace representando cada componente básico por un símbolo gráfico que tiene indicadas sus puertos de entrada y salida. Figura 38 Representación gráfica de un modelo estructural con las herramientas de Xilinx (Fuente: Captura de pantalla de Herramienta Esquemática ECS de Xilinx) ©2003 Guillermo Güichal 63 . EntradaAnd2_IN => Entrada2_IN. Muchas herramientas de desarrollo permiten armar un componente con una arquitectura estructural de manera gráfica.2 de Xilinx. Esto se hace usando la palabra open en la “instancia”. También pueden dejarse señales abiertas. por ejemplo cuando no se utilizan algunas salidas. Una asociación por nombre es el uso de la expresión (Puerto => SeñalALaQueSeConecta) que se utiliza para cada señal del puerto del componente. La herramienta de diseño traduce luego el diagrama esquemático a su representación en VHDL para el análisis y elaboración. En el ejemplo presentado se interconectan los puertos de los componentes con señales usando una asociación por nombre. Estos puertos se interconectan con líneas como se haría al diseñar un circuito con una herramienta de captura de esquemáticos (como Orcad o PowerLogic). No pueden dejarse desconectadas las entradas. puede usarse ComponenteBasicoAnd : CompuertaAnd port map (EntradaAnd1_IN => Entrada1_IN.Diseño digital utilizando FPGAs UTN. lo que dejará desconectada la salida. Facultad Regional Bahía Blanca explícita a señales declaradas anteriormente. Por ejemplo.

protected2. with xnor2. access. in. shared2. guarded if. library. alter. 2 3 Estas no son palabras reservadas en VHDL-87 Estas no son palabras reservadas en VHDL-93 ©2003 Guillermo Güichal 64 .1 Palabras Reservadas Las siguientes son las palabras reservadas en VHDL. loop map. sra2. Facultad Regional Bahía Blanca 7. impure2.3. to. alias. function generate. is label. rol2. 7. or. literal2. array. exit file. sll2. register. port. configuration. ror2 select. bus case. units. and. transport. srl2. pure2 range. report. mod nand. elsif. reject2. architecture. body. null of. out package. block. open. abs. sla2. No deberán utilizarse como nombres de ningún tipo que no sea como instrucciones de VHDL. in. end.Diseño digital utilizando FPGAs UTN. next. return. not. until. all. inertial2. procedure. severity. new.2 Símbolos Especiales Algunos símbolos 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 librerías. process. signal. assert. rem. when. generic. while. inout. for. attribute begin. component. downto else. record. use variable wait. constant disconnect. others. group2. type unaffected2. entity. on.3 Elementos del Lenguaje VHDL En esta sección se presentan los elementos básicos del lenguaje VHDL para familiarizar al lector con algunas expresiones y operadores antes de comenzar con los elementos y construcciones mas complejas del lenguaje. xor Cuadro 6 Palabras reservadas de VHDL 7.3. postponed2.3. nor. buffer. linkage. subtype then.

B => B) (others => ‘0’) ** := /= >= <= <> \ _ (Guión bajo) 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 b”0100_0110” 2#0110_1100# X”12FD_C46B_4567” ©2003 Guillermo Güichal 65 . etc. (coma) . when Mapeo de puertos en arquitecturas estructurales Para dar valor a bits no asignados de vectores Exponencial Asignación para variables No igual en comparaciones Mayor o igual en comparaciones Asignación para señales Menor o igual en comparaciones Usado para indicar rango indefinidos Usado para definir identificadores extendidos Usado para separar números o cadenas de bits largas Ejemplos de uso std_logic_vector := “001000” “Una cadena” “una cadena con “”comillas””.all A := A / 4. (punto) / : .std_logic_1164.número binario 16#af125f# -. Facultad Regional Bahía Blanca Símbolo “ # & ‘ (comilla simple) ( ) * + . constant C : integer.100# use ieee. -. signal A : std_logic. A+B Cuenta_REG + 1 A–B Cuenta_REG – 1 port map(A => A.Cuando la expresión sea -. < = > [ ] | (barra vertical) => Significado Agrupa valores de bits Forma cadenas de texto Divisor para números en base 2 a 16 Operador de concatenación Atributos Calificación de tipo ambiguo Caracteres Valores de dígitos de bit Subprogramas.Diseño digital utilizando FPGAs Tabla 5 Símbolos especiales de VHDL UTN.1 o 2 o 3 when “000” => port map(A => A. A_REG <= ‘1’. B => B) 0.5 2#0. para agrupar operadores y dar prioridad en expresiones.número hexadecimal “001” & “111” -. Multiplicación Suma o identidad Resta o negación Separa listas de parámetros Punto decimal Jerarquía en librerías División Especificación de tipo Fin de instrucción Menor en comparaciones Igual en comparaciones Mayor en comparaciones Múltiples opciones en una condición Opciones case. if (A < B) then if (A = ‘0’) then if (A > 0) then when 1 | 2 | 3 => -.equivalente a “001111” Clock’event A’left B’high unsigned’(“10001”) ‘A’ ’c’ ‘ ’ ‘0’ ‘1’ ‘Z’ (alta impedancia) function () (A + B) * 4 A := A * 4.” 2#1001000# -.

Se puede usar notación exponencial con ambos tipos de número. Los reales son números representan aproximaciones a números fraccionarios y contienen un punto decimal con al menos un número antes y uno después.3. Estas pueden estar definidas en base binaria. octal o hexadecimal Ejemplos de cadenas de bits B”1100000” (8 bits) b”100_000” (7 bits) x”FA” (8 bits) x”A3B6C1” (24 bits) o” 530” (9 bits) O”54” (6 bits) X”F160_1234” (32 bits) ©2003 Guillermo Güichal 66 . Facultad Regional Bahía Blanca 7. -.23e-4 0. -. En general los reales no se utilizan en diseños para síntesis.5 2#0. Deben comenzar con una letra y no pueden tener mas de dos guiones bajos seguidos ni terminar con un guión bajo. Ejemplos de números reales: 1. Esto se hace para poder comunicarse con herramientas de desarrollo que aceptan identificadores con formatos diferentes a los de VHDL. Los números pueden representarse en cualquier base de 2 a 16 usando #.Una señal variable CuentaModulo1_VAR : std_logic_vector(3 downto 0).Diseño digital utilizando FPGAs UTN.2e4 1.Una variable A partir de VHDL-93 se permite definir identificadores extendidos utilizando el símbolo “\”.3 Identificadores Los identificadores se utilizan para dar nombre a los elementos de un diseño. Los identificadores pueden utilizar los caracteres alfanuméricos y el guión bajo “_”. -. variables o cualquier otro elemento del diseño. ya sea señales. Estos identificadores extendidos pueden tener cualquier símbolo sin las limitaciones de los identificadores básicos de VHDL.5 Cadenas de bits Para poder representar los valores básicos binarios de señales de diferentes anchos VHDL define las cadenas de bits. Ejemplos: constant UTN_CUENTA_MAXIMA : integer := 56. Hay dos tipos básicos de números.3. 7.4 Números Los números pueden representarse en diferentes bases y formatos.23 1. los enteros (integer) y reales (real).4# Ejemplos de números enteros: 1 2 3467 2#01110# 16#0AFD24# 7.10# 8#0.3. Recordar que no deben usarse palabras reservadas como identificadores y que VHDL no diferenciará identificadores solo por las mayúsculas.Una constante signal CuentaDeReloj_REG : std_logic_vector(3 downto 0).

2 Declaración de Tipos Como ya se mencionó. type IdentificadorDeTipo is range MayorValor downto MenorValor. Facultad Regional Bahía Blanca 7. Esto significa que no pueden asignarse valores a señales o variables que no sean del tipo declarado para esa señal o variable. La tabla presenta algunos de los tipos más utilizados.4 Tipos en VHDL VHDL es un lenguaje de tipos fuertes (strong typing) como el Ada o Pascal4.231 + 1) hasta el (231-1) Usado para representar valores fraccionarios Usado para controlar tiempo en los modelos. Usada para señales Definido a partir de std_logic. Un tipo que toma un rango de valores se declara de la siguiente manera type IdentificadorDeTipo is range MenorValor to MayorValor. También está diseñado para que haya mucha flexibilidad para definir nuevos tipos. 4 ©2003 Guillermo Güichal 67 . es muy simple definir nuevos tipos en VHDL. ya que no solo define que valores podrá tomar. toma los valores TRUE o FALSE Contiene todos los caracteres ISO de 8 bits Valores enteros.4. Como mínimo deben incluir los valores desde el (. señales y archivos.4. variables. Especialmente importante durante las simulaciones. Para poder asignar un tipo diferente. En algunos casos los tipos más utilizados no son los predefinidos sino tipos estándares definidos por el usuario. El tipo de un objeto es muy importante.Diseño digital utilizando FPGAs UTN. el programador debe llamar explícitamente a una función de conversión de tipo. Hay cuatro clases de objetos en VHDL: constantes. Tabla 6 Tipos más utilizados en VHDL Tipo bolean carácter integer real time std_logic std_logic_vector Comentario Tipo buleano. sino también que operaciones se pueden realizar sobre él. Cuadro 7 Declaración de tipos A diferencia del C que tiene tipos débiles 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). 7. permite tener señales de un ancho de varios bits 7.1 Tipos Comunes VHDL tiene solo unos cuantos tipos predefinidos.

4. ‘3’. ‘4’. ‘1’.3 Tipos enumerados También pueden declararse tipos que toman un número discreto de valores usando la declaración: type IdentificadorDeTipo is (Valor1. Valor2. ‘1’.1 Tipo Natural y Positivo El estándar VHDL incluye dos subtipos definidos de la siguiente manera. lectura. fin). ‘5’. type tdHorasDelDia is range 0 to 23. type tdCicloLectura is (comienzo.4 Subtipos Así como se pueden definir nuevos tipos. ’6’. Mas ejemplos de tipos: type tdMinutos is range 0 to 59.). fácilmente se pueden definir subtipos a partir de tipos ya declarados. ‘2’. ‘Z’). subtype Subtipo is Tipo range ValorMenor to ValorMayor.4.Los enteros de 0 al mas alto subtype positive is integer range 1 to EnteroMasAlto. -. -. Un tipo muy subtype natural is integer range 0 to EnteroMasAlto. execute1.Diseño digital utilizando FPGAs UTN. 7.. type tdUnTipoRaro is range 59355 downto -456. type tdLogica3Estados is (‘0’.Los enteros de 1 al mas alto ©2003 Guillermo Güichal 68 . execute2). decode. Facultad Regional Bahía Blanca Ejemplos: type tdDiaDelMes is range 0 to 31. Cuadro 8 Declaración de tipo enumerado Ejemplos: type tdCPUCycle is (fetch.. . type tdOctal is (‘0’. La siguiente expresión permite hacer esto.4. 7. ‘7’).4. Cuadro 9 Declaración de subtipos 7. Valor2.

ms = 1000 us.Declaración de un tipo para medidas type tdLongitud is range 0 to 1E9.4. cm = 10 mm. -.4 mm pie = 12 pulgada. units fs. La declaración de time es la siguiente. units um. type time is (rango depende de la implementación). ps = 1000 fs.5.6 Tipos compuestos VHDL permite declarar tipos compuestos por mas de un valor. m = 100 cm.Multiplicador debe ser entero -. ©2003 Guillermo Güichal 69 . mm = 1000 um. -.5 Tipos Físicos VHDL puede definir tipos físicos para representar valores de cantidades físicas del mundo real. pulgada = 25400 um.1 Tipo Tiempo El tipo físico predeterminado tiempo (time) es muy importante ya que es muy usado al modelar retardos. end units tdLongitud.4. Cuadro 10 Declaración de tipo físico 7. Facultad Regional Bahía Blanca 7. Cuadro 11 Tipo físico tiempo (time) 7. Los tipos compuestos en VHDL pueden ser arreglos (array) o records (record).4. min = 60 sec. sec = 1000 ms. Al declarar un tipo físico se define una unidad primaria y unidades secundarias.No puede ser pulgada = 25. hour = 60 min. Un tipo compuesto es un conjunto o agrupación de valores que se trata como una unidad.Diseño digital utilizando FPGAs UTN. ns = 1000 ps. end units time. us = 1000 ns. El cuadro muestra algunos ejemplos de declaraciones de tipos físicos.

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

7.4.6.1 Arreglos Un arreglo (array) es una colección de valores todos del mismo tipo. Se describe la declaración de tipos arreglos con varios ejemplos. Aunque todavía 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 (4) := ‘1’; PalabraDecontrol (6) := ‘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 asignación por posición ContadorPrincipio := (0, 0 ,0); -- Ejemplo de asignaciones nombrada (named) ContadorPrincipio := (Inicial to Ejecucion => 0); -- Otro ejemplo ContadorPrincipio := (Inicial => 0,

©2003 Guillermo Güichal

70

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

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 más 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 notación por posición 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 explícita con notación 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 continuación 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 más utilizado para señales de ancho de más de un bit. Los paquetes se presentan más adelante. El segundo es un tipo predefinido de VHDL, string, y permite definir cadenas de caracteres. No se utilizan para diseños 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 diseños sintetizables constant Cadena: string (0 to 10); -- Rango definido explicitamente variable Cadena: string := “Cadena de caracteres “; -- Rango definido -- de manera implícita

©2003 Guillermo Güichal

71

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

-- std_logic_vector. Buena práctica siempre definirla como (MSB downto 0) constant PalabraControl : std_logic_vector (3 downto 0) := “1001”; constant PalabraControl : std_logic_vector (15 downto 0) := X“F5D6”; signal PalabraEntrada : std_logic_vector (3 downto 0); 7.4.6.3 Records Un record es una colección de valores que no deben ser todos del mismo tipo. Se presentarán 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 : integer range 0 to horas : integer range 0 to end record tdTiempo; valores para llevar un minutos y segundos 59; 59; 23;

-- Declaración y asignación para un objeto del tipo tdTiempo constant Espera : tdTiempo := (seg => 4, min => 21, horas => 0);
Cuadro 14 Declaración de un record

7.4.7 Calificación y Conversión 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 explícitamente 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 -- también 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 conversión explícitamente. Esto se hace utilizando el tipo al que se quiere convertir seguido del valor de otro tipo entre paréntesis. Ejemplos: real(3) integer (4.5)

-- Para convertir el entero 3 a real -- Para redondear el real 4.5 a entero

©2003 Guillermo Güichal

72

En vez de esto. hay cuatro clases de objetos que pueden declararse en . se mantienen constantes en el tiempo. con tipos nombres que tengan sentido al leer el código. signal Reset : std_logic. Como su nombre lo indica. 7. -. signal InterrupcionCPU : std_logic.5 Objetos en VHDL Como se mencionara anteriormente. Estos tipos se han definido por un estándar del IEEE que se describe más adelante.5. constant TIEMPO_SIMULACION_MAXIMO : time = 200 ns. variables y señales. En esta sección se presentarán las constantes. Los tipos de señales mas utilizados son los mostrados en las declaraciones del cuadro. ©2003 Guillermo Güichal 73 . puede definirse un paquete que contenga todas las constantes usadas en el proyecto. Las constantes se utilizan para poder asignar tipos definidos a valores. Se utilizan para parametrizar valores que se repetirán en distintos lugares del diseño y evitar “números mágicos”. Cuadro 15 Declaración de constantes 7. Facultad Regional Bahía Blanca 7. constant CONTADOR_ANCHO_DE_CUENTA : natural := 2. constant ADC_VALOR_MINIMO : integer := -3000.5. Los archivos no pueden usarse para diseños sintetizables y se describirán en otra sección. ----- Declaración de constantes El formato usado en este ejemplo para los identificadores de constantes es el recomendado en varias guías de código VHDL constant ADC_VALOR_MAXIMO : integer := 3000.1 Constantes Las constantes son tipos en las que se almacenan datos que no cambian. En general deben utilizarse señales al hacer un diseño que será sintetizado. Las constantes se declaran como se muestra en el cuadro.Declaración de señales usadas en un modelo signal Reloj : std_logic.Diseño digital utilizando FPGAs UTN.2 Señales Las señales son la representación de las conexiones de hardware que toman valores lógicos. EL operador para asignación de valores a una señal es el símbolo “<=”. que aparecen en el código pero no se entiende bien que significan ni que tipo tienen.

3. variable B : integer := 56. BufferSalida <= “ZZZZZZZZ”.5. variable TiempoDeEspera : time := 0 ns.Señal a tres estados BufferSalida <= (others => ‘Z’) -. Las variables toman los valores instantáneamente al asignarse en el código. -.Asignación de valores de señales.5. Al sintetizar un circuito.Señal a tres estados -. -. variable ValorMaximo_VAR : std_logic_vector(1 downto 0). ADCData_REG <= ADCData_IN after 2 ps. -. Cuadro 17 Declaración de variables ©2003 Guillermo Güichal 74 .Asignación de valores de variables A := 45. Reloj <= ‘1’ after 20 ns. -.Declaraciones de variables variable A : integer. ADCData_REG <= ADCData_IN. Cuenta_REG <= “0111111” after 1 ms. Reloj <= ‘0’. signal ADCData_REG : std_logic_vector(ADC_MSB downto 0). -. variable C : natural := 2#100_0111.Ambas variables del mismo tipo TiempoViejo := TiempoActual. como se explicara en la sección 5. Reloj <= ‘1’.El tipo de A debe aceptar el valor 45 C := B. o un cable. 7.3 Variables Las constantes pueden almacenar datos para utilizarlos en el modelo. -.Asignación de valores de señales con retardo. pero las variables son muy útiles al diseñar bancos de prueba. la asignación puede verse como una conexión física. Para diseños sintetizables se recomienda utilizar señales.Diseño digital utilizando FPGAs UTN. Reloj <= ‘0’ after 20 ns. Cuenta_REG <= “0111111”. Se asemejan a las variables de otros lenguajes de programación. Facultad Regional Bahía Blanca signal Cuenta_REG : std_logic_vector(5 downto 0). El operador de asignación para las variables es “:=”. Cuadro 16 Declaración y uso de señales En simulación las señales toman sus valores un delta de tiempo después de que se ejecuta la instrucción. BufferSalida <= (others => ‘Z’) after 40 ns.

darles una jerarquía y poder reutilizarlas de una manera ordenada. Al analizar el código.Para usar las compuertas básicas se debe agregar la -. la herramienta puede tener un menú donde se seleccionan las librerías y se especifica el lugar dentro del disco rígido donde estas se localizan. VHDL reserva el nombre de librería work para la librería del diseño actual. A esto se lo denominará unidad de librería. La librería work se agrega al diseño en el que se está trabajando de manera implícita. Facultad Regional Bahía Blanca 7. Si se necesita acceder a entidades. Esto significa que una librería es solo una manera de agrupar diferentes unidades para organizarlas.1 Librerías Una librería se define como una colección de unidades de librería.6 Librerías y Paquetes En VHDL los componentes se describen utilizando entidades y definiendo arquitecturas por separado.Diseño digital utilizando FPGAs UTN. declaraciones o funciones de otra librería se debe utilizar la instrucción library.Aquí pueden utilizarse los componentes declarados en -.2 Paquetes (Packages) Un paquete (package) en VHDL es otras unidad de diseño además de las entidades y arquitecturas que contiene definiciones de objetos que pueden ser utilizados por otros ©2003 Guillermo Güichal 75 . -.librería que las contiene library CompuertasBasicas.6. Cuadro 18 Uso de una librería La localización de la librería no está especificada por VHDL sino por la herramienta que se está utilizando. architecture Estructural of LogicaCompleja is begin -. 7. 7. Dependiendo de la herramienta y el sistema operativo de la computadora que se utilice una librería puede ser una carpeta directorio o una base de datos que contenga los nombres de las entidades y arquitecturas que le pertenecen. Supongamos que hay un conjunto de componentes que se quieren reutilizar y han sido asignados a una librería llamada CompuertasBasicas en algún diseño anterior. Estos bloques se denominarán unidades de diseño. cada unidad se asigna a una librería de una manera dependiente de las herramientas utilizadas. Por ejemplo. Esa información luego queda guardado en una base de datos para poder procesarla cuando el analizador encuentra la directiva library en el VHDL.la librería CompuertasBasicas end architecture Estructural.6. Para utilizar esos componentes se debe agregar lo siguiente antes de la especificación de una arquitectura.

.Declaraciones de constantes constant . .----------------------------------------------------.. En el cuadro se muestra el formato general de un paquete.) return .) return .. .) is . La segunda sección del paquete es el cuerpo (body) en el cual se implementan los subprogramas.. subtype .. end package NombrePaquete... Esto permite esconder la implementación del funcionamiento de los ítems del paquete.Declaraciones de señales signal . . constantes.--. -.. -..Declaraciones de tipos type . En esta sección se deben especificar todas las declaraciones de los ítems que luego serán visibles a las unidades en las que se incluya el paquete. procedimientos y componentes... . La expresión utilizada para utilizar un paquete de una librería dada redescribe a continuación ©2003 Guillermo Güichal 76 . -.. -. funciones.Definición del cuerpo del paquete package body NombrePaquete is function F1(.. Facultad Regional Bahía Blanca módulos.. Cuadro 19 Declaración de paquetes La estructura de definición de paquete tiene primero una declaración en la que se define la interfase con el paquete... Las señales que se definen en un paquete serán globales y podrán accederse por cualquier entidad que utilice el paquete..Declaraciones de subprogramas function F1(. Estas podrán ser utilizadas en cualquier archivo en el que se incluya el paquete.) is .. Lo mismo sucede con los tipos y constantes definidas en el paquete...Declaración de un paquete package NombrePaquete is -.Diseño digital utilizando FPGAs UTN. function F2(. -. . tipos.. Las clases de objetos que se puede colocarse en un paquete incluyen declaraciones de señales. end package body NombrePaquete. function F2(.... ...

-.all.Utilización de los paquetes lógicos estándar del IEEE library ieee. -.una libreria library NombreLibreria. el IEEE definió un paquete con operaciones aritméticas para números representados por vectores de bits. -.NombreItem.all.6. use ieee.NombrePaquete. este paquetes es tan utilizado que casi podría considerarse un aparte del lenguaje. Además de definir el paquete std_logic_1164.std_logic_1164. -.paquete -. Se recomienda siempre usar los tipos definidos en estos paquetes.NombreLibreria debe usarse la instrucción use library NombreLibreria. Para estandarizar el IEEE desarrolló un paquete lógico estándar denominado std_logic_1164. Facultad Regional Bahía Blanca -.en un paquete NombrePaquete de una librería -. -. -.Para agregar un item declarado como NombreItem -.Declara que se usara la libreria use NombreLibreria.numeric_std.Diseño digital utilizando FPGAs UTN.3 Paquetes de Lógica Estándar del IEEE Como puede verse de la sección donde se describen los tipos en VHDL el lenguaje tiene una gran capacidad para extender los tipos y definir y sobrecargar operadores y funciones. Aunque no es realmente parte de VHDL.all. Para utilizar la lógica 1164 del IEEE o los paquetes numéricos estándar con las operaciones aritméticas sobre la lógica estándar se debe agregar el use de los paquetes adecuados. como se detallará mas adelante.Lógica estándar use ieee. -.Operaciones aritméticas Cuadro 21 Uso de los paquetes estándar IEEE ©2003 Guillermo Güichal 77 .Uso del paquete Cuadro 20 Uso de un paquete 7.NombrePaquete.Uso del -. Este paquete se denomina numeric_std y es el recomendado para diseños sintetizables.Declara que se usara la libreria use NombreLibreria.Para agregar todos los tipos y constantes de -.

3. std_logic_vector es un arreglo sin límites. Facultad Regional Bahía Blanca 7. y el valor de los índices máximo y mínimo se dan al declarar el objeto de ese tipo. Ejemplo de uso del tipo std_logic en la declaración de señales en una arquitectura signal Cuenta_REG : std_logic_vector (31 downto 0). Si la salida del buffer es alta impedancia (‘Z’) el valor de la señal estará dado por la resistencia.6. esta forzará el valor de la señal mas allá de la resistencia de “pullup”. pero si el buffer tiene una salida lógica. Este tipo es lo que se denomina lógica resuelta ya que incluye funciones que definen que pasa cuando varias salidas se conectan a una señal. ‘1’ y ‘Z’) y además una resistencia de “pull-up” a la tensión de alimentación con un valor alto (valor ‘H’). Estos tipos se nos permite modelar señales y buses de diferentes anchos. Por ejemplo.Diseño digital utilizando FPGAs UTN. Ejemplo de uso del tipo std_logic en la declaración de una entidad : entity Contador is port( Clock_IN : IN std_logic. Del tipo std_logic se define el tipo std_logic_vector que es un arreglo (array) de std_logic. signal intFinDeCuenta : std_logic. Reset_IN : IN std_logic. ©2003 Guillermo Güichal 78 . Los tipos std_logic y std_logic_vector son los recomendados para su uso y son los que se usarán en los ejemplos de este texto. Cuenta_OUT : OUT std_logic_vector (31 downto 0) ). Tabla 7 Valores posibles para lógica std_logic Valor ‘U’ ‘X’ ‘0’ ‘1’ ‘Z’ Descripción Sin inicializar Desconocido forzado 0 forzado 1 forzado alta impedancia Valor ‘W’ ‘L’ ‘H’ ‘-‘ Descripción Desconocido débil 0 débil 1 débil No importa A partir de esta lógica también se define el subtipo std_logic.1 Lógica estándar std_logic y std_ulogic definidos en std_logic_1164 El paquete std_logic_1164 dentro de la librería ieee define un tipo std_ulogic con nueve valores posibles. si una señal tiene un buffer de tres estados que la maneja (posibles valores ‘0’. Los valores débiles y forzados se incluyen para poder modelar hardware que tiene diferentes capacidades de controlar una señal.

Así las señales del tipo std_logic_vector serán tratadas como con signo o sin signo según cual paquete se haya incluido. A continuación se resumen las opciones de encabezamientos recomendados para usar diferentes paquetes. que se distribuyen como parte de la librería IEEE. define las operaciones dadas en la siguiente tabla. Al utilizar los paquetes std_logic_arith junto a std_logic_signed o std_logic_unsigned se puede operar directamente sobre std_logic_vector. usados para representar números enteros con y sin signo respectivamente. sino devuelve FALSE. Además de esos dos tipos. Si se desea utilizar estos paquetes. Estos son signed y unsigned.6.2 Detección de flancos de señales 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 síntesis.6. sino que obliga al programador a declarar explícitamente las cadenas de bits como del tipo signed o unsigned antes de poder realizar operaciones aritméticas sobre ellos. falling_edge(S) boolean 7. -. Estos paquetes surgieron antes de la librería estandarizada numeric_std.4 Aritmética sobre lógica estándar El paquete numeric_std define dos nuevos tipos a partir de la std_logic. mientras que en los otros dos se definen conversiones para poder usar las funciones aritméticas con tipos std_logic_vector. ©2003 Guillermo Güichal 79 . se debe incluir el paquete std_logic_arith y solo uno de los otros dos paquetes.Encabezamiento para usar los tipos std_logic y std_logic_vector sin operaciones aritméticas library ieee.all. Los paquetes std_logic_arith. Devuelve TRUE si hay un flanco descendente sobre S. Tabla 8 Funciones de detección de flanco de señales Función rising_edge(S) Tipo que devuelve boolean Descripción Devuelve TRUE si hay un flanco ascendente sobre S. por lo que resultan más prácticos. Facultad Regional Bahía Blanca 7. sino devuelve FALSE. use std_logic_1164.Diseño digital utilizando FPGAs UTN. Las siguientes líneas deben incluirse de la manera especificada en los diseños para usar los tipos std_logic_vector. Inc. En la tabla se enumeran las operaciones y el resultado de operar sobre los distintos tipos. Estos paquetes cumplen la misma función para cadenas de bits del tipo std_logic_vector. este paquete numeric_std no define operaciones sobre los vectores estándar. como ya se verá mas adelante.3. Como se mencionó antes. En std_logic_arith se definen las operaciones sobre tipos del tipo signed y unsigned. std_logic_unsigned y std_logic_signed son paquetes de Synopsis.

use std_logic_arith. -. Tabla 9 Resumen de tipos de las operaciones aritméticas Oper.Encabezamiento para usar los tipos std_logic y std_logic_vector y tratarlos como -. Ambos deben ser de igual longitud. use std_logic_1164. use std_logic_unsigned.all.all.all. ©2003 Guillermo Güichal 80 .all. Operación Tipo del operando izquierdo abs + * / rem mod = /= < <= > >= sll srl rol ror not and or nand nor xor xnor valor absoluto negación suma resta multiplicación división resto módulo igualdad diferente menor menor o igual mayor mayor o igual corrimientos lógicos rotaciones negación operaciones lógicas Tipo del operando derecho signed unsigned signed natural unsigned integer signed unsigned signed natural unsigned integer signed integer integer Tipo del resultado signed unsigned signed unsigned unsigned signed signed boolean boolean boolean boolean boolean boolean unsigned signed Longitud del resultado Longitud del operando La mas grande de los dos operandos Suma de las longitudes Longitud del izquierdo Longitud de operando derecho unsigned signed unsigned natural signed integer unsigned signed unsigned natural signed integer unsigned signed Longitud del operando del tipo vector de bits unsigned signed unsigned signed unsigned signed unsigned signed unsigned signed Longitud del operando Longitud de los operandos. use std_logic_signed.Diseño digital utilizando FPGAs UTN.Encabezamiento para usar los tipos std_logic y std_logic_vector y tratarlos como -.números con signo (complemento a dos) en las operaciones aritméticas library ieee. use std_logic_1164. use std_logic_arith.all. Facultad Regional Bahía Blanca -.all.números sin signo en las operaciones aritméticas library ieee.

entity Componente is port( … Declaración de puertos de entrada salida … ). o que las presentadas sean las únicas estructuras sintetizables. como se mostró en la sección 7.7 Construcciones Básicas de VHDL En esta sección se presentarán las construcciones básicas de modelado. Esto facilita la comprensión del diseño. En la arquitectura. antes de la palabra begin se definen todas las señales internas que se utilizarán en el modelo. En los apéndices pueden consultarse ejemplos de este tipo de modelo que servirán como guía para nuevos diseños. En términos generales. No conviene mezclar ambos modelos y no se hará en este texto. En este esquema se van las declaraciones de la entidad y arquitectura. separadas de otras declaraciones de entidades y arquitecturas. Después de la palabra begin recién comienza una serie de operaciones que concurrentes que se ejecutarán en paralelo. Es buena práctica incluir ambas unidades5 para un componente en un solo archivo que tenga el mismo nombre que la entidad. Las descripciones y ejemplos dados estarán orientados a diseños sintetizables. un componente en VHDL se define utilizando dos unidades de diseño: entity y architecture. Esto permite modelar el verdadero funcionamiento del hardware ya que en general habrá muchas tareas ejecutando en paralelo e interactuando entre sí. Utiliza las palabras port map para logar esta interconexión. Un modelo estructural incluye todos los componentes básicos y las señales que los interconectan. Como se ha visto de las secciones anteriores El VHDL es muy flexible y una misma tarea o función puede modelarse de muchas maneras diferentes. Esto no significa que no haya otras estructuras y maneras diferentes de definir la misma funcionalidad para un modelo.3. y dentro de la arquitectura varias secciones básicas. 5 Si existe más de una arquitectura para una entidad todas deberían estar definidas en el mismo archivo. Facultad Regional Bahía Blanca 7. la arquitectura de un componente puede ser un modelo de comportamiento o estructural. ayuda a localizar rápidamente los componentes y ayuda a reutilizar el código.2. Es importante destacar que en VHDL-87 se deben declarar los componentes básicos que se usarán usando la palabra component antes del begin de la arquitectura. En VHDL-93 pueden usarse componentes directamente destacando explícitamente a que librería pertenecen.Diseño digital utilizando FPGAs UTN. Como se ha visto anteriormente. La estructura general de un componente en el que se modela su comportamiento es la mostrada en el cuadro. ©2003 Guillermo Güichal 81 . Los ejemplos se presentarán siguiendo prácticas recomendadas para el código que facilitan su entendimiento y reutilización.

Diseño digital utilizando FPGAs
end Componente;

UTN, Facultad Regional Bahía Blanca

-- ---------------------------------------------------- -architecture Comportamiento of Componente is … Declaración de señales internas del componente … begin – Comienzo de la especificación del comportamiento -- En esta sección se define el comportamiento -- utilizando las construcciones de VHDL necesarias -- según el modelo que se implemente … Serie de operaciones concurrentes: … Operación concurrente 1 (proceso u operación aislada) … Operación concurrente 2 (proceso u operación aislada) … proceso A … Declaración de variables internas del componente begin -- Comienzo de las instrucciones secuénciales del proceso … operaciones secuenciales … end process; proceso B … Declaración de variables internas del componente begin -- Comienzo de las instrucciones secuénciales del proceso … operaciones secuenciales … end process; … end architecture Comportamiento;
Cuadro 22 Esquema básico de un componente en VHDL

7.7.1 Declaración de señales
Todas las señales que se utilizan internamente en el componente deben declararse. Los tipos recomendados de señales para diseños sintetizables son std_logic, std_logic_vector, signed y unsigned, como se explicara en la descripción de paquetes en secciones anteriores. Para diseños sintetizables no se deben asignar valores iniciales a las señales ya que estos no tienen sentido en una implementación de hardware real.

©2003 Guillermo Güichal

82

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

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 instrucción concurrente. Este mecanismo se denomina proceso (process) Algo importante a tener en cuanta para diseños sintetizables sobre PLDs es que a una señal se le debe asignar un valor en solo una operación concurrente. Es decir, dos operaciones concurrentes no pueden tratar de asignar un valor a la misma señal. Si se piense que significaría esto en hardware se vería que habría dos o mas componentes o elementos lógicos con sus salidas conectadas a la misma señal. 7.7.2.1 Flujo de datos La manera más simple de modelar una operación concurrente es usando las asignación para señales “<=”. Este operador indica que el resultado de la expresión a la derecha debe asignarse a la señal de la izquierda. Obviamente la señal y el resultado de la evaluación de la expresión deben ser del mismo tipo. Estas asignaciones se sintetizarán como lógica combinacional. La expresión de la derecha debe utilizar operadores que estén definidos para las señales utilizadas y que además sean sintetizables. Los operadores lógicos LISTA, de suma “+” y resta “–“ y la multiplicación y división 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 evaluarán todas al mismo tiempo.

library ieee; use ieee.std_logic_1164.all; -- Lógica estándar 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í

©2003 Guillermo Güichal

83

Diseño digital utilizando FPGAs
); end Logica2Entrdas;

UTN, Facultad Regional Bahía Blanca

architecture Comportamiento of Logica2Entrdas is -- Señales 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;

intSalidaAnd <= Entrada1_IN and Entrada2_IN; intSalidaOr <= Entrada1_IN or Entrada2_IN; end architecture Comportamiento; -- ----------------------------------------------------- -library ieee; use ieee.std_logic_1164.all; -- Lógica estándar use ieee.std_logic_arith.all; -- Lógica estándar 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í

architecture Comportamiento of Logica2Entrdas is -- Señales 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;

©2003 Guillermo Güichal

84

Cuadro 25 Uso de la palabra AFTER Como VHDL permite modelar el comportamiento eventos en el tiempo. architecture Comportamiento of Logica2Entrdas is begin -. En general las herramientas de síntesis son los suficientemente “inteligentes” como para optimizar esta lógica y sintetizar ambas arquitecturas a la misma implementación. incluye la palabra reservada after que en el contexto presentado significa “después de” “luego de”. SalidaNor_OUT <= not (Entrada1_IN or Entrada2_IN).Operaciones concurrentes que modelan flujo de datos SalidaAnd_OUT <= Entrada1_IN and Entrada2_IN. En este ejemplo no se utilizan señales internas. end architecture Comportamiento. sino que todas las salidas se definen como funciones de las entradas.a la lógica Salida1_OUT <= Entrada1_IN and Entrada2_IN after 20 ns. Esta palabra permite modelar retardos entre el evento que provoca los cambios en una ©2003 Guillermo Güichal 85 . Cuadro 23 Ejemplo de arquitectura definida como flujo de datos Otras manera de definir la misma lógica se muestra en el siguiente cuadro. intSalidaOr <= Entrada1_IN or Entrada2_IN. Esta implementación dependerá del PLD que se esté utilizando.2 Palabra reservada AFTER En los siguientes ejemplos se presentan asignaciones de señal que utilizan la palabra clave palabra clave after. Salida_OUT <= not (Entrada1_IN or Entrada2_IN) after 2 ms.con retardo entre cambios en las entradas y salidas -.Diseño digital utilizando FPGAs UTN.Operaciones concurrentes que modelan flujo de datos -.7. -. Facultad Regional Bahía Blanca intSalidaAnd <= Entrada1_IN and Entrada2_IN.2. SalidaNand_OUT <= not (Entrada1_IN and Entrada2_IN). Logica1 <= Entrada1_IN or Entrada2_IN after 40 ps. end architecture Comportamiento. SalidaOr_OUT <= Entrada1_IN or Entrada2_IN. Cuadro 24 Otro ejemplo de flujo de datos 7. Registro_REG <= not (Entrada1_IN and Entrada2_IN) after 4 ps.

ya que los retardos en un circuito sintetizados dependerán del PLD y de cómo se haya implementado la lógica. y para ello es conveniente usar la palabra others para asignar los valores que faltan y completar los casos.Formato general de la expresión "with. Cuadro 26 Uso de la expresión WITH … SELECT Deben especificarse todos los casos. etc.7. Fuente2 when Condicion2.Ejemplo 2 . tiempos de repuesta de componentes.Operación concurrente with . -. ©2003 Guillermo Güichal 86 . “010101” when "100".. ‘U’. la palabra others debe incluirse siempre para el último caso y así evitar problemas. -. ya sea en una instrucción concurrente o secuencial. 7. Eso hace que haya más combinaciones posibles en un select que las esperadas.3 Expresión with … select La expresión with … select modela un multiplexor. La palabra after no es tenida en cuanta al sintetizar un diseño.Diseño digital utilizando FPGAs UTN.Ejemplo 1 – Con SenalDeControl de 2 bits with SenalDeControl select SenalDeDestino_OUT <= Fuente1_IN when “00”.. "XXXXXX" when others. Mediante esta palabra se pueden modelar retardos en compuertas. select with Seleccion_IN select Salida1_OUT <= Datos1_IN when "001".. La palabra reservada alter puede ser utilizada en cualquier asignación de señal. Esto se muestra en el Ejemplo 2. y permite que se optimice la lógica en el momento de la síntesis. Datos2_IN when "010". Facultad Regional Bahía Blanca señal y la actualización de la señal. Se debe tener en cuenta que los valores posibles de las señales del tipo std_logic no son solo ‘1’ y ‘0’.. select" with SenalDeControl select SenalDeDestino <= Fuente1 when Condicion1. 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. El formato y algunos ejemplos se muestran en el cuadro. Fuente2_IN when “01”. sino que hay otros tales como ‘Z’. Fuente4_IN when “10”. -. ... FuenteN when others.2. Otro puno importante es que muchas herramientas aceptan el valor ‘X’ para las señales de salida. en el que de acuerdo a alguna señal de control puede seleccionarse el valor a aplicar a una señal . Fuente5 when others.

-. else con la SenalDeDestino_OUT <= Fuente1 when Fuente2 when Fuente3 when Fuente4 . con una condición compleja SenalDeDestino <= ‘1’ when X = ‘0’ and Y = ‘1’. En esta operación no es necesario especificar todos los casos.....2..la palabra after OtraSenal <= ‘1’ after 4 ns when X = ‘0’ and Y = ‘1’ else ‘0’ after 3 ns. -. Cuadro 27 Uso de la expresión WHEN… ELSE En el ejemplo 1 se modela una lógica de asignación que toma decisiones sobre una sola señal de control.. else SenalDeDestino <= Fuente1 when Condicion1 else Fuente2 when Condicion2 else . En este caso no se infiere un multiplexor sino que se genera lógica combinacional con prioridades para implementar el circuito modelado.Ejemplo 2 de when. OtraFuente when Condicion3 else FuenteN .Diseño digital utilizando FPGAs UTN. -.Caso por defecto -. -misma señal de control SenalDeControl=”00” else SenalDeControl=”01” else SenalDeControl=”10” else Caso por defecto -. ya que las palabras else indican prioridad. y así hasta llegar a la última.Ejemplo 3 de when. La segunda condición se prueba solo si no se cumple la primera.. Las condiciones de asignación a su vez no deben ser necesariamente sobre la misma señal de control.Ejemplo 3 de when. pero no es la manera recomendable de modelarlo.Caso por defecto -. Muchas herramientas reconocerán en esto un multiplexor y lo sintetizarán como tal. Para evitar ©2003 Guillermo Güichal 87 ..Formato de when... pero debe tenerse en cuanta que al no hacerlo se inferirá un match para guardar el valor de salida anterior. y esto se muestra en el ejemplo 2. else con condiciones varias SenalDeDestino_OUT <= Fuente1 when Control = ”00” else Fuente2 when Control /= ”01” else Fuente3 when OtroControl = ”101” else Fuente4 . else La expresión when … else es otra operación concurrente que puede usarse para modelar lógica con prioridades.4 Expresión when. Si ninguna de las condiciones se cumple se mantendrá el valor anterior utilizando un “latch”. -. Facultad Regional Bahía Blanca 7..Ejemplo 1 de when.. la tercera si no se cumplen ni la primera ni la segunda.7. con una condición compleja y ejemplos de -.

se deben presentar las operaciones secuenciales. wait on PulsoRespuesta_IN.Ejemplos de uso de la instrucción wait. Los usos de la instrucción wait y algunos ejemplos se muestran en el cuadro. wait until (Expresión buleana). En la sección sobre procesos se explicará este mecanismo en más detalle. 7.utiliza para modelos NO SINTATIZABLES -. La principal diferencia es que el bloque de instrucciones secuenciales agrupadas por un proceso se ejecutarán en paralelo con los otros procesos y operaciones concurrentes.un evento sobre la señal -.Diseño digital utilizando FPGAs UTN.Formatos posibles para la instrucción wait wait.--------------------------------------------------------. 7. Esta instrucción es una instrucción secuencial. Facultad Regional Bahía Blanca este “latch“ se debe incluir el último else sin condición final y asignar un valor por defecto. ©2003 Guillermo Güichal 88 . -. En general se -.Suspende el proceso para siempre -.--.7. que son la operación concurrente clave.evaluación de la expresión devuelva TRUE -.fijo de tiempo wait for Tiempo.Suspende el proceso hasta que se la -.. de manera similar a las instrucciones de un lenguaje de programación convencional. Las instrucciones secuenciales se ejecutarán una tras otra.3.1 Instrucción WAIT Además de la palabra reservada after presentada anteriormente.3 Operaciones secuenciales Antes de presentar los procesos. -. -. la otra instrucción que modela el tiempo en VHDL es la instrucción wait.con acarreo Resultado <= A xor B after 20 ns..Suspende el proceso hasta que ocurra -.Espero un cambio en la entrada -.7. SenalAccion_OUT <= ‘1’.Instrucciones secuenciales en un proceso de suma de 1 bit -. -.Suspende el proceso un intervalo -.wait on . y por lo tanto solo se utilizará dentro de un proceso. Permite suspenderlo por un período determinado de tiempo o hasta que se cumpla alguna condición. wait on Señal.

6 ©2003 Guillermo Güichal 89 .--------------------------------------------------------. wait on A.--------------------------------------------------------. -. -. -. -. como se detallará en la sección 0..Pulso de la señal reset en ‘1’ wait for 230 ns.--------------------------------------------------------.. on.Generación de un pulso de 200 ns Reset_OUT <= ‘1’.en el ultimo valor asignado (‘0’) -. wait until (((Entrada1 and Entrada2) xor Entrada3 )= ‘0’). B. El reset queda -. La expresión wait es sintetizable solo en procesos sincrónicos que usan el wait para esperar un evento en la señal de reloj..Suspende 10 nanosegundos wait for 40 ms. Suspende hasta que cambie A o B -. Cuadro 28 Uso de la palabra WAIT Pueden armarse expresiones más complejas con la instrucción wait utilizando combinaciones de los tres formatos for.--. Facultad Regional Bahía Blanca Carry <= A and B after 20 ns. -.wait for .se haga ‘1’ -.. Puede consultarse la bibliografía para una mayor explicación y ejemplos varios. wait for 10 ns..Señal reset a ‘0’ wait. until..Suspende 40 milisegundos -.usando una constante predefinida wait for ADC_TIEMPO _CONVERSION.wait for y wait solo --. wait until (Senal1 = ‘0’ and Entrada2 = ‘0’).--. SenalAccion_OUT <= ‘1’. -.. estas expresiones no se presentarán de manera exhaustiva en este texto. -.wait until .--.Suspende para siempre. Como en general la expresión wait no es sintetizable6 y lo presentado alcanza para armar bancos de prueba simples.. condiciones mas complejas.Ancho del pulso es 230 ns Reset_OUT <= ‘0’.. wait until (PulsoRespuesta_IN = ‘1’).Espero que la entrada -. -.Diseño digital utilizando FPGAs UTN.

.condiciones 1 ni 2) elsif (Condición 4) then .. 2 ni 3) ...se cumple la condición 4 (y no se cumplieron las -. -..los elsif y else son optativos (Condición 1) then . Siempre se debe cerrar un lazo if con una instrucción end if.3. Facultad Regional Bahía Blanca 7. que se ejecutará solo si no se cumple ninguna de las condiciones anteriores..Instrucciones secuenciales que se ejecutan si -.Instrucciones secuenciales que se ejecutan si -.se cumple la condición 1 elsif (Condición 2) then ..Si la cuenta llega a su valor final volver a cero ©2003 Guillermo Güichal 90 ..--------------------------------------------------------. La condición else permite que se de un caso por defecto...condición 1) elsif (Condición 3) then . -. -. Sino se saltearán. Cuando la condición buleana de la instrucción if se evalúa a TRUE se ejecutarán las instrucciones secuénciales que la siguen. .condiciones 1.Una sola condición -. ELSIF. –. ELSE -.ningún caso de las condiciones anteriores end if..Ejemplos de instrucciones if -..se cumple la condición 2 (y no se cumplió la -.. La instrucción elsif permite anidar condiciones. y así sucesivamente.. Los cuadros muestran el formato general y dan ejemplos para la utilización de las instrucciones if.Instrucciones secuenciales que se ejecutan si -. Cuadro 29 Uso de la expresión IF. Si no se da primer condición se evalúa la segunda.2 Expresión if… elsif… else La expresión if permite condicionar la ejecución de instrucciones secuenciales. . else .Instrucciones secuenciales que se ejecutan si -. -. else. generando una lógica de prioridad.7..se cumple la condición 3 (y no se cumplieron las -. elsif... ---if Formato general de la instrucción secuencial if Solo es necesario que haya una condición if.Diseño digital utilizando FPGAs UTN..Instrucciones que se ejecutan solo si no se da -.--.

Diseño digital utilizando FPGAs UTN.Un ejemplo raro que no modela nada if (Control_IN = “00”) then Salida_REG <= Entrada0_IN.if. -. else -. elsif (Entrada1_IN = “0100”) then Cualquiercosa_REG <= ”1100000”. end if. end if.Dar valores iniciales a los registros Registro_REG <= (others => ‘0’).--. -.if. else Salida _REG <= ‘1’.--. Facultad Regional Bahía Blanca if (Contador_REG = VALOR_MAXIMO) then Contador_REG <= (others => ‘0’). elsif (Control_IN = CONTROL_LEO_LSB) then Salida_REG <= DatoEntrada_IN(0). else Salida_REG <= ‘0’. else Signo_REG <= ‘1’. end if. -.--------------------------------------------------------.Detecto el signo de una entrada y lo guardo a un registro if (DatoEntrada_IN(MSB) = ‘0’) then Signo_REG <= ‘0’.Instrucciones secuenciales sincrónicas end if. elsif (Cualquiercosa_REG = ”1111111”) then TodosUnos_OUT <= ‘1’.--------------------------------------------------------. elsif -.Reset asincrónico y ejecución sincrónica if (Reset_IN = ‘1’) then -. else Salida_REG <= Entrada3_IN.. ©2003 Guillermo Güichal 91 . elsif (Rising_Edge(Clock_IN)) then . end if.--------------------------------------------------------.--. end if.if else anidados if (Control_IN = CONTROL_LEO_SIGNO) then if (DatoEntrada_IN(MSB) = ‘0’) then Salida_REG <= ‘0’.--. -. -.if elsif else -.--------------------------------------------------------.

Se utiliza muchas veces en expresiones como case donde deben explicitarse las acciones para todas las alternativas posibles. Se mostrarán ejemplos de su uso en la sección donde se describe la expresión case. Las opciones deben ser .Instrucciones secuenciales que se ejecutan -.7..3 Expresión null En algunos casos es necesario modelar que hay situaciones en las que no se debe tomar ninguna acción.3.ExpresiónSelectora resulta en la condición when Condición 2 => . elsif (Control_IN = “01”) then Salida_OUT <= Entrada1_IN.4 Expresión case Cuando las opciones que se desean evaluar son mutuamente excluyentes y no se necesita una lógica de prioridad.case es la mas recomendada en estos casos) if (Control_IN = “00”) then Salida_OUT <= Entrada0_IN. -.--. En este caso se usa la palabra null para especificar que en algunos casos no se debe hacer nada.7.. Esto puede hacerse en VHDL usando la instrucción null. Facultad Regional Bahía Blanca -.Instrucciones secuenciales que se ejecutan -.. -.Formato general de la instrucción secuencial case case ExpresiónSelectora is when Condición 1 => . ELSE 7.Todos los casos -.Esto implementa un multiplexor usando if (la instrucción -. Esta es una instrucción secuencial y puede usarse en cualquier estructura secuencial.3.Instrucciones secuenciales que se ejecutan si 1 si 2 si ©2003 Guillermo Güichal 92 . Cuadro 30 Ejemplos de la expresión IF. -.ExpresiónSelectora resulta en la condición when Condición 3 | Condición 4 => . Puede utilizarse la barra vertical “|” para agrupar varias opciones y la palabra others para declarar un caso para las opciones que no se evalúan de manera explícita. la expresión a usar es case.. else Salida_OUT <= Entrada3_IN.Diseño digital utilizando FPGAs UTN.--------------------------------------------------------.. ELSIF. 7. Todas las opciones deben tenerse en cuanta en la expresión. elsif (Control_IN = “10”) then Salida_OUT <= Entrada2_IN. En el cuadro se presenta el formato general de la instrucción case. Esta expresión utiliza la palabra when para evaluar las diferentes opciones en paralelo y siempre debe terminarse con un end case. -. end if..

signal EstadoSiguiente : tdEstado ..El estado inicial y la asignación de EstadoSiguiente a -..Multiplexor utilizando la expresión case case Control_IN is when ”00” => Salida_OUT <= Entrada0_IN.--.. Facultad Regional Bahía Blanca -.. when others => . -. -. ..CASE dentro de un proceso combinacional que asigna el -. .. LachearDato..ExpresiónSelectora no resulta ser ninguna de las -. ..Declaración de estado actual y siguiente signal EstadoActual : tdEstado . PulsoAlADC ). -. -.Instrucciones secuenciales que se ejecutan si -.--.Declaración del tipo para estados type tdEstado is ( EsperarDato. when ”10” => Salida_OUT <= Entrada2_IN.--------------------------------------------------------.EstadoActual se hacen en otro proceso sincrónico con reset case EstadoActual is when EsperarDato => if (ADCDataAvailable_IN = '1') then ©2003 Guillermo Güichal 93 . end case. when ”01” => Salida_OUT <= Entrada1_IN.--------------------------------------------------------. -.próximo estado según el estado actual y las entradas.Diseño digital utilizando FPGAs UTN...Ejemplo para una máquina de estado .. when others => Salida_OUT <= Entrada3_IN. -. -. Cuadro 31 Uso de la Expresión CASE En el siguiente cuadro se presentan ejemplos que ayudará a entender el uso de la instrucción case.Ejemplos de instrucciones case -..opciones anteriores end case.ExpresiónSelectora resulta en la condición 3 o 4 .

5 Procesos (process) El tipo fundamental de operación concurrente es el proceso (process).Diseño digital utilizando FPGAs UTN. como se describe en la sección 5. La asignación de señales en simulación siempre tiene un retardo mínimo de al menos un retardo delta.3. when others => EstadoSiguiente <= EsperarDato. Read_N_REG <= '0'. El proceso en si contiene operaciones secuenciales que se tratarán en bloque como una operación concurrente..sobre escriben en la expresión case . -. end case. Se debe tener en cuanta que no hacer nada significa mantener el valor de salida anterior. when PulsoAlADC => EstadoSiguiente <= LachearDato. la ejecución de todas sus instrucciones secuenciales) será netamente cero7..5..internas y las salidas . y esto implica generar latches o realimentar señales adicionales. El proceso es el bloque clave para modelar la interacción compleja entre señales. end case. when LachearDato => EstadoSiguiente <= EsperarDato. when PulsoAlADC => Read_N_REG <= '0'.A algunas señales se les da valores por defecto que se -. end if. 7 ©2003 Guillermo Güichal 94 . Cuadro 32 Ejemplos de la expresión CASE El uso de null en la segunda expresión case significa no hacer nada. case EstadoActual is when EsperarDato => DatosInternos_REG <= DatosADC_IN. puede dejarse algún caso deseado como caso por defecto y así simplificar la lógica generada. when others => null. Esto significa que el proceso se ejecutará en paralelo con otros procesos y operaciones concurrentes. Si lo que realmente sucede es que no importa que valor tenga la señal se con esa combinación del case. y que el tiempo de ejecución de un proceso (es decir. else EstadoSiguiente <= EsperarDato.7. NuevaMuestra_REG <= '1'. -.3.CASE dentro de un proceso sincrónico que asigna las señales -.. Las operaciones secuenciales utilizadas dentro de los procesos se describen en las siguientes secciones. 7. Facultad Regional Bahía Blanca EstadoSiguiente <= PulsoAlADC.

Declaraciones: Pueden declararse funciones... Después del nombre se utiliza la palabra clave process.. • Declaración del proceso y lista de sensibilidad (señales entre paréntesis) • Declaración de variables.Comienzo de las instrucciones secuenciales ..Formato general de un proceso NombreDeProceso : process(Señal1. Lista de sensibilidad: Un proceso debe tener alguna manera de suspender su ejecución. . . El cuadro muestra el formato básico de un proceso.. y hay varias maneras de especificar cuales serán las señales que causan que un proceso ejecute. . Cuadro 33 Declaración de un proceso Del formato básico mostrado pueden destacarse las secciones principales.más instrucciones secuenciales . los procesos se implementarán como circuitos combinacionales o secuenciales que efectúan la operación modelada..... señal2. La lista de sensibilidad es una de las maneras de definir que señales actúan sobre un proceso.Diseño digital utilizando FPGAs UTN... La otra es la utilización de la instrucción wait.) ... Un evento se entiende como un cambio en el valor de una señal. más declaraciones internas al proceso begin -.. Al sintetizar el diseño. constantes y variables que se utilizarán en el proceso.. Declaración de tipos internos al proceso. Declaración de constantes internas al proceso.. Declaración de variables internas al proceso.. Los circuitos implementados producirán cambios en sus salidas ante eventos en las señales a las que son “sensibles”.. funciones y procedimientos • Bloque secuencial Declaración del proceso: Se recomienda dar un nombre al proceso para ayudar en la depuración y mejor comprensión del código.. los procesos permanecen inactivos hasta que algún evento los hace ejecutar. Facultad Regional Bahía Blanca En simulación. Cuando se utiliza una lista de sensibilidad no puede usarse la palabra wait para suspender un proceso. end process NombreDeProceso. Los procesos se dicen que son “sensibles” a las señales que causan su ejecución. ©2003 Guillermo Güichal 95 . constantes. -.. Instrucción secuencial Instrucción secuencial .

Solo puede usarse uno de los métodos para suspender un proceso Cuando se utiliza una lista de sensibilidad no puede usarse la palabra wait entre las instrucciones secuenciales.Contiene un reset asincrónico que puede usarse para dar -.. ------ --------------------------------------------------------.. Al diseñar circuitos para sintetizar sobre lógicas programables (FPGAs..Solo reloj y reset begin if (Reset_IN = '0') then -.Instrucciones secuenciales sincrónicas . end process Proceso1.Evalúa el flanco de reloj .--------------------------------------------------------. En algunos casos puede ser que el proceso directamente no pueda sintetizarse.sincrónico.Formatos básicos de los procesos recomendados para diseños -.asynchronous reset . El proceso se ejecutará solo cuando haya un cambio en alguna señal de su lista de sensibilidad..Este proceso se sintetiza como flip-flops + lógica -..PROCESO 1 -.Test active level of -.. Si el proceso no tiene lista de sensibilidad se ejecutará cuando se cumpla la condición dada en la instrucción wait.Diseño digital utilizando FPGAs UTN.valores iniciales conocidos a las señales y un bloque -. -..--. -Proceso1 : process (Clock_IN. end if.-PROCESO 2 --------------------------------------------------------.. . elsif Rising_edge(Clock_IN) then -.combinacional.--. -. . Todas las instrucciones secuenciales de un proceso se ejecutarán como un bloque en paralelo con los otros procesos y demás expresiones concurrentes.. Facultad Regional Bahía Blanca Instrucciones secuenciales: Estas están entre las palabras begin y end.--------------------------------------------------------. No hacerlo significa en muchos casos generar lógica adicional que ocupará mayor cantidad de recursos del PLD innecesariamente. -.. El cuadro muestra los patrones (templates) de procesos recomendados para diseños sintetizables.-Este proceso genera solo lógica combinacional ©2003 Guillermo Güichal 96 .Instrucciones secuenciales asincrónicas . CPLDs u otros PLDs) es mejor que los modelos en VHDL se adapten a la lógica básica de los PLDs. -. Reset_IN) -...sintetizables -.

combinacional...Espera un flanco de reloj . -.Todas las entradas a la -.. . -.--------------------------------------------------------..Diseño digital utilizando FPGAs UTN..--------------------------------------------------------.--------------------------------------------------------. -. -.--------------------------------------------------------. -.Solo el reloj en la -..--.--.combinacional. end if.Este proceso se sintetiza como un latch transparente + -lógica combinacional.. -Proceso5 : process (Entrada1..--. end process Proceso3. Es equivalente al Proceso 3 -Proceso4 : process – Sin lista de sensibilidad begin wait until Rising_edge(Clock_IN).. -.lista de sensibilidad begin if Rising_edge(Clock_IN) then -.Solo se evalúa flanco de reloj .--. –.PROCESO 3 -. –.se infieran latches end process Proceso2..Instrucciones secuenciales con latch ©2003 Guillermo Güichal 97 .combinacionales sin realimentación para que no .Instrucciones secuenciales sincrónicas . -..lógica en la lista begin ..) –.PROCESO 4 -..Se asigna salidas para todas las opciones ...--------------------------------------------------------. .--------------------------------------------------------.Este proceso se sintetiza como flip-flops + lógica -....... -Proceso3 : process (Clock_IN) -. .Este proceso se sintetiza como flip-flops + lógica -..Instrucciones secuenciales sincrónicas .. end process Proceso4. -.--..--.lógica en la lista begin if Enable = '1' then . Facultad Regional Bahía Blanca Proceso2 : process (Entrada1. .Contiene solo lógica sincrónica.PROCESO 5 -. ..) –..Todas las entradas a la -. -.

secuenciales X <= ‘1’. Cuadro 34 Declaración de procesos para síntesis UTN. La decisión tomada en este momento no dependerá del valor asignado en la instrucción anterior a X (que todavía no ha sido asignado. En este caso ©2003 Guillermo Güichal 98 . Estos dos procesos son los procesos 1 y 2 mostrados en el cuadro. Luego se procesará la operación X <= ‘0’.4 Operaciones secuenciales. VHDL utiliza retardos-delta. retardos delta y síntesis Debido a la manera en que VHDL simula y sintetiza las instrucciones secuenciales en un proceso pueden surgir algunas confusiones al observar su funcionamiento. muchos usuarios esperarían que al finalizar. Para explicar el procesamiento del proceso.5. para diseños orientados a FPGAs es recomendable generar procesos sincrónicos con una señal de reset asincrónica. En general no se recomienda usar sistemas que utilicen latches como el presentado en el proceso 5. 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.Diseño digital utilizando FPGAs . El cuadro muestra un ejemplo para explicar esto.3.. sino del valor actual de X (que no es ‘1’). Luego se analizará la instrucción if (X = ‘1’). if (X = ‘1’) then Y <= ‘0’. A continuación siguen dos procesos equivalentes. sobrescribiendo la asignación ‘1’ que estaba agendada. Facultad Regional Bahía Blanca Como se verá en el próximo capítulo. Estos procesos son sincrónicos sin señal de reset. -. end if. También es posible que se necesiten procesos totalmente combinacionales. sino que solo agendado). Otra vez. end process Proceso5. A Y se le agendará entonces el valor ‘1’ de la rama else. 7. al procesar la instrucción X<= ‘1’. else Y <= ‘1’. Después de haber procesado todas las instrucciones secuenciales se asignan los valores agendados a las señales. ¡Esto puede no suceder nunca! A continuación se explicará porque. X <= ‘0’. Si se supone que el valor de X al comenzar el proceso (asignado en algún momento anterior de alguna manera no descripta) no es ‘1’.7. la señal Y tenga el valor ‘0’. sino que se agendará como se ha explicado en la sección 5. este valor no se asignará instantáneamente sino que se agendará. end if. no se asignará en ese instante el valor ‘1’ a X.Ejemplo para explicar el funcionamiento de instrucciones -..

En la Figura 39 se muestra un esquema de un componente. pero tienen una visibilidad que abarca la declaración de interfase y toda la arquitectura del componente. nunca se asigna el valor ‘1’ a X de la primer instrucción. A su vez las variables declaradas dentro de los procesos y funciones tendrán una visibilidad local. Si se declaran como parte de la declaración de la arquitectura serán visibles en toda la arquitectura. Para que sean visibles se deben usar antes de la declaración de entidad o arquitectura respectivamente.5 Visibilidad de las declaraciones de objetos en VHDL Los objetos declarados en VHDL. Esto se hace usando el nombre de la librería.Diseño digital utilizando FPGAs UTN. ©2003 Guillermo Güichal 99 . Las constantes genéricas no han sido descriptas todavía. Si se declaran dentro de un proceso solo podrán verse dentro del proceso.7. Estas se pueden declarar en las regiones de declaración de la arquitectura o de los procesos (antes de la palabra begin).std_logic. 7. Por ejemplo. constantes y señales hechas en una arquitectura serán visibles para toda la arquitectura. En el siguiente capítulo se presentarán ejemplos de circuitos sintetizados para mostrar como se implementa en hardware una secuencia de instrucciones como la recién descriptas. Las señales de interfase declaradas en la entidad con port serán visibles dentro de toda la arquitectura definida para esa entidad. Por supuesto el circuito sintetizado de estas instrucciones se comportará de la misma manera.” de la siguiente manera: signal SenialDePrueba : ieee.std_logic_1164. Podrán ser usadas solo por las construcciones que las “ven”. señal o variable. Facultad Regional Bahía Blanca ‘0’ a X y ‘1’ a Y. los procedimientos y funciones. constantes y en general todas las declaraciones dentro de un paquete serán visibles en todo el componente que los use. Los tipos. Las líneas a los costados muestran donde es visible cada declaración de tipo. aunque no se han presentado. Una excepción a esto es cuando se usan dos paquetes que declaran un objeto con el mismo identificador. no podrá usarse ese tipo sin declarar explícitamente a que librería se está haciendo referencia. Las variables declaradas en cada proceso tendrán una visibilidad local a cada proceso. paquete y tipo separado por “. ya sean constantes. señales o variables. Es decir que estas señales podrán usarse en cualquier proceso o construcción concurrente dentro de la arquitectura. si en el ejemplo anterior el usuario declara un tipo std_logic en el paquete “Constantes”. Estos objetos tienen una visibilidad limitada según el lugar de su declaración. Es decir. y no podrán ser vistas por construcciones externas. Las declaraciones de tipos. Se deben mencionar en esta sección.

Facultad Regional Bahía Blanca Figura 39 Visibilidad de las declaraciones en VHDL ©2003 Guillermo Güichal 100 .Diseño digital utilizando FPGAs UTN.

Las constantes genéricas son visibles a partir de su declaración hasta el final de la declaración de la entidad y en toda(s) la(s) arquitecturas del componente. La declaración genérica se cierra con un paréntesis y un punto y coma “). 8. de una manera similar a la declaración de la interfase con la palabra port. -. los bancos de prueba (testbench). ParametroGenericoN : TipoDelGenericoN := ValorPorDefectoN ).” después de su declaración y antes del paréntesis que cierra la declaración genérica. end Componente. Al igual que en la declaración de la interfase con port. Cuadro 36 Formato de declaración con parámetros genéricos Notar que. – Declaración de interfaces ). se ahonda en el tema de optimización para síntesis con ejemplos concretos y se presenta la metodología de prueba utilizada para validar un diseño.. De esta manera se puede diseñar un componente flexible y reutilizable.2... ..2 Parámetros Genéricos VHDL permite escribir modelos parametrizables utilizando una lista de constantes genéricas en la declaración de una entidad. Se tratan como constantes dentro de declaración de interfase y la arquitectura de la entidad. port( .Diseño digital utilizando FPGAs UTN.1 Introducción En la sección de introducción al VHDL se presentaron las estructuras y construcciones básicas y se dieron ejemplos para poder comenzar a crear diseños sintetizables. Esto se hace declarando una interfase genérica con la palabra generic.. Facultad Regional Bahía Blanca 8 Más VHDL 8. – Declaración de interfase genérica ..Formato de una declaración de entidad con genéricos entity Componente is generic( ParametroGenerico1 : TipoDelGenerico1 := ValorPorDefecto1.” ©2003 Guillermo Güichal 101 .. . el último parámetro no tiene un punto y coma “. En esta sección se dan algunos otros conceptos de VHDL. 8. El Cuadro 36 muestra el formato de una declaración de entidad con parámetros genéricos.1 Declaración de parámetros genéricos Utilizando constantes genéricas pueden parametrizarse tanto la estructura como el comportamiento de un componente.

Clock_IN) begin if (Reset_IN = ‘1’) then Cuenta_REG <= (others => ‘0’). architecture Comportamiento of ContadorRollover is signal Cuenta_REG : std_logic_vector(MSBContador downto 0).genérico entity ContadorRollover is generic( MSBContador : positive := 31 ). end Comportamiento. begin -.La salida esta dada por un registro Cuenta_OUT <= Cuenta_REG. end if. Facultad Regional Bahía Blanca El Cuadro 37 y Cuadro 38 muestran dos ejemplos de contadores que utilizan parámetros genéricos para parametrizar los límites del contador. elsif Rising_Edge(Clock_IN) then Cuenta_REG <= Cuenta_REG + 1.Reset.Contador con bit más significativo dado por un parámetro -.EJEMPLO 1 -. -. Este contador pasará de largo al llegar a su cuenta máxima (todos los bits en ‘1’) y recomenzará en 0. end ContadorRollover. Cuadro 37 Ejemplo de declaración de entidad y arquitectura con parámetros genéricos ©2003 Guillermo Güichal 102 . Clock end process ProcesoCuenta.Diseño digital utilizando FPGAs UTN. Para el segundo contador se define el número de bits (será uno más que el bit más significativo) y el valor máximo de la cuenta para reestablecer el valor del contador a cero. -. Cuenta_OUT : OUT std_logic_vector(MSBContador downto 0) ). Clock_IN : IN std_logic.La cuenta de salida se incrementa y pasa de largo a 0 al -. En el primero se define el bit más significativo del registro de cuenta como un genérico.llegar al valor máximo ProcesoCuenta : process(Reset_IN.-----------------------------------------------------------. port( Reset_IN : IN std_logic. -.

Diseño digital utilizando FPGAs UTN. port( Reset_IN : IN std_logic.Contador con número de bits y valor de la cuenta máxima dado -. Aunque este componente se sintetizará sin problemas.EJEMPLO 2 -. elsif Rising_Edge(Clock_IN) then Cuenta_REG <= Cuenta_REG + 1. BitsContador : positive := 8 ). if (Cuenta_REG = CuentaMaxima) then end if. begin -. la especificación del tiempo de propagación no será tenida en cuanta por las herramientas. Clock end process ProcesoCuenta. end Comportamiento. Clock_IN) begin if (Reset_IN = ‘1’) then Cuenta_REG <= (others => ‘0’). end ContadorConLimite.por parámetros genéricos entity ContadorConLimite is generic( CuentaMaxima : positive := 128.La salida esta dada por un registro Cuenta_OUT <= Cuenta_REG. En este ejemplo además de parametrizarse la estructura.Cuenta máxima? end if.Reset. -. Clock_IN : IN std_logic. Cuadro 38 Ejemplo de declaración de entidad y arquitectura con parámetros genéricos El Cuadro 39 muestra un ejemplo de la parametrización del comportamiento de un componente. Cuenta_OUT : OUT std_logic_vector((BitsContador-1) downto 0) ). pero los retardos en los modelos pueden utilizarse para aproximar el comportamiento post-síntesis o para visualizar mejor los efectos durante la simulación. architecture Comportamiento of ContadorConLimite is signal Cuenta_REG : std_logic_vector(BitsContador-1 downto 0). se utiliza un parámetro genérico para definir el tiempo de propagación de una compuerta usando el tipo predefinido time. -. El retardo de propagación en un circuito sintetizado estará dado por la implementación real en el dispositivo. ©2003 Guillermo Güichal 103 .a la cuenta máxima ProcesoCuenta : process(Reset_IN. Facultad Regional Bahía Blanca -.La cuenta de salida se incrementa y se vuelve a 0 al llegar -. -.-----------------------------------------------------------.

Instrucción en after TPropagacion. El Cuadro 40 muestra un ejemplo del uso de un componente con constantes genéricas en un modelo estructural para crear un componente de mayor complejidad. Facultad Regional Bahía Blanca -. TPropagacion : time := 25 ns ). con diferentes parámetros genéricos en cada instancia.retardo entre entrada y salida entity LogicaMultiple is generic( MSB : positive := 8. En este caso el componente superior utiliza dos instancias del mismo componente base. end LogicaMultiple.Modelo de lógica múltiple con señales de ancho variable y -. Estos parámetros al igual que las conexiones de las señales se hacen al usar el generic map y al port map. port( Entrada1_IN : IN std_logic_vector(MSB downto 0).-----------------------------------------------------------. SalidaAnd_OUT : OUT std_logic_vector(MSB downto 0). Cuadro 39 Ejemplos de declaración de entidad y arquitectura con parámetros genérico físico 8. SalidaOr_OUT : OUT std_logic_vector(MSB downto 0) ). -.2 Uso de componentes con parámetros genéricos Hasta ahora solo se describió la declaración de componentes con constantes genéricas. La flexibilidad de diseño la dan esas constantes al usar los componentes en una arquitectura estructural.EJEMPLO 3 -.Diseño digital utilizando FPGAs UTN. Entrada2_IN : IN std_logic_vector(MSB downto 0).2.varias líneas SalidaOr_OUT <= Entrada1_IN OR Entrada2_IN after TPropagacion. architecture Comportamiento of LogicaMultiple is begin SalidaAnd_OUT <= Entrada1_IN AND Entrada2_IN -. end Comportamiento. ©2003 Guillermo Güichal 104 .

Diseño digital utilizando FPGAs UTN.Se crea una instancia del contador de 4 bits y limite -. ClockTop_IN : IN std_logic. BitsContador => 5 ) ©2003 Guillermo Güichal 105 . -. end ContadorDualConLimite. Cuenta_OUT : OUT std_logic_vector(BitsContador-1 downto 0) ).Declaración del componente para poder usarlo en la -.-----------------------------------------------------------. BitsContador : positive := 8 ).diseño jerárquico entity ContadorDualConLimite is port( ResetTop_IN : IN std_logic.arquitectura component ContadorConLimite generic( CuentaMaxima : positive := 128. begin -. architecture Estructura of ContadorDualConLimite is -. Cuenta_OUT => Cuenta1_OUT ). Clock_IN : IN std_logic. Facultad Regional Bahía Blanca -. Cuenta1_OUT : OUT std_logic_vector(3 downto 0).Se crea una instancia del contador de 5 bits y limite -.Utilización de un componente con constantes genéricas en un -. end component.máximo = 25 con la salida a la salida 2 del contador dual Contador25 : ContadorConLimite generic map ( CuentaMaxima => 25. BitsContador => 4 ) port map ( Reset_IN => ResetTop_IN. Clock_IN => ClockTop_IN. port( Reset_IN : IN std_logic. Cuenta2_OUT : OUT std_logic_vector(4 downto 0) ).máximo = 12 con la salida a la salida 1 del contador dual Contador12 : ContadorConLimite generic map ( CuentaMaxima => 12.

=> ResetTop_IN. SalidaAnd_OUT : OUT std_logic_vector(MSB downto 0) ). Puede notarse que lo mismo sucede con las señales de los puertos.Utilización de un componente con constantes genéricas en un -.Diseño digital utilizando FPGAs UTN. => ClockTop_IN. El componente creado tiene un parámetro genérico con el mismo nombre que los componentes que utiliza. port( Entrada1_IN : IN std_logic_vector(MSB downto 0).genérica entity CompuertaAnd3Entradas is generic( MSB : positive := 3 ).-----------------------------------------------------------. ©2003 Guillermo Güichal 106 . -.diseño jerárquico para generar otro componente con constante -. end CompuertaAnd3Entradas. end Estructura. => Cuenta2_OUT Cuadro 40 Ejemplo de modelo estructural usando constantes genéricas En el ejemplo del Cuadro 41 se usa el componente definido en el último ejemplo de la subsección anterior.Declaración del componente para poder usarlo en la -. Entrada3_IN : IN std_logic_vector(MSB downto 0). architecture Estructura of CompuertaAnd3Entradas is -. Entrada2_IN : IN std_logic_vector(MSB downto 0). y estos dos genéricos pueden tener el mismo nombre. TPropagacion : time := 25 ns ).arquitectura component LogicaMultiple generic( MSB : positive := 8. En este caso se genera una AND de tres entradas y con un ancho de señal parametrizado a partir del componente LogicaMultiple. Facultad Regional Bahía Blanca port map ( Reset_IN Clock_IN Cuenta_OUT ). Esto no es problema ya que al asociar los puertos siempre se usa GenéricoDelComponenteBase => GenéricoDelComponenteSuperior.

end Estructura. SalidaOr_OUT => open ).la parte AND y una de las entradas es la señal interna Compuerta2DosEntradas : LogicaMultiple generic map ( MSB => MSB.interconexión de los componente internos -. begin -.Diseño digital utilizando FPGAs port( Entrada1_IN Entrada2_IN SalidaAnd_OUT SalidaOr_OUT ). UTN. end component. Entrada2_IN => Entrada2_IN. 0). SalidaAnd_OUT => SalidaAnd_OUT. -. 0) -. TPropagacion => 0 ns ) port map ( Entrada1_IN => Entrada1_IN.Declaración de una señal interna que permite la -. Entrada2_IN => Entrada3_IN. SalidaOr_OUT => open ). TPropagacion => 0 ns ) port map ( Entrada1_IN => SenialIntermedia. 0).Comienzo de la arquitectura de AND de 3 entradas -.la parte AND y la salida a una señal interna Compuerta1DosEntradas : LogicaMultiple generic map ( MSB => MSB.El genérico MSB es la definida para CompuertaAnd3Entradas signal SenialIntermedia : std_logic_vector(MSB downto 0). Cuadro 41 Otro ejemplo de modelo estructural usando constantes genéricas ©2003 Guillermo Güichal 107 .Se crea una instancia de la compuerta donde solo se usa -.Se crea una instancia de la compuerta donde solo se usa -. Facultad Regional Bahía Blanca : : : : IN IN OUT OUT std_logic_vector(MSB std_logic_vector(MSB std_logic_vector(MSB std_logic_vector(MSB downto downto downto downto 0). SalidaAnd_OUT => SenialIntermedia.

En esta sección se declaran las constantes genéricas y las interfases o puertos. Su visibilidad dependerá de donde está declarado..1 Procedimientos Los procedimientos se utilizan para agrupar instrucciones secuenciales. sin ahondar en demasiados detalles. -. las funciones se sintetizarán como un bloque de lógica combinacional independiente para cada llamado. Un procedimiento se declara con un nombre y opcionalmente un conjunto de parámetros. Después de esto se declara la arquitectura y dentro de esta los componentes y señales que se utilizarán. Después de la palabra begin se “instancian” o crean las dos instancias de los componentes bases.Declaración de variables locales al procedimiento ©2003 Guillermo Güichal 108 . En esta sección se dará una breve descripción de cada una de ellas. 8. En cuanto a síntesis. La diferencia entre estas dos estructuras es que el procedimiento es una instrucción secuencial que se utiliza por su cuenta. Es posible forzar el final de la ejecución en medio del procedimiento usando la palabra return.Diseño digital utilizando FPGAs UTN. 8. Facultad Regional Bahía Blanca Del cuadro pueden verse las diferentes secciones. Puede declararse al comienzo de una arquitectura.. El generic map da valores a las constantes genéricas de las instancias de componentes bases.3 Subprogramas: FUNCTION y PROCEDURE VHDL provee dos maneras de definir subprogramas que pueden invocarse desde otras secciones de código: los procedimientos (procedure) y las funciones (function).. mientras que una función es parte de una expresión. Los procedimientos son sintetizables si no utilizan instrucciones de detección de flancos de reloj o wait y se sintetizarán como lógica combinacional que depende del uso del procedimiento y las optimizaciones que implementen las herramientas. proceso o en un paquete.-. El Cuadro 42 muestra el formato de declaración y descripción de un procedimiento Un procedimiento termina al llegar la secuencia de ejecución a la instrucción end procedure. 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. Estos componentes se conectan a las entadas y salidas y entre sí mediante los port map. Por un lado está la declaración de la entidad del nuevo componente (de nivel superior en la jerarquía del diseño). .3..Formato de la declaración de un procedimiento sin parámetros procedure NombreProcedimiento is . y cualquier herramienta de síntesis optimizará esto deshaciéndose de cualquier lógica no conectada e innecesaria.

.Valores de reset elsif Rising_Edge(Clock_IN) then if ... end if.... .Formato de la declaración de un procedimiento con parámetros procedure NombreProcedimiento (-. Facultad Regional Bahía Blanca -. begin –.—.. -.. Cuadro 42 Formato de declaración de procedimientos Un procedimiento se invoca desde un conjunto de instrucciones secuenciales utilizando su nombre.Ejemplo de procedimiento dentro de un proceso sincrónico ProcesoLecturaADC : process(Reset_IN. end procedure NombreProcedimiento.Interfase y lectura del ADC ©2003 Guillermo Güichal 109 .Lista de parámetros ClaseDeParametro Identficador1 : Modo Tipo..Más parámetros ClaseDeParametro Identficador N : Modo Tipo ) is ..Instrucciones secuenciales ..-.Instrucciones secuenciales .. . -. end procedure NombreProcedimiento. El Cuadro 43 muestra la declaración y uso de un procedimiento dentro de un proceso que satura una señal a un valor máximo.. . Clock_IN) -..Diseño digital utilizando FPGAs begin . -... –.Declaración del procedimiento procedure SaturarADC is begin if (ADCValue_REG > ADC_SATURACION) then ADCValue_REG <= ADC_SATURACION...Comienzo de la sección secuencial del proceso if (Reset_IN = ‘1’) then .. end procedure SaturarADC..Declaración de variables locales al procedimiento begin .... UTN. –.. -.Si se debe leer un dato para leer del ADC . .

..Arquitectura de una entidad architecture Comportamiento of EntradaADC is -. integer. boolean. Para declarar un procedimiento con parámetros se utiliza el formato mostrado en el Cuadro 42. con un procedimiento que no funcionará y uno que si. Esta es similar a la declaración de los puertos de una entidad.Reset.Si se lee ADC end if.. –. -. con los siguientes elementos: ClaseDeParámetro : constant : constante. -. etc. ©2003 Guillermo Güichal 110 . utilizada por defecto si el modo es out signal : señal. -. signal Dato_REG : std_logic_vector(15 downto 0). el procedimiento actúa y modifica directamente la señal ADCValue_REG. utilizada por defecto si el modo es in variable : variable..Ejemplo 1: NO FUNCIONA.Llamado al procedimiento que satura el valor del ADC SaturarADC.) Los procedimientos que se declaran al principio de una arquitectura (no dentro de un proceso específico) solo pueden modificar señales a las que acceden en su lista de parámetros. En el ejemplo anterior. Clock end process. end if. El Cuadro 44 muestra un ejemplo de esto.Diseño digital utilizando FPGAs UTN. Cuadro 43 Ejemplo de declaración y llamado a un procedimiento en un proceso Los procedimientos sin parámetros actuarán sobre las señales o variables visibles para ellos. -. modifica directamente a la señal que representa Identficador : Nombre con el que se identificará al parámetro en las instrucciones dentro del procedimiento Modo : in : parámetro de entrada que no se modifica en el procedimiento out : parámetro que no se lee pero se modifica en el procedimiento inout : parámetro que se usa internamente y además se modifica en el procedimiento Tipo : Tipo del parámetro (ej.Declaración de una señal y el máximo valor aceptado constant LIMITE_MAX : std_logic_vector. Facultad Regional Bahía Blanca ADCValue_REG <= ADC_IN.Procedimiento mal hecho que no funcionará procedure SaturarADC is begin if (Dato_REG > LIMITE_MAX) then Dato_REG <= LIMITE_MAX. Si se utilizan parámetros para declarar y llamar un procedimiento se podrá utilizar o modificar diferentes variables o señales con cada llamado. NO SE PUEDE ACCEDER A Dato_REG -.DIRECTAMENTE CON EL PROCEDIMIENTO SaturarADC . -. No pueden modificar señales declaradas en la arquitectura directamente como en el ejemplo del Cuadro 43.: std_logic.

end if. La diferencia es que debe declararse un tipo que devolverá el llamado a la función usando return en la declaración. NO PUEDE ACCEDER A Dato_REG DIRCTAMENTE .. como se muestra en el Cuadro 45 es muy similar a los procedimientos.. end procedure SaturarADC.Diseño digital utilizando FPGAs end if.Declaración de una señal y el máximo valor aceptado constant LIMITE_MAX : std_logic_vector.3. Si hay mas de un parámetro deben separarse con comas como al asociar un componente usando port map.. architecture Comportamiento of EntradaADC is -. Facultad Regional Bahía Blanca -. ©2003 Guillermo Güichal 111 . end procedure SaturarADC. . signal Dato_REG : std_logic_vector(15 downto 0).2 Funciones Las funciones pueden verse como la generalización de expresiones. El procedimiento se ejecutará con los otras elementos concurrentes como las asignaciones de señal y los procesos. SE DEBE INVOCAR EL PROCEDIMIENTO -. ... para llamar al procedimiento SaturarADC del ejemplo 2 del cuadro anterior para saturar la señal Dato_REG se utiliza: SaturarADC (Dato => Dato_REG). Cuadro 44 Ejemplos de procedimiento al principio de una arquitectura bien y mal hechos Un procedimiento puede utilizarse como una instrucción concurrente directamente en la arquitectura de un componente.. UTN. ----Se asocia el parámetro Dato del procedimiento con la señal Dato_REG declarada en la arquitectura. -. Para llamar a un procedimiento se utiliza el nombre del procedimiento seguido de una lista de asociación si el procedimiento requiere parámetros..Ejemplo 2: ESTE SI FUNCIONA.Procedimiento que funciona porque usa un parámetro procedure SaturarADC(signal Dato : inout std_logic_vector(15 downto 0)) is begin if (Dato > LIMITE_MAX) then Dato <= LIMITE_MAX. Estas operaciones se describen como un conjunto de instrucciones secuénciales que calculan un resultado. 8. Son una manera de definir nuevas operaciones que luego podrán ser utilizadas en expresiones..CON UN PARAMETROS. Por ejemplo. Su declaración.

.Diseño digital utilizando FPGAs UTN.. ..Ejemplo de la declaración de una función con parámetros de -.Formato de la declaración de una función function NombreFuncion (parámetros opcionales) return RTipo is . Cuadro 45 Formato de declaración de una función A diferencia de los procedimientos las funciones deben devolver un valor del tipo declarado en la declaración usando el formato de la instrucción return : return expresión.. Los parámetros no pueden ser del tipo variable. en una función que solo devolverá un valor a partir de una serie de señales de entrada puede declararse de manera simple según el esquema del ejemplo mostrado en el Cuadro 46. end function NombreFuncion. ...Uso de la función en una expresión concurrente o secuencial ©2003 Guillermo Güichal 112 .que debe ser del tipo declarado para la -. -.. . -.entrada constantes function Mayor ( Entrada1 : std_logic_vector. Este formato tiene similitud con las funciones de otros lenguajes de programación.. -. Así. end if. -. .función La lista de parámetros opcionales de una función tiene el mismo formato que el de un procedimiento con algunas limitaciones y detalles... else return Entrada2.. Entrada2 : std_logic_vector ) return std_logic_vector is begin if (Entrada1 > Entrada2) then return Entrada1.. si no especifica la clase del parámetro esta se asume constant y si no se especifica el modo este se asume in. end function Mayor.Esto devuelve el resultado de expresión. Facultad Regional Bahía Blanca -..Instrucciones secuenciales ..-. -.Declaraciones begin .

-.Diseño digital utilizando FPGAs UTN. En todos estos casos pueden asociarse parámetros por posición. Facultad Regional Bahía Blanca Resultado <= Mayor(Entrada1 => DatoADC_IN. El tipo de la salida no puede tener un rango predeterminado. Cuadro 46 Ejemplo de declaración y uso de una función con parámetros de entrada solamente En este ejemplo los parámetros de entrada no tienen un rango prefijado.-----------------------------------------------------.--. También hace más difícil la modificación del código. ©2003 Guillermo Güichal 113 . LimiteUsuario_IN). como se muestra en el segundo ejemplo del llamado de la función Mayor. En el ejemplo.Ejemplo de la instrucción generarte para crear un inversor -. -. que utilizan el símbolo “=>”. Hay que tener mucho cuidado al hacer esto ya que pueden cometerse errores de orden y no obtener los resultados deseados. Para los componentes en arquitecturas estructurales se recomienda la asociación por nombre.4 Instrucción GENERATE La instrucción generate permite generar múltiples copias de un componente para no tener que declararlos uno por uno en un diseño estructural. use ieee.de 16 bits a partir de un componente INV de 1 bit library ieee. -. El muestra el formato y un ejemplo de esta instrucción. pero en llamados a funciones hay veces que es práctico usar la asociación por posición. En el caso del ejemplo se asociará DatoADC_IN con Entrada1 porque este es el primer parámetro en la lista.std_logic_1164. En las asociaciones por nombre no es necesario mantener el orden de los parámetros igual que en la declaración de la función o procedimiento. y LimiteUsuario_IN con Entrada1 porque es el segundo parámetro. como las utilizadas para los port map y llamados de procedimientos.Formato de la instrucción generate Etiqueta : for Identificador in Rango generate Instrucción concurrente end generate. Los rangos se asignarán cuando se llame a la función con parámetros reales. el rango estará dado por las señales DatoADC_IN y LimiteUsuario_IN y la señal que se devuelve también dependerá de la cantidad de bits de estas dos entradas.all.3. Entrada2 => LimiteUsuario_IN).3 Asociación de parámetros por posición y por nombre Hasta ahora solo se han descrito las listas de asociación por nombre.Uso de la función con asociación por posición Resultado <= Mayor(DatoADC_IN. library unisim. 8. 8.

5 Componentes Básicos de Diseño (Primitivas . UTN.5. lógica de acarreo. end component. end generate. Cuadro 47 Uso de GENERATE 8. Para utilizarlos se deben declarar los componentes con los nombres especificados por los fabricantes. pero los detalles están escondidos al diseñador. O : out std_logic).vcomponents.1 Utilización de Primitivas desde VHDL Las primitivas pueden usarse desde el VHDL. Esta primitiva está formada por los elementos lógicos. Los componentes de las librerías ©2003 Guillermo Güichal 114 . Con ellas Xilinx unifica los componentes para todos sus dispositivos programables. architecture Estructura of Inversor16 is -. O => Salida_N_OUT(Indice)). Las herramientas detectan los sumadores en el código VHDL y lo traducen a una interconexión del componente "sumador" con otras primitivas. Cada fabricante provee un conjunto librerías de componentes que están optimizados para su arquitectura en particular. Si se utilizan las herramientas de diseño esquemático provistos por los fabricantes esto es muy directo. end Estructura. los fabricantes proveen una primitiva "sumador". Estos componentes son óptimos porque hay una relación directa entre ellos y la funcionalidad provista por los bloques lógicos básicos de la arquitectura del dispositivo Por ejemplo.all. Facultad Regional Bahía Blanca entity Inversor16 is port(Entrada_IN : in std_logic_vector(15 downto 0). 8. las herramientas traducen el código VHDL a un conjunto de componentes básicos (denominados primitivas) interconectados para proveer la funcionalidad que se desea. etc. creando una instancia como cualquier otro componente en una arquitectura estructural. end Inversor16.Diseño digital utilizando FPGAs use unisim. para cada familia de FPGAs en particular.Declaración del componente primitivo que se usará component INV port(I : in std_logic. Estas primitivas están formadas por los elementos básicos de las FPGAs. que no existe directamente en las FPGAs.Primitives) Al sintetizar un diseño. Salida_N_OUT : out std_logic_vector(15 downto 0)). begin CompGenerado : for índice in 15 downto 0 generate CompBasico : INV port map (I => Entrada_IN(Indice). Xilinx provee las denominadas “librerías unificadas”..

Las primitivas incluyen bloques para realizar funciones especiales de entrada/salida. Cada fabricante provee esos componentes para su uso de alguna manera. Ese buffer es el buffer de entrada de las señales de reloj en las FPGA. funciones aritméticas. En la placa D2E de Digilent Inc. El Cuadro 48 muestra un ejemplo en que se usa una primitiva de un buffer tipo “BUFG”. comparadores..Demás puertos de interfase al componente ). -. contadores. memorias. Facultad Regional Bahía Blanca unificadas se describen en el documento “Libraries Guide” de Xilinx. use ieee.Resto de la descripción structural utiliza intReset -. O => intReset). architecture Estructura of Componente is signal intReset : std_logic. el botón está conectado a uno de estos pines.. o : out std_logic). Cuando se hace un diseño con las herramientas de Xilinx ISE 5. use ieee. .all. use unisim. Cuadro 48 Utilización de una instancia de un componente de librería BUFG en una estructura ©2003 Guillermo Güichal 115 . end component. library ieee.numeric_std..all.all. library unisim.. multiplexores. . begin BufferReset : bufg port map (I => Reset_IN.Diseño digital utilizando FPGAs UTN. Reset_IN : in std_logic.. component bufg port ( I : in std_logic.vcomponents. etc.std_logic_1164.como señal de reset . –. este componente debe incorporarse como una instancia explícitamente si se conecta una señal que no es una señal de reloj a uno de estos pines. y para todos los diseños debe agregarse una instancia de BUFG si se desea utilizar. manejo de reloj. entity Componente is port( Clock_IN : in std_logic. end Componente..

De esa manera el diseño será mas fácil de portar de una FPGA a otra. En general se recomienda tratar de no utilizar primitivas específicas de un fabricante. Estos estarán configurados de maneras específicas según su función. haciendo la tarea un poco mas simple. Muchas FPGAs incluyen bloques de memoria entre los elementos lógicos. Al crear una instanciar mediante VHDL y sintetizarlos. En otros casos.2 Librerías de Primitivas (componentes) Específicos para Simulación Los componentes básicos o primitivas son expresiones directas de la arquitectura básica de una FPGA. se desean utilizar recursos especiales provistos por una familia de FPGAs. un diseño que utilice primitivas debe poder simularse. Facultad Regional Bahía Blanca 8. Para poder re-utilizar luego el diseño con otras FPGAs se puede envolver las primitivas en código VHDL genérico (creando un "wrapper"). se deben agregar a la lista de librerías las siguientes líneas library unisim.all. Para ellos se necesitan modelos de simulación de estas primitivas.3 Memoria La memoria es un componente básico de muchos diseños digitales. Xilinx provee estos modelos en la librería unisim. si se desea usar un tipo de memoria con una configuración particular. antes de la declaración de la entidad. De esta manera solo habrá que cambiar la implementación de ese bloque al cambiar de FPGA. ©2003 Guillermo Güichal 116 . Dependiendo de las herramientas. es posible que haya que crear una instancia explícitamente como una primitiva. Además de la memoria embebida o en bloque (la que está integrada en el chip junto a la lógica programable).5.all. lo que permite integrarla de manera rápida y eficiente con los diseños lógicos. se transforman directamente en recursos de la FPGA. Cada fabricante provee estos modelos de simulación para sus primitivas. En algunos casos pueden inferirse a partir de la descripción que se hace en el HDL.vComponents. De cualquier manera.Diseño digital utilizando FPGAs UTN. En muchos casos. Altera en la librería altera_mf y Actel tiene una librería para cada familia de FPGAs. Por ejemplo. las memorias pueden . Si en un diseño se utiliza directamente alguna primitiva (componente) de Xilinx. 8. las FPGAs basadas en memoria SRAM para su configuración permiten usar parte de la lógica como memoria. su configuración y el estilo del código HDL. sin embargo. En el ejemplo anterior del uso de BUFG estas líneas aparecen al comienzo del archivo. En general no son compatibles entre fabricantes. por ejemplo. y muchas veces no son compatibles entre distintas familias de FPGAs del mismo fabricante. fabricante y familia de la FPGA.5. use unsim.altera_mf_components. En el caso de Altera será library altera_mf. use altera_mf.

©2003 Guillermo Güichal 117 . Facultad Regional Bahía Blanca A continuación se describirán algunas configuraciones para las memoria de las FPGA de Xilinx.DPRA3 SPO DPO Descripción Habilitación de escritura (Write Enable) Reloj de escritura (Write Clock) Dato escritura Dirección de escritura Dirección de lectura Salida dada por A0. 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). Hay varias posibilidades de uso y configuración de las memorias... ya sea con puerto simple.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.A3 Salida dada por DPRA0. Para utiliza cualquiera de los dos tipos de memoria deben inferir o crear una instancia de alguna versión de ellos en una arquitectura estructural. La Tabla 11 describe brevemente las señales.. tomados de la guía de librerías unificada de Xilinx.Diseño digital utilizando FPGAs UTN. puerto dual.. A continuación se presentarán algunos ejemplos de estos componentes.A3 DPRA0. La RAM distribuida (distributed RAM) se implementa utilizando las tablas de búsqueda LUT de los bloques lógicos como. etc. Esta memoria solo puede configurarse como memoria (RAM o ROM) y no utilizarse como lógica configurable. Tabla 10 Puertos de interfase de la memoria RAM16x1D Señal WE WCLK D A0. Esta memoria tiene los siguientes puertos interfase. La Figura 40 muestra una memoria RAM de puerto dual de 16 palabras por 1 bit de ancho. diferentes anchos de palabra. que está formada por los bloques de memoria embebidos en la FPGA.

puerto dual) o no permiten inicializar una memoria inferida. use IEEE. DO0 Descripción Habilitación de escritura (Write Enable) Habilitación Reset Reloj Datos de entrada Dirección Datos de salida Inferencia de Memorias Ciertas estructuras en VHDL pueden modelar el comportamiento de memorias RAM o ROM. ALL. El tipo de estructura reconocida y las memorias inferidas dependerán de las herramientas. En lo siguientes cuadros y figuras se muestra código VHDL con el cual se infieren distintos tipos de memoria y los resultados de la síntesis... architecture Comportamiento of infer_ram is ©2003 Guillermo Güichal 118 . DI0 A3. a : in std_logic_vector(4 downto 0).. Algunas herramientas infieren bien ciertos tipos de memoria pero no otros (puerto simple vs. do : out std_logic_vector(3 downto 0)). library IEEE.STD_LOGIC_1164. entity infer_ram is port (clk : in std_logic. ALL. end infer_ram. use IEEE.Diseño digital utilizando FPGAs UTN.A0 DO3. Facultad Regional Bahía Blanca Figura 41 Interfase de memoria de bloque de 1024 x 4 Tabla 11 Puertos de interfase de la memoria RAMB4_S4 Señal WE EN RST CLK DI3. Muchas herramientas detectan estas estructuras e infieren el uso de una memoria interna de la FPGA (ya sea en bloque o distribuida).STD_LOGIC_ARITH. we : in std_logic. di : in std_logic_vector(3 downto 0). use IEEE.ALL.STD_LOGIC_UNSIGNED.

end Comportamiento. Facultad Regional Bahía Blanca type ram_type is array (31 downto 0) of std_logic_vector(3 downto 0). end if. 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 ©2003 Guillermo Güichal 119 . -. begin process (clk) begin if Rising_Edge(clk) then -.Diseño digital utilizando FPGAs UTN.La memoria BRAM necesita la dirección de lectura registrada read_a <= a. signal RAM : ram_type.La memoria se escribe con un WE sincronico if (we = '1') then RAM(conv_integer(a)) <= di. end process. end if.Datos de salida do <= RAM(conv_integer(read_a)).Señal para registrar la dirección de lectura signal read_a : std_logic_vector(4 downto 0). -. -.

architecture Comportamiento of infer_ram is type ram_type is array (31 downto 0) of std_logic_vector(3 downto 0).Resultados de la síntesis. El resultado de utilización del dispositivo refleja la diferencia entre usar RAM distribuida o en bloque. Notar que hay solo una sutil diferencia en el VHDL respecto al código que infiere RAM distribuida. ALL. end infer_ram.Diseño digital utilizando FPGAs UTN. use IEEE. (Fuente: Captura de pantalla de herramienta Xilinx ECS) En los siguientes cuadros se muestra el código VHDL y los resultados de síntesis al inferir memoria RAM distribuida. a : in std_logic_vector(4 downto 0). BRAM inferida. use IEEE. ALL. Facultad Regional Bahía Blanca Figura 42. Para inferir RAM distribuida la dirección de lectura no está registrada. entity infer_ram is port (clk : in std_logic. begin process (clk) ©2003 Guillermo Güichal 120 .STD_LOGIC_1164.STD_LOGIC_ARITH. do : out std_logic_vector(3 downto 0)). di : in std_logic_vector(3 downto 0). library IEEE. signal RAM : ram_type.STD_LOGIC_UNSIGNED.ALL. use IEEE. we : in std_logic.

end Comportamiento. we : in std_logic. Notar en la figura que la memoria ROM se implementa como una RAM con sus entradas de escritura deshabilitadas.all. end process. Direccion de entrada asincrónica directamente do <= RAM(conv_integer(a)).all.std_logic_arith. use IEEE. architecture Xilinx of ROM_infer is ©2003 Guillermo Güichal 121 .Datos de salida. Facultad Regional Bahía Blanca begin if Rising_Edge(clk) then -.std_logic_1164. -. end if.La interfaz de la ROM no tiene datos de lectura entity ROM_infer is port(clk : in std_logic. library IEEE. addr: in std_logic_vector(3 downto 0).Diseño digital utilizando FPGAs UTN. Cuadro 51 VHDL para inferir memoria distribuida en las herramientas de Xilinx ====================================================================== HDL Synthesis Report Macro Statistics # LUT RAMs : 1 1024x4-bit single-port distributed RAM: 1 ====================================================================== Device utilization summary: --------------------------Selected Device : 2s200epq208-7 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. use IEEE.std_logic_unsigned. end entity ROM_infer. -. do : out std_logic_vector(7 downto 0)). use IEEE.La memoria se escribe con un WE sincronico if (we = '1') then RAM(conv_integer(a)) <= di.all. end if.

when "1001" => do <= X"88". Facultad Regional Bahía Blanca Cuadro 53 VHDL para inferir memoria ROM (usando BRAM) en las herramientas de Xilinx ====================================================================== HDL Synthesis Report Macro Statistics # Block RAMs 16x8-bit single-port block RAM : 1 : 1 ====================================================================== Device utilization summary: --------------------------Selected Device : 2s200epq208-7 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 ©2003 Guillermo Güichal 122 . when "1010" => do <= X"99". end if. when "1101" => do <= X"CC". when others => do <= X"EE". when "1100" => do <= X"BB".Diseño digital utilizando FPGAs begin -. when "0110" => do <= X"DE". end process the_rom. when "0100" => do <= X"9A". when "0011" => do <= X"78". end case. when "0010" => do <= X"56". when "1000" => do <= X"77".Este proceso solo lee datos the_rom: process (clk) begin if rising_edge(clk) then case addr is when "0000" => do <= X"12". when "0101" => do <= X"BC". UTN. when "1110" => do <= X"DD". when "0001" => do <= X"34". when "0111" => do <= X"F0". when "1011" => do <= X"AA". end architecture Xilinx.

ENTITY ram_dual IS PORT (clock1: clock2: data: write_address: read_address: we: q: ). INTEGER RANGE 0 to 31.ALL. INTEGER RANGE 0 to 31.Diseño digital utilizando FPGAs UTN. END ram_dual.std_logic_1164. USE ieee. SIGNAL ram_block: MEM. ©2003 Guillermo Güichal 123 . 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). ROM implementada como RAM escritura deshabilitada. Facultad Regional Bahía Blanca Figura 43 Resultados de la síntesis. IN IN IN IN IN IN OUT STD_LOGIC. en el siguiente cuadro se muestra un ejemplo de VHDL para inferir una memoria RAM de puerto dual. STD_LOGIC. LIBRARY ieee. STD_LOGIC_VECTOR (3 DOWNTO 0). (Fuente: Captura de pantalla de herramienta Xilinx ECS) Altera recomienda estructuras similares para inferir memorias en sus dispositivos desde los HDLs. STD_LOGIC.

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 código HDL para una FPGA y herramienta dada. wraddress : IN STD_LOGIC_VECTOR (4 DOWNTO 0). PROCESS (clock2) BEGIN IF (clock2'event AND clock2 = '1') THEN q <= ram_block(read_address_reg).Diseño digital utilizando FPGAs UTN. ©2003 Guillermo Güichal 124 . referirse a los manuales de las herramientas y notas de aplicación de los fabricantes de FPGAs. END PROCESS. Para esto hay que referirse a la documentación de los fabricantes y entender las interfaces de las primitivas. rdaddress : IN STD_LOGIC_VECTOR (4 DOWNTO 0). END rtl. Las herramientas provistas por los fabricantes de FPGAs tienen ayudas y plantillas que permiten generar código HDL de manera rápida. BEGIN PROCESS (clock1) BEGIN IF (clock1'event AND clock1 = '1') THEN IF (we = '1') THEN ram_block(write_address) <= data. Facultad Regional Bahía Blanca SIGNAL read_address_reg : INTEGER RANGE 0 to 31.Declaración del componente COMPONENT ram_32x8_dp PORT ( data : IN STD_LOGIC_VECTOR (7 DOWNTO 0). wren : IN STD_LOGIC := '1'. En estos casos se debe colocar una instancia (instantiate) del componente usando port map . Mas adelante se muestra el uso de memorias de Xilinx para crear una cola FIFO. read_address_reg <= read_address. END IF. Para modelar el comportamiento de la memoria se debe incluir al proyecto el VHDL correspondiente al componente ram_32x8_dp provisto por Altera. Una vez definido el componente se instancia como cualquier otra primitiva. END IF. … ARCHITECTURE rtl_text OF fifo_1clk_32x8 IS -. En el siguiente ejemplos e muestra el uso de una memoria del tipo ram_32x8_dp en una FPGA de Altera. END PROCESS. Instancia de Memorias Hay muchos casos en los que se desea controlar en detalle el tipo de memoria (u otra primitiva) a utilizar. END IF.

std_logic_vector(3 downto 0). std_logic. 8. clock => Clock_IN.. wraddress => WriteAddress_REG(4 DOWNTO 0).Diseño digital utilizando FPGAs UTN. std_logic. END COMPONENT. std_logic. . std_logic_vector(3 downto 0). end DRamDual16xN. BEGIN -------------------------------------.. ambas formadas a partir de la primitiva RAM16x1D. wren => WriteEnable_IN. 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. is : positive := 15. std_logic_vector(MSB_MEMORIA_RAM downto 0). ------------------------------------RamFifo : ram_32x8_dp PORT MAP ( data => Writedata_IN. q => Readdata_OUT).Componente de memoria RAM de 16 x N a partir de primitiva RAM16X1D entity DRamDual16xN generic ( MSB_MEMORIA_RAM ). ©2003 Guillermo Güichal 125 . Facultad Regional Bahía Blanca clock : IN STD_LOGIC.5. -.Altera RAM instantiation for FIFO. En los siguientes ejemplos se presenta una memoria de 16 por N y una cola FIFO de 16 x 16. : : : : : : in in in in in out std_logic. std_logic. END ARCHITECTURE rtl_text. q : OUT STD_LOGIC_VECTOR (7 DOWNTO 0)). port ( Clock_IN WriteEnable_IN WriteAddress_IN WriteData_IN ReadAddress_IN ReadData_OUT ). std_logic.4 Definición de Nuevos Componentes de Diseño A partir de algunas primitivas de diseño pueden definirse componentes con parámetros genéricos que pueden reutilizarse en distintas aplicaciones. rdaddress => ReadAddress_REG(4 DOWNTO 0). std_logic.

DPRA1 => ReadAddress_IN(1). A2 => WriteAddress_IN(2). Facultad Regional Bahía Blanca --------------------------------------------.Instancia de RAM -------------------------------------------G1: for I in MSB_MEMORIA_RAM downto 0 generate L: RAM16X1D port map ( WCLK => Clock_IN.Diseño digital utilizando FPGAs D : in std_logic. A1 => WriteAddress_IN(1). Cuadro 56 Memoria RAM de 16 x N En el siguiente ejemplo se define una cola tipo FIFO de 16 palabras por 16 bits. DPRA2 => ReadAddress_IN(2). DPRA1 : in std_logic. 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. end Estructura. DPO => ReadData_OUT(I)). end component. Se utiliza como bloque básico para guardar los datos la primitiva RAM16X1D. end generate G1. WE => WriteEnable_IN. SPO => open.Componente FIFO 16 x 16 a partir de primitiva RAM16X1D ©2003 Guillermo Güichal 126 . y tiene más sentido y hace más entendible el funcionamiento mantener todos los elementos juntos que separarlos en dos componentes diferentes. A0 => WriteAddress_IN(0). DPRA3 => ReadAddress_IN(3). begin UTN. DPRA2 : in std_logic. DPO : out std_logic). Aunque esto no es recomendable en general. DPRA3 : in std_logic. El dato de escritura se escribe sobre la memoria en el lugar indicado por el puntero de escritura. En la arquitectura de este componente se mezclan las descripciones estructurales y de comportamiento. DPRA0 : in std_logic. Es decir. LA salida de lectura siempre tiene el primer dato de salida disponible. D => WriteData_IN(I). -. en este componente todos los procesos junto a la memoria como instancia forman un solo componente. Este componente tiene una entrada y una salida de datos y dos señales que indican si se desea leer el dato de la cola o escribir el dato a la cola. A3 => WriteAddress_IN(3). El correcto funcionamiento depende de que la lógica que se conecta a este componente no actúe de manera no prevista. SPO : out std_logic. Otra salida indica el número de datos disponibles en la cola. y al leerlo se incrementa un puntero y se pasa al siguiente. DPRA0 => ReadAddress_IN(0).

Facultad Regional Bahía Blanca : : : : : : : in in in in in out out std_logic. WE : in std_logic. D => WriteData_IN(I). std_logic. begin --------------------------------------------. component RAM16X1D port ( WCLK : in std_logic. A2 => WriteAddress_REG (2). A2 : in std_logic. DPRA0 : in std_logic. SPO : out std_logic. DPO => ReadData_OUT(I)).Diseño digital utilizando FPGAs entity FifoDRam16x16 is port ( Clock_IN Reset_IN WriteEnable_IN ReadEnable_IN WriteData_IN ReadData_OUT DatosDisponibles_OUT ). DPRA3 => ReadAddress_REG (3). A1 : in std_logic. std_logic. -. DPO : out std_logic). DPRA1 : in std_logic. WE => WriteEnable_IN. D : in std_logic. std_logic_vector(15 downto 0). std_logic_vector(15 downto 0). A1 => WriteAddress_REG (1). A3 => WriteAddress_REG (3). A0 => WriteAddress_REG (0). DPRA0 => ReadAddress_REG (0). SPO => open. end component.Control de dirección lectura ©2003 Guillermo Güichal 127 . UTN. signal WriteAddress_REG : std_logic_vector(4 downto 0). A3 : in std_logic. std_logic. DPRA2 => ReadAddress_REG (2). DPRA1 => ReadAddress_REG (1). end FifoDRam16x16. DPRA3 : in std_logic. DPRA2 : in std_logic. signal DatosDisponibles_REG : std_logic_vector(4 downto 0). end generate G1. A0 : in std_logic. std_logic_vector(4 downto 0) architecture Mixta of FifoDRam16x16 is signal ReadAddress_REG : std_logic_vector(4 downto 0).Instancia de RAM 16 x 16 -------------------------------------------G1: for I in 15 downto 0 generate L: RAM16X1D port map ( WCLK => Clock_IN.

end if.Reset. Clock end process CuentaDatosDisponibles. end if. elsif Rising_Edge(Clock_IN) then if (WriteEnable_IN = ‘1’) then WriteAddress_REG <= ReadAddress_REG + 1. if (ReadEnable_IN='0') and (WriteEnable_IN='1') then DatosDisponibles_REG <= DatosDisponibles_REG + 1. -. elsif Rising_Edge(Clock_IN) then if (ReadEnable_IN = ‘1’) then ReadAddress_REG <= ReadAddress_REG + 1.Calculo de numero de datos disponibles CuentaDatosDisponibles : process(Reset_IN. DatosDisponibles_OUT <= DatosDisponibles_REG. -. end if. elsif Rising_Edge(Clock_IN) then if (ReadEnable_IN='1') and (WriteEnable_IN='0') then DatosDisponibles_REG <= DatosDisponibles_REG . Clock_IN) begin if (Reset_IN =’1’) then ReadAdrress_REG <= (others => ‘0’). end if.Diseño digital utilizando FPGAs UTN. Facultad Regional Bahía Blanca ControlDireccionLectura : process(Reset_IN. end process ControlDireccionLectura. -.Control de dirección escritura ControlDireccionEscritura : process(Reset_IN. Clock_IN) begin if (Reset_IN =’1’) then DatosDisponibles_REG <= (others => ‘0’). end if. Cuadro 57 Cola FIFO de 16 x 16 ©2003 Guillermo Güichal 128 .1. end Mixta. end if. Clock_IN) begin if (Reset_IN =’1’) then WriteAdrress_REG <= (others => ‘0’). end if. end process ControlDireccionEscritura.

Sobre las flechas se especifican las condiciones necesarias para esas transiciones. Las máquinas de estado infinitas no tienen sentido práctico para las aplicaciones que se tratan en este texto 8 ©2003 Guillermo Güichal 129 . En general se grafican diagramas de burbujas y la condiciones de transición y salidas. Facultad Regional Bahía Blanca 8. La Figura 44 muestra esta máquina de estados como un diagrama de burbujas.Diseño digital utilizando FPGAs UTN. Existen muchas herramientas gráficas con las que se pueden diseñar máquinas de estado. Las entradas se agrupan en la primera fila como un vector de 2 bits. El diseño tiene dos entradas de un bit y una salida. Un diseño en el que el estado de funcionamiento no está solo dado por las entradas sino también por la historia de funcionamiento anterior no puede resolverse mediante lógica combinacional.6 Máquinas de Estado Si el estado de funcionamiento de un diseño. Los datos de las tablas indican el próximo estado. Se está presencia de un circuito secuencial que incluirá no solo lógica combinacional sino también una máquina de estados. y por ende las salidas. La Tabla 12 muestra un ejemplo de una tabla de transición para un diseño secuencial genérico. Si la cantidad de estados es limitada a se la denomina máquina de estados finita8. están dadas por las entradas al circuito solamente el diseño puede resolverse mediante lógica combinacional. Las maneras clásicas de modelar máquinas de estados son las tablas de transición y los diagramas de estados de burbujas. Estas representaciones gráficas son luego traducidas a VHDL por las herramientas. Tabla 12 Tabla de transición 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. En las tablas de transición se describen los diferentes estados de funcionamiento en las filas y las combinaciones de entradas en las columnas.

se recomienda utilizar máquinas de estado sincrónicas. Si la velocidad del reloj es demasiado rápida y se desea hacer más lenta una máquina de estados. Facultad Regional Bahía Blanca Figura 44 Ejemplo de maquina de estado Siguiendo las recomendaciones para diseños sintetizables sobre FPGAs.Diseño digital utilizando FPGAs UTN. se puede utilizar una señal de habilitación de reloj en el proceso ©2003 Guillermo Güichal 130 . con un estado de reset asincrónico. En las máquinas de estado sincrónicas solo hay cambios de estado y sobre las salidas con un flanco de reloj.

pero no se actualiza inmediatamente. La consecuencia es que las salidas estarán en realidad retrasadas un ciclo de reloj respecto al estado actual (debido a los registros antes de las salidas). El otro es sincrónico y asigna el estado actual y define las salidas. La implementación básica de una máquina de estados como la descripta será la mostrada en la Figura 45. Si eso no es aceptable puede usarse lógica combinacional para las salidas o replantearse la máquina de estados para obtener las salidas necesarias. HDL Designer de Mentor Graphics. al haber un flanco de reloj y ejecutarse la instrucción de asignación del próximo estado. La asignación de salidas en el proceso sincrónico puede prestarse a confusión. pero existen una variedad de combinaciones de procesos y lógica concurrente que pueden ser utilizadas. Figura 45 .Diseño digital utilizando FPGAs UTN.Esquema lógico de la maquina de estados del ejemplo Aunque es muy práctico diseñar una máquina de estados con una interfase gráfica como la provista por StateCad de Xilinx. con la asignación del estado actual y las salidas hecha a través de elementos sincrónicos (registros). El ejemplo presentado es una manera de modelar máquinas de estado. 9 Las herramientas traducen los diseños gráficos a VHDL o Verilog antes de sintetizarlos. EL estilo preferido para describir una máquina de estados en VHDL es mediante dos procesos. se tomará el valor del estado actual y no el agendado. Facultad Regional Bahía Blanca sincrónico como se describirá más adelante. Debe recordarse que. o cualquier otra herramienta de ese estilo. este valor se agenda. El Cuadro 58 muestra el la máquina de estados de la figura anterior a modo de ejemplo. ©2003 Guillermo Güichal 131 . La implementación será como la de la Figura 45. Uno es combinacional y calcula el próximo estado a partir del estado actual y las entradas. al evaluarse el case de asignación de las salidas. también se puede desarrollar directamente en VHDL9. Por eso.

©2003 Guillermo Güichal 132 .-------------------------------------------------------.Valores de reset Salida_REG <= “001”.Declaración de la arquitectura de la máquina de estados -. end if.Diseño digital utilizando FPGAs UTN. -. Estado2.-------------------------------------------------------. Facultad Regional Bahía Blanca -. when Estado4 => Salida_REG <= “111”.Declaración de señales internas de ser necesarias signal Salida_REG : std_logic_vector (2 downto 0). Estado1.Asignaciones e instrucciones concurrentes -.Acciones para la asignación de señales y salidas case EstadoActual is when Inicial => Salida_REG <= “001”. when Estado3 => Salida_REG <= “100”. Estado3.Proceso sincrónico de asignación de estado actual y señales -. when Estado2 => Salida_REG <= “011”. Reset_IN) begin if (Reset_IN = '1') then EstadoActual <= Inicial.--. -.Paso al próximo estado de manera sincrónica EstadoActual <= EstadoSiguiente.--. signal EstadoSiguiente : tdEstado . end process ProcesoSincronico. elsif (Rising_Edge(Clock_IN) then -. when others => null.-------------------------------------------------------.La entidad se declara como en cualquier otro caso para -. begin -.-Salida <= Salida_REG. when Estado1 => Salida_REG <= “010”.-------------------------------------------------------.Utilización de un tipo enumerado para describir los estados type tdEstado is ( Inicial. -.-ProcesoSincronico : process(Clock_IN.Mantiene las salidas actuales con un registro end case. -. signal EstadoActual : tdEstado .describir las interfases (port) architecture ComportamientoFSM of EjemploFSM is -. -. Estado4 ).

EstadoActual ) begin -. 8. Entrada2.-AsignacionProximoEstado : process (Entrada1.Proceso combinacional de asignación de estados -.Entrada1= ‘1’. else EstadoSiguiente <= Estado3. al evaluar las entradas para el próximo estado en las instrucciones if. Facultad Regional Bahía Blanca -.-------------------------------------------------------.-------------------------------------------------------. elsif (Entrada2_IN=‘0’) then –. else deben evaluarse todos los casos de combinaciones de entradas para evitar que se infieran “latches”. else EstadoSiguiente <= Inicial.Entrada1= ’1’. end if. end process AsignacionProximoEstado. Entrada2= ‘0’ EstadoSiguiente <= Estado2. Entrada2= ‘1’ EstadoSiguiente <= Estado3.Acciones combinadas de asignación de estado siguiente case EstadoActual is when Inicial => if (Entrada1_IN = ‘1’) then EstadoSiguiente <= Estado1.Diseño digital utilizando FPGAs UTN. Si se describe la máquina de estados en VHDL el diseñador puede optar por utilizar un registro del tipo std_logic_vector directamente. else -. end if. end if.--.. when others => -. end case. when Estado2 => EstadoSiguiente <= Estado3. Con ©2003 Guillermo Güichal 133 . Cuadro 58 Ejemplo de máquina de estados en VHDL En el proceso combinacional todas las señales que producen cambios deben estar en la lista de sensibilidad. Al sintetizar este código las herramientas usarán registros y asignarán un valor a cada estado. Además. when Estado3 => if (Entrada2_IN = ‘0’) then EstadoSiguiente <= Estado4.Entrada1= ‘1’.Estado4 EstadoSiguiente <= Inicial. Entrada2= ‘X” EstadoSiguiente <= Estado4. end ComportamientoFSM.6. when Estado1 => if (Entrada1_IN = ‘0’) then –.1 Codificación de Estados En el ejemplo se utiliza un tipo enumerado para describir los estados y así hacer el código más fácil de entender.

. Reset_IN) begin if (Reset_IN = '1') then -..Habilitación de reloj end if.-. -.Valores de reset elsif Rising_Edge(Clock_IN) then -. y no agrega lógica combinacional adicional. Esta es una señal con la que se habilita el reloj por un ciclo solo cada N ciclos. Cuadro 59 Utilización de la señal de habilitación de reloj Este método de habilitación de reloj es útil y recomendado para cualquier diseño secuencial y no solo para máquinas de estado. La señal de habilitación se debe generar en un bloque aparte dividiendo el reloj principal..Diseño digital utilizando FPGAs UTN.. Esto hace que un proceso sincrónico se ejecute solamente cada N ciclos de reloj en vez de con cada flanco del reloj. ©2003 Guillermo Güichal 134 .Instrucciones secuenciales del proceso . En una FPGA esta señal se conecta y distribuye a los bloques lógicos por una red de conexiones global dedicada a ese fin.6.Reset.. Lo que se utiliza es una señal de habilitación de reloj. Facultad Regional Bahía Blanca un registro de n bits pueden codificarse 2n estados. -.2 División de la Señal de Reloj (Clock Enable) Al diseñar para síntesis lo ideal es utilizar una sola señal de reloj que se distribuye a todos los bloques del diseño. pero muchas veces es más eficiente utilizar codificación “one-hot” o “one-cold”. Si se desea hacer funcionar parte del diseño. a una frecuencia diferente de la del reloj principal no debe proveerse una señal de reloj más lenta. end if. como puede ser una máquina de estados finita. Esto permite simplificar la lógica combinacional que determina en que estado se encuentra la máquina para asignar las salidas y el próximo estado. En VHDL esto debe describirse como se muestra en el Cuadro 59.. En general este método puede sintetizarse de manera eficiente utilizando las señales de habilitación de los flip-flops de salida en los bloques lógicos de las FPGA. -.Solo ejecutar las instrucciones secuenciales si el reloj -. .está habilitado if (HabilitacionDeReloj_IN = ‘1’) then . Clock end process ProcesoConHabilitacionClock. 8. En este tipo de codificación se usan tantos bits como estados haya y un solo bit está en ‘1’ (one hot) o ‘0’ (one cold) en un momento dado.Formato de un proceso con señal de habilitación de reloj ProcesoConHabilitacionClock : process(Clock_IN.

Es decir si el diseño hace lo que debería con los datos de entrada y responde con los datos de salida adecuados. Esto es más fácil de hacer en VHDL que ©2003 Guillermo Güichal 135 . Esto se hace creando lo que se denomina un "testbench". Por un lado se quiere ver si las formas de onda de la interfase responden a lo esperado. La realidad es que eso depende de las herramientas y del uso que se le da a ese VHDL. La utilización de bancos de prueba y simulaciones no elimina por completo la necesidad de probar luego el circuito sintetizado y colocado sobre una placa. Si el componente solo genera una forma de onda fija quizás no sea necesario hacer un análisis a nivel de datos.Diseño digital utilizando FPGAs UTN. Las próximas secciones describen VHDL que muchas veces no es sintetizable. 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. En el primer caso una observación de las formas de onda en general alcanza para analizar la interfase. si el componente es muy complejo quizás puede llevar más esfuerzo el diseño del banco de pruebas que el del componente en sí. pero algunas herramientas (Ej. con algún algoritmo de prueba más sofisticado y posiblemente leer y guardar datos de y a un archivo para su posterior análisis. Esto se hace mediante simulaciones utilizando los llamados “bancos de prueba”.1 Introducción El lenguaje VHDL no solo puede usarse para sintetizar circuitos sino que también pueden crearse modelos de simulación para verificar el diseño en sus distintas etapas mediante simulaciones. Facultad Regional Bahía Blanca 9 VHDL para Simulación y Verificación 9. Los lazos serán sintetizables si pueden resolverse para un instante dado y modelan lógica combinacional.2 Bancos de Prueba En el proceso de diseño de un circuito sintetizable se deben probar primero los componentes o bloques y luego el diseño completo. En general hay dos niveles de interfase que se desean probar. pero sí simplifica muchísimo todo el proceso de depuración. Los accesos a archivos no son sintetizables sobre la lógica de las FPGAs.: Quartus II de Altera) permiten usar código de acceso a archivos para inicializar valores de memoria o realizar tareas similares. El término banco de prueba proviene de las pruebas que se hacen a diseños mecánicos o eléctricos convencionales en que el dispositivo que se quiere probar se coloca en un banco donde también están los generadores de señales y los analizadores para medir las respuestas. A un nivel superior se desea probar si los datos de entrada/salida cumplen con lo esperado. o banco de pruebas. es importante probar los casos límite. Como en cualquier circuito digital. Para el análisis de funcionamiento a nivel datos probablemente se requerirá una metodología mas estructurada. En el ambiente de VHDL todo esto se hace de manera virtual utilizando código VHDL para generar señales de prueba y analizando las respuestas mediante simulaciones. 9.

La estructura superior contiene el diseño bajo prueba (DUT) y el componente que genera las pruebas y analiza los resultados.Diseño digital utilizando FPGAs UTN. usar números aleatorios para ver el funcionamiento. Mode_IN para que se permita evaluar. : : : : : IN IN IN IN IN std_logic. Clock_IN. std_logic_vector(2 downto 0). Se recomienda separar e independizar la generación de datos de la generación de temporizados.2 Diseño de un Banco de Pruebas Al diseñar un banco de pruebas no se deben seguir las reglas estrictas que se necesitan para síntesis. 9.2. std_logic. Es bueno dar siempre el mismo nombre de DUT o UUT (de Device Under Test o Unit Under Test) al diseño bajo prueba. si un diseño tiene la siguiente interfase. utilizar un número significativo de datos de entrada. Algunos de estos casos son que sucede cuando los contadores llegan a sus valores finales.1 Vectores de prueba Se denominan vectores de prueba (test vectors) a una secuencia de señales utilizadas para estimular y probar un diseño. Algunas organizaciones requieren que todos los elementos del banco de pruebas se separen en una librería completamente diferente a la de diseño. std_logic. Esto también se mostró en la figura en el interior del “Probador” Utilizar el prefijo “tb” para todos los componentes del banco de pruebas. Este último método es recomendable porque es muy flexible y permite redefinir fácilmente los vectores de prueba sin tocar el código VHDL. usando ciclos y arreglos de valores o leyendo los datos de un archivo. que sucede con combinaciones de entradas no esperadas. port ( Reset_IN Clock_IN Enable_IN Mode_IN Dato_OUT ). Enable_IN. etc. Estos vectores pueden generarse mediante VHDL secuencial que explícitamente genera la secuencia de señales deseadas. pero es buen seguir buenas prácticas de programación y estructura del banco de pruebas. std_logic_vector(7 downto 0) los vectores de prueba serian el conjunto de señales que prueban diferentes combinaciones de las entradas Reset_IN. Luego conectar este modelo al diseño que se desea probar. que sucede cuando se sobrepasan los límites esperados para las entradas.2. 136 • • ©2003 Guillermo Güichal . Facultad Regional Bahía Blanca con hardware “real” ya que podemos generar cualquier combinación de señales solo cambiando un poco de código. mediante observaciones de la salida Dato_OUT si el diseño está funcionando bien. La Figura 46 muestra el esquema sugerido para un banco de pruebas. Por ejemplo. Así es fácil diferenciar que elementos pertenecen al diseño y cuales al banco de pruebas. Algunas pautas y guías para hacer un buen banco de pruebas son las siguientes: • Englobar todo el banco de pruebas en un modelo estructural de nivel superior. 9.

nombres. Ambas se han presentado en secciones anteriores. Los procesos de prueba deberán tener un valor de reposo ya que esto es lo que indica que se terminó la simulación y facilita la tarea al simulador (ayuda a ejecutar la simulación más rápido). y en esta sección solo se darán ejemplos de su utilización.3 Manejo de tiempo en simulaciones usando VHDL En las simulaciones se debe controlar y medir la variable tiempo. Es bueno seguir las mismas pautas de código y nombres ya que eso hace que el banco de pruebas sea mas fácil de entender. Facultad Regional Bahía Blanca No se necesitan seguir las estructuras presentadas para síntesis: como los bancos de prueba no serán sintetizados. sino que solo sirven para las simulaciones. El manejo del tiempo se hace a través de la instrucción wait y la palabra after. Figura 46 Esquema de banco de pruebas para DUT 9. P_PruebaReadEnable : process variable Dato1_VAR.2. modificar e incluso reutilizar. Dato2_VAR : std_logic_vector(7 downto 0). etc. En el Cuadro 60 se muestran algunos de sus usos mediante un proceso que prueba la lectura de un dato usando un protocolo.1 Uso del WAIT y AFTER La instrucción wait es la que permite esperar una cierta cantidad de tiempo o a que suceda un evento. Usar las mismas guías en el código.2.Diseño digital utilizando FPGAs • • • UTN. no es necesario seguir las estructuras presentadas para diseños sintetizables. De esta manera se pueden crear las situaciones necesarias para probar el diseño y se puede evaluar la respuesta temporal del mismo.3. ©2003 Guillermo Güichal 137 . 9.

En el Cuadro 61 se muestra un ejemplo en el que se verifica que el tiempo entre cambios de una señal no sea menor que 4 ns. Esto es muy útil cuando se quieren medir los tiempos de respuesta de un diseño. -.. -.ciclo de lectura -. -. TCambioAnterior := TCambioActual. UTN. -.Mantengo señal x Thold wait for 400 ns.Espero aviso Dato1_VAR := Dato_IN.Ver si cambia el dato. -.Espero aviso Dato2_VAR := Dato_IN.Primer ciclo de lectura wait until ReadAck_IN = ‘1’. end process P_ReadEnable.Verifico si hay suficiente tiempo entre cambios ©2003 Guillermo Güichal 138 .Fin del primer ciclo de lectura ReadEnable_N_OUT <= ‘1’ after 12 ns.Espera para generar 2do -.Leo el dato -. 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. -. .Comienzo del segundo ciclo de lectura ReadEnable_N_OUT <= ‘0’. Si lo hace calcular el tiempo de cambio if (DatoAnterior_VAR /= DatoActual_VAR) then -.Leo el tiempo de cambio actual DatoAnterior_VAR := DatoActual_VAR.Diseño digital utilizando FPGAs begin -.Guardo el dato y el tiempo de cambio de dato anterior -.Leo el dato ReadEnable_N_OUT <= ‘1’ after 12 ns. Puede esperarse un evento.Comienzo del primer ciclo de lectura ReadEnable_N_OUT <= ‘0’.Fin de la simulación 9.Espero x transitorio -. -. wait for 1 ms.Comienzo de la simulación ReadEnable_N_OUT <= ‘1’.3. -. Facultad Regional Bahía Blanca -.2 Función NOW La palabra NOW se utiliza para leer el tiempo actual de simulación..Mantengo señal x Thold wait. -.Comienzo sin lectura -. -. -. TCambioActual := now.2. Cuadro 60 Ejemplo del uso de wait y alter en un proceso de prueba -.Ciclo de lectura wait until ReadAck_IN = ‘1’.

.Diseño digital utilizando FPGAs UTN.TCambioAnterior) < 4 ns then -. La síntesis o no de estos lazos depende de las herramientas.Ejemplo de la instrucción FOR para verificar la diferencia -. -. end loop. -.cero for Indice in 31 downto 0 loop ArregloBits(Indice) = ‘0’.... UltimoIndice := UltimoIndice + 1. Cuadro 61 Ejemplo del uso de NOW para leer el tiempo de un evento 9.Formato de la instrucción FOR for Indice in Primero to/downto Ultimo loop . Facultad Regional Bahía Blanca if (TCambioActual .. -. end if.Ejemplo de la instrucción FOR para inicializar un arreglo -. -... 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 diseños sintetizables como se verá más adelante en la sección sobre bancos de prueba. El lazo for puede usar un índice que se incrementa o reduce según se usa la palabra to o downto. estas instrucciones solo son sintetizables si el resultado final puede modelarse como lógica y no contienen instrucciones de manejo de tiempo (WAIT) dentro de los lazos.. -. Esto dependerá de la tarea que deba llevar a cabo el lazo. .Instrucción secuencial end loop..Instrucción secuencial . end if. El lazo se termina con end loop y en el cuerpo se describen las tareas que se deben realizar usando instrucciones secuénciales. -. En el Cuadro 62 se dan ejemplos de lazos for .1 Instrucciones de lazo FOR. WHILE y LOOP.Se guarda el tiempo de lectura e incrementa el índice TiemposLectura(UltimoIndice) := now.entre elementos de un arreglo con elementos de tipo time ....3 VHDL (Generalmente) No Sintetizable Hay muchas instrucciones y estructuras de VHDL que no se pueden sintetizarse. 9. NEXT y EXIT Las instrucciones de lazo son instrucciones secuenciales que permiten realizar una tarea más de una vez. En general.Tareas que se hacen con cada Índice . -. ©2003 Guillermo Güichal 139 . hasta que se cumpla alguna condición.3.Error! Hay un cambio antes de los 4 ns .

Escribir a un archivo que hay error en los tiempos .Formato de la instrucción WHILE while Indice in Primero to/downto Ultimo loop .Para todos los elementos del arreglo .condición especificada for Idx in 2 to UltimoIndice loop if (TiemposLectura(Idx) .TiemposLectura(Idx-1) > 5 ns) then . .entre elementos de un arreglo con elementos de tipo time . -.Ejemplo de la instrucción FOR para verificar la diferencia -.Tareas que se hacen con cada Indice . -. end loop..Ejemplo de la instrucción FOR para inicializar un arreglo -.. .....Instrucción secuencial end loop..Si hubo un deltaT > Limite end loop.cero for Indice in 31 downto 0 loop ArregloBits(Indice) = ‘0’.. . end if.Se verifican los tiempos leídos para ver si cumplan la -. -..TiemposLectura(Idx-1) > 5 ns) then ... -.. -.. Cuadro 62 Formato y ejemplo de lazo FOR El Cuadro 63 muestra el uso de la instrucción while.. end if.Se verifican los tiempos leídos para ver si cumplan la -. -.Si hubo un deltaT > Limite ©2003 Guillermo Güichal 140 .. -.... -. -.... -. . -.. Mientras esa condición se evalúe como verdadera (true) se seguirá ejecutando el cuerpo secuencial del lazo.Se guarda el tiempo de lectura e incrementa el índice TiemposLectura(UltimoIndice) := now.Diseño digital utilizando FPGAs . UltimoIndice := UltimoIndice + 1. UTN.Instrucción secuencial . -......Escribir a un archivo que hay error en los tiempos .condición especificada for Idx in 2 to UltimoIndice loop if (TiemposLectura(Idx) . En esta expresión se especifica una condición buleana al comienzo.. -. Facultad Regional Bahía Blanca -.

--.Para todos los elementos del arreglo .Comienzo del lazo Indice := Indice + 1... -. -..--------------------------------------------------------. -. La más simple es como instrucciones por su cuenta. -..Reinicia el lazo .del “end loop”) .Reinicia el lazo si Indice < 5 . En este lazo se usan las instrucciones next y exit para manejar los saltos a la próxima ejecución del lazo o para salir..Instrucciones secuenciales next (when Condición).. -..Instrucciones secuenciales exit (when Condición). -Indice es mayor que 5 ... -. generalmente utilizado después de una comparación if. -. para salir del lazo si l condición se cumple. Hay varias maneras de usar las instrucciones next y exit.Sale del lazo (salta después -.. –para todos los valores de Indice . Cuadro 63 Formato del lazo WHILE En el Cuadro 64 se muestra el formato del lazo utilizando la instrucción loop. exit when Indice = 10. ...--------------------------------------------------------.. ...Instrucciones secuenciales que se ejecutarán .Formato de la instrucción LOOP.Sale del lazo con Indice = 10 end loop. -..Ejemplo de lazo loop con condiciones de salida -Indice := 0... Facultad Regional Bahía Blanca end loop.Instrucciones secuenciales que se ejecutan solo si . -.. ©2003 Guillermo Güichal 141 .Incremento del índice . -.. .Inicialización del índice loop -. Cuadro 64 Formato del lazo LOOP Ejemplos de formatos de uso de next y exit en un lazo: • exit. -.Instrucciones secuenciales end loop... -. NEXT y EXIT loop .--. -.Diseño digital utilizando FPGAs UTN... También se puede usar la palabra when para especificar la condición en la misma línea de instrucción -.. next when Indice <= 5...

Ejemplos de uso de assert. exit when (Condición buleana). Facultad Regional Bahía Blanca 9.Diseño digital utilizando FPGAs • • • • • next. if (Condición buleana) then next. A continuación 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. En general el simulador detendrá la simulación si la falla es muy grave. end if. UTN. if (Condición buleana) then exit. El formato para esta instrucción es assert ExpresiónDeCondición report Mensaje severity NivelDeFalla. -. Son instrucciones secuenciales que pueden utilizarse en cualquier punto del cuerpo de un proceso. report: -. se sobrescribirán primeros valores” severity note. ExpresiónDeCondición: expresión buleana que provocará una falla si se evalúa como false Mensaje: Cadena de caracteres que da un mensaje al usuario sobre la falla.Error en una señal que no generará el efecto esperado ©2003 Guillermo Güichal 142 .Mal funcionamiento dentro del modelo assert NumeroBytes = 0 report “Se recibió paquete sin datos” severity warning. end if. -. Detendrá al simulador. next when (Condición buleana). • error : Error en el modelo que no • failure : Falla muy grave que no puede suceder nunca. El límite para esto puede ser fijado por el usuario.Nota al usuario sobre el funcionamiento del modelo assert MemoriaLibre >= MEM_LIMITE_MINIMO report “Memoria baja.3.2 Instrucciones ASSERT y REPORT Estas instrucciones se utilizan durante simulación para dar mensajes sobre el estado de funcionamiento de un modelo al usuario. NivelDeFalla: Usado para informar el nivel de severidad de la falla.

Para simplificar la escritura y lectura de archivos en un formato entendible para el usuario. De esta manera se hace fácil especificar los datos de entrada a un modelo o verificar sus resultados. o esto puede hacerse más adelante utilizando la instrucción open. Estas operaciones se muestran en la Tabla 13. VHDL contiene el tipo file para poder manejar archivos. un proceso o un subprograma. ya sea de una arquitectura. arreglos de una dimensión o datos de tipo record.Error en el modelado de un componente assert NumeroDeEntradas = NumeroDeSalidas report “Error en el modelo. Al escribir datos a un archivo estos se guardarán con un formato binarios que dependerá del sistema sobre el que se está trabajando.” severity error. Tabla 13 Operaciones con archivos provistas por VHDL file_open file_close read write endfile Descripción Procedimiento utilizado para abrir de manera explícita un archivo Procedimiento utilizado para cerrar de manera explícita un archivo Procedimiento utilizado para leer un dato de un archivo Procedimiento utilizado para escribir un dato a un archivo Función que verifica si se ha llegado al final de un archivo y devuelve true o false Un archivo puede declararse en cualquier sección de declaración. No generará interrupción. En general estos no pueden ser analizados directamente por el desarrollador. -. Facultad Regional Bahía Blanca assert AnchoDePulso >= 2 ns report “Pulso demasiado chico. Los archivos en VHDL pueden contener un solo tipo de datos. 9.3 Manejo de Archivos y Paquete TEXTIO Además de los tipos predefinidos nombrados anteriormente. En muchos casos es importante que se puedan escribir o leer los datos directamente de los archivos. incluyendo escalares. No se puede simular” severity failure. la librería std provee el ©2003 Guillermo Güichal 143 . La instrucción report puede usarse por si sola para generar mensajes que ayuden en la depuración del código. -. La expresión tiene la forma Uso y ejemplos de report report Mensaje. Además provee varias instrucciones para el manejo de archivos. Al hacer la declaración puede asociarse un archivo físico.3. write_mode para escritura a un archivo nuevo y append_mode para agregar datos al final de un archivo existente.Diseño digital utilizando FPGAs UTN.Formato de la instrucción report report “Nuevo dato de entrada”. Los archivos pueden abrirse en tres modos: read_mode para lectura.

Como la secuencia de escritura a un archivo de varios procesos concurrentes es impredecible. También incluye los archivos que pueden utilizarse directamente "input" y "output" asociados a los archivos físicos "std_input" y "std_output". Para utilizar archivos de texto en un banco de pruebas (el manejo de archivos no es sintetizable). Si cada proceso marca de alguna manera las líneas que escribe es fácil descifrar el funcionamiento del modelo en su conjunto al analizar el archivo. use std.Diseño digital utilizando FPGAs UTN. al escribir líneas completas no se entremezclarán los datos sino que a lo sumo se alternan líneas de un proceso y otro. que en general están definidos como la pantalla y el teclado en casi todos los sistemas. Este paquete permite acceder a archivos que contienen cadenas de caracteres. El lector puede referirse a la bibliografía para estudiar el uso de otros tipos de archivo. Facultad Regional Bahía Blanca paquete textio.textio. Tabla 14 Tipos y procedimientos en textio Tipo line text side width Procedimiento Procedimiento que permite copiar (leer) una línea 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 parámetro que permiten leer diferentes datos de una variable tipo line Serie de procedimientos sobrecargados para diferentes tipos de write parámetro que permiten escribir diferentes datos a una variable tipo line Las operaciones de entrada salida sobre los archivos utilizando textio se hacen línea a línea. Esto hace accesible el paquete textio que incluye los tipos y procedimientos mostrados en la Tabla 14.all. En lo que resta de esta sección se presentará el paquete textio y su utilización para leer y guardar datos de simulación. Así. Pueden usarse funciones de conversión para guardar o escribir cualquier tipo de dato en estos archivos. Esto permite que varios procesos accedan a un mismo archivo. se deben agregar las siguientes líneas en el código library std. Descripción 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 (números de 0 al máximo entero) ©2003 Guillermo Güichal 144 . Estos se proveen para poder acceder a los dispositivos estándar de entrada / salida. todos los datos serán cadenas de texto.

Esa línea luego se procesa usado las diferentes variantes de read para extraer los datos.Ejemplo de alias para nombrar los registros y bits -.4 Palabra reservada ALIAS Como se mencionó anteriormente. type tdCPUSetRegistros is record ContadorPrograma : tdCPURegistro. ©2003 Guillermo Güichal 145 . y se recomienda no utilizarlas para diseños que se sintetizarán para FPGAs. CpuGPR_REG is CPURegisterSet_REG. el lenguaje VHDL da mucha flexibilidad para la definición de nuevos tipos y subtipos. -.Se declara una señal con el nuevo tipo signal CPURegisterSet_REG : tdCPUSetRegistros.RegistroAuxiliar1. 9. CpuA1_REG is CPURegisterSet_REG.Se alias alias alias alias alias alias definen alias para los registros de la señal declarada CpuPC_REG is CPURegisterSet_REG.Se definen alias para algunos bits de algunos registros alias CpuPCHigh_REG is CpuPC_REG(15 downto 8). -.RegistroControl. Facultad Regional Bahía Blanca Para leer datos usando textio se debe declarar una variable del tipo line y abrir un archivo de subtipo text. RegistroControl : tdCPURegistro. end record. RegistroGeneral : tdCPURegistro. RegistroAuxiliar1 : tdCPURegistro.RegistroEstado. El Cuadro 65 muestra algunos ejemplos.Diseño digital utilizando FPGAs UTN.RegistroAuxiliar1. En el caso más simple un alias se refiere a un dato con otro nombre.del conjunto de registros de una CPU subtype tdCPURegistro is std_logic_vector(15 downto 0). -. RegistroAuxiliar2 : tdCPURegistro. CpuControl_REG is CPURegisterSet_REG.3. Otra instrucción que es muy útil para poder hacer que los modelos sean más claros de entender es la palabra reservada alias. La capacidad de sintetizar o no diseños que utilizan alias depende de las herramientas. Esta palabra permite definir nuevos nombres para datos y otros objetos.ContadorPrograma. alias CpuPCHigh_REG is CpuPC_REG(7 downto 0). -. RegistroEstado : tdCPURegistro. Esto permite ordenar y organizar los modelos para que sean fáciles de entender y se adecuen a los componentes que se quieren modelar.RegistroGeneral. CpuState_REG is CPURegisterSet_REG. Mediante una instrucción secuencial readline se lee una línea del archivo. CpuA2_REG is CPURegisterSet_REG. Para escribir una línea 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 línea al archivo usando writeline.

use ieee.Vector de interrupciones que incluye todos los bits alias CpuInterrupcion_REG is CpuState_REG(4 downto 0).3.3. while (SimmulacionActiva_IN = '1') loop std_logic.5 Ejemplos de Componentes para Bancos de Prueba A continuación se dan algunos ejemplos de componentes para pruebas que usan manejo del tiempo y otras estructuras no sintetizables.Estado de las interrupciones -.Bits de interrupcion uno a alias CpuInterrupcion1_REG is alias CpuInterrupcion2_REG is alias CpuInterrupcion3_REG is alias CpuInterrupcion4_REG is Cuadro 65 Ejemplos declaración de alias uno CpuState_REG(0). -. El último ejemplo muestra como puede simularse un ciclo de bus de CPU. entity tbGeneradorReloj is generic ( PERIODO_NS : time := 20 ns ). Los primeros dos serán utilizados para probar casi todos los diseños. architecture Comportamiento of tbGeneradorReloj is begin P_Reloj : process begin wait for 1 ns.1 Generación de Señal de Reloj En el Cuadro 66 se muestra un componente que genera una señal de reloj con el período dado por una constante genérica.all.std_logic_1164. 9. port ( SimmulacionActiva_IN : IN Reloj_OUT : OUT ).5. end tbGeneradorReloj . std_logic ©2003 Guillermo Güichal 146 . CpuState_REG(1). CpuState_REG(2).Diseño digital utilizando FPGAs UTN. library ieee. 9. Facultad Regional Bahía Blanca -. CpuState_REG(3). ya que describen una generación de reloj y generación de una señal de reset.

library ieee. use ieee. wait for TIEMPO_RESET.5. Cuadro 66 Generación de una señal de reloj para pruebas 9. wait for PERIODO_NS / 2.std_logic_1164. wait. entity tbGeneradorReset is generic ( TIEMPO_RESET : time := 250 ns ). architecture Comportamiento of tbGeneradorReset is begin P_Reset : process begin Reset_OUT <= ‘1’.Diseño digital utilizando FPGAs UTN.Proceso en espera permanente end process P_Reloj. -. end loop. wait. Cuadro 67 Generación de una señal de reset para pruebas ------ Reset activo Se mantiene reset activo Reset baja. end tbGeneradorReset . end Comportamiento. end process P_Reset.Simulación activa Reloj_OUT <= '0'. Reloj_OUT <= '1'.3. -. Reset_OUT <= ‘0’. wait for PERIODO_NS / 2. port ( Reset_OUT : OUT std_logic ).all.2 Generación de una Señal de Reset En el Cuadro 67 se muestra un componente que genera una señal de “Reset” con el tiempo de reset activo dado por una constante genérica. end Comportamiento. Comienza a funcionar el circuito Proceso en espera permanente ©2003 Guillermo Güichal 147 . Facultad Regional Bahía Blanca Reloj_OUT <= '0'.

La Tabla 15 y Tabla 16 dan los valores de tiempo correspondientes y el Cuadro 68 muestra el VHDL que simula la interfase. Por un lado se generarán y leerán datos para verificar el funcionamiento del diseño a alto nivel.3 Temporizado de la Interfase de un Bus de Microcontrolador En este ejemplo la FPGA tendrá una interfase con un microcontrolador (uC) genérico muy simple.Diseño digital utilizando FPGAs UTN. Facultad Regional Bahía Blanca 9. Para probar el diseño se debe crear un banco de pruebas que simule la interfase de ese uC. Ciclo de lectura Ciclo de escritura Clock tClock tSRData tSWData tHRData tHWData Data tHAddress tSAddress tHAddress tSAddress Address tSRead tHRead ReadEnable tSWrite tHWrite WriteEnable Figura 47 Temporizado de uC a simular en el banco de pruebas Tabla 15 Tiempos para ciclo de lectura de uC Parámetro tClock tSAddress tHAddress tSRead tHRead tSRData tHRData Descripción Período del reloj (48 . Por otro esos datos se transferirán desde y hacia la FPGA simulando el temporizado del bus del uC (ya que esa es la manera en la que los dos dispositivos irán conectados en el hardware final).3.5. El banco de pruebas tendrá dos niveles.52% duty cycle) Tiempo de “setup” de direcciones antes del primer flanco positivo de reloj Tiempo de mantenimiento o “hold” de la dirección después del flanco positivo de reloj Tiempo de “setup” de señal ReadEnable en ‘0’ antes del flanco positivo de reloj Tiempo de mantenimiento o “hold” de la señal ReadEnable después 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 después del flanco positivo de reloj Mínimo 100 ns 50 ns 8 ns 54 ns 4 ns 15 ns 1 ns Máximo 1 us 14 ns 8 ns ©2003 Guillermo Güichal 148 . En la Figura 47 se muestra el temporizado de este bus sincrónico.

. constant T_HOLD_WRITEENABLE : time := 4 ns.52% duty cycle) Tiempo de “setup” de direcciones antes del primer flanco positivo de reloj Tiempo de mantenimiento o “hold” de la dirección después del flanco positivo de reloj Tiempo de “setup” de señal WriteEnable en ‘0’ antes del flanco positivo de reloj Tiempo de mantenimiento o “hold” de la señal WriteEnable después del flanco positivo de reloj Tiempo de “setup” de datos antes del flanco positivo de reloj Tiempo de mantenimiento o “hold” del dato después del flanco positivo de reloj Mínimo 100 ns 50 ns 8 ns 62 ns 4 ns 58 ns 6 ns Máximo 1 us 14 ns 8 ns 15 ns -. . etc. ©2003 Guillermo Güichal 149 .. constant T_SETUP_W_DATA : time := 58 ns. port( Reset_IN : in std_logic.... Data_IO : inout std_logic_vector(15 downto 0) ). constant T_SETUP_READENABLE : time := 54 ns. constant T_HOLD_R_DATA : time := 1 ns..--. WriteEnable_OUT : out std_logic. constant T_HOLD_W_DATA : time := 6 ns. constant T_HOLD_READENABLE : time := 4 ns. -.------------------------------------------------------.. Facultad Regional Bahía Blanca Parámetro tClock tSAddress tHAddress tSWrite tHWrite tSWData tHWData Descripción Período del reloj (48 . -.Declaración de librerías y uso de paquetes.Declaración de tipos.. .. . -... señales internas. constant T_SETUP_R_DATA : time := 15 ns.Ejemplo de ciclo de temporizado de un bus de uC . Address_OUT : out std_logic_vector(19 downto 0) . constant T_HOLD_ADDRESS : time := 8 ns.Diseño digital utilizando FPGAs Tabla 16 Tiempos para ciclo de escritura de uC UTN. architecture Comportamiento of tbMicroControlador is -. .Constantes de parámetros de temporizado del bus constant T_SETUP_ADDRESS : time := 50 ns... constant T_SETUP_WRITEENABLE : time := 62 ns. end tbMicroControlador. Clock_IN : in std_logic.Entidad para banco de pruebas que simula el micocontrolador entity tbMicroControlador is generic( T_CLOCK : time := 200 ns ). ReadEnable_OUT : out std_logic.

de las operaciones a nivel dato para leer y escribir -. ©2003 Guillermo Güichal 150 . wait until Rising_Edge(Clock_IN). Los ciclos del bus y los datos se guardan a un archivo junto a una etiqueta de tiempo. EscribirDato definidos antes del begin del proceso SimulacionDeMicro : process variable FinDeSimulacion : boolean := false. mensajes de error. para ser revisados después y analizar el funcionamiento del diseño Cada vez que se debe acceder al bus se usan los procedimientos de LeerDato. procedure EscribirDato is begin wait until Rising_Edge(Clock_IN). wait for (T_CLOCK – T_SETUP_R_DATA). 0).Procedimientos de acceso al bus que controlan los -.Diseño digital utilizando FPGAs UTN. -.. etc. Address_OUT end LeerDato.el bus procedure LeerDato is begin wait until Rising_Edge(Clock_IN). Address_OUT <= DireccionRead_VAR after T_CLOCK – T_SETUP_ADDRESS. DatoEnTiempoHold_VAR := Data_IO. –. 0). wait until Rising_Edge(Clock_IN).. .temporizados y se usan en los procesos de simulación -.Otras variables auxiliares para controlar simulación 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). ReadEnable_OUT <= ‘1’ after (T_HOLD_READENABLE–T_HOLD_R_DATA). <= (others => ‘0’) after (T_HOLD_ADDRESS – T_HOLD_R_DATA). 0). ReadEnable_OUT <= ‘0’ after (T_CLOCK – T_SETUP_READENABLE). 0). Facultad Regional Bahía Blanca begin ---------En el proceso de control se leen las operaciones y datos de los ciclos del uC de un archivo de comandos. WriteEnable_OUT <= ‘0’ after (T_CLOCK – T_SETUP_WRITEENABLE). wait for T_HOLD_R_DATA. DatoEnTiempoSetup_VAR := Data_IO.

. Address_OUT <= (others => '0'). . . ...Otros comandos y procesamiento de los datos leídos.. -.. end EscribirDato. wait until Rising_Edge(Clock_IN).Escribir resultados a un archivo . Address_OUT <= (others => ‘0’) after T_HOLD_ADDRESS.Valores iniciales ReadEnable_OUT <= '1'. -.. -..Lazo de simulación de X operaciones. LeerDato.... Data_IO <= (others => 'Z')..Leer operación y datos de un archivo . -.... when OP_CPU_ESCRITURA => ..Escribir resultados a un archivo .. -.el archivo while (FinDeSimulacion = false) loop . -.Diseño digital utilizando FPGAs Address_OUT UTN.. . WriteEnable_OUT <= '1'. Cuadro 68 Simulación de la interfase de un microcontrolador ©2003 Guillermo Güichal 151 .Comienzo del proceso de simulación del uC begin -... o hasta que se acabe -. when . wait until Rising_Edge(Clock_IN). Facultad Regional Bahía Blanca <= DireccionWrite_VAR after (T_CLOCK – T_SETUP_ADDRESS).. .... Data_IO <= DatoWrite_VAR after (T_CLOCK – T_SETUP_W_DATA). etc. EscribirDato... Data_IO <= (others => ‘Z’) after T_HOLD_W_DATA. pero aquí no se hace wait until Reset_IN = '0'. WriteEnable_OUT <= ‘1’ after T_HOLD_WRITEENABLE.a ver que pasa durante el re3set.. .. NO es mala idea probar -.. case OperacionDeCPU is when OP_CPU_LECTURA => . -.Esperar a salir del estado de reset..

etc. ©2003 Guillermo Güichal 152 . Hay varias instrucciones. Algunas de estos temas no se usan en circuitos sintetizables y otros no se incluyeron para no hacer estas notas demasiado largas y pesadas. Facultad Regional Bahía Blanca 9.. etc. blocks) • Manejo de archivos de otro tipo que el definido en textio • etc. 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 síntesis) • Atributos de tipos escalares y señales (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 • Múltiples arquitecturas y uso de configuraciones (configure) • Bloques y guardas (guards. estructuras. e infinitas posibilidades de uso de VHDL que no han sida descriptas.Diseño digital utilizando FPGAs UTN. Para ahondar más en estos temas se recomiendan los textos mencionados en la sección Bibliografía o utilizar Internet para buscar la información deseada..4 Que Falta sobre VHDL… El objetivo de estas notas en cuanto a VHDL es presentarlo en el contexto de los diseños sintetizables para FPGAs y dar una guía rápida y ejemplos para que el lector pueda utilizarlo lo más rápido posible.

3 Guía de estilo para el código HDL Ya se ha planteado la importancia de crear diseños que puedan ser entendidos facilmente. Lo más importante es ser consistente a través del tiempo y con el resto de la organización al escribir código (ya sea VHDL o en cualquier otro lenguaje de programación). ya sea otros desarrolladores. Por otro lado. solo por las mayúsculas o Colocar las instrucciones begin y end en su propia línea de programa o En general. • Lenguaje de programación en general o En los lenguajes que no son sensibles a las mayúsculas ser consistente en el uso de la capitalización para las palabras reservadas. De esta manera se evitan las confusiones y se acelera el aprendizaje de nuevos integrantes del equipo. En esta sección se presentarán de manera básica una serie de puntos y recomendaciones relacionadas con estos temas. Para facilitar esto. 10. entidades. cada instrucción independiente del programa deberá estar en su propia línea o No usar constantes mágicas. o Dar un nombre a todos los procesos para aclarar su funcionalidad. En este sentido el diseñador debe estar al tanto de los requerimientos. Estos diseños pueden llegar a ser bastante sofisticados y tener una jerarquía que utilice componentes desarrollados por diferentes personas. frecuencias etc. Definir todas las constantes con palabras que las identifiquen inequívocamente. las FPGAs permiten el desarrollo de sistemas muy complejos en un solo componente.Diseño digital utilizando FPGAs UTN. etc. vendible. 10. tolerancias.1 Introducción Al diseñar hardware utilizando VHDL no debe olvidarse que el producto es parte de un sistema más grande y que interactuará con componentes y señales externas sobre las que no hay control. una organización debería tener una guía documentada que pueda ser consultada por todos los desarrolladores. clientes. Facultad Regional Bahía Blanca 10 Buenas Prácticas de Diseño 10. 153 ©2003 Guillermo Güichal . auditores o el mismo desarrollador un tiempo más tarde. y no debe tomarse como el único modelo que puede ser utilizado.2 Documentación Si se pretende tener un producto (re)utilizable. o En los lenguajes que son sensibles a las mayúsculas no se deben diferenciar los nombres de funciones. COMPLETAR CON PAUTAS SOBRE DOCUMENTACIÓN. Para poder manejar esto de manera controlada es bueno tener pautas o guías de diseño que ayuden a la interacción y reutilización de la propiedad intelectual. En esta sección se presenta un ejemplo de documento de este tipo. de estas señales y componentes para poder proveer una interfase que se adecue a la funcionalidad prevista. procesos. o que pueda entenderse después de tenerlo archivado unos meses es imprescindible crear buena documentación. Este es solo un ejemplo.

Dar un prefijo especifico a todas las constantes de acuerdo al proyecto. En vez de eso usar tipos “OUT” y agregar otra señal interna a la que se le asigna el mismo valor. Facultad Regional Bahía Blanca o Usar un prefijo “td” para los tipos definidos en el programa o Usar paréntesis aunque no sean necesarios si ayudan a entender la prioridad y sentido de la lógica que se está describiendo. variables y constantes o Usar nombres que den una clara idea de los datos que contiene la señal o constante. UTN_ADC_MINIMO). • Programación en VHDL o No mezclar estándares de programación. o Para los nombres de las señales usar mayúsculas solo para identificar las palabras del nombre. procesos o procedimientos. (Ej. o Usar tipos std_logic para todas los puertos de interfase externa o Nunca asignar un valor desconocido ‘X’ o verificar un don’t care ‘-‘ (producen resultados inesperados en la síntesis y las simulaciones) o No usar los valores por defecto para señales y variables. Usar sintaxis VHDL 87 o 93 exclusivamente) o Usar un archivo por entidad (“entity”) que defina su interfase y arquitectura. o Usar los siguientes sufijos para las señales en VHDL sin sufijo : cable _N : lógica negada (“active low”) _REG : señal almacenada en un registro _LATCH : señal almacenada en un match _DLY : señal retrasada a través 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) • ©2003 Guillermo Güichal 154 . Nombres de las señales. quizás agregando prefijos o sufijos.: UTN_ADC_MAXIMO. o Usar nombres que den una idea clara de la función de los módulos.: NombreDelProceso) o Usar todas mayúsculas separadas con “_” para definir constantes. Usar palabras completas y no abreviaturas que son difíciles de descifrar y recordar. o Tratar de usar el mismo nombre para las señales a través de toda la jerarquía de diseño. El nombre del archivo deberá ser igual al de la entidad. Usar una secuencia jerárquica de palabras clave para especificar a que valor se está refiriendo una constante (Ej.Diseño digital utilizando FPGAs UTN. Asignarles un valor inicial durante el estado de Reset. (Ayuda a reutilizar el código) o No utilizar puertos del tipo “BUFFER” para leer un valor de salida. o Definir todas las constantes para un diseño en un solo “package” o Usar constantes y parámetros genéricos para definir el tamaño de los buffers y buses.

Dos espacios es un valor razonable. • • Ejemplos: • Comentarios.LIMITES PARA LOS DATOS LEIDOS DEL ADC -.-----------------------------------------------------------------------------. Comentarios o Usar los comentarios para describir la lógica y el motivo del programa.SEÑALES -. constant UTN_ADC_VALOR_MINIMO : std_logic_vector(12 downto 0) := “1110000000000”. Dejar “_” para las nombres de las variables. o Indentar la primer línea de código después de la declaración de un proceso o procedimiento. Indentación.-----------------------------------------------------------------------------. Todo el código que implementa el proceso quedará así indentado debajo de la declaración. o Usar líneas completas comentadas para dividir grandes bloques lógicos del programa o Usar comentarios para especificar que condición está cerrando un comando END o Siempre debe agregarse un comentario para describir lógica que no es obvia o tiene particularidades que son difíciles de entender a simple vista. Los TABs deberán estar definidos como 2 espacios. o La indentación debe ser fija y consistente para todo proyecto. espacios y nombres -. o Usar líneas en blanco para separar las declaraciones de las funciones. Facultad Regional Bahía Blanca o Usar los siguientes prefijos para las señales en VHDL sin prefijo : cable int : representación interna de un puerto de una “entity” • Nombres de módulos procesos. o Usar mayúsculas para dividir las palabras de un nombre. etc. procesos o procedimientos.----------------------------------------------------------------------------constant UTN_ADC_VALOR_MAXIMO : std_logic_vector(12 downto 0) := “0010000000000”. o No escribir líneas de código de mas de 80 caracteres.----------------------------------------------------------------------------signal ADCdataBus : std_logic_vector(12 downto 0). espacios y líneas en blanco o Hacer un consistente y buen uso de los espacios. signal ADCReady : std_logic. Partir la línea larga entre varias y alinearla para que se comprenda mejor. los bloques funcionales de código. signal ADCRead : std_logic.Diseño digital utilizando FPGAs UTN. ©2003 Guillermo Güichal 155 . procedimientos o Usar nombres que den una idea clara de la función de los módulos. indentación y líneas en blanco para que el código sea mas entendible y claro. -. No comentar lo obvio. o Ser sistemático en el formato de los nombres.

if Reset.. Las recomendaciones de VHDL para síntesis generales (estándar 1076.no hay consistencia en Proceso_Entradas_Resta : PROCESS(Clock_IN.4. espacios e indentación Usar: -. . Reset_IN) -..No hay un estándar -. no aquí . Reset_IN)… -. Hay que hacer síntesis y anotar con SDF. -.1 Diferencias entre Síntesis y Simulación Diferencias que pueden existir entre diseño simulado y sintetizado. -. Según la herramienta que se use la implementación puede depender más o menos del código que se escriba. elsif (Clock_IN’event and Clock_IN = ‘1’) then .. para diseños con FPGAs no se recomienda dividir el reloj y generar una señal de menor frecuencia y duty cycle del 50%. Si se desea hacer funcionar parte del diseño a una frecuencia diferente de la del reloj principal no debe proveerse una señal de reloj más lenta..si hay un flanco de reloj Obvio -. Reset_IN)… P_RestaDeEntradas : PROCESS(Clock_IN. Reset_IN) begin if (Reset_IN = ‘0’) then . 10. end PROCESS.4. signal DatoDeSalida_REG : std_logic_vector(2 downto 0). Puede haber diferencias.alinear los espacios ..2 División de la Frecuencia Mediante Habilitación del Reloj Al diseñar para síntesis lo ideal es utilizar una sola señal de reloj que se distribuye a todos los bloques del diseño. Clock end process.Cada end en su propia línea • Usar: signal DatoDeEntrada_N_REG : std_logic_vector(2 downto 0). Esto es. 10.. especialmente con lógica combinacional y latches.. -.Diseño digital utilizando FPGAs • UTN. Tiempos no exactos en simulación.x) y de los fabricantes enseñan que esperan las herramientas para indicar las características que se desean en un diseño. -. Facultad Regional Bahía Blanca Capitalización. comentarios nombres.suma los datos Esto debería estar describiendo el proceso.4 Programación para Diseños Sintetizables Al hacer código VHDL para diseños sintetizables conviene utilizar las normas de código para síntesis recomendadas.. sino que se ©2003 Guillermo Güichal 156 .Si el Reset es cero Obvio elsif (Clock_IN’EVENT And Clock_IN = ‘1’) then -.. end.Proceso que suma las dos entradas leídas de los puertos serie P_SumaDatosSerie : process (Clock_IN.la indentación esta mal if (Reset_IN = ‘0’) THEN -.. Reset_IN)… y no: signal datodeentrada_N_REG : std_logic_vector(2 downto 0). En una FPGA esta señal se conecta y distribuye a los bloques lógicos por una red de conexiones global dedicada a ese fin. SumaDeEntradas : PROCESS(Clock_IN.para los nombres signal salida : std_logic_vector(2 downto 0). Reset_IN)… -. -. P_umaDeEntradas : PROCESS(Clock_IN.el formato de los nombres 10.No hay una descripción del proceso BEGIN -. end.Proceso Suma Datos Serie y no ProcesoX1 : process (Clock_IN.

Figura 48 División de frecuencia recomendada para FPGAs usando habilitación de reloj (CE) La Figura 49 muestra como NO debe implementarse una división de reloj en un diseño con FPGAs. Esto hace que un proceso sincrónico se ejecute solamente a la frecuencia deseada (cada N flancos de reloj) en vez de con cada flanco del reloj. Esta es una señal con la que se habilita el reloj por un ciclo solo cada N ciclos. no aprovecha los recursos de la FPGA y puede causar problemas de temporizado y sincronización en el circuito implementado. En general. Facultad Regional Bahía Blanca recomienda generar una señal de habilitación de reloj.Diseño digital utilizando FPGAs UTN. solo se recomienda manejar las señales de reloj de los flip-flops a partir de las redes de distribución global de reloj y nunca desde lógica combinacional. ©2003 Guillermo Güichal 157 . La Figura 48 muestra el método de división de frecuencia recomendado para diseños sobre FPGAs. Aunque este método es muy utilizado en diseños digitales convencionales.

Reset.Solo ejecutar las instrucciones secuenciales si el reloj -. -. Clock end process ProcesoConHabilitacionClock.Diseño digital utilizando FPGAs UTN...Valores de reset elsif (Rising_Edge(Clock_IN) then -.. Reset_IN) begin if (Reset_IN = '1') then -. -. -..Instrucciones secuenciales del proceso . Cuadro 69 Utilización de la señal de habilitación de reloj ©2003 Guillermo Güichal 158 .Habilitación de reloj end if.. end if.-.Formato de un proceso con señal de habilitación de reloj ProcesoConHabilitacionClock : process(Clock_IN. La señal de habilitación se debe generar en un bloque aparte dividiendo el reloj principal.está habilitado if (HabilitacionDeReloj_IN = ‘1’) then . Esta manera de dividir el reloj se sintetiza de manera muy eficiente utilizando las señales de habilitación de los flip-flops en los bloques lógicos de las FPGA. Facultad Regional Bahía Blanca Figura 49 División de frecuencia mediante divisor de reloj (No utilizar en FPGAs) Usando VHDL. .. el método recomendado para implementar la división de frecuencia se muestra en el Cuadro 69.

o Se deberán usar la mínima cantidad de dominios de reloj posibles. No usar un dato como reloj o Reset. Estos son las pautas que se ha tratado de utilizar a través de este texto para todos los ejemplos. Este Reset deberá estar conectado a la pata de Reset global de la FPGA o CPLD de ser posible. En este documento deberían volcarse las normas preferidas de interfase y estructuras de desarrollo así como también la experiencia y aprendizajes de la organización.5 Guía de Estilo Para un Buen Diseño de Hardware Así como una organización debería tener una guía para la estructura y formato del código para que sea entendible y reutilizable. De esta manera se ayuda a que luego la propiedad intelectual sea más fácil de comprender y reutilizar por otros o incluso por la misma persona después de un tiempo. asincrónico. (Esto es lo que espera el “boundary scan” y evita tener valores ) Reloj o Todas las señales que cruzan dominios de reloj deberán muestrearse antes y después de cruzar dominios (previene estados meta-estables). esto puede causar errores al integrarlos en un diseño.Diseño digital utilizando FPGAs UTN. Hay muchos errores comunes que pueden evitarse facilmente siguiendo este tipo de pautas Por ejemplo. o El Reset asincrónico se usará a nivel local en todos los módulos. si algunos desarrolladores utilizan una señal de reset positiva y otros negativa. Este se sincronizará con el reloj al nivel lógico mas alto de la jerarquía de diseño. Es una buena idea que se tengan estas normas o guías para el desarrollo de hardware centralizadas en un documento que puede ser consultado por los desarrolladores. o si algunos no proveen un estado de reset conocido o si algunos nombran los buses del bit más significativo al menor y otros al revés. o Durante el estado de Reset todos los puertos bidireccionales deberán colocarse en el estado de entrada. lo mismo es válido a nivel de componentes para que estos puedan interconectarse sin mayores esfuerzos a otros bloques y reutilizarse en otros proyectos. A continuación se da como ejemplo una lista de algunas recomendaciones para diseños utilizando VHDL tomado de guías de desarrollo de organizaciones reales. (Evita des-sincronización por caminos de diferente longitud de la señal de Reset). • Señal de Reset Proveer una señal de Reset porque hace que un diseño sea determinístico y evita que se llegue a estados prohibidos o Todos los Flip-Flop deberán tener un Reset de lógica positiva. (los resultados durante simulaciones pueden diferir del circuito sintetizado y causar problemas de temporizado) • ©2003 Guillermo Güichal 159 . Facultad Regional Bahía Blanca 10. se evita repetir errores y los nuevos desarrolladores pueden aprender de la experiencia de otros. o No usar señales de reloj o Reset como Enable o dato.

END PROCESS.. ELSIF (Clock'event AND Clock = '1') THEN . Reset) BEGIN IF (Reset = '1') THEN . END IF. lenta e innecesaria) ©2003 Guillermo Güichal 160 . de temporizado y en las simulaciones) o Tratar de no utilizar Flip-Flops con flanco de reloj descendente (dificulta la verificación y puede crear problemas durante la síntesis) o No usar latches. END PROCESS. tratar de definirla en un proceso solo con el siguiente formato PROCESS (Clock... (así las herramientas de síntesis utilizarán así la señal de enable interna de los bloques lógicos de la FPGA y no generarán lógica externa) o No utilizar largas cadenas de if. (crea problemas de síntesis y de verificación de tiempos) o Usar procesos con lista de sensibilidad a las señales de Reset y Reloj solamente con el siguiente formato • PROCESS (Clock. o Para lógica sincrónica con “enable”. END IF. Reset) BEGIN IF (Reset = '1') THEN intOutSignal <= '0'.Señal de enable intOutSignal <= '1'. Facultad Regional Bahía Blanca o Las señales de reloj deberán estar conectadas a un "pad" global de reloj en la FPGA o CPLD.. (evita problemas durante la síntesis. (esto evita que se genere lógica de prioridad grande. END IF. o bajo “skew”) • Buses o Comenzar los buses en el bit 0. else sino que utilizar una instrucción case. ELSIF (Clock'event AND Clock = '1') THEN IF (CE = '1') THEN -. (para evitar interpretaciones diferentes y provocar malos conexionados) Recomendaciones para Síntesis o Usar solo diseños sincrónicos. (estos pines tienen canales de distribución especiales con baja diferencia de retardo en la distribución.Diseño digital utilizando FPGAs UTN.. (Algunas herramientas no aceptan buses que no comienzan en 0) o Usar (MSB downto LSB) para todos los buses. END IF.

Facultad Regional Bahía Blanca o En un proceso combinacional incluir todas las señales en la lista de sensibilidad. usar dos procesos separados.Diseño digital utilizando FPGAs UTN. (Esto facilita la verificación de los datos por un lado y el temporizado por otro. Además facilita la modificación del protocolo de comunicación o “handshaking” con el módulo a probar). (Ayuda a entender el código y predecir el tamaño de la lógica combinacional) • Recomendaciones Generales de Diseño o No usar buffers de tres estados internamente en los diseños. Uno para generación y verificación de datos y otro para la generación del temporizado de las señales. o No usar elementos de retardo. • ©2003 Guillermo Güichal 161 . (evita que se generen latches no deseados) o En máquinas de estado. o Definir los tiempos para los ciclos de comunicación con el módulo a probar como constantes que pueden ser modificadas fácilmente. o Todas las señales de interfase externa deberán tener registros Bancos de Prueba (testbenches) y Depuración o Tratar de crear el banco de pruebas en dos partes. Uno para la asignación sincrónica de los estados y uno asincrónico para las salidas.

etc. Hay una nota interesante en EETimes o FPGAJournal que guardé sobre estos temas. Que es un "core". Cores y Propiedad Intelectual 11.2 Presentación de un Core TBD. Papel que juegan en el rápido desarrollo de un SoC y "time to market" de un producto (tiempos hace unos años: 2 años.1 Introducción Que es un SoC. Buscar en carpeta Research 11. Facultad Regional Bahía Blanca 11 SoCs. ahora 6-8 meses para tener un chip). Cores para FPGAs. Como se debe presentar un Core: Documentación.4 Reutilización de Propiedad Intelectual Diseñar bien los cores para hacerlos reutilizables. interfaces. 11. 11. bancos de prueba.3 Diseño para Verificación (Design For Test) Puntos intermedios para poder evaluar funcionamiento. Modelo de negocios basado en proveer cores y servicios de integración de los cores. SoPC. modelos.Diseño digital utilizando FPGAs UTN. etc. ©2003 Guillermo Güichal 162 . cada vez mas los proveen los fabricantes (no solo chips).

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

12 Notas Sobre Síntesis con FPGAs
12.1 Introducción
Introducción al proceso de síntesis. RTL a . Alto nivel (comportamiento) a físico. Physical Synthesis.

12.2 Diseño y Optimización Para Síntesis
De la nota de aplicación.: Aunque muchas herramientas pueden optimizar el código, la implementación de un circuito en una FPGA muchas veces depende del estilo usado por el diseñador en la descripción del hardware.

12.3 Formato Edif

12.4 Estructuras Recomendadas para Diseños Sintetizables
Los procesos YA ESTAN EN LA PRIMERA (3) SECCION¿? Nombrarlos, hacer referencias y presentar cosas nuevas.

12.4.1 Estructuras de Decisión Jerárquicas y Concurrentes (IF vs. CASE)
Ver nota de aplicación

12.4.2 Procesos sincrónicos 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;

©2003 Guillermo Güichal

163

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

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… Máquina de estados. Mostrar Flip-Flops, quizás con diferentes “encoding”

©2003 Guillermo Güichal

164

Diseño digital utilizando FPGAs

UTN, Facultad Regional Bahía Blanca

13 Notas sobre Verificación
13.1 Introducción
Qué es verificación, simulación. Filosofías de prueba. Herramientas para verificar. Etc., etc.

©2003 Guillermo Güichal

165

3 Manejo Básico de Actel Libero (o la que sea gratuita) ©2003 Guillermo Güichal 166 . Facultad Regional Bahía Blanca 14 Uso de las Herramientas 14.Diseño digital utilizando FPGAs UTN.1 Manejo Básico de Xilinx Project Manager 14.2 Manejo Básico de Altera Quartus II 14.

Facultad Regional Bahía Blanca 14. Si el test es un archivo de forma de onda se ver el testbench en VHDL usando “View Behavioral Testbench” • • Menús de ModelSim • • • Para ver las formas de onda ir al menú View/Wave Para ver la estructura del diseño cargado en ModelSim View/Structure Para agregar señales a la ventana ver las formas de onda ir al menú ©2003 Guillermo Güichal 167 . Seleccionar el módulo al que se desea asociar (que módulo va a probar) 4.tbw o *. Para el ModelSim versión 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.vhd) Para enviar un proyecto a ModelSim y simularlo 6.Diseño digital utilizando FPGAs UTN. En la ventana “Processes for Current Source” seleccionar ModelSim Simulator 8. Seleccionar el testbench o archivo de forma de onda que se desea simular 7. Seleccionar el archivo del banco de pruebas (*.4 Manejo Básico de ModelSim Nota Importante de Instalación 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 diseño y simulación completo En Xilinx Project Navigator • Para poder invocar a ModelSim desde Project Navigator debe estar bien definido el “path” al ejecutable. Ponerle un nombre y presionar OK 3. Hacer doble clock en la opción “Simulate Behavioral Testbench” para abrir el proyecto y su banco de pruebas en ModelSim 9. 5. Project/New Source/Testbench Waveform (para diagramas de forma de onda) o Project/New Source/VHDL Testbench (para banco de prueba en VHDL) 2. Editar el testbench o formas de onda como se desee y grabarlo.

do”) File/Load Format o Save Format • • • Para insertar una línea divisoria entre grupos de señales Botón derecho (o menú Insert) / Divider Para guardar/abrir una simulación File/Save Dataset o Open Dataset Para hacer zoom en la ventana de señales Lupa negra: muestra toda la simulación Lupa + y –: hacen zoom Cuadraditos con flecha hacia abajo y a la derecha: seleccionan un área ©2003 Guillermo Güichal 168 . Facultad Regional Bahía Blanca 1. arrastrar la/las señal deseada/s a la ventana “Wave” (forma de onda) Comandos de línea Tarea Recomenzar simulación Correr simulación Ayuda sobre comandos Comando restart –all run TIEMPO help commands help run 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 específico Salir del programa quit Presionar YES cuando pregunta si quiere salir Menús de la ventana de forma de onda (waveform) • Para ver solo los nombres de las señales (sin path) poner “1” en la casilla: Tools/Windows Preferences/ Display Signal Path [] # of elements Para guardar/abrir una configuración de formas de onda (Los archivos tienen una extensión “. View/Signals. De la ventana de señales. Seleccionar el componente deseado en la jerarquía de la ventana principal o en la ventana “Structure” 3. Esto abrirá la ventana de señales 2.Diseño digital utilizando FPGAs UTN.

com ©2003 Guillermo Güichal 169 . Low-cost programmable logic: How low should you go?. Facultad Regional Bahía Blanca 15 Referencias 15. 2001. Diseño Digital Principios y Prácticas Tercera Edición. 2002. Hoja de datos de Xilinx DS077. IEEE Design and Test of Computers. 2001. www.atmel. IEC Francisco Javier Torres Valle.com. 2002 Excalibur Device Overview Data Sheet. Guía de selección de Altera SA-CPLDMTRX-1. www.0. Hoja de datos de Xilinx DS083. www. Editorial Prentice Hall.altera.com Sitio web de Xilinx: www. 1991 Links de Interés • • • • • • Sitio web de Altera: www.com. 2002 CPLD Package and I/O Matriz. www.1 Dispositivos Lógicos Programables Bibliografía • • • • • • • • • • • • • • • • Spartan IIe Device Family.com Sitio web de Cypress Semiconductor: www. www. IEEE Custom Integrated Circuits Conference. Nota de aplicación de Lattice Semiconductors. Hoja de datos de Altera DS-STXFAMLY-3.vantis.altera.5. The Effect of LUT and Cluster Size on Deep-Submicron FPGA Performance and Density.com. GAL22V10 Data Sheet. 2002 MAX 7000 Programmable Device Family.com. www. Hoja de datos de Altera DS-EXCARM-2.altera. 2000 Introduction to GAL Devices.com. March 2004 FPGA Performance vs Cell Granularity.com Sitio web de Atmel: www.0.xilinx.com. Brian Dipert.xilinx.com Sitio web de Quicklogic: www.chipcenter.cypress. Murray Disman. John F.actel.vantis. Jack Kouloheris & Abbas El Gamal. Stratix FPGA Family Data Sheet. EDN.altera. Hoja de datos de Lattice Semiconductors. Stephen Brown & Jonathan Rose. Síntesis y Descripción de Circuitos Digitales Utilizando VHDL. Elias Ahmed a& Jonathan Rose.altera. Lattice Introduces FPGA. Junio 2000 Using Delay Locked Loops in Spartan II Devices.Diseño digital utilizando FPGAs UTN.com. Wakerly. www. 2002 FPGA and CPLD Architectures: A Tutorial. 2002. Hoja de datos de Altera DS-MAX7000-6.xilinx. IEEE Transactions on VLSI Systems.com.com Sitio web de Actel: www.xilinx. www. Universidad Autónoma de Guadalajara.com.0. Nota de aplicación de Xilinx XAPP174.com.quicklogic. 16/3/2001 Programmable Logic Device Review. 1996. Virtex II Pro Data Sheet. www. www.

seas.vhd.com) las palabras clave “VHDL” o “VHDL tutorial” se hallarán cientos de sitios de interés. Kluwer Academic Publishers. Xilinx Rapid Prototyping of Digital Systems.3 VHDL Bibliografía • • • • • • • • • • • • The Designer’s Guide to VHDL 2nd Edition.vhd. Peter J. 1995 In Search of the Origins of VHDL’s Delta Delays. 2001 Synthesis and Simulation Design Guide.org: www.google. Synthesis and Simulation Design Guide. 2003 Artículo de Embedded Systems Programming: "Tools are not Enough". John F.1. 1995 VHDL Style Guidelines for Performance. Bob Zeidman. Shawn McCloud. Facultad Regional Bahía Blanca 15. Código VHDL de los paquetes.eda.webnexus. XCell Journal Fall 2004.org Preguntas frecuentes (FAQ) sobre VHDL: vhdl.vhd. Hamlen Michael D.org/vi/comp. std_logic_signed. Xilinx Libraries Guide. Proceedings of the IEEE International Symposium on Quality Electronic Design. Furman.vhdl.asp 15. Editorial Morgan Kaufman.upenn.vhd y std_logic_unsigned.vhdl Tutorial de VHDL de Jan Van der Spiegel en University of Pennsylvania http://www.html ©2003 Guillermo Güichal 170 . Oct 1999. Links de Interés • • • • • • www. std_logic_arith. Sumit Gosh. James O. Model Technology. Wakerly. Editorial Prentice Hall.2 Diseño Digital con PLDs Bibliografía • • • Artículo de Embedded Systems Programming: "The Universal Design Methodology". Enero 27. Nov 4.com Curso de introducción al lenguaje Verilog (en inglés) www.1. Xilinx Development System Reference Guide ISE 5 . Mentor Graphic Corporation Links de Interés • What is Behavioral Synthesis? http://www.forteds.de lógica estándar IEEE: std_logic_1164. Doulos. Xilinx The VHDL Golden Reference Guide version 1.de/forschung/vhdl/ Lista de recursos sobre VHDL Buscando en Google (www. Sitio de vhdl. 2002.ei. Doulos. 2000 The VHDL Golden Reference Guide version 1. Lindsey Vereen.com/pub/bd/whatisbd.tum.vol. 2004 "Algorithmic C Synthesis Optimizes ESL Design Flows".Diseño digital utilizando FPGAs UTN.lang. Ashenden.edu/~ee201/vhdl/vhdl_primer. 2002 Diseño Digital Principios y Prácticas Tercera Edición.

4 Buenas Prácticas de Diseño Bibliografía • • • Code Complete.0. ESD Coding Standards Rev 1. Facultad Regional Bahía Blanca 15.. Inc.Diseño digital utilizando FPGAs UTN. 2001 15. Steve McConell.0.5 Síntesis Bibliografía • Xilinx Synthesis Technology (XST) User Guide. Embedded Systems Design. Embedded Systems Design.org/vi/vhdlsynth/vhdlsynth. 2002.. Xilinx Links de Interés (síntesis) • http://www. Microsoft Press.vhdl. Inc.html ©2003 Guillermo Güichal 171 . 2001 ESD VHDL Coding Guidelines Rev 1.

. otros ejemplos de laboratorios hechos en clase.3 Ejemplos de Lógica Secuencial 16.7 Ejemplo Completo: UART 16..6. Facultad Regional Bahía Blanca 16 Ejemplos Los ejemplos se describen en este apéndice pero el código está en un CD o archivos adjuntos 16. etc ©2003 Guillermo Güichal 172 .4 Divisor Reloj 16.1 Ejemplos de Lógica Combinacional 16.8 etc.Diseño digital utilizando FPGAs UTN. 16.6 .2 Controlador VGA 16.2 16.1 Interfase Mouse 16..6.5 Control display 7 segmentos 16..

Sign up to vote on this title
UsefulNot useful