P. 1
NotasCompletas sobre fpga

NotasCompletas sobre fpga

|Views: 551|Likes:
Publicado porAntonio Melendez

More info:

Published by: Antonio Melendez on Mar 04, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

11/20/2015

pdf

text

original

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

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

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

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

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

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 . Facultad Regional Bahía Blanca 2 Versiones Ver 0.5 (27/06/2005) Publicación inicial en www.6 (29/06/2005) Sección de Agradecimientos y Versiones.Diseño digital utilizando FPGAs UTN.ar Ver 0.com.fpga.

Se trata de enseñar a través de ejemplos funcionales.com). además. que puedan usarse como plantillas bases para un diseño o que puedan copiarse directamente. Este libro. tecnologías y técnicas digitales. DIO1 y DIO2 de Digilent. 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. conectores PS2 y VGA.digilentinc. en muchos casos no se presentará formalmente el uso de • • ©2003 Guillermo Güichal 9 . leds. Se espera que el lector de estas notas tenga una base de diseño digital. sino presentar el material que permitirá comenzar a trabajar lo más rápido posible. Esto debe tenerse en cuenta especialmente en las secciones sobre VHDL. 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. en las secciones o ejemplos que utilicen o presenten herramientas de desarrollo. etc. Wakerly detallado al final de esta sección. Las otras placas se conectan a la D2E y contienen periféricos. contiene una excelente introducción a los dispositivos lógicos programables. Por ese motivo. En el futuro se completará una sección introductoria con un repaso de temas de diseño. La placa D2E contiene una FPGA Spartan IIe 200 y varios conectores. En las secciones generales. sin realmente tener una base demasiado formal sobre PLDs y VHDL. sin embrago. display. Esto se intenta hacer limitando el contenido y focalizándolo sobre aplicaciones y ejemplos para diseños sintetizables sobre FPGAs. Los ejemplos de aplicaciones fueron desarrollados para la placa de desarrollo D2E. ya que los temas tratados y los ejemplos presentados se limitan a ese uso del lenguaje.Diseño digital utilizando FPGAs UTN. Inc (www. Se tratan de presentar los temas con ejemplos que permitan la rápida utilización y aprendizaje. Para el que necesita estudiar los conceptos básicos de diseño digital se recomienda el libro de John F. 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 intentan presentar dispositivos y herramientas de varios fabricantes para que el lector tenga una visión más amplia de las alternativas existentes. y en los ejemplos en donde se presenten dispositivos específicos. se utilizarán herramientas y dispositivos de Xilinx. 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. La intención no es hacer un tratamiento exhaustivo y completo de este tema. tales como botones. En las secciones sobre VHDL. 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.

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

signal attenuation and EMI/EMC. One-hot.3 Algunas Notas sobre Diseño Secuencial Sincrónico 4.Diseño digital utilizando FPGAs UTN.4. improper routing and inadequate return-current paths.5 Dominios de Reloj 4.3. 4. Mínima. while board-level issues include crosstalk. Chip-level concerns include improper I/O buffer design and inadequate return-current paths.2 Máquinas de Moore 4. etc.3 Máxima Frecuencia de Trabajo 4. Package-level issues include high package inductance.5 Integridad de Señal 4.1 Diseño Combinacional y Secuencial 4.2 Diseño Secuencial Asincrónico y Sincrónico 4.1 Temporizado y Utilización de Registros 4.3.2 Distribución de Reloj 4.1 Máquinas de Mealy 4. 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.3. 4. Como afecta fuera y dentro del chip (FPGA?) Ver nota Altera de PLD design line.3.4.4.3.3.3 Codificación de estados. mismatched traces.5.6 Metaestabilidad en los Flip-Flops 4. ©2003 Guillermo Güichal 11 . One-cold. Grey.1.1 Que afecta la integridad de señal y que es.4 Autómatas de Estados Finitos (Máquinas de estados finitos) 4. reflections.4 Pipelines 4.1 Flip-Flops y Latches 4.

. Resistencias de pull-up/down internas.). 4. Potencia estática vs dinámica.2 Terminaciones de Señales Usar terminaciones para evitar rebotes en diseños de alta velocidad. 4.6 Interfaces Eléctricas Estándares de interfase posibles con las FPGAs actuales. Dificultoso de calcular para las FPGA. 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. Hay herramientas que analizan y calculan. Terminaciones internas en las FPGAs. etc. 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. Flancos lentos y rápidos.5. Las FPGA tienen grandes cantidades de entradas salidas que pueden requerir mucha corriente.7 Potencia y Consumo de los Circuitos Puede ser importante. ©2003 Guillermo Güichal 12 . Facultad Regional Bahía Blanca 4. etc.

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

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

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. El nivel de abstracción dependerá entonces de la aplicación y restricciones sobre el diseño. 5. Si se diseña un integrado digital con bloques predefinidos (IP. Facultad Regional Bahía Blanca Nivel RTL: Describe el comportamiento de todas las señales (entradas. Para poder atacar el problema del diseño de sistemas digitales complejos (ya sea para desarrollos sobre FPGAs. Según su autor (ver Referencias). incluso en localidades separadas.Diseño digital utilizando FPGAs UTN. En muchos casos varias personas pueden estar trabajando sobre el mismo producto. 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. esto no es siempre posible con la tecnología existente (pero esta cambia permanentemente). Como ejemplo. si se utilizan correctamente. Para lograr tiempo más rápidos de diseño. y mayor productividad. la "Metodología Universal de Diseño" define pasos que permiten: ©2003 Guillermo Güichal 15 . Nivel Registros: Describe la estructura como la interconexión de registros y lógica de interconexión. ASICs o PCBs) es importante tener una metodología de trabajo que permita planificar y ordenar el trabajo. Si se debe diseñar un integrado full-custom analógico es probable que se trabaje al nivel de ecuaciones diferenciales. gran parte del aspecto físico ha sido solucionado por el fabricante. Desafortunadamente. al nivel de transistores y haciendo el layout manual. RTL). sin entrar en los detalles de bajo nivel. En general se trabaja al nivel de transferencia de registros con algunas herramientas que ayudan a diseñar a niveles de algoritmo. lo ideal sería poder trabajar al máximo nivel de abstracción posible (algoritmos). memoria e interconexión. 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.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. no solo para diseñar sino también para especificar y documentar el sistema que se quiere desarrollar. En el ciclo de diseño con FPGAs. Dominio Físico: Describe la implementación física del sistema (plano). menos errores. la necesidad de seguir un método ordenado para lograr buenos resultados se hace más importante. pueden utilizarse en varios pasos del proceso de desarrollo. Los lenguajes de descripción de hardware. en la Figura 3 se muestra un esquema de un método que permite ordenar el trabajo de diseño. sin mayores detalles de implementación.

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

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

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

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

En este paso se traducen todos los módulos a VHDL. 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.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. También se hace una ©2003 Guillermo Güichal 20 . 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. Para los módulos ingresados como VHDL. Figura 4 .

utilizando los componentes específicos del PLD que va a utilizarse. 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. 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.Diseño digital utilizando FPGAs UTN. 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. Después de la ubicación e interconexión. Compilado (Compile): Los simuladores actuales compilan el código VHDL a un formato que permite una simulación mas rápida y eficaz. La segunda es después de sintetizar el circuito. etc. puede hacerse una estimación de los retardos de propagación que habrá entre las señales. cada componente del diseño sintetizado se ubica dentro del PLD específico. Síntesis (Synthesis): En este paso se traduce el VHDL original a su implementación con lógica digital. Ubicación e Interconexión (Place and Route): El PLD está compuesto por muchos bloques idénticos. y se simulan la implementación real sobre el PLD. Una vez sintetizado el diseño. La simulación puede hacerse en tres etapas diferentes del diseño. Facultad Regional Bahía Blanca • • • • • • • • • elaboración de los archivos. Tareas Adicionales: Las tareas adicionales dependen del fabricante y las herramientas. La tercer etapa en la cual se puede simular el diseño es después de la Ubicación e Interconexión. 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. Esto se hace en este paso. 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. En este paso. También se interconectan los componentes entre sí y con los pines de entradasalida. Esta es la más exacta y la mas engorrosa y lenta. 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 . Anotación de Retardos: Como en todo circuito digital. Esta traducción puede llegar hasta el nivel más básico de elementos lógicos (CLBs. ya sea con o sin la anotación de tiempos. seleccionar áreas del PLD para ubicar los bloques lógicos. las señales tendrán un retardo de propagación que influirá sobre su comportamiento. La primera es sobre el código VHDL original para verificar el correcto funcionamiento del diseño. 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. el cálculo de retardos es mucho mas exacto. Simulación y verificación: En este paso se simula el comportamiento del diseño y se evalúa su comportamiento. Estas opciones dependerán de las herramientas y del PLD que se esté utilizando. como se presentó en las secciones anteriores. LUTs. FFs) o hasta un nivel superior. ya que incluye la información final lógica y temporal el diseño sobre el PLD.

muchos son propietarios. 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á. Al utilizar un HDL para modelar un sistema. En el hardware. 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. En la etapa de producción deben configurarse memorias PROM y conectarlas a la FPGA en el circuito impreso. desarrollados por los distintos proveedores de herramientas o PLD. hay muchas tareas que suceden de manera concurrente y la variable tiempo juega un papel predominante. sin embargo. Aunque hay muchos lenguajes de descripción de hardware. los sistemas digitales pueden describirse de diferentes maneras. 5. se definen de manera precisa las interfases de cada componente de un sistema y sus interconexiones. y no escribiendo software. En la figura. En la actualidad casi todos los fabricantes de PLD y proveedores de herramientas de desarrollo proveen soporte para VHDL y Verilog. desde los más básicos hasta el nivel superior que describe el sistema completo. De los demás lenguajes. Así se arma un jerarquía de componentes. 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.4 Lenguajes de descripción de hardware Los lenguajes de descripción de hardware (HDLs) permiten modelar sistemas digitales completos. una CPU ejecutará cada instrucción después de la anterior. En la actualidad están surgiendo nuevos lenguajes que incorporan mayores facilidades y prestaciones. pueden descubrirse fallas o haber cambios de requerimientos que obligan al diseñador a volver y modificar la descripción del diseño. Los efectos de una instrucción dependen exclusivamente de los efectos de las instrucciones anteriores. Después de simularlo o configurar un PLD. el retardo de una traza en una plaqueta. Un cambio en el tiempo de propagación de una compuerta. es importante recordar que se está modelando hardware. de acuerdo a las ©2003 Guillermo Güichal 22 . En una descripción estructural. Usando HDLs. 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). Para poder describir los procesos concurrentes que caracterizan un sistema de hardware. Utilizando un conjunto de instrucciones secuenciales puede modelarse el comportamiento de un sistema digital y controlar la variable tiempo en los modelos. El software se caracteriza por ser de secuencial. 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. Los HDLs también permiten describir el comportamiento de los componentes. Facultad Regional Bahía Blanca • cuando se les aplica tensión de alimentación. 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.Diseño digital utilizando FPGAs UTN. dos predominan actualmente el mundo del desarrollo de hardware digital: Verilog y VHDL.

5. En 1995 el lenguaje Verilog se transformó en un estándar del IEEE. 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. Sus orígenes datan de la década de 1980.4. 5. Este estándar fue extendido y modificado en 1993 (VHDL-93) y 2002 (VHDL-2002).Diseño digital utilizando FPGAs UTN.3 Otros En la actualidad los dos lenguajes mencionados.1 VHDL Las siglas VHDL provienen de “VHSIC Hardware Description Lenguaje” y a su vez VHSIC quiere decir “Very High Speed Integrated Circuit”. VHDL se utiliza no solo para modelar circuitos electrónicos sino también para crear. 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. El lenguaje se estandarizó mediante el estándar 1076 del IEEE en 1987 (VHDL-87). el Verilog proviene del C y tiene una sintaxis mas parecida a este. VHDL y Verilog. Mientras que la sintaxis del VHDL es parecido a los lenguajes de programación Ada y Pascal. Una vez probado un algoritmo con estas herramientas se genera de manera automática el hardware necesario para implementarlo. 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. O sea que VHDL significa lenguaje de descripción de hardware para circuitos integrados de alta velocidad.4. son los mas utilizados para la síntesis automática de hardware. nuevos circuitos. En la actualidad. Facultad Regional Bahía Blanca nuevas tecnologías y necesidades de los desarrolladores. Muchos vendedores de FPGAs proveen herramientas o "toolboxes" que se integran a lenguajes de modelado como Matlab y Simulink. 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. En 1988 Synposis presentó la primera herramienta de síntesis basada en Verilog. El VHDL nació entonces como un lenguaje de modelado y documentación de sistemas electrónicos digitales. 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.2 Verilog El lenguaje Verilog fue desarrollado por Gateway Design Automation en 1984.4. 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. ©2003 Guillermo Güichal 23 . A continuación se presenta una breve introducción a cada lenguaje 5. o sintetizar. con la aparición de herramientas que traducen los modelos VHDL a circuitos reales.

1 Descripción del Diseño En la creación de fuentes se usan diferentes herramientas para facilitar el diseño. a un lenguaje de descripción de hardware. Aunque todavía no se ha presentado ninguna característica específica del lenguaje. es decir. En la descripción que sigue se mencionan de manera general algunas características de VHDL. si se utiliza la operación X <= ‘1’ que indica la asignación un ©2003 Guillermo Güichal 24 . Simular esto tiene su complejidad. 5. 5. A continuación se describen algunas características de estas herramientas para los distintos pasos del ciclo de diseño. Los lenguajes de descripción de hardware modelan o describen. bloques de hardware que funcionarán de manera concurrente. Es importante tener en cuenta que ninguna asignación de valores a una señal en hardware será inmediata. mediante instrucciones secuenciales. Los más comunes son VHDL o Verilog. Interfases gráficas. 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. 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.Diseño digital utilizando FPGAs UTN. etc.5. el lector con una base de diseño de hardware podrá seguirla sin problemas. 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. Es decir. al mismo tiempo.3 Simulación La simulación de un sistema descrito de modelos en HDL merece algunos comentarios. 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"). 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. tales como representaciones gráficas de máquinas de estado o diagramas esquemáticos. Diferentes niveles.5.2 Generación o Traducción Se lleva todos los tipos de fuentes. Facultad Regional Bahía Blanca En general todas las herramientas actuales.5. 5. Algunas herramientas comunes: Estas herramientas incluyen: Modelos de comportamiento. Puede haber una cantidad indefinida de retardos delta en un paso de simulación.4 Notas Manejo del tiempo en VHDL La simulación en VHDL se basa en incrementos finitos de tiempo. 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.

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

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

Esto da lugar a las denominaciones System-on-a-Programmable Chip. 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. En resumen. 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. 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. sistemas de desarrollo integrados. maquina de estado. Permiten reemplazar grandes diseños digitales que antes se implementaban con componentes discretos (como compuertas y flip-flops) por un solo integrado.Diseño digital utilizando FPGAs UTN.). etc. Su función puede ser definida (o programada) por el usuario. ©2003 Guillermo Güichal 27 . que permiten hacer diseños de manera rápida. sistemas completos pueden desarrollarse sobre un solo circuito integrado. etc. o SoPC (sistema sobre un circuito integrado programable) y System-on-a-Reprogammable Chip (SoRC). que incluyen interfases gráficas. Debido a la gran capacidad lógica que tienen los dispositivos modernos. Los dispositivos actuales (CPLD y FPGAs) tienen una capacidad lógica de hasta millones de compuertas. Guías y “Templates” automáticos para el diseño de circuitos básicos. El soporte de diseño para FPGA por parte de las herramientas clásicas utilizadas para el diseño de circuitos electrónicos (Orcad. Uno de los factores más importantes para el auge de las FPGA es el conjunto de herramientas disponibles. 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. HDL. 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. Esta gran capacidad y variedad de los dispositivos los hace sumamente útiles a la hora de crear prototipos. multiplicadores o CPUs completas. etc. la capacidad de desarrollar sistemas utilizando diversas metodologías (esquemático. 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 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. desarrollo rápido de nuevos productos.

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

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

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

com) Además de los bloques lógicos básicos. En las siguientes subsecciones se presentan en mayor detalle ©2003 Guillermo Güichal 34 .).altera.com) Figura 16 . Logic Array. Facultad Regional Bahía Blanca Figura 15 .actel. Logic Tile.Arquitectura de una FPGA ProAsicPlus de Actel (Fuente: hoja de datos Actel Familia ProAsicPlus www. que ocupan la mayor parte de las FPGAs (CLBs. etc.Diseño digital utilizando FPGAs UTN.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.

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

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

Como ejemplos.xilinx.com) ©2003 Guillermo Güichal 37 .Diseño digital utilizando FPGAs UTN. Estos pueden configurarse como flip-flops D con reloj o como latches controlado por nivel.Esquema del CLB de una FPGA Spartan 3 de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 3 www. 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”. y sin entrar en detalles. en la Figura 19 y Figura 20 se muestran dos ejemplos de bloques lógicos para otras FPGAs. Figura 19 . 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.

La familia de FPGAs Spartan IIe de Xilinx. para permitir que haya diferentes dominios de reloj con interfases eléctricas diferentes. Los bancos se configuran aplicando diferentes tensiones de alimentación a los pines denominados VccO y VREF.altera.Esquema del Elemento Lógico de una FPGA Cyclone II de Altera (Fuente: hoja de datos Altera Familia Cyclone II www. por ejemplo. 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. 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.2 Bloque de Entrada / Salida Las interfaces de entrada-salida son otro de los componentes particulares que tienen las FPGAs.3. Las entradas de reloj están asociadas a diferentes bancos de entrada-salida. Facultad Regional Bahía Blanca Figura 20 .Diseño digital utilizando FPGAs UTN. La Figura 21 muestra un esquema de estos bancos de entrada-salida.com) 6. ©2003 Guillermo Güichal 38 .

3V 2. 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. Tabla 2 . GTL. LVPECL. SSTL3 I. GTL+ LVCMOS18. HSTL IV. GTL+ Además de la tensión VccO.xilinx.Tensión VccO para diferentes interfases lógicas de la familia Spartan IIe de Xilinx Valor de VccO 3. LVCMOS2. GTL. HSTL III. GTL+ HSTL I. cada bloque de entrada-salida de la familia Spartan IIe de Xilinx tiene la estructura mostrada en la Figura 22. Bus LVDS. LVDS. GTL+ SSTL2 I. Internamente. LVTTL.Diseño digital utilizando FPGAs UTN. GTL.8V 1. SSTL2 II. SSTL3 II. Los elementos de entrada-salida de las FPGAs de Altera Cyclone II tienen la estructura mostrada en la Figura 23. ©2003 Guillermo Güichal 39 . GTL.com) La siguiente tabla muestra el valor de VccO para las diferentes interfases lógicas. AGP. CTT.5V 1. 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.5V Lógica de interfase PCI. 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.

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

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. 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’).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. Estos bloques sincronizan el reloj interno al reloj externo del sistema. Cada fabricante utiliza una arquitectura diferente para el control y distribución de reloj. sincronizan los diferentes dominios de reloj y aseguran un retardo de distribución del reloj pareja para la lógica interna de la FPGA. La red de distribución de reloj en las FPGA asegura retardos parejos a todos los bloques lógicos de la FPGA.xilinx. La siguiente Figura 24 muestra el esquema de distribución de reloj para la familia Spartan IIe de Xilinx.com) A continuación se presentan dos ejemplos de bloques de control para FPGAs de diferentes fabricantes. La familia Spartan IIe de Xilinx tiene bloques específicos para control de reloj denominados DLL (Delay Locked Loop). ©2003 Guillermo Güichal 41 . 6. La Figura 25 muestra un esquema básico de la estructura de un DLL. 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.Diseño digital utilizando FPGAs UTN.3. controlan el desplazamiento de fase entre los relojes.

com) La familia Stratix de Altera tiene los bloques de control de reloj que se muestran en la Figura 26. Figura 26 –Esquema de un bloque de control de reloj de la FPGA Stratix de Altera (Fuente: hoja de datos Altera Familia Stratix www. 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.xilinx.Diseño digital utilizando FPGAs UTN.com) ©2003 Guillermo Güichal 42 .altera.

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

por ejemplo. Facultad Regional Bahía Blanca Tabla 3 . La Figura 28 muestra un bloque de memoria de Actel.com) 6. 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 . contienen uno o más módulos de procesamiento de señal entre los bloques de lógica programable de propósito general. dual o multi-puerto. Como muestra la Figura 29.5 Bloque de Procesamiento de Señal Varias FPGA contienen bloques específicos que optimizan en hardware ciertas funciones especiales. 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" .www. Estos bloques permiten desarrollar ciertas funciones específicas típicas de las aplicaciones de procesamiento de señal de manera muy eficiente.3. Pueden configurarse de varias maneras diferentes según las necesidades del usuario. que puede configurarse como memoria de puerto simple.Diseño digital utilizando FPGAs UTN. varios bloques pueden conectarse utilizando lógica externa para implementar memorias de otros tamaños y colas FIFO o FILO.actel.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. Las FPGA de la familia Stratix de Altera.

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

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. de tecnología RISC de 16 bits que puede utilizarse sobre varias de las FPGA de Altera. El micro es de arquitectura RISC de 32 bits. La lógica programable del Excalibur puede ser de hasta un millón de compuertas.CPU PC405 embebida en una Virtex II Pro de Xilinx (Fuente: hoja de datos Xilinx Familia Virtex 2 Pro www.3. ©2003 Guillermo Güichal 46 .Diseño digital utilizando FPGAs UTN. Hay muchos micros "softcore" públicos y propietarios. A este tipo de diseño se lo denomina "softcore". Esto permite utilizar toda la potencia de una CPU integrada con la flexibilidad de los periféricos diseñados mediante lógica programable.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. Figura 30 .xilinx. ya que a FPGA no tiene ningún bloque específico para la CPU implementado sobre el circuito integrado. y puede correr a una frecuencia de reloj de hasta 200 MHz. Facultad Regional Bahía Blanca 6. Altera ofrece el microcontrolador Nios. Los bloques específicos integrados en el silicio de las FPGAs se denominan "hardcores". La Figura 30 muestra un esquema de la arquitectura del Virtex II-PRO.

Los recursos de interconexión local. el interconexionado a este nivel provee conexiones a la matriz de interconexionado general y a los CLB adyacentes. como las tablas de búsqueda (LUT). 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. 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. permiten hacer las conexiones entre los elementos internos de un bloque lógico o CLB. A través de ellos se configuran las conexiones entre CLBs no adyacentes y hacia los bloques de entrada/salida. Los recursos de interconexionado global que no forman parte de la GRM permiten distribuir señales con un fan-out grande. los elementos lógicos presentados en las secciones anteriores no solo deben configurarse adecuadamente sino que también deben conectarse entre si. mostrados en la Figura 31. A modo de ejemplo.7 Matriz de Interconexión Para poder implementar circuitos lógicos. se describirá a continuación la arquitectura de interconexión de las FPGA Spartan IIe de Xilinx. La Figura 32 muestra un esquema de la red dedicada de distribución de señales de alto “fan-out”. de entrada-salida y recursos de interconexión global para la distribución de reloj y señales específicas. Estas FPGA tienen dos niveles de interconexión. 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. ©2003 Guillermo Güichal 47 . 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. Los elementos de la GRM se encuentran entre los CLB. La mayor parte de las señales se conectarán a través de la matriz general de interconexionado (GRM).3. Permiten hacer la interconexión entre las trazas horizontales y verticales y hacia los CLB. Por otro lado contienen recursos de interconexión local.Diseño digital utilizando FPGAs UTN. Además. en los canales de interconexión horizontales y verticales de la FPGA. 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. Facultad Regional Bahía Blanca 6. las FPGA Spartan IIe contienen recursos de interconexión dedicados a señales de tres estados. Además de los ya mencionados. los flip-flop y las realimentaciones dentro del CLB. como son las señales de reloj y posiblemente las señales de reset.

com) Figura 32 .Red dedicada de distribución de reloj en la FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www.com) 6.Caminos de interconexión local en la FPGA Spartan IIe de Xilinx (Fuente: hoja de datos Xilinx Familia Spartan 2e www. 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 . Facultad Regional Bahía Blanca Figura 31 .Diseño digital utilizando FPGAs UTN.xilinx.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. o la relación entre las celdas lógicas y los recursos de interconexionado.

www.. Por otro lado cada bloque consume más área que puede desaprovecharse. de varias entradas/salidas. La granularidad de un dispositivo lógico influirá en la manera que se implemente una función lógica dada.Diseño digital utilizando FPGAs UTN. en su frecuencia máxima de funcionamiento y en la utilización que se hace del dispositivo. En general la mejor granularidad dependerá de la aplicación y las restricciones que hay sobre el diseño. A estas se las denomina de granularidad fina. 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.actel. para una función dada. 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. se deberán conectar un mayor número de celdas. Otras arquitecturas están formadas por celdas básicas que solo permiten implementar lógica muy simple.com) ©2003 Guillermo Güichal 49 . Una arquitectura de granularidad fina será típicamente más densa y tendrá menor retardo de interconexión entre celda y celda. Para mayor información ver la sección Referencias. 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. A estas se las denomina de granularidad gruesa. Sin embargo. 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 . Esto es lo que utilizan los dos fabricantes principales de FPGAs basados en tecnología SRAM.

com) ©2003 Guillermo Güichal 50 .Diseño digital utilizando FPGAs UTN.xilinx. 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.

funciones aritméticas.altera.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 . 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. • 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.Diseño digital utilizando FPGAs UTN.

latticesemi.www.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 .

Virtex4. ya sean los bloques lógicos o las interconexiones.5 Tecnología de Configuración de los PLDs La tecnología . Cada tecnología tiene sus ventajas y desventajas respecto a las otras. Stratix. 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. Cyclone y Apex de Altera Flash: Actel ProAsic. ProAsicPlus Antifusible: Actel A54SX.Diseño digital utilizando FPGAs UTN. 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.utilizada para configurar los elementos de un PLD. Si se comete un error. 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. Facultad Regional Bahía Blanca 6. dependen del fabricante y el dispositivo. SRAM y Flash. 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. SRAM: Virtex II. se destacan las tecnologías EEPROM. Spartan 3 de Xilinx. Quicklogic pAsic EEPROM: Altera MAX7000. se pierde el integrado A continuación se dan algunos ejemplos de dispositivos que utilizan cada tecnología. Los dispositivos que solo pueden configurarse una vez en general utilizan tecnologías de antifusible. Cypress Ultra37000 EEPROM + SRAM: Lattice Semiconductor ispXPGA ©2003 Guillermo Güichal 53 . Entre los dispositivos reprogramables. Spartan2e.

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

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

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. En este texto se usarán palabras reservadas en minúscula con algunas palabras especiales en mayúscula. Por ejemplo.3 Comentarios en VHDL Los comentarios en VHDL se indican con un doble guión “--".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. -. BEGIN.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.1.1.A<= ‘1’ Esto es un comentario de una línea completa. • 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.1.4 Delimitadores de Código en VHDL Las instrucciones en VHDL se terminan con “. Facultad Regional Bahía Blanca 7 Primeros Pasos con VHDL 7. las palabras begin. 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.Esto es una asignación de la señal a con un comentario al final -.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.Una asignación a la señal A ©2003 Guillermo Güichal 56 . Abracan desde “--" hasta el final de la línea Ejemplos: -. No hace nada A <= ‘1’.Diseño digital utilizando FPGAs UTN. Ejemplos: A <= ‘1’. 7.” y aunque se pueden escribir varias instrucciones por línea esa práctica no se recomienda y no se usará en este texto. -. y debe comentarse línea por línea si se quiere comentar un bloque completo de código 7. 7.

Instrucciones que modelan la arquitectura end architecture Comportamiento. Una es la interfase del componente.Doble asignación en una línea NO RECOMENDADO Los bloques lógicos en VHDL se delimitan por las palabras reservadas begin y end. 7. -. ©2003 Guillermo Güichal 57 . D <= ‘1’. 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. un módulo o componente de hardware se modela en dos secciones.Diseño digital utilizando FPGAs UTN. Ejemplos: -.2.Instrucciones que definen el proceso end process. Facultad Regional Bahía Blanca B <= ‘0’.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 -.2 Estructura Básicas de un Modelo en VHDL Con VHDL. -. denominado entidad y la otra es la arquitectura que describe su funcionamiento interno.Definición de un proceso P_IncrementoCuenta : process(Clock_IN) begin -. --Se debe cerrar con la palabra reservada process 7.Una asignación a la señal B C <= ‘0’. Este modelo permite esconder los detalles internos de implementación e incluso definir varias implementaciones para un componente sin afectar la interfase externa.

Esta entidad tendrá el nombre “Contador”. entity Contador is port( Reset_IN Clock_IN Cuenta_OUT ). : IN : IN : OUT std_logic. 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. std_logic. 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 . • BUFFER Señal de salida que puede leerse internamente. 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. Usada para interfases de tres estados.A continuación se definen las señales de interfase mediante la palabra port. end Contador.Diseño digital utilizando FPGAs UTN. No recomendada para diseños sintetizables.

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

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

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

Instancia se refiere a crear una copia de un componente. ). EntradaOr2_IN => Entrada2_IN. Puede verse la instancia de un componente como la creación de una copia del componente dentro del componente actual. 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. end architecture Estructura. Facultad Regional Bahía Blanca ). como puede verse en la conexión de las señales de salida. EntradaOr2_IN : IN 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. Notar el símbolo de conexión “=>” (diferente al de asignación para señales “<=” ) y el uso de los separadores “. SalidaOr_OUT => SalidaOr_OUT ). El símbolo => indica conexión. Los puertos del componente se conectan a diferentes señales mediante el mapeo con las palabras port map.” entre los diferentes puertos de los componentes básicos. 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.Diseño digital utilizando FPGAs UTN. EntradaAnd2_IN => Entrada2_IN. ComponenteBasicoAnd : CompuertaOr port map (EntradaOr1_IN => Entrada1_IN. En el ejemplo todos los puertos de los componentes se interconectan de manera ©2003 Guillermo Güichal 62 . dándole un nombre único dentro del diseño. SalidaAnd_OUT => SalidaAnd_OUT ). En el modelo estructural pueden apreciarse dos partes principales. La otra es crear una "instancia" (instantiation) de los componentes dentro de la arquitectura. 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. Una es la declaración de los componentes antes del comienzo (begin) de la arquitectura utilizando la palabra component. component CompuertaOr port(EntradaOr1_IN : IN std_logic.

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. por ejemplo cuando no se utilizan algunas salidas. Por ejemplo. Esto se hace usando la palabra open en la “instancia”. EntradaAnd2_IN => Entrada2_IN. Esto se hace representando cada componente básico por un símbolo gráfico que tiene indicadas sus puertos de entrada y salida. La herramienta de diseño traduce luego el diagrama esquemático a su representación en VHDL para el análisis y elaboración. si no se quiere conectar la salida de la compuerta AND. En el ejemplo presentado se interconectan los puertos de los componentes con señales usando una asociación por nombre.2 de Xilinx. 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. pero eso no es recomendable y no se presentarán ejemplos de ello en este texto. puede usarse ComponenteBasicoAnd : CompuertaAnd port map (EntradaAnd1_IN => Entrada1_IN.Diseño digital utilizando FPGAs UTN. También pueden dejarse señales abiertas. lo que dejará desconectada la 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 . 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). Facultad Regional Bahía Blanca explícita a señales declaradas anteriormente. También puede hacerse una asociación por lugar. No pueden dejarse desconectadas las entradas. Muchas herramientas de desarrollo permiten armar un componente con una arquitectura estructural de manera gráfica.

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

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 . 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 => -. etc.número binario 16#af125f# -. Facultad Regional Bahía Blanca Símbolo “ # & ‘ (comilla simple) ( ) * + . para agrupar operadores y dar prioridad en expresiones.all A := A / 4. A+B Cuenta_REG + 1 A–B Cuenta_REG – 1 port map(A => A.5 2#0. < = > [ ] | (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. B => B) 0.Cuando la expresión sea -. (coma) . constant C : integer.” 2#1001000# -.1 o 2 o 3 when “000” => port map(A => A. A_REG <= ‘1’.número hexadecimal “001” & “111” -.std_logic_1164. (punto) / : . 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””. B => B) (others => ‘0’) ** := /= >= <= <> \ _ (Guión bajo) VariableA := 1 if (A /= ‘0’) then if (A >= 2) then A <= ‘1’.100# use ieee. signal A : std_logic.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.

Una constante signal CuentaDeReloj_REG : std_logic_vector(3 downto 0).4 Números Los números pueden representarse en diferentes bases y formatos. Ejemplos de números reales: 1.2e4 1.3. -. Hay dos tipos básicos de números.5 Cadenas de bits Para poder representar los valores básicos binarios de señales de diferentes anchos VHDL define las cadenas de bits. En general los reales no se utilizan en diseños para síntesis. 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 .3.3.Una variable A partir de VHDL-93 se permite definir identificadores extendidos utilizando el símbolo “\”. ya sea señales. Facultad Regional Bahía Blanca 7.5 2#0. los enteros (integer) y reales (real).Una señal variable CuentaModulo1_VAR : std_logic_vector(3 downto 0). 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.4# Ejemplos de números enteros: 1 2 3467 2#01110# 16#0AFD24# 7. Ejemplos: constant UTN_CUENTA_MAXIMA : integer := 56. Los identificadores pueden utilizar los caracteres alfanuméricos y el guión bajo “_”. Esto se hace para poder comunicarse con herramientas de desarrollo que aceptan identificadores con formatos diferentes a los de VHDL.Diseño digital utilizando FPGAs UTN. Deben comenzar con una letra y no pueden tener mas de dos guiones bajos seguidos ni terminar con un guión bajo. Recordar que no deben usarse palabras reservadas como identificadores y que VHDL no diferenciará identificadores solo por las mayúsculas.3 Identificadores Los identificadores se utilizan para dar nombre a los elementos de un diseño.10# 8#0.23 1. Estos identificadores extendidos pueden tener cualquier símbolo sin las limitaciones de los identificadores básicos de VHDL. Estas pueden estar definidas en base binaria. -. Se puede usar notación exponencial con ambos tipos de número. variables o cualquier otro elemento del diseño. 7.23e-4 0. Los números pueden representarse en cualquier base de 2 a 16 usando #. -.

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

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

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

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

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

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

Al analizar el código. 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. -.Diseño digital utilizando FPGAs UTN. Estos bloques se denominarán unidades de diseño. 7. A esto se lo denominará unidad de librería. Esa información luego queda guardado en una base de datos para poder procesarla cuando el analizador encuentra la directiva library en el VHDL.6. Si se necesita acceder a entidades.la librería CompuertasBasicas end architecture Estructural. 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.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.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 . cada unidad se asigna a una librería de una manera dependiente de las herramientas utilizadas. La librería work se agrega al diseño en el que se está trabajando de manera implícita.1 Librerías Una librería se define como una colección de unidades de librería.librería que las contiene library CompuertasBasicas. VHDL reserva el nombre de librería work para la librería del diseño actual.Aquí pueden utilizarse los componentes declarados en -. 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. Para utilizar esos componentes se debe agregar lo siguiente antes de la especificación de una arquitectura. Esto significa que una librería es solo una manera de agrupar diferentes unidades para organizarlas.Para usar las compuertas básicas se debe agregar la -. Por ejemplo. Facultad Regional Bahía Blanca 7.6 Librerías y Paquetes En VHDL los componentes se describen utilizando entidades y definiendo arquitecturas por separado. declaraciones o funciones de otra librería se debe utilizar la instrucción library. darles una jerarquía y poder reutilizarlas de una manera ordenada. architecture Estructural of LogicaCompleja is begin -. 7.

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

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

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. ‘1’ y ‘Z’) y además una resistencia de “pull-up” a la tensión de alimentación con un valor alto (valor ‘H’). si una señal tiene un buffer de tres estados que la maneja (posibles valores ‘0’.3. Facultad Regional Bahía Blanca 7. 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. Los valores débiles y forzados se incluyen para poder modelar hardware que tiene diferentes capacidades de controlar una señal. std_logic_vector es un arreglo sin límites. 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. y el valor de los índices máximo y mínimo se dan al declarar el objeto de ese tipo. esta forzará el valor de la señal mas allá de la resistencia de “pullup”. Reset_IN : IN std_logic. Estos tipos se nos permite modelar señales y buses de diferentes anchos.Diseño digital utilizando FPGAs UTN. 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). ©2003 Guillermo Güichal 78 . pero si el buffer tiene una salida lógica. 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. Ejemplo de uso del tipo std_logic en la declaración de una entidad : entity Contador is port( Clock_IN : IN std_logic.6. signal intFinDeCuenta : std_logic. Cuenta_OUT : OUT 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. Por ejemplo. Del tipo std_logic se define el tipo std_logic_vector que es un arreglo (array) de std_logic.

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

use std_logic_arith. Facultad Regional Bahía Blanca -.all. Ambos deben ser de igual longitud.Encabezamiento para usar los tipos std_logic y std_logic_vector y tratarlos como -.números sin signo en las operaciones aritméticas library ieee.Encabezamiento para usar los tipos std_logic y std_logic_vector y tratarlos como -. use std_logic_1164. use std_logic_signed. ©2003 Guillermo Güichal 80 . -.all.números con signo (complemento a dos) en las operaciones aritméticas library ieee.all. use std_logic_arith. 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.Diseño digital utilizando FPGAs UTN. Tabla 9 Resumen de tipos de las operaciones aritméticas Oper.all.all. use std_logic_1164. use std_logic_unsigned.all.

separadas de otras declaraciones de entidades y arquitecturas. 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 UTN. La estructura general de un componente en el que se modela su comportamiento es la mostrada en el cuadro. Como se ha visto anteriormente. En términos generales. Facultad Regional Bahía Blanca 7. Esto no significa que no haya otras estructuras y maneras diferentes de definir la misma funcionalidad para un modelo.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.2. No conviene mezclar ambos modelos y no se hará en este texto. 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 los apéndices pueden consultarse ejemplos de este tipo de modelo que servirán como guía para nuevos diseños. Es buena práctica incluir ambas unidades5 para un componente en un solo archivo que tenga el mismo nombre que la entidad. ayuda a localizar rápidamente los componentes y ayuda a reutilizar el código. En la arquitectura. Las descripciones y ejemplos dados estarán orientados a diseños sintetizables. antes de la palabra begin se definen todas las señales internas que se utilizarán en el modelo. un componente en VHDL se define utilizando dos unidades de diseño: entity y architecture.3. 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. 5 Si existe más de una arquitectura para una entidad todas deberían estar definidas en el mismo archivo. Esto permite modelar el verdadero funcionamiento del hardware ya que en general habrá muchas tareas ejecutando en paralelo e interactuando entre sí. En VHDL-93 pueden usarse componentes directamente destacando explícitamente a que librería pertenecen. y dentro de la arquitectura varias secciones básicas. la arquitectura de un componente puede ser un modelo de comportamiento o estructural. como se mostró en la sección 7. Después de la palabra begin recién comienza una serie de operaciones que concurrentes que se ejecutarán en paralelo. o que las presentadas sean las únicas estructuras sintetizables. ©2003 Guillermo Güichal 81 . Un modelo estructural incluye todos los componentes básicos y las señales que los interconectan. En este esquema se van las declaraciones de la entidad y arquitectura. entity Componente is port( … Declaración de puertos de entrada salida … ). Utiliza las palabras port map para logar esta interconexió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. sino que todas las salidas se definen como funciones de las entradas. En este ejemplo no se utilizan señales internas. intSalidaOr <= Entrada1_IN or Entrada2_IN. Esta palabra permite modelar retardos entre el evento que provoca los cambios en una ©2003 Guillermo Güichal 85 .Diseño digital utilizando FPGAs UTN. Salida_OUT <= not (Entrada1_IN or Entrada2_IN) after 2 ms. end architecture Comportamiento. -. SalidaOr_OUT <= Entrada1_IN or Entrada2_IN. Logica1 <= Entrada1_IN or Entrada2_IN after 40 ps. end architecture Comportamiento. SalidaNor_OUT <= not (Entrada1_IN or Entrada2_IN).con retardo entre cambios en las entradas y salidas -.2 Palabra reservada AFTER En los siguientes ejemplos se presentan asignaciones de señal que utilizan la palabra clave palabra clave after.a la lógica Salida1_OUT <= Entrada1_IN and Entrada2_IN after 20 ns. incluye la palabra reservada after que en el contexto presentado significa “después de” “luego de”. 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. Cuadro 23 Ejemplo de arquitectura definida como flujo de datos Otras manera de definir la misma lógica se muestra en el siguiente cuadro.2.Operaciones concurrentes que modelan flujo de datos SalidaAnd_OUT <= Entrada1_IN and Entrada2_IN. Facultad Regional Bahía Blanca intSalidaAnd <= Entrada1_IN and Entrada2_IN. SalidaNand_OUT <= not (Entrada1_IN and Entrada2_IN). Registro_REG <= not (Entrada1_IN and Entrada2_IN) after 4 ps. Cuadro 24 Otro ejemplo de flujo de datos 7. architecture Comportamiento of Logica2Entrdas is begin -.7. Esta implementación dependerá del PLD que se esté utilizando.Operaciones concurrentes que modelan flujo de datos -.

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

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

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

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

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

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

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

end case.. Facultad Regional Bahía Blanca -. LachearDato. PulsoAlADC ).ExpresiónSelectora no resulta ser ninguna de las -.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 . -. 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.CASE dentro de un proceso combinacional que asigna el -.Multiplexor utilizando la expresión case case Control_IN is when ”00” => Salida_OUT <= Entrada0_IN. signal EstadoSiguiente : tdEstado .Ejemplos de instrucciones case -. when others => . -. -. -. -..Instrucciones secuenciales que se ejecutan si -.--. -.Declaración de estado actual y siguiente signal EstadoActual : tdEstado .... when ”10” => Salida_OUT <= Entrada2_IN..ExpresiónSelectora resulta en la condición 3 o 4 .opciones anteriores end case. . when ”01” => Salida_OUT <= Entrada1_IN. -.--------------------------------------------------------....próximo estado según el estado actual y las entradas...Ejemplo para una máquina de estado .--------------------------------------------------------.--.. when others => Salida_OUT <= Entrada3_IN.Declaración del tipo para estados type tdEstado is ( EsperarDato. . .El estado inicial y la asignación de EstadoSiguiente a -.Diseño digital utilizando FPGAs UTN.

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

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

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

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

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

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

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

8.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... La declaración genérica se cierra con un paréntesis y un punto y coma “)..Formato de una declaración de entidad con genéricos entity Componente is generic( ParametroGenerico1 : TipoDelGenerico1 := ValorPorDefecto1. El Cuadro 36 muestra el formato de una declaración de entidad con parámetros genéricos.. ParametroGenericoN : TipoDelGenericoN := ValorPorDefectoN ). Al igual que en la declaración de la interfase con port.. el último parámetro no tiene un punto y coma “.Diseño digital utilizando FPGAs UTN. Facultad Regional Bahía Blanca 8 Más VHDL 8. . end Componente. De esta manera se puede diseñar un componente flexible y reutilizable.1 Declaración de parámetros genéricos Utilizando constantes genéricas pueden parametrizarse tanto la estructura como el comportamiento de un componente. Esto se hace declarando una interfase genérica con la palabra generic. Cuadro 36 Formato de declaración con parámetros genéricos Notar que.2. – Declaración de interfase genérica . 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. -.” después de su declaración y antes del paréntesis que cierra la declaración genérica. Se tratan como constantes dentro de declaración de interfase y la arquitectura de la entidad.. En esta sección se dan algunos otros conceptos de VHDL.” ©2003 Guillermo Güichal 101 .2 Parámetros Genéricos VHDL permite escribir modelos parametrizables utilizando una lista de constantes genéricas en la declaración de una entidad. los bancos de prueba (testbench). – Declaración de interfaces ). 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. . port( . de una manera similar a la declaración de la interfase con la palabra port. 8..

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.La salida esta dada por un registro Cuenta_OUT <= Cuenta_REG. elsif Rising_Edge(Clock_IN) then Cuenta_REG <= Cuenta_REG + 1.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. -. Clock_IN) begin if (Reset_IN = ‘1’) then Cuenta_REG <= (others => ‘0’). Clock end process ProcesoCuenta. Este contador pasará de largo al llegar a su cuenta máxima (todos los bits en ‘1’) y recomenzará en 0.Reset.genérico entity ContadorRollover is generic( MSBContador : positive := 31 ). end if. -. architecture Comportamiento of ContadorRollover is signal Cuenta_REG : std_logic_vector(MSBContador downto 0). Cuenta_OUT : OUT std_logic_vector(MSBContador downto 0) ).EJEMPLO 1 -. end ContadorRollover. En el primero se define el bit más significativo del registro de cuenta como un genérico. -. port( Reset_IN : IN std_logic.La cuenta de salida se incrementa y pasa de largo a 0 al -.-----------------------------------------------------------. Cuadro 37 Ejemplo de declaración de entidad y arquitectura con parámetros genéricos ©2003 Guillermo Güichal 102 . begin -.llegar al valor máximo ProcesoCuenta : process(Reset_IN. end Comportamiento. Clock_IN : IN std_logic.Contador con bit más significativo dado por un parámetro -.

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

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

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

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

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

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

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

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

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

-.Declaraciones begin . -. . else return Entrada2.. 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.Instrucciones secuenciales .Esto devuelve el resultado de expresión. 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 if. Así.que debe ser del tipo declarado para la -. -...-. end function Mayor... . .Uso de la función en una expresión concurrente o secuencial ©2003 Guillermo Güichal 112 ...Diseño digital utilizando FPGAs UTN.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. end function NombreFuncion. Los parámetros no pueden ser del tipo variable. Este formato tiene similitud con las funciones de otros lenguajes de programación.. .entrada constantes function Mayor ( Entrada1 : std_logic_vector. Facultad Regional Bahía Blanca -.Ejemplo de la declaración de una función con parámetros de -.... -. si no especifica la clase del parámetro esta se asume constant y si no se especifica el modo este se asume in. Entrada2 : std_logic_vector ) return std_logic_vector is begin if (Entrada1 > Entrada2) then return Entrada1.Formato de la declaración de una función function NombreFuncion (parámetros opcionales) return RTipo is . -..

LimiteUsuario_IN).--. En todos estos casos pueden asociarse parámetros por posició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.all. como las utilizadas para los port map y llamados de procedimientos. use ieee.de 16 bits a partir de un componente INV de 1 bit library ieee. En el ejemplo. library unisim.Diseño digital utilizando FPGAs UTN. Los rangos se asignarán cuando se llame a la función con parámetros reales. El tipo de la salida no puede tener un rango predeterminado. Para los componentes en arquitecturas estructurales se recomienda la asociación por nombre. 8. También hace más difícil la modificación del código.Ejemplo de la instrucción generarte para crear un inversor -. Facultad Regional Bahía Blanca Resultado <= Mayor(Entrada1 => DatoADC_IN.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.std_logic_1164. como se muestra en el segundo ejemplo del llamado de la función Mayor. Hay que tener mucho cuidado al hacer esto ya que pueden cometerse errores de orden y no obtener los resultados deseados. y LimiteUsuario_IN con Entrada1 porque es el segundo parámetro. 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. El muestra el formato y un ejemplo de esta instrucción.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. -. 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.-----------------------------------------------------.3. 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. 8. que utilizan el símbolo “=>”. Entrada2 => LimiteUsuario_IN). ©2003 Guillermo Güichal 113 . -.Formato de la instrucción generate Etiqueta : for Identificador in Rango generate Instrucción concurrente end generate.

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

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

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

.. A continuación se presentarán algunos ejemplos de estos componentes. ©2003 Guillermo Güichal 117 . Esta memoria solo puede configurarse como memoria (RAM o ROM) y no utilizarse como lógica configurable. Una es la memoria RAM en bloque (block RAM). Las FPGA de Xilinx pueden implementar dos tipos de memoria RAM que se incluyen como primitivas. Hay varias posibilidades de uso y configuración de las memorias. tomados de la guía de librerías unificada de Xilinx.. diferentes anchos de palabra.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. que está formada por los bloques de memoria embebidos en la FPGA. La Tabla 11 describe brevemente las señales.Diseño digital utilizando FPGAs UTN. 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. ya sea con puerto simple.A3 Salida dada por DPRA0. etc. Facultad Regional Bahía Blanca A continuación se describirán algunas configuraciones para las memoria de las FPGA de Xilinx. La Figura 40 muestra una memoria RAM de puerto dual de 16 palabras por 1 bit de ancho..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. Esta memoria tiene los siguientes puertos interfase. Tabla 10 Puertos de interfase de la memoria RAM16x1D Señal WE WCLK D A0.A3 DPRA0. La RAM distribuida (distributed RAM) se implementa utilizando las tablas de búsqueda LUT de los bloques lógicos como. puerto dual. de 1024 palabras por 4 bits.

end infer_ram. use IEEE..STD_LOGIC_UNSIGNED. architecture Comportamiento of infer_ram is ©2003 Guillermo Güichal 118 . ALL. puerto dual) o no permiten inicializar una memoria inferida. 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. use IEEE. use IEEE.. Algunas herramientas infieren bien ciertos tipos de memoria pero no otros (puerto simple vs. 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. we : in std_logic. a : in std_logic_vector(4 downto 0).STD_LOGIC_ARITH. 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. entity infer_ram is port (clk : in std_logic. El tipo de estructura reconocida y las memorias inferidas dependerán de las herramientas. Muchas herramientas detectan estas estructuras e infieren el uso de una memoria interna de la FPGA (ya sea en bloque o distribuida).Diseño digital utilizando FPGAs UTN. do : out std_logic_vector(3 downto 0)).STD_LOGIC_1164.A0 DO3. library IEEE.. ALL. DI0 A3.ALL. di : in std_logic_vector(3 downto 0).

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

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

use IEEE. end if. Direccion de entrada asincrónica directamente do <= RAM(conv_integer(a)). 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. end process.La interfaz de la ROM no tiene datos de lectura entity ROM_infer is port(clk : in std_logic. -. Facultad Regional Bahía Blanca begin if Rising_Edge(clk) then -. -. addr: in std_logic_vector(3 downto 0).std_logic_1164. library IEEE. we : in std_logic.Diseño digital utilizando FPGAs UTN. do : out std_logic_vector(7 downto 0)). architecture Xilinx of ROM_infer is ©2003 Guillermo Güichal 121 .La memoria se escribe con un WE sincronico if (we = '1') then RAM(conv_integer(a)) <= di.all.all. end entity ROM_infer. end if.std_logic_unsigned. Notar en la figura que la memoria ROM se implementa como una RAM con sus entradas de escritura deshabilitadas. end Comportamiento. use IEEE.std_logic_arith.all.Datos de salida.

Diseño digital utilizando FPGAs begin -. when "0111" => do <= X"F0". when "1000" => do <= X"77". when "0011" => do <= X"78". when "1100" => do <= X"BB". when "0110" => do <= X"DE". end if. when "0101" => do <= X"BC". when "1101" => do <= X"CC". end case. when "0010" => do <= X"56". end architecture Xilinx. when "1011" => do <= X"AA". 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 "0001" => do <= X"34".Este proceso solo lee datos the_rom: process (clk) begin if rising_edge(clk) then case addr is when "0000" => do <= X"12". when "0100" => do <= X"9A". when "1010" => do <= X"99". UTN. when others => do <= X"EE". when "1110" => do <= X"DD". end process the_rom.

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

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

q : OUT STD_LOGIC_VECTOR (7 DOWNTO 0)).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. BEGIN -------------------------------------. std_logic. std_logic. clock => Clock_IN. wraddress => WriteAddress_REG(4 DOWNTO 0). std_logic. END ARCHITECTURE rtl_text. ambas formadas a partir de la primitiva RAM16x1D. port ( Clock_IN WriteEnable_IN WriteAddress_IN WriteData_IN ReadAddress_IN ReadData_OUT ). std_logic. wren => WriteEnable_IN. En los siguientes ejemplos se presenta una memoria de 16 por N y una cola FIFO de 16 x 16. ©2003 Guillermo Güichal 125 . : : : : : : in in in in in out std_logic. -. end DRamDual16xN. ------------------------------------RamFifo : ram_32x8_dp PORT MAP ( data => Writedata_IN.Altera RAM instantiation for FIFO..5. std_logic_vector(3 downto 0). std_logic_vector(MSB_MEMORIA_RAM downto 0) architecture Estructura of DRamDual16xN is component port ( WCLK WE A0 A1 A2 A3 RAM16X1D : : : : : : in in in in in in std_logic. . END COMPONENT. std_logic. is : positive := 15. Facultad Regional Bahía Blanca clock : IN STD_LOGIC. rdaddress => ReadAddress_REG(4 DOWNTO 0).Componente de memoria RAM de 16 x N a partir de primitiva RAM16X1D entity DRamDual16xN generic ( MSB_MEMORIA_RAM ). 8.Diseño digital utilizando FPGAs UTN. q => Readdata_OUT). std_logic.. std_logic_vector(MSB_MEMORIA_RAM downto 0). std_logic_vector(3 downto 0).

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

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

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

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

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

9 Las herramientas traducen los diseños gráficos a VHDL o Verilog antes de sintetizarlos. se tomará el valor del estado actual y no el agendado. La asignación de salidas en el proceso sincrónico puede prestarse a confusión. Debe recordarse que. Por eso. o cualquier otra herramienta de ese estilo. 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. Figura 45 . también se puede desarrollar directamente en VHDL9. El Cuadro 58 muestra el la máquina de estados de la figura anterior a modo de ejemplo. 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). con la asignación del estado actual y las salidas hecha a través de elementos sincrónicos (registros). El otro es sincrónico y asigna el estado actual y define las salidas.Diseño digital utilizando FPGAs UTN. EL estilo preferido para describir una máquina de estados en VHDL es mediante dos procesos. pero existen una variedad de combinaciones de procesos y lógica concurrente que pueden ser utilizadas. HDL Designer de Mentor Graphics. Facultad Regional Bahía Blanca sincrónico como se describirá más adelante. El ejemplo presentado es una manera de modelar máquinas de estado. ©2003 Guillermo Güichal 131 . al evaluarse el case de asignación de las salidas. La implementación básica de una máquina de estados como la descripta será la mostrada en la Figura 45. pero no se actualiza inmediatamente.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. 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. este valor se agenda. al haber un flanco de reloj y ejecutarse la instrucción de asignación del próximo estado.

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

when Estado2 => EstadoSiguiente <= Estado3. end if. when others => -. end case. end process AsignacionProximoEstado. else EstadoSiguiente <= Estado3. Entrada2= ‘X” EstadoSiguiente <= Estado4.-------------------------------------------------------.Entrada1= ‘1’. Facultad Regional Bahía Blanca -.Estado4 EstadoSiguiente <= Inicial.-------------------------------------------------------. Además. EstadoActual ) begin -. 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.Entrada1= ‘1’. when Estado3 => if (Entrada2_IN = ‘0’) then EstadoSiguiente <= Estado4. elsif (Entrada2_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. end if. Entrada2. when Estado1 => if (Entrada1_IN = ‘0’) then –. else EstadoSiguiente <= Inicial.Acciones combinadas de asignación de estado siguiente case EstadoActual is when Inicial => if (Entrada1_IN = ‘1’) then EstadoSiguiente <= Estado1. al evaluar las entradas para el próximo estado en las instrucciones if.-AsignacionProximoEstado : process (Entrada1.Proceso combinacional de asignación de estados -. Al sintetizar este código las herramientas usarán registros y asignarán un valor a cada estado.6. end if. Con ©2003 Guillermo Güichal 133 .--.Entrada1= ’1’. end ComportamientoFSM. 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.Diseño digital utilizando FPGAs UTN. Entrada2= ‘0’ EstadoSiguiente <= Estado2. else -. else deben evaluarse todos los casos de combinaciones de entradas para evitar que se infieran “latches”. 8. Entrada2= ‘1’ EstadoSiguiente <= Estado3..

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.Diseño digital utilizando FPGAs UTN.Habilitación de reloj end if. Clock end process ProcesoConHabilitacionClock. Facultad Regional Bahía Blanca un registro de n bits pueden codificarse 2n estados. -.. como puede ser una máquina de estados finita. Esto hace que un proceso sincrónico se ejecute solamente cada N ciclos de reloj en vez de con cada flanco del reloj.Solo ejecutar las instrucciones secuenciales si el reloj -. . 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.. La señal de habilitación se debe generar en un bloque aparte dividiendo el reloj principal. Esta es una señal con la que se habilita el reloj por un ciclo solo cada N ciclos.-. 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. -.. y no agrega lógica combinacional adicional. end if. Si se desea hacer funcionar parte del diseño. -. pero muchas veces es más eficiente utilizar codificación “one-hot” o “one-cold”. 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. 8.está habilitado if (HabilitacionDeReloj_IN = ‘1’) then . Lo que se utiliza es una señal de habilitación de reloj.6. En VHDL esto debe describirse como se muestra en el Cuadro 59. Reset_IN) begin if (Reset_IN = '1') then -. a una frecuencia diferente de la del reloj principal no debe proveerse una señal de reloj más lenta.. ©2003 Guillermo Güichal 134 ..Formato de un proceso con señal de habilitación de reloj ProcesoConHabilitacionClock : process(Clock_IN.Valores de reset elsif Rising_Edge(Clock_IN) then -. 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. 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.Reset..Instrucciones secuenciales del proceso .

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. A un nivel superior se desea probar si los datos de entrada/salida cumplen con lo esperado. 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í. Esto se hace mediante simulaciones utilizando los llamados “bancos de prueba”. pero algunas herramientas (Ej.: Quartus II de Altera) permiten usar código de acceso a archivos para inicializar valores de memoria o realizar tareas similares.Diseño digital utilizando FPGAs UTN. 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.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. es importante probar los casos límite. Si el componente solo genera una forma de onda fija quizás no sea necesario hacer un análisis a nivel de datos. En el primer caso una observación de las formas de onda en general alcanza para analizar la interfase. Facultad Regional Bahía Blanca 9 VHDL para Simulación y Verificación 9. Por un lado se quiere ver si las formas de onda de la interfase responden a lo esperado. Los lazos serán sintetizables si pueden resolverse para un instante dado y modelan lógica combinacional. 9. La realidad es que eso depende de las herramientas y del uso que se le da a ese VHDL. Las próximas secciones describen VHDL que muchas veces no es sintetizable. o banco de pruebas. Esto se hace creando lo que se denomina un "testbench". En general hay dos niveles de interfase que se desean probar. 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. Es decir si el diseño hace lo que debería con los datos de entrada y responde con los datos de salida adecuados. Como en cualquier circuito digital.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. Para el análisis de funcionamiento a nivel datos probablemente se requerirá una metodología mas estructurada. pero sí simplifica muchísimo todo el proceso de depuración. 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. Los accesos a archivos no son sintetizables sobre la lógica de las FPGAs. Esto es más fácil de hacer en VHDL que ©2003 Guillermo Güichal 135 . 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.

La Figura 46 muestra el esquema sugerido para un banco de pruebas. Clock_IN. que sucede con combinaciones de entradas no esperadas. Así es fácil diferenciar que elementos pertenecen al diseño y cuales al banco de pruebas. usando ciclos y arreglos de valores o leyendo los datos de un archivo. 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. Enable_IN. 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. std_logic_vector(2 downto 0). si un diseño tiene la siguiente interfase. utilizar un número significativo de datos de entrada. mediante observaciones de la salida Dato_OUT si el diseño está funcionando bien.Diseño digital utilizando FPGAs UTN. 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. : : : : : IN IN IN IN IN std_logic.2. pero es buen seguir buenas prácticas de programación y estructura del banco de pruebas.2. La estructura superior contiene el diseño bajo prueba (DUT) y el componente que genera las pruebas y analiza los resultados. Luego conectar este modelo al diseño que se desea probar. Estos vectores pueden generarse mediante VHDL secuencial que explícitamente genera la secuencia de señales deseadas. Se recomienda separar e independizar la generación de datos de la generación de temporizados. Es bueno dar siempre el mismo nombre de DUT o UUT (de Device Under Test o Unit Under Test) al diseño bajo prueba. usar números aleatorios para ver el funcionamiento. 9. etc. std_logic.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. que sucede cuando se sobrepasan los límites esperados para las entradas. 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. Mode_IN para que se permita evaluar. Por ejemplo. port ( Reset_IN Clock_IN Enable_IN Mode_IN Dato_OUT ). 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. 136 • • ©2003 Guillermo Güichal . 9. Algunas organizaciones requieren que todos los elementos del banco de pruebas se separen en una librería completamente diferente a la de diseño. 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. std_logic.

y en esta sección solo se darán ejemplos de su utilización.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. ©2003 Guillermo Güichal 137 . no es necesario seguir las estructuras presentadas para diseños sintetizables. modificar e incluso reutilizar. 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).2. sino que solo sirven para las simulaciones.2. De esta manera se pueden crear las situaciones necesarias para probar el diseño y se puede evaluar la respuesta temporal del mismo. nombres. En el Cuadro 60 se muestran algunos de sus usos mediante un proceso que prueba la lectura de un dato usando un protocolo. El manejo del tiempo se hace a través de la instrucción wait y la palabra after. 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. P_PruebaReadEnable : process variable Dato1_VAR.Diseño digital utilizando FPGAs • • • UTN.3. Facultad Regional Bahía Blanca No se necesitan seguir las estructuras presentadas para síntesis: como los bancos de prueba no serán sintetizados. 9. Figura 46 Esquema de banco de pruebas para DUT 9.3 Manejo de tiempo en simulaciones usando VHDL En las simulaciones se debe controlar y medir la variable tiempo. Dato2_VAR : std_logic_vector(7 downto 0). etc. Ambas se han presentado en secciones anteriores. Usar las mismas guías en el código.

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

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

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

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

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

Los archivos pueden abrirse en tres modos: read_mode para lectura. la librería std provee el ©2003 Guillermo Güichal 143 . De esta manera se hace fácil especificar los datos de entrada a un modelo o verificar sus resultados. 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. -. Los archivos en VHDL pueden contener un solo tipo de datos.3 Manejo de Archivos y Paquete TEXTIO Además de los tipos predefinidos nombrados anteriormente. VHDL contiene el tipo file para poder manejar archivos. En general estos no pueden ser analizados directamente por el desarrollador.Formato de la instrucción report report “Nuevo dato de entrada”. 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. o esto puede hacerse más adelante utilizando la instrucción open. ya sea de una arquitectura. 9. Para simplificar la escritura y lectura de archivos en un formato entendible para el usuario. incluyendo escalares. -. La expresión tiene la forma Uso y ejemplos de report report Mensaje.Error en el modelado de un componente assert NumeroDeEntradas = NumeroDeSalidas report “Error en el modelo.” severity error. un proceso o un subprograma. arreglos de una dimensión o datos de tipo record. Facultad Regional Bahía Blanca assert AnchoDePulso >= 2 ns report “Pulso demasiado chico. Estas operaciones se muestran en la Tabla 13.3. La instrucción report puede usarse por si sola para generar mensajes que ayuden en la depuración del código. Al hacer la declaración puede asociarse un archivo físico. No se puede simular” severity failure. Además provee varias instrucciones para el manejo de archivos. En muchos casos es importante que se puedan escribir o leer los datos directamente de los archivos. No generará interrupción. Al escribir datos a un archivo estos se guardarán con un formato binarios que dependerá del sistema sobre el que se está trabajando.

Para utilizar archivos de texto en un banco de pruebas (el manejo de archivos no es sintetizable). Este paquete permite acceder a archivos que contienen cadenas de caracteres. Esto hace accesible el paquete textio que incluye los tipos y procedimientos mostrados en la Tabla 14. El lector puede referirse a la bibliografía para estudiar el uso de otros tipos de archivo. 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. 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.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. todos los datos serán cadenas de texto. que en general están definidos como la pantalla y el teclado en casi todos los sistemas. Esto permite que varios procesos accedan a un mismo archivo. 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. También incluye los archivos que pueden utilizarse directamente "input" y "output" asociados a los archivos físicos "std_input" y "std_output". Pueden usarse funciones de conversión para guardar o escribir cualquier tipo de dato en estos archivos.textio. Como la secuencia de escritura a un archivo de varios procesos concurrentes es impredecible. Facultad Regional Bahía Blanca paquete textio. use std. Así.Diseño digital utilizando FPGAs UTN. 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. se deben agregar las siguientes líneas en el código library std.

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

El último ejemplo muestra como puede simularse un ciclo de bus de CPU. CpuState_REG(2). while (SimmulacionActiva_IN = '1') loop std_logic. use ieee.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. Facultad Regional Bahía Blanca -.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. port ( SimmulacionActiva_IN : IN Reloj_OUT : OUT ). Los primeros dos serán utilizados para probar casi todos los diseños. library ieee.Diseño digital utilizando FPGAs UTN. 9.all. 9.std_logic_1164. end tbGeneradorReloj .3.3. ya que describen una generación de reloj y generación de una señal de reset.5. -.Estado de las interrupciones -.Vector de interrupciones que incluye todos los bits alias CpuInterrupcion_REG is CpuState_REG(4 downto 0). std_logic ©2003 Guillermo Güichal 146 . architecture Comportamiento of tbGeneradorReloj is begin P_Reloj : process begin wait for 1 ns. entity tbGeneradorReloj is generic ( PERIODO_NS : time := 20 ns ). CpuState_REG(1).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). CpuState_REG(3).

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

3. 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). Facultad Regional Bahía Blanca 9.Diseño digital utilizando FPGAs UTN. En la Figura 47 se muestra el temporizado de este bus sincrónico. Por un lado se generarán y leerán datos para verificar el funcionamiento del diseño a alto nivel.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 . 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 . Para probar el diseño se debe crear un banco de pruebas que simule la interfase de ese uC.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. La Tabla 15 y Tabla 16 dan los valores de tiempo correspondientes y el Cuadro 68 muestra el VHDL que simula la interfase. El banco de pruebas tendrá dos niveles.5.

Declaración de tipos. constant T_SETUP_R_DATA : time := 15 ns. ReadEnable_OUT : out std_logic. . Clock_IN : in std_logic. . end tbMicroControlador. constant T_SETUP_W_DATA : time := 58 ns.Diseño digital utilizando FPGAs Tabla 16 Tiempos para ciclo de escritura de uC UTN.. constant T_HOLD_R_DATA : time := 1 ns. constant T_HOLD_WRITEENABLE : time := 4 ns. constant T_HOLD_W_DATA : time := 6 ns.. -. Facultad Regional Bahía Blanca Parámetro tClock tSAddress tHAddress tSWrite tHWrite tSWData tHWData Descripción Período del reloj (48 .. constant T_SETUP_WRITEENABLE : time := 62 ns.. port( Reset_IN : in std_logic.Ejemplo de ciclo de temporizado de un bus de uC . .Entidad para banco de pruebas que simula el micocontrolador entity tbMicroControlador is generic( T_CLOCK : time := 200 ns ). -.. architecture Comportamiento of tbMicroControlador is -..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 -. Address_OUT : out std_logic_vector(19 downto 0) .--. Data_IO : inout std_logic_vector(15 downto 0) ).. -. constant T_HOLD_READENABLE : time := 4 ns. constant T_HOLD_ADDRESS : time := 8 ns. señales internas. ..Constantes de parámetros de temporizado del bus constant T_SETUP_ADDRESS : time := 50 ns. WriteEnable_OUT : out std_logic.Declaración de librerías y uso de paquetes. ©2003 Guillermo Güichal 149 . constant T_SETUP_READENABLE : time := 54 ns....------------------------------------------------------. etc.. .

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

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

estructuras. Algunas de estos temas no se usan en circuitos sintetizables y otros no se incluyeron para no hacer estas notas demasiado largas y pesadas. ©2003 Guillermo Güichal 152 .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.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. 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.. Facultad Regional Bahía Blanca 9. etc. e infinitas posibilidades de uso de VHDL que no han sida descriptas. Hay varias instrucciones. blocks) • Manejo de archivos de otro tipo que el definido en textio • etc..

auditores o el mismo desarrollador un tiempo más tarde. 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). de estas señales y componentes para poder proveer una interfase que se adecue a la funcionalidad prevista. 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.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. Este es solo un ejemplo. frecuencias etc. o que pueda entenderse después de tenerlo archivado unos meses es imprescindible crear buena documentación. 153 ©2003 Guillermo Güichal .2 Documentación Si se pretende tener un producto (re)utilizable. ya sea otros desarrolladores. entidades. 10. Facultad Regional Bahía Blanca 10 Buenas Prácticas de Diseño 10. De esta manera se evitan las confusiones y se acelera el aprendizaje de nuevos integrantes del equipo. procesos. En esta sección se presentarán de manera básica una serie de puntos y recomendaciones relacionadas con estos temas. • 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. o Dar un nombre a todos los procesos para aclarar su funcionalidad. y no debe tomarse como el único modelo que puede ser utilizado. una organización debería tener una guía documentada que pueda ser consultada por todos los desarrolladores. Para facilitar esto. COMPLETAR CON PAUTAS SOBRE DOCUMENTACIÓN. Estos diseños pueden llegar a ser bastante sofisticados y tener una jerarquía que utilice componentes desarrollados por diferentes personas. etc. vendible.Diseño digital utilizando FPGAs UTN. En esta sección se presenta un ejemplo de documento de este tipo. tolerancias. las FPGAs permiten el desarrollo de sistemas muy complejos en un solo componente. 10. cada instrucción independiente del programa deberá estar en su propia línea o No usar constantes mágicas. clientes.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. Por otro lado. En este sentido el diseñador debe estar al tanto de los requerimientos. solo por las mayúsculas o Colocar las instrucciones begin y end en su propia línea de programa o En general. Definir todas las constantes con palabras que las identifiquen inequívocamente. o En los lenguajes que son sensibles a las mayúsculas no se deben diferenciar los nombres de funciones.

En vez de eso usar tipos “OUT” y agregar otra señal interna a la que se le asigna el mismo valor.Diseño digital utilizando FPGAs UTN. Usar una secuencia jerárquica de palabras clave para especificar a que valor se está refiriendo una constante (Ej.: UTN_ADC_MAXIMO. 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. procesos o procedimientos. Asignarles un valor inicial durante el estado de Reset. o Para los nombres de las señales usar mayúsculas solo para identificar las palabras del nombre. 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. (Ayuda a reutilizar el código) o No utilizar puertos del tipo “BUFFER” para leer un valor de salida. quizás agregando prefijos o sufijos.: NombreDelProceso) o Usar todas mayúsculas separadas con “_” para definir constantes. Dar un prefijo especifico a todas las constantes de acuerdo al proyecto. • Programación en VHDL o No mezclar estándares de programación. 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. UTN_ADC_MINIMO). (Ej. El nombre del archivo deberá ser igual al de la entidad. Usar sintaxis VHDL 87 o 93 exclusivamente) o Usar un archivo por entidad (“entity”) que defina su interfase y arquitectura. o Usar nombres que den una idea clara de la función de los módulos. 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 . Usar palabras completas y no abreviaturas que son difíciles de descifrar y recordar. variables y constantes o Usar nombres que den una clara idea de los datos que contiene la señal o constante. o Tratar de usar el mismo nombre para las señales a través de toda la jerarquía de diseño. Nombres de las señales.

o La indentación debe ser fija y consistente para todo proyecto. 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. los bloques funcionales de código. ©2003 Guillermo Güichal 155 . • • Ejemplos: • Comentarios. Los TABs deberán estar definidos como 2 espacios.LIMITES PARA LOS DATOS LEIDOS DEL ADC -. procedimientos o Usar nombres que den una idea clara de la función de los módulos. 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. -. Todo el código que implementa el proceso quedará así indentado debajo de la declaración. etc. espacios y nombres -. Dejar “_” para las nombres de las variables.----------------------------------------------------------------------------constant UTN_ADC_VALOR_MAXIMO : std_logic_vector(12 downto 0) := “0010000000000”. Indentación. procesos o procedimientos. constant UTN_ADC_VALOR_MINIMO : std_logic_vector(12 downto 0) := “1110000000000”. No comentar lo obvio.Diseño digital utilizando FPGAs UTN. Comentarios o Usar los comentarios para describir la lógica y el motivo del programa. o Usar líneas en blanco para separar las declaraciones de las funciones. indentación y líneas en blanco para que el código sea mas entendible y claro. Dos espacios es un valor razonable. signal ADCRead : std_logic. o Ser sistemático en el formato de los nombres.-----------------------------------------------------------------------------. signal ADCReady : std_logic. o No escribir líneas de código de mas de 80 caracteres. espacios y líneas en blanco o Hacer un consistente y buen uso de los espacios.----------------------------------------------------------------------------signal ADCdataBus : std_logic_vector(12 downto 0). o Usar mayúsculas para dividir las palabras de un nombre. Partir la línea larga entre varias y alinearla para que se comprenda mejor. o Indentar la primer línea de código después de la declaración de un proceso o procedimiento.SEÑALES -.-----------------------------------------------------------------------------.

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

La Figura 48 muestra el método de división de frecuencia recomendado para diseños sobre FPGAs. 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. no aprovecha los recursos de la FPGA y puede causar problemas de temporizado y sincronización en el circuito implementado. 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. Aunque este método es muy utilizado en diseños digitales convencionales. En general. Esta es una señal con la que se habilita el reloj por un ciclo solo cada N ciclos.Diseño digital utilizando FPGAs UTN. ©2003 Guillermo Güichal 157 . 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. Facultad Regional Bahía Blanca recomienda generar una señal de habilitación de reloj.

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

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. esto puede causar errores al integrarlos en un diseño. (Evita des-sincronización por caminos de diferente longitud de la señal de Reset). 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. Hay muchos errores comunes que pueden evitarse facilmente siguiendo este tipo de pautas Por ejemplo. 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. Facultad Regional Bahía Blanca 10. o No usar señales de reloj o Reset como Enable o dato. asincrónico. 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.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. 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. (los resultados durante simulaciones pueden diferir del circuito sintetizado y causar problemas de temporizado) • ©2003 Guillermo Güichal 159 . si algunos desarrolladores utilizan una señal de reset positiva y otros negativa.Diseño digital utilizando FPGAs UTN. se evita repetir errores y los nuevos desarrolladores pueden aprender de la experiencia de otros. 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 El Reset asincrónico se usará a nivel local en todos los módulos. 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. Este se sincronizará con el reloj al nivel lógico mas alto de la jerarquía de diseño. • 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. (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). o Durante el estado de Reset todos los puertos bidireccionales deberán colocarse en el estado de entrada.

END IF. (para evitar interpretaciones diferentes y provocar malos conexionados) Recomendaciones para Síntesis o Usar solo diseños sincrónicos. END IF... Reset) BEGIN IF (Reset = '1') THEN ..Diseño digital utilizando FPGAs UTN. tratar de definirla en un proceso solo con el siguiente formato PROCESS (Clock. (esto evita que se genere lógica de prioridad grande. lenta e innecesaria) ©2003 Guillermo Güichal 160 . else sino que utilizar una instrucción case. Reset) BEGIN IF (Reset = '1') THEN intOutSignal <= '0'. 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.. ELSIF (Clock'event AND Clock = '1') THEN IF (CE = '1') THEN -. END PROCESS. 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. (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. END IF.. END IF. (estos pines tienen canales de distribución especiales con baja diferencia de retardo en la distribución. (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 bajo “skew”) • Buses o Comenzar los buses en el bit 0. (Algunas herramientas no aceptan buses que no comienzan en 0) o Usar (MSB downto LSB) para todos los buses. ELSIF (Clock'event AND Clock = '1') THEN . o Para lógica sincrónica con “enable”. END PROCESS. (evita problemas durante la síntesis.Señal de enable intOutSignal <= '1'.

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. o No usar elementos de retardo. Además facilita la modificación del protocolo de comunicación o “handshaking” con el módulo a probar). • ©2003 Guillermo Güichal 161 . Uno para la asignación sincrónica de los estados y uno asincrónico para las salidas. usar dos procesos separados. Facultad Regional Bahía Blanca o En un proceso combinacional incluir todas las señales en la lista de sensibilidad. o Definir los tiempos para los ciclos de comunicación con el módulo a probar como constantes que pueden ser modificadas fácilmente. (Esto facilita la verificación de los datos por un lado y el temporizado por otro. (evita que se generen latches no deseados) o En máquinas de estado. Uno para generación y verificación de datos y otro para la generación del temporizado de las señales.Diseño digital utilizando FPGAs UTN. (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.

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

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

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

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. Seleccionar el testbench o archivo de forma de onda que se desea simular 7. 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 archivo del banco de pruebas (*. 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.Diseño digital utilizando FPGAs UTN. En la ventana “Processes for Current Source” seleccionar ModelSim Simulator 8.vhd) Para enviar un proyecto a ModelSim y simularlo 6. 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. Facultad Regional Bahía Blanca 14.tbw o *.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. Seleccionar el módulo al que se desea asociar (que módulo va a probar) 4. Editar el testbench o formas de onda como se desee y grabarlo.

Diseño digital utilizando FPGAs UTN. View/Signals. Esto abrirá la ventana de señales 2. De la ventana de señales. Seleccionar el componente deseado en la jerarquía de la ventana principal o en la ventana “Structure” 3.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 . 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 “. Facultad Regional Bahía Blanca 1.

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

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

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

1 Interfase Mouse 16.8 etc.2 16.4 Divisor Reloj 16..7 Ejemplo Completo: UART 16.6.2 Controlador VGA 16.Diseño digital utilizando FPGAs UTN..5 Control display 7 segmentos 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.1 Ejemplos de Lógica Combinacional 16.. otros ejemplos de laboratorios hechos en clase. etc ©2003 Guillermo Güichal 172 ..6. 16.3 Ejemplos de Lógica Secuencial 16.

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->