Source: https://www.scribd.com/doc/56245342/19983234-Diseno-de-Sistemas-Digitales-Vhdl-Dsd-Vhdl
Timestamp: 2017-01-19 08:52:47+00:00

Document:
19983234 Diseno de Sistemas Digitales Vhdl Dsd Vhdl
BrowseInterestsBiography & MemoirBusiness & LeadershipFiction & LiteraturePolitics & EconomyHealth & WellnessSociety & CultureHappiness & Self-HelpMystery, Thriller & CrimeHistoryYoung AdultBrowse byBooksAudiobooksArticlesSheet MusicBrowse allUploadSign inJoinDISEÑO DE SISTEMAS DIGITALES MEDIANTE LENGUAJES DE DESCRIPCIÓN DE HARDWARE.Miguel Ángel Aguirre Echánove Jonathan Noel Tombs Fernando Muñoz Chavero
DISEÑO DE SISTEMAS DIGITALES MEDIANTE LENGUAJES DE DESCRIPCIÓN DE HARDWARE. ..................................................................... 1
CAPÍTULO I. LENGUAJES DE DESCRIPCIÓN DE HARDWARE..................................................4 1. Introducción histórica.....................................................................................................................4 2. Los HDL’s en la metodología de diseño. .......................................................................................6 3. Jerarquía de un diseño....................................................................................................................9 4. Niveles de abstracción de un HDL.................................................................................................9 5. HDL: Programa o diseño. ..............................................................................................................9 6. Lenguajes HDL ............................................................................................................................11 6.1 VHDL ........................................................................................................................................11 6.2 Verilog ........................................................................................................................................12 6.3 VHDL vs Verilog........................................................................................................................12 6.4 Nuevos lenguajes de alto nivel....................................................................................................12 7. Síntesis de Circuitos.....................................................................................................................12 CAPÍTULO II. ESTRUCTURA DE UN BLOQUE FUNCIONAL EN VHDL .................................14 1. Cuestiones previas........................................................................................................................14 2. Un primer ejemplo en VHDL.......................................................................................................14 3. Estructura de un diseño VHDL ....................................................................................................17 3.1 Código general de una entidad VHDL........................................................................................18 4. La sección ENTITY .....................................................................................................................18 5. La sección ARCHITECTURE .....................................................................................................20 5.1 Diseño jerárquico (estructural) en una arquitectura. ...................................................................20 5.2 Diseño de comportamiento en una arquitectura..........................................................................23 5.3 Diseño con primitivas. ................................................................................................................23 6. La sección CONFIGURATION...................................................................................................23 6.1 Estilo par entidad-arquitectura ....................................................................................................24 7. La sección LIBRARY ..................................................................................................................25 7.1 La necesidad de la librería std_logic_1164 ................................................................................25 7.2 Librerías aritméticas...................................................................................................................26 CAPÍTULO III. DESCRIPCIÓN DE LA FUNCIONALIDAD ...........................................................27 1. Concepto de concurrencia..................................................................................................................27 2. Estructura de un proceso ..............................................................................................................27 3. Bloques de sentencias ..................................................................................................................33 4. Asignaciones concurrentes...........................................................................................................34 5. La sentencia generate ...................................................................................................................36 CAPÍTULO IV. TIPOS DE DATOS Y SEÑALES ..............................................................................38 1. Definición de tipos de datos...............................................................................................................38 2. Tipo entero.........................................................................................................................................38 3. Tipo matriz ........................................................................................................................................39 3.2 Tipo vector..................................................................................................................................40 4. Definición de tipos compuestos.........................................................................................................41 5. Tipos simples.....................................................................................................................................42 4.1 Los atributos de las señales.........................................................................................................42 4.2 El atributo EVENT .....................................................................................................................43 6. La librería IEEE.................................................................................................................................44 6.1 Los tipos SIGNED y UNSIGNED..............................................................................................45 6.2 Las funciones de conversión .......................................................................................................46 CAPÍTULO V. SUBSISTEMAS DIGITALES. EJEMPLOS DE DISEÑO. .......................................47 1. Codificación de Sistemas Síncronos..................................................................................................47 Ejemplo 1. Codificación de un registro simple ................................................................................47 Ejemplo 2. Codificación de un registro con señal de carga .............................................................48 Ejemplo 3. Codificación de un contador síncrono ...........................................................................49
Ejemplo 4. Codificación de una máquina de estados finita tipo Moore...........................................50 Ejemplo 5. Codificación de una máquina de estados finita tipo Mealy ...........................................52 2. Codificación de sistemas aritméticos.................................................................................................54 Ejemplo 6. Operador aritmético con el signo tratado globalmente. .................................................54 Ejemplo 7. Operador aritmético con el signo tratado localmente. ...................................................55 3. Codificación de módulos de memoria. ..............................................................................................56 Ejemplo 8. Memoria RAM síncrona de tamaño genérico................................................................56 CAPÍTULO VI. VHDL NO SINTETIZABLE. SIMULACIÓN Y MODELADO..............................59 1. Mecanismo de simulación............................................................................................................59 2. Sentencias para modelado..................................................................................................................60 2.1 Lista de sensibilidad y WAIT ON...............................................................................................61 2.2 Concurrencia de procesos. ..........................................................................................................62 3. Construir un “Test Bench”.................................................................................................................62 4. La librería TextIO ..............................................................................................................................64
constituidos por una gran cantidad de transistores: son los llamados circuitos integrados de muy alta escala de integración. Los primeros circuitos integrados eran diseñados a partir del trazado directo de las máscaras sobre un editor de layout. en la actualidad el hombre dispone de tecnologías de integración capaces de producir circuitos integrados con millones de transistores a un coste no muy elevado. Se confiaba en la pericia del diseñador a la hora de elaborar los dibujos. Posteriormente introduciremos el concepto de jerarquía de un diseño y de nivel de abstracción. Moore ya vaticinaba un desarrollo de la tecnología planar en el que cada año la escala de integración se doblaría. y que la tendencia continuará durante los próximos 20. Introducción histórica La necesidad de construir circuitos digitales cada vez más complejos es patente día a día. al alcance de una PYME. el 100% de la electrónica de control y supervisión de los sistemas. LENGUAJES DE DESCRIPCIÓN DE HARDWARE
Este tema tiene por objeto dar una introducción general a los Lenguajes de Descripción de Hardware. tanto en aportar la información necesaria al piloto para determinar su rumbo como para asistirle en sus tareas de pilotaje y combate. Si bien construir estos circuitos parece una cuestión superada. y acerca de sus herramientas. ya que un fallo en la transferencia de información acarrearía un sinfín de problemas con los inversores. o VLSI. Las predicciones de Moore se han cumplido con gran exactitud durante los siguientes 30 años. Si en los años cincuenta y sesenta. El objetivo es aportar una visión de conjunto acerca del significado de en qué consiste diseñar grandes sistemas electrónicos digitales utilizando HDL. A mediados de los años sesenta Gordon E. diseñarlos supone un serio problema. 1. Tras una breve introducción histórica se procede a analizar el salto cualitativo de diseñar en esquemáticos a diseñar en HDL. Ya en el siglo XXI somos capaces de construir microprocesadores de muy altas prestaciones que están compuestos por millones de unidades funcionales (transistores) que realizan tareas de gran responsabilidad en la sociedad. y prácticamente no eran comprobados antes de fabricarse. Finalmente se describe el comportamiento de una herramienta de síntesis de circuitos mediante HDL. en los que el número de elementos constituyentes de los circuitos no pasaba de la centena. un sistema de control de transacciones económicas de una bolsa de valores ha de ser un sistema informático extraordinariamente rápido y robusto. la electrónica de control de un avión supersónico tiene igualmente una responsabilidad extrema. En el año 2012 Intel espera integrar 1000 millones de transistores funcionando a 10GHz. y de la misma manera aumentaría la capacidad de integrar funciones más complejas y la velocidad de procesamiento de esas funciones. Por ejemplo. elaboración de datos y transferencia de los mismos se realiza mediante circuitos integrados digitales. En la práctica. Con la aparición de los primeros ordenadores de entonces gran potencia. Otro ejemplo. en los albores de la electrónica integrada los circuitos eran esencialmente analógicos.CAPÍTULO I. llamados estaciones de trabajo (concepto que hoy en día no difiere sustancialmente del 4
como parte del flujo de CAE o secuencia de programas que se han de utilizar para construir nuestro circuito integrado. Se precisa una verificación. Estos editores tienen un nivel de desarrollo espectacular. • La presentación del esquema ha de ser limpia y permitir una lectura rápida. el tamaño de los circuitos digitales es una complicación que requiere una visión del problema muy diferente. La microelectrónica digital continúa por otro camino su desarrollo con herramientas específicas. lo que se ha dado en llamar la interrelación hombre-máquina. líder mundial en sistemas de CAE para microelectrónica. por un lado la electrónica digital supone una simplificación funcional de un comportamiento analógico. Nace así la ingeniería de computación o CAE en las que se delegan en herramientas software las tareas de manejo de grandes cantidades de información. con escaso número de elementos muy bien dimensionados para determinar fielmente su comportamiento. etc que ralentiza mucho el proceso de inserción del esquema. Si bien. verificar su funcionalidad antes de la fabricación. pero requiere para cada unidad un gran esfuerzo y tiempo. con circuitos analógicos. Son capaces de dar una visión muy precisa y completa del diseño rápidamente. A esto ha contribuido en gran manera el auge de los entornos gráficos de los sistemas operativos al estilo del conocido Windows. Tradicionalmente se han utilizado los editores de esquemas.de ordenador personal) se incorporaron complejos programas de resolución de ecuaciones diferenciales que permitían. • Como se puede observar la técnica de los esquemas es suficiente.. paleta de dibujo. ¿Que hacer ante este panorama? A principios de los años 90 Cadence Design Systems. que a finales de lo ochenta tenía ya unos predecesores de gran potencia y prestaciones. • La edición se hace con una interacción ratón.. Para una determinada función: • La función ha de presentarse sin errores en ninguna conexión y función lógica. • Se construye a partir de unos elementos funcionales contenidos en una librería que proporciona un fabricante y por tanto ligada al mismo. un lenguaje alfanumérico para describir los circuitos de forma sencilla y precisa: es el primer lenguaje de descripción de hardware en sentido amplio como veremos en epígrafes posteriores. Editar un esquema requiere un esfuerzo de desarrollo muy alto. • Las señales han de tener asociadas un nombre significativo que permita su posterior identificación. Otros fabricantes de hardware habían propuesto un lenguaje más centrado en la resolución de un problema concreto: generación de una función para un dispositivo programable. Una vez comentada la incidencia de la tecnología nos centramos en la especificación de la funcionalidad en si. Estos editores son un magnífico mecanismo de proyección de un diagrama de símbolos (tradicionalmente es el lenguaje utilizado por la electrónica) para expresar la funcionalidad deseada. que resuelven el problema de la construcción del circuito y la verificación del mismo. como son los simuladores digitales o los generadores automáticos de layout. por simple que sea el módulo. de su geometría y de su conexiones así como de su comportamiento eléctrico. propone el Verilog. y aún funciona. de forma óptima contienen la información acerca de la funcionalidad del circuito. alimentados con un modelo matemático del circuito. Sin embargo la complejidad de los circuitos digitales aumentaba y las prestaciones de los editores de esquemas no eran suficientes para responder a una capacidad de diseño tan elevada. Este esquema funcionaba con circuitos digitales. bases de datos que. resolución del 5
DESCOMPOSICIÓN ARRIBA-ABAJO DEL DISEÑO INTRODUCCIÓN DEL DISEÑO MEDIANTE ESQUEMAS. Nacen los conceptos de descripción de alto nivel y de síntesis lógica. Hardware Description Language). Por el momento nos referiremos a los HDL’s como lenguajes alfanuméricos comprensibles para describir circuitos electrónicos en sentido amplio. tecnología y conexionado • Permitiera describir y verificar los circuitos a todos los niveles: funcional. El lenguaje resultante es el VHDL. En el año 1982 el Departamento de Defensa de los Estados Unidos promueve un proyecto para desarrollar un lenguaje de descripción (conocido como MIL-STD-454L) de hardware que: • Describiera los circuitos digitales de forma amplia: Funcionalidad. que posteriormente formalizaremos. REALIZACIÓN ABAJO-ARRIBA BASE DE DATOS DEL DISEÑO SIMULACIÓN FUNCIONAL Y VERIFICACIÓN BASE DE DATOS CON LAS PRIMITIVAS DEL FABRICANTE ¿CONFORME ESPECIFICACIONES? SI
2.circuito de una máquina de estados finitos a partir de su descripción de la evolución de los estados. ..
DISEÑO NIVEL FÍSICO
¿CONFORME ESPECIFICACIONES?
Figura 1. en 1987) en la norma IEEE-1076.1. • Describiera la tecnología misma. Los HDL’s en la metodología de diseño. el VHDL se impone como lenguaje estándar de diseño. Metodología clásica. Aunque en este sentido el Verilog cumple las propuestas anteriormente anunciadas.. arquitectural y tecnológico (posteriormente matizaremos estas tres categorías). que responde a las siglas VHSIC HDL (Very High Speed Integrated Circuits. 2. y es ratificado por el Instituto para la Ingeniería Eléctrica y Electrónica (IEEE. En primer lugar veremos cuál ha sido la aportación de los HDL’s en la metodología clásica de diseño. Posteriormente veremos diferencias generales entre uno y otro. etc. para poder diseñar circuitos que sean independientes de la propia tecnología o bien durante la puesta a punto del proceso de fabricación. La secuencia de herramientas informáticas que procesan un diseño desde su descripción en un lenguaje fácilmente comprensible por el hombre hasta la información final. La figura representa un flujo típico en el que se han introducido las derivaciones debidas a las comprobaciones necesarias para verificar la correcta introducción del diseño. • Describiera modelos del entorno en el que se va a insertar el circuito de forma que hubiese unas posibilidades de verificación más amplias del propio circuito. útil para la fabricación del dispositivo se llama flujo de diseño. Flujo de diseño con herramientas CAD 6
Esta es la fase de la metodología Abajo-Arriba (Bottom-Up). se procede a la introducción del diseño.. dimensiones y esfuerzos para cada elemento del mismo. usualmente realizado sin la ayuda de ninguna herramienta informática. RESTRICCIONES
Figura 2. El ingeniero ha de estudiar a partir de las especificaciones más generales: ubicación. cuarto. aspectos económicos y medioambientales. Este proceso continúa hasta alcanzar funciones basadas en los elementos de menor entidad. 2.Una vez que se decide la funcionalidad del circuito que queremos integrar el procedimiento a seguir suele ser una descomposición jerárquica de las funciones. Este es el concepto denominado reusabilidad de una función. Suelen ser diagramas de bloques y las señales que los conectan estableciendo las relaciones entre ellos. Cada pilar es descrito y dimensionado a partir de las unidades de los materiales elegidos. Obviamente intentará que en la medida de lo posible los planos de cada pilar se repitan y reutilizar los cálculos de esta unidad jerárquica.
DESCOMPOSICIÓN ARRIBA-ABAJO DEL DISEÑO
Ilustraremos lo expuesto mediante un ejemplo sencillo: Imaginemos el proceso de diseño y construcción de un puente. Estos primeros bloques se incorporan a la librería de elementos que constituirán nuestro diseño.2. y en función de los cálculos de la estructura. ALFANUMÉRICO (HDL). que es nuestro diseño y las interconexiones con el sistema exterior. hasta llegar al nivel más elevado. formas posibles y materiales. tercero. procede a realizar los planos. Terminada la etapa de decisiones. Metodología basada en HDL’s
INTRODUCCIÓN DEL DISEÑO MEDIANTE LENG. REALIZACIÓN ABAJO-ARRIBA
BASE DE DATOS DE MÓDULOS DE DISEÑO SIMULACIÓN ALTO NIVEL Y VERIFICACIÓN
BASE DE DATOS CON LAS PRIMITIVAS DEL FABRICANTE
SINTESIS LÓGICA
CONDICIONES DE DISEÑO. Seguidamente construimos y verificamos el segundo nivel. La descripción general de todos los elementos del puente y su ubicación geográfica es el elemento de mayor rango en la jerarquía. Cada unidad de material será una primitiva. Cada unidad funcional es incorporada a la librería de diseño de forma que varias funciones podrían hacer uso de una misma función de inferior rango jerárquico. hasta decidir la mejor de las soluciones posibles.. Si utilizamos librerías de elementos básicos proporcionadas por los fabricantes (también llamados primitivas) construimos los primeros elementos de la jerarquía a partir de estas primitivas creando y verificando estas funciones del primer estadio jerárquico. A su vez estos bloques son descompuestos en otros más simples. de menor rango en la jerarquía. . A este proceso se le denomina descomposición ArribaAbajo (Up-Bottom). Flujo de diseño mediante HDL's
. Una vez realizados los cálculos de estructuras.
.La introducción de los HDL’s como métodos de descripción de circuitos han enriquecido el proceso de creación de un diseño. La penalización ha sido la pérdida de cierto control en la generación del circuito. Mediante lenguajes de alto nivel la sentencia a*b representa todo el circuito multiplicador correctamente generado automáticamente por un programa. Sin embargo también se podría realizar manualmente una primera aproximación al puente final y dejar la responsabilidad al programa informático de hacer los cálculos más pesados y concretos. sería una primera “ayuda” al programa allí donde el razonamiento humano es más potente: en la creación.
. Se utiliza para alimentar el flujo de síntesis física. La figura 2 muestra la modificación del flujo clásico cuando se utiliza esta técnica para la introducción del diseño. ya que en la nueva metodología hay una fase de síntesis automática en la que se cede a una herramienta software la responsabilidad de la resolución del circuito final. y la tecnología disponible del fabricante. encontraría la solución final que cumpliera todas las premisas. normativas. dimensiones. resistencia del terreno. y que cumple otras premisas más propias del razonamiento humano. las condiciones de contorno en que funcionará. Es independiente de la tecnología. aunque seguramente no será la más económica. Esta netlist se podría representar en un plano esquemático. Solamente cuando se obtiene una imagen física del diseño puede predecirse con cierta certeza si cumple o no cumple las especificaciones. lo han acelerado y asegurado. abaratando los costes de desarrollo.. etc. La solución final sería más cercana a la óptima. No solo se puede compartir entre diseños sino que puede ser compartido por diferentes procesos de fabricación. El código introducido es de Alto Nivel y la simulación para su comprobación es asimismo de Alto Nivel. En el ejemplo del puente sería como el pedir a un programa informático que realizara el propio puente proporcionándole los datos de situación geográfica. esfuerzos que tendría que soportar. y generaría los planos de un puente exento de estética. geológica. sin la necesidad de verificar su correcta implementación. Nos acercamos a la situación ideal de la obtención totalmente automática del circuito a partir de las especificaciones. lo que se conoce como una netlist. El programa de síntesis ha de alimentarse con el diseño. El resultado será un código HDL de Bajo Nivel o lo que es lo mismo una representación del circuito alfanumérica compuesta por primitivas y sus conexiones. por ejemplo de los pilares y la cubierta a sustentar. pero no encontraríamos una ordenación racional y comprensible entre las primitivas y sus conexiones. materiales. por lo que la reusabilidad de los módulos constituyentes es total. La herramienta buscaría entre las múltiples y posibles soluciones. Por ejemplo un multiplicador editado en un esquema a base de puertas lógicas elementales (primitivas) había de ser verificado ante prácticamente todas las posibles combinaciones de las entradas. En la práctica esta aproximación es la más utilizada en la que el diseñador ha cedido la responsabilidad de diseño de módulos regulares. . Existen varias mejoras sustanciales: La librería de diseño es independiente de la tecnología para la que se diseña.
. y por tanto.) 2. Jerarquía de un diseño. Análisis sintáctico para detección de errores e inconsistencias del programa. Niveles de abstracción de un HDL Como se ha comentado un HDL puede expresar un mismo diseño bajo diversos puntos de vista. Veamos de una forma somera las tareas que se han de realizar para elaborar un programa informático: 1. C++.. PASCAL.. Estos comandos y funciones están expresados en un lenguaje alfanumérico que es fácilmente comprensible por el hombre. Existen típicamente dos soluciones: la arquitectura Harvard y la arquitectura Von Newman. 4. Generación de un código basado en el lenguaje elegido (C. nos referiremos a él siempre como “diseño”. Elaboración de los códigos objeto reubicables o imagen binaria de los módulos componentes. Un diseño de gran dimensión. Posteriormente veremos que podemos definir niveles intermedios o mixtos compuestos por mezclas de ambos. En particular una subrutina puede ser accedida mediante un mecanismo de saltos tantas veces como se precise. 3. sino que son módulos de rango jerárquico inferior. que se suceden con una descripción cada vez más detallada de sus funciones. El más bajo es un modelo íntimamente relacionado con la tecnología compuesto por primitivas y conexiones. El más elevado es una descripción en la que se define el comportamiento del circuito. típico de un circuito microelectrónico digital requiere una buena organización del diseño. HDL: Programa o diseño. una descomposición razonada en módulos de inferior rango. También llamaremos nivel estructural al que expresa una interrelación entre bloques funcionales del mismo nivel jerárquico. es el llamado nivel estructural (structural). El lector habrá notado que hemos procurado eludir la palabra “programa” a la hora de referirnos a la elaboración de un código HDL. resultando un ahorro en términos de memoria de programa. Durante la ejecución del programa se ejecutan una tras otra las instrucciones siguiendo un esquema secuencial definido por la arquitectura de la CPU. La traducción de uno a otro la realiza un programa compilador. en el que las unidades de un nivel estructural no son primitivas.3.
. son los llamados niveles de abstracción. que realizan unas tareas definidas por el diseñador en una computadora. Montaje del programa por parte del montador de enlaces y detección de errores en la relación entre los módulos. representando la estructura del circuito. los llamados bloques funcionales. es el llamado nivel comportamental (behavioral). accesos a memoria y saltos en la secuencia de ejecución. En realidad se sigue la conocida táctica de divide y vencerás. Fortran. que es la llamada máquina de Turing. En este momento del desarrollo del tema es fácil comprender la idea de descomposición jerárquica de un diseño. En ambos casos la estructura del programa es una secuencia de instrucciones. pero que tiene una proyección directa sobre el lenguaje comprensible por la computadora. Como programa conocemos a una secuencia ordenada de comandos y funciones. fiel a su arquitectura. 5. 4.
.. int aux. Esto tiene un conjunto de implicaciones que han de tenerse en cuenta a la hora de elaborar el diseño que particularizaremos al caso del VHDL. En un diseño HDL. en esencia algo poco recomendable. estando habituado a realizar programas software. Otro caso muy corriente es la utilización de módulos aritméticos. por tanto. ya que una variable así es una posición de memoria que puede accederse cuantas veces sea preciso y si se reutiliza el programa resultante es más compacto. aux=a+b.. lo que más adelante llamaremos diseño rtl (register transfer level)...
. En HDL el resultado sería un circuito con múltiples operadores que ocuparían gran cantidad de área de silicio. implicaría una compartición del mismo registro por varios módulos . .. Este uso es muy poco aconsejable si estamos diseñando circuitos. Cuando se declara la misma operación varias veces en software se utilizan el sumador y el multiplicador de la CPU exhaustivamente. realizan aquello para lo que están diseñados. con diferentes accesos y salidas. . Posteriormente es posible reutilizar de nuevo la misma variable en otro punto del programa. Otra situación muy típica es la evaluación secuencial de asignaciones: a=a * b.. como nivel de abstracción adecuado para diseñar. La primera implicación es la relación entre el lenguaje y la plataforma de desarrollo.. aux=a*b.. “ayudar” al programa de síntesis a elaborar el diseño definiendo una estructura que defina el circuito a nivel modular. Un caso típico es utilizar variables auxiliares para almacenar temporalmente un valor. Es importante..). Representan un comportamiento inherentemente paralelo. El mencionado ahorro en este caso exige une cuidadosa planificación del diseño previa a su elaboración. //reutilización de la variable . ya que una variable de este estilo sería un registro. Sin embargo en un software es útil. Por tanto simulación y síntesis han de estar provistas de mecanismos o artificios que emulen el paralelismo y que inciden directamente en la formulación del código. ... describir un hardware: Describen un comportamiento propio de un circuito en sentido amplio y por tanto no existen precedencia entre la activación de una parte del mismo u otra. j=función2(aux. una suma o un producto implica necesariamente la síntesis de un circuito digital suma o producto. sin más. La segunda implicación es en un cambio de mentalidad en el diseñador a la hora de elaborar la descripción del diseño. ... que es una computadora y tiene el comportamiento descrito en el párrafo anterior.. HDL’s. c=función1(aux.). Existen usos típicos del programador de software que están absolutamente prohibidos en la formulación de un diseño hardware.Los lenguajes de descripción de hardware..
• AHDL: Lenguaje promovido por ALTERA para facilitar la introducción de diseños en sus FPGA’s.1 VHDL El VHDL fue desarrollado por la Departamento de Defensa de los Estados Unidos para modelar y simular sistemas. 6.
. en VHDL se puede escribir el comando: wait for 47ns. como máquinas de estados finitos. la de describir un hardware para implementación de un circuito (síntesis del circuito) y modelado del circuito (simulación del circuito). • EDIF. Elaboración de una descripción en bajo nivel del circuito. para posteriormente transferir el valor a la posición de a. ¿existe un circuito capaz de hacer la operación de espera de 47ns exactos? Obviamente no. Análisis sintáctico para detección de errores en la generación del código. una realimentación combinacional.. Esto es algo impensable en hardware ya que se trata de describir un multiplicador cuya salida es la entrada. pero se utilizan cómo medios para transferir netlist entre herramientas. Queda. Sin embargo puede servir para expresar el retardo de una señal o un módulo en simulación. HDL para síntesis y HDL para modelado y simulación. Generación del código en un lenguaje paralelo. Por ejemplo. Por tanto existen funciones que no identifican bien un circuito. Los más conocidos son: • ABEL: Lenguaje promovido por XILINX para la introducción de módulos de carácter específico. 3. de la tecnología y del sistema. lo que se conoce como modelo de referencia de una estructura HDL. 4. Lenguajes HDL Existen un buen número de lenguajes HDL’s la mayoría de ellos con un propósito limitado. El Instituto para la Ingeniería Eléctrica y Electrónica (IEEE) ha formulado una norma que regula el VHDL: la norma IEEE 1076-1987.. Distinguiremos pues. generación automática del diseño final con las restricciones definidas por el usuario. teniendo en cuenta las condiciones de contorno del diseño.: No son lenguajes propiamente dichos. 6. XNF. El primero es un subconjunto del segundo. Optimización del circuito. . 5. Elaboración del módulo.. 6. se genera un circuito basado en primitivas. Verilog. A partir del modelo de referencia. pues. en el sentido de no ser fácilmente comprensibles por el usuario. una netlist en un formato estándar para la síntesis física. 2.). comprensible por el usuario (VHDL. Emula el paralelismo mediante eventos y utiliza como modelo de formulación el ADA. . En los lenguajes HDL’s se da la doble implicación. ABEL. identificación y asignación de una imagen hardware del mismo (existen comandos y funciones de los HDL’s que no son traducibles a hardware. y que se utilizan para la simulación).. es decir. comentar el proceso que realiza un programa de síntesis a la hora de elaborar el circuito a partir de nuestra descripción del hardware: 1. es decir.El procesador evalúa a * b y almacena el resultado en un registro propio.
a veces poco ágil. 2. El resultado es un lenguaje más rígido y con una sistematización en el código que lo hace más legible. 6. secuencial. En este sentido se coincide que el conocedor de Verilog le cuesta aprender VHDL. y que conceptualmente es más didáctico el VHDL. Los más conocidos son Handel-C de Celóxica y SystemC. algorítmica y de comportamiento. Síntesis lógica.6. 7. La comunidad científica ha llegado a la conclusión de que no existe una razón de peso para claramente decantarse por uno o por otro. Ante la duda de cuál de ellos enseñar en este curso la respuesta está en la propia comunidad científica: lo ideal es conocer ambos. Estos lenguajes tienen como objeto facilitar la traslación de los lenguajes de diseño y pruebas de estudio a la descripción hardware. de la misma manera emula el paralelismo mediante eventos. uno de los mayores contribuidores al CAD/CAE para circuitos VLSI definía síntesis como “generar el circuito desde una descripción algorítmica.2 Verilog Es un lenguaje HDL propiedad de CADENCE Design Systems. 3. es decir con mayor amplitud de miras. y otras futuras. mas aceptado. Sangiovanni-Vincetelli.3 VHDL vs Verilog Llevamos casi un década debatiendo cuál de los dos lenguajes es el más apropiado para diseñar. sin embargo el proceso contrario es en general. VHDL nace como un lenguaje que resuelve las necesidades actuales de diseño. La naturaleza del problema estriba en que no existe una única formulación para una misma función lógica. Síntesis modular o particionamiento razonado: es el análisis a nivel de diseño. Síntesis física. En particular existen dos casos especialmente interesantes: aquel en que el área ocupada por la función es mínima y aquel en que el número de etapas o niveles de la función es mínimo. Por un lado. es decir. de la tarjeta PCB. 6.. una misma función puede adoptar muchas expresiones. Esta labor se la hemos dejado al diseñador.4 Nuevos lenguajes de alto nivel A partir de los años 2000 han nacido nuevos lenguajes de alto nivel cuya sintaxis y método de codificación son idénticos a los lenguajes informáticos más usuales en ingeniería como el C ó C++. fabricante de software para diseño de circuitos integrados. Es decir. Por otro. Verilog nace ante la necesidad de mejorar un flujo de diseño y por tanto es un lenguaje que cubre todas las necesidades de diseño y simulación. combinacional. ya que
.. El resultado ha de obtenerse en un tiempo razonable de computación y con la calidad similar o mejor a la que el razonamiento humano podría obtener”. El resultado es un lenguaje simple y flexible que es fácil de aprender aunque tiene ciertas limitaciones. La síntesis completa de un circuito requiere tres niveles: 1. Síntesis de Circuitos. una descripción de la tecnología y una descripción de las condiciones de diseño en una función de costes. funcional o de comportamiento del circuito. de la programación de la FPGA.. y su implementación y comportamiento físico es diferente en cada caso. El tema que nos ocupa se centra fundamentalmente en el punto segundo. Hemos mencionado repetidamente la palabra síntesis como un proceso fundamental en la generación del circuito. generación automática del layout. aunque las reglas de diseño obligan a proceder de forma. En el año 1987 A. El programador de VHDL aprende Verilog en poco tiempo La experiencia de los autores de estos capítulos es precisamente esa.
. • Síntesis de módulos aritméticos. • Leonardo de MENTOR GRAPHIC’s. Memorias. De ahí que en el punto 5 de este capítulo descrito la necesidad de obtener un modelo de referencia como paso previo a la síntesis del circuito. Comercialmente existen varios programas de síntesis en el mercado que merecen mencionarse: • SYNOPSYS. aplicados a cada estructura digital.
. Optimización de funciones combinacionales. Registros.. solución que está definida por las condiciones de diseño. La realidad es que se han desarrollado algoritmos específicos para cada estructura y por tanto estrategias diferentes para cada módulo a implementar por tanto en el proceso de síntesis lógica ha de haber una etapa previa de identificación del módulo en cuestión. de Synopsys para PC y centrado en FPGA’s. multilenguaje en plataforma PC • FPGA-EXPRESS. programa de carácter general que permite realizar síntesis ante multitud de lenguajes y tecnologías. Funciona sobre plataforma UNIX. sucedido de una optimización combinacional global. • Síntesis de circuitos secuenciales: FSM’s. de CADENCE para VHDL • VerilogXL. En adelante síntesis será un sinónimo de síntesis lógica. Durante los años 80 y 90 las investigaciones en materia de síntesis se han centrado en desarrollar algoritmos que resuelven de una manera eficiente y óptima diferentes estructuras típicas de los circuitos digitales. de CADENCE para Verilog. Podemos identificar: • Síntesis a dos niveles y síntesis multinivel. en cada caso ha de evaluarse la formulación más adecuada o bien una situación intermedia. Debido a que son dos factores normalmente contrapuestos. • Leapfrog.. Contadores. Generación de estructuras regulares que permitan generar circuitos digitales aritméticos de cualquier dimensión. Un programa de síntesis es una recopilación de programas específicos de optimización.hay una relación directa entre el número de etapas y el retardo en la propagación de las señales.
llamado selector. por defecto se suele llamar WORK. por tanto la señal PEPE es igual a la señal PePe y a su vez a la señal pepe. de pocas funciones y tipos de variables. Los comentarios son solamente de línea y van marcados por dos signos menos: --Esto es un comentario en VHDL El lenguaje VHDL está dotado de muy pocos recursos inicialmente. Estos elementos serán debidamente formalizados en secciones posteriores. es decir.CAPÍTULO II. La importancia de este comentario radica en que el nivel de descripción más bajo que podemos alcanzar en VHDL es el nivel de puerta lógica. Esta librería de modelos. En particular escribiremos el código que describe un multiplexor 4 a 1. Existen varias cuestiones previas que hay comentar antes de iniciar la exposición formal del lenguaje. el VHDL es un lenguaje en el que se define el sentido del flujo de las señales. y no de transistor. Por ejemplo. Para darle mayor versatilidad es preciso utilizar librerías estándar que le dotan de mucha mayor potencia para representar comportamientos digitales. para representar un switch en VHDL se ha de incluir una subrutina de cerca de 750 líneas de código. La salida es la señal salida. que físicamente es un subdirectorio en el directorio de diseño. Ampliaremos esta idea en el apartado referido a librerías. que corresponde a una arquitectura de tipo comportamental (behavioural)
. inefienciente a todas luces. Un primer ejemplo en VHDL En esta sección vamos a exponer un ejemplo de las diferentes posibilidades del lenguaje VHDL. En Verilog esto esta bien resuelto por comando switch. una señal es de entrada y/o salida definida en el código. En segundo lugar. no por la evolución de la señal en si misma. El mecanismo para realizar la síntesis de un diseño descrito en VHDL se realiza. ESTRUCTURA FUNCIONAL EN VHDL
1. de tal manera que se pongan de manifiesto los diferentes elementos fundamentales del lenguaje. El multiplexor tiene un bus de entradas de 4 bits llamado datos y un bus de selección de dos bits. Cuestiones previas Una vez introducida la necesidad de diseñar utilizando lenguajes HDL y todo lo que ello significa nos decantamos por presentar el VHDL como lenguaje de diseño. de modo estándar utilizando una librería de compilación donde se ubican los modelos de referencia. 2. Dejaremos a capítulos posteriores la formalización de esta idea. En primer lugar haremos la descripción basada en la función lógica del multiplexor. Además estamos interesados en dar la misma descripción desde diferentes puntos de vista. Primeramente. el VHDL no es sensible a mayúsculas y minúsculas.
En particular utilizaremos la sentencia WHEN condición ELSE. La fase
. pero basada en la resolución de la lógica asociada a nuestro multiplexor. selector: IN std_logic_vector(1 downto 0). USE IEEE.
Esta es una descripción de comportamiento. USE IEEE. En particular. END mux41.
En esta formulación se utiliza un procedimiento más complejo de asignación y no es inmediata su implementación en un circuito. salida: OUT std_logic ). Una segunda versión del multiplexor puede realizarse empleando sentencias de más alto nivel. El programa de síntesis realmente lo que hace es revisar las funciones y generar un circuito equivalente eliminando redundancias si las hubiere. Std_logic_1164. para la satisfacción de la asignación de datos(3) debe cumplirse la no asignación de las condiciones anteriores.LIBRARY IEEE. ENTITY mux41 IS PORT( datos: IN std_logic_vector(3 downto 0). salida: OUT std_logic ). consumo mínimo ó mínimo retardo. ARCHITECTURE comport2 OF mux41 IS BEGIN Salida <= datos(0) WHEN (selector(0)=’0’ AND selector(1)=’0’) ELSE datos(1) WHEN (selector(0)=’1’ AND selector(1)=’0’) ELSE datos(2) WHEN (selector(0)=’0’ AND selector(1)=’1’) ELSE datos(3). dicho de otra manera. dependiendo de las restricciones impuestas al proceso de optimización lógica. el código expresa una precedencia de datos(0) frente a los demás. selector: IN std_logic_vector(1 downto 0).all. END mux41. END comport1. o buscando la morfología de área mínima. ENTITY mux41 IS PORT( datos: IN std_logic_vector(3 downto 0). ARCHITECTURE comport1 OF mux41 IS BEGIN Salida <= (((datos(0) AND (NOT selector(0))) OR (datos(1) AND selector(0)) AND (NOT selector(1))) OR (((datos(2) AND (NOT selector(0))) OR (datos(3) AND selector(0)) AND selector(1)). Std_logic_1164. que expresa una asignación bajo el cumplimiento de una condición y su alternativa:
LIBRARY IEEE. END comport2. en buena lógica los datos(0) tiene un menor tiempo de propagación que el resto a través del circuito. en la que se describe su comportamiento mediante recursos del lenguaje más cecanos al pensamiento humano.all. Cuando se formula directamente el circuito que lo representa.
Esta situación típica cuando los multiplexores son de gran tamaño.
LIBRARY IEEE. salida: OUT std_logic ). END mux41.de optimización posterior ecualiza los retardo al eliminar las redundancias que hay implícitas. ENTITY mux41 IS PORT( datos: IN std_logic_vector(3 downto 0).all. basada en puertas triestado. END comport3. Una versión alternativa sería:
LIBRARY IEEE. USE IEEE. En este caso obviamos su arquitectura. ya que la estructura es más parecida a la versión final. El esfuerzo de optimización se centra en el decodificador del multiplexor. Salida <= datos(1) WHEN (selector(0)=’1’ AND selector(1)=’0’) ELSE ‘Z’. USE IEEE.
Es este caso en la fase de optimización se realizaría menos esfuerzo. ARCHITECTURE compor3 OF mux41 IS BEGIN Salida <= (datos(0) WHEN selector(0)=’0’ ELSE datos(1)) WHEN selector(1)=’0’ ELSE (datos(2) WHEN selector(0)=’1’ ELSE datos(3)). Finalmente haremos una versión estructural del multiplexor. Salida <= datos(3) WHEN (selector(0)=’0’ AND selector(1)=’1’) ELSE ‘Z’. Std_logic_1164. END mux41. ARCHITECTURE compor4 OF mux41 IS BEGIN Salida <= datos(0) WHEN (selector(0)=’0’ AND selector(1)=’0’) ELSE ‘Z’. selector: IN std_logic_vector(1 downto 0). Para ello supondremos que ya existe una descripción de un multiplexor más simple 2 a 1. Salida <= datos(2) WHEN (selector(0)=’0’ AND selector(1)=’1’) ELSE ‘Z’. END comport4.all. Std_logic_1164. descrito bajo la entidad mux21.
. ENTITY mux41 IS PORT( datos: IN std_logic_vector(3 downto 0). selector: IN std_logic_vector(1 downto 0). ya que se vierte sobre el conexionado la función OR del multiplexor. salida: OUT std_logic ). ya que solamente estamos interesados en su descripción como entidad. Un ejemplo para controlar la estructura del multiplexor es el siguiente:
En este caso el circuito se realiza con una estructura muy distinta de las anteriores.
llamadas salida_parcial.
En ésta versión haremos tres instancias del mux21. Como se puede comprobar. mx3: mux21 PORT MAP(datos => salida_parcial . BEGIN mx1: mux21 PORT MAP(datos =>datos(1 downto 0) .
.all. aunque en este caso somos nosotros los que hemos definido la estructura. junto con los elementos de inferior nivel jerárquico. SIGNAL salida_parcial: std_logic_vector(1 downto 0). con entradas.selector=>selector(0). Además se precisa la utilización de señales auxiliares internas. salida: OUT std_logic ). de tal manera que cada elemento. salidas y funciones. END COMPONENT. END estruct.salida=>salida_parcial(0)).all. Estructura de un diseño VHDL Una de las grandes aportaciones de los lenguajes HDL. Std_logic_1164. END mux21. 3.salida=> salida_parcial(1)). es la posibilidad de organizar jerárquicamente los diseños. USE IEEE. es en sí mismo un diseño autocontenido. ENTITY mux41 IS PORT( datos: IN std_logic_vector(3 downto 0).salida=>salida ). salida: OUT std_logic ). En consecuencia cada unidad en la jerarquía tiene entidad como circuito. Std_logic_1164. es la utilización de una decripción puramente conectiva. selector=>selector(0). selector: IN std_logic. selector: IN std_logic_vector(1 downto 0). selector=> selector(1) . ENTITY mux21 IS PORT( datos: IN std_logic_vector(1 downto 0). mx2: mux21 PORT MAP(datos =>datos(3 downto 2) .USE IEEE. selector: IN std_logic. salida: OUT std_logic ). ARCHITECTURE estruct OF mux41 IS COMPONENT mux21 PORT( datos: IN std_logic_vector(1 downto 0). como se expuso en el capítulo 1. END mux41.
Esta es la situación que eventualmente se obtendría tras un proceso de optimización en el caso de que mux21 fuera un componente primitiva.
. La entidad tiene asociado un nombre identificador usualmente relativo a la función que realiza. --Cuerpo de la entidad ARCHITECTURE nombre_architecture OF nombre_entity IS --Declaración de sub-entidades (componentes) y señales internas BEGIN --Descripción de la funcionalidad END nombre_architecture. PORT(.all. USE paquete_funciones_librería....1 Código general de una entidad VHDL El código de una entidad se presenta en el siguiente esquema:
--Zona de declaración de librerías LIBRARY nombre_librería. Asimismo está definida por señales de enlace con el exterior y una arquitectura funcional.. No pueden existir dos entidades del mismo nombre en la jerarquía definidas de forma diferente.). END nombre_entity.... --Cabecera de la entidad ENTITY nombre_entity IS GENERIC(... --Enlace con las arquitecturas de otras entidades CONFIGURATION nombre_configuracion OF nombre_entidad IS FOR nombre_arquitectura --Cuerpo de la configuración END nombre_configuracion.)...... Veamos un ejemplo concreto:
ENTITY contador IS GENERIC(N:integer:=10).. Asimismo dispone de un mecanismo para poder acceder de forma automática a las diferentes arquitecturas de una misma entidad desde una entidad de orden jerárquico superior... La sección ENTITY Identifica la unidad jerárquica de forma unívoca.
El desarrollo de este tema consiste en explicar cada uno de los elementos expuestos en el esquema anterior. Junto con la palabra ENTITY hay asociados dos campos: • GENERIC: utilizado para pasar parámetros a la entity • PORT: utilizado para definir las señales que relacionan la entity con el resto del diseño... ENABLE: in BIT.
. RST: in BIT..La unidad jerárquica en cuestión es designada por la palabra reservada entity o entidad. PORT( CLK: in BIT... 4. Cada vez que hagamos uso de este circuito utilizaremos el nombre asociado. Es el mecanismo de la configuración o configuration 3.. COUNT: out BIT_VECTOR(N-1 DOWNTO 0). El VHDL ha previsto la posibilidad de modelar diferentes arquitecturas para una misma entidad de ahí que haya que asignar nombres tanto a la entidad como a la arquitectura.
Una señal IN recibe sus valores desde el exterior de la entidad. Pueden definirse tantos parámetros como se desee. No puede haber otra señal dentro de la arquitectura con el nombre de la señal.SATUR: out BIT ). es decir. sin embargo. --Correcto Una señal OUT genera valores al exterior de la entidad. no puede ser reasignada en el interior de la entidad. El motivo es doble.
El nombre de la señal identifica unívocamente la señal en cuestión. Cada vez que se utiliza la entidad como parte del diseño se han de determinar los parámetros que definitivamente definen el diseño. un contador de tamaño N no tiene sentido como circuito. El campo “dirección” de la señal indica el sentido del flujo de la misma.
. END contador. al dar un valor sí queda bien definido y a la hora de generar su correspondiente modelo hardware de referencia es posible generar la arquitectura. No puede ser asignada a ninguna otra señal en la arquitectura: A<=Señal_out.
El código representa una descripción de las entradas y salidas de un contador de tamaño 10. Por un lado el valor por defecto se utilizará en caso de no redefinición del parámetro. BUFFER tipo extendido de salida. --Correcto Una señal INOUT puede ser asignada en ambos sentidos y es responsabilidad del diseñador determinar en que condiciones de la función lógica descrita la señal puede ser IN o OUT. --Error A<=Señal_in. el valor 10 al tamaño del contador. Por tanto. Este campo puede tomar los siguientes valores: IN para indicar que la señal es una entrada OUT para indicar que la señal es una salida INOUT para indicar que la señal es una entrada o salida dependiendo de cada instante. La gran ventaja es que es posible redefinir el parámetro N tantas veces como queramos y extender el contador a la longitud que convenga en cada momento sin modificar el código. De los tipos posibles de parámetros hablaremos en el capítulo siguiente.
La cláusula PORT indica las señales que interrelacionan la entity con el resto del diseño. LINKAGE es un tipo restringido de salida que está en desuso. La sintaxis es:
Nombre_señal : dirección tipo_de_señal. La sintaxis seguida es:
Nombre_parámetro : tipo_parámetro := valor_por_defecto. Sin embargo hemos dado un valor por defecto. --Error Señal_out<=A. pero la más importante es que este parámetro tiene la misión de dar coherencia al modelo del circuito. es decir no puede aparecer a la izquierda de una asignación en la arquitectura: Señal_in<=A.
Consta de dos partes: La parte declarativa. ..
Todas las señales especificadas pertenecen al mismo tipo. De las órdenes comandos y funciones que se pueden incluir en una arquitectura hablaremos más adelante. Una señal BUFFER es señal de salida asignable a otra señal en la arquitectura.. nombre2.
. que es describir de la forma más explícita y precisa posible un circuito. Asimismo. seguida de uno o varios nombres y de un tipo según la sintaxis:
SIGNAL nombre1. cuestión que se abordará en el capítulo correspondiente. Luego se especifican las señales mediante la palabra signal. donde se especifican los elementos de tipo estructural que van a componer la arquitectura. es decir: • Señales internas. pero no puede ser forzada desde el exterior. 5. Son enlaces entre los diferentes elementos que definen la arquitectura. : Tipo de señal:= valor inicial. y opcionalmente se puede asignar un valor inicial de la señal. llamadas componentes o component. Como se puede apreciar este es el mismo esquema empleado en la declaración de las señales de enlace de la entidad.1 Diseño jerárquico (estructural) en una arquitectura. dicho de otra manera. Se utilizan fundamentalmente para describir señales que realimentan dentro de la entidad y simultáneamente salen al exterior. Un caso típico es un registro síncrono. 5. • Entidades de orden inferior en la jerarquía. no es en ningún momento una entrada. Por ahora profundizaremos en la cuestión de la jerarquía de un diseño y cómo se especifica en una arquitectura. Este valor suele utilizarse en simulación y es omitido por los sintetizadores.El lector podría pensar que para evitar errores lo más sencillo sería describir todas las señales como INOUT. No entraremos en detalles acerca de los tipos de datos. Hacemos referencia a otras entidades. En primer lugar especificamos en la parte declarativa que componentes (component) se utilizarán en la arquitectura. La parte descriptiva. con la salvedad de omitir la direccionalidad de la señal. De la otra manera un mal estilo de diseño nos llevaría a una mala descripción del circuito y seguramente a otro tipo de errores. La sección ARCHITECTURE La arquitectura de la entidad es la descripción de la funcionalidad. También se pueden declarar valores constantes:
CONSTANT nombre: Tipo de señal:= valor inicial. donde se define la funcionalidad que concretamente se le asigna a la arquitectura. Sin embargo esto sería atentar contra la naturaleza de los HDL. a sus señales de enlace y a los parámetros.
.. SATUR=>enlace1). Lo primero que hay que haces notar es la presencia de una etiqueta que identifica cada uno de los componentes de una manera unívoca.. De ahora en adelante esta etiqueta identificará al componente..clr: IN BIT.SATUR=>salida). COUNT: out BIT_VECTOR(N-1 DOWNTO 0)....... PORT( CLK: in BIT.. común a ambos bloques: en un caso enlace1 es de salida y en el otro. RST: in BIT.. Obviamente en la declaración de la misma no existe direccionalidad. ARCHITECTURE estructura_mod OF mod IS COMPONENT contador GENERIC(N:integer:=10). SIGNAL enlace1.. CLEAR: in BIT. cont1: contador GENERIC MAP(N=>8) PORT MAP(CLK=>clk. a diferencia de la señales de los puertos de la entidad...
El ejemplo muestra la utilización de un mismo componente varias veces..rst...) PORT MAP(. de entrada.RST=>rst. Supongamos un contador doble:
ENTITY doble_contador IS PORT( clk.Veamos un ejemplo concreto. y cada uno de ellos tiene un valor diferente del parámetro.. BEGIN slogic0<=’0’.. ENABLE: in BIT. COUNT=>cuenta1... RST=>rst. CLEAR=> CLR....). cont1 y cont2 son dos instancias de un mismo componente tipo contador. En el ejemplo aparece la señal enlace1 como señal interna. salida: OUT BIT.. Utilizando la declaración de la entidad superior construiremos una arquitectura que llama dos veces al contador anterior. END estructura_mod.. ENABLE=>enlace1. SIGNAL cuenta1: BIT_VECTOR(7 DOWNTO 0). SATUR: out BIT ). CLEAR=>slogic0. END COMPONENT... slogico0: BIT. cont2: contador GENERIC MAP(N=>12) PORT MAP(CLK=>clk.... ENABLE=>enable1. END doble_contador. La sintaxis es simple:
nombre_instancia : nombre_entidad (o componente) GENERIC MAP(.
En segundo lugar debemos destacar la manera de referenciar señales internas a la entidad. cuenta: OUT BIT_VECTOR(7 DOWNTO 0) ).. COUNT=>OPEN.enable1. Tras la declaración de los componentes se declaran señales que son interiores al diseño.
En tercer lugar conviene repasar la sintaxis y la puntuación. es decir. slogic0<=’0’.OPEN. lo cual en la práctica no es nada aconsejable. La palabra reservada open. Es correcto pasar los parámetros por orden. constant clogic0: std_logic :=’0’.salida). si bien se escribe más.rst. de ahí que la asociación de clogic0 no sería válida. Este método se denomina pasar parámetros por referencia. En la práctica se debe asociar un valor lógico concreto a la entrada para evitar resultados impredecibles.enable1. La arquitectura presentada es un ejemplo de arquitectura estructural.. mediante los caracteres ‘=>’ y separados por comas. en este caso el componente que se trata. ya que se deja libertad al proceso de síntesis para que realice las operaciones sin nuestro control. Las secciones generic y port son ahora generic map y port map.
Si bien es más conciso. --Este valor no se puede asignar signal slogic0: std_logic.. Las cláusulas map no van separadas por ‘. ya que está compuesta únicamente de componentes y sus enlaces. En este sentido conviene hacer algún comentario adicional. que es tanto como decir que se deja sin conectar. En este caso es obligado que aparezcan todos los parámetros. ya que un error obliga a estar constantemente comparando con el componente y verificando una correcta asociación. Es posible asociar open a una entrada. --Este es el modo de asignación ….) la señal ha de conservar el tipo. indicando las señales que van a ser asociadas a sus entradas y salidas.’. port map (clr=> slogic0.. En VHDL no se admite que en la referencia a un componente se asocie un valor lógico directamente.. es decir con la sintaxis:
cont2: contador GENERIC MAP(12) PORT MAP(clk. salida. La palabra reservada open se utiliza para dejar señales sin conectar. por lo que hay que declarar una señal auxiliar. ….. Finalmente la manera de asociar señales que se propone es especificando qué señal se asocia a qué entrada. se tarda en tener éxito mucho menos tiempo. La etiqueta de instancia va seguida del nombre de la entidad.rst. es decir.enlace1. En el caso de que hubiese direccionalidad en las señales.. La omisión de un parámetro es equivalente a la asociación de open. Si hacemos referencia al 22
. muy poco legible.) La asociación para la conexión de componentes se realiza mediante señales del mismo tipo por tanto no es válido asociar constantes con señales de puertos. es también poco práctico.. que vengan declaradas desde la entidad (en el ejemplo clk. La experiencia demuestra que siendo más explícito.
. Sin entrar excesivamente en detalles.
.. La sección CONFIGURATION La sección CONFIGURATION responde a un complejo mecanismo de selección entre las diferentes arquitecturas posibles de una misma entidad utilizada en un nivel jerárquico superior. No se hacen referencia a otros componentes.paralelismo entre ellos.. Veamos un ejemplo:
--Entidad inferior ENTITY mi_contador IS PORT( clk. END comport. ya que serán motivos de capítulos posteriores. La sintaxis es:
CONFIGURATION nombre_configuracion OF nombre_entidad IS FOR nombre_arquitectura FOR nombre_instancia : nombre_entidad USE CONFIGURATION WORK.. ya que a ella se le asocia un nombre. Una configuración está asociada a una entidad y una arquitectura..... aunque el segundo dependa del primero. Podemos definir tantas configuraciones como sean necesarias..rst.. este caso es un ejemplo claro que no existe precedencia en el comportamiento de un contador u otro..... END contador.... Están asociadas a la tecnología elegida y están representadas como componentes en una librería que el fabricante de circuitos integrados proporciona. 5.. END FOR.. mediante la selección de la configuración determinaremos qué arquitectura es seleccionada para esa entidad..3 Diseño con primitivas. END FOR. 6. lo que equivale a realizar un esquemático escrito.. ya que ambos se activan de igual manera. 5. --definimos dos arquitecturas diferentes para la misma entidad ARCHITECTURE comport OF contador IS BEGIN ..
Es en el nivel jerárquico superior cuando se particulariza qué configuración se desea para determinada entidad. END nombre_configuracion.2 Diseño de comportamiento en una arquitectura.. Las primitivas son las unidades funcionales elementales que describen el diseño después de realizar la síntesis.. . sino que en la propia arquitectura se definen las operaciones que se realizan sobre las señales.. Por tanto.nombre_configuracion..........enable: in std_logic. Es posible realizar una descripción de un diseño a partir de una descripción mediante primitivas.. cuenta: out std_logic_vector(7 downto 0) ).... En el nivel más bajo del diseño ha de haber una información acerca de la funcionalidad del propio diseño..
ARCHITECTURE estruct OF contador IS BEGIN .................... END estruct; --asociamos una configuración a cada una de las arquitecturas CONFIGURATION comport_conf OF contador IS FOR comport END FOR; END comport_conf; CONFIGURATION estruct_conf OF contador IS FOR estruct END FOR; END estruct_conf; -- configuración de la entidad superior que referencia el componente CONFIGURATION estruct_top OF top IS FOR estruct FOR cont1: contador USE CONFIGURATION WORK.estruct_conf; END FOR; FOR cont2: contador USE CONFIGURATION WORK.comport_conf; END FOR; ................ END FOR; END estruct_conf;
En este ejemplo hemos utilizado dos arquitecturas diferentes del mismo componente. En el caso de que no exista la necesidad de variar las configuraciones se puede resumir en la cláusula ALL:
-- configuración de la entidad superior que referencia el componente CONFIGURATION estruct_top OF top IS FOR estruct FOR ALL: contador USE CONFIGURATION WORK.estruct_conf; END FOR; ................. END FOR; END estruct_conf;
6.1 Estilo par entidad-arquitectura Existe una sintaxis alternativa que permite una asociación más explícita:
CONFIGURATION estruct_top OF top IS FOR estruct FOR cont1: contador USE ENTITY WORK.contador(estruct); END FOR; FOR OTHERS: contador USE ENTITY WORK.contador(comport); END FOR; ................. END FOR; END estruct_conf;
En este caso hemos introducido también la cláusula OTHERS para identificar a aquello que no se ha hecho referencia previamente. Este primer ejemplo de una palabra que es muy utilizada en VHDL. En la práctica este potente mecanismo es poco utilizado, dado que no se ofrecen muchas situaciones de varias arquitecturas para una misma entidad. Si solamente existe 24
una única arquitectura en todos y cada uno de los componentes del diseño, la configuración será única y por tanto se omite la sección de configuraciones. 7. La sección LIBRARY Tiene un especial interés el dedicar un párrafo completo a las librerías en VHDL, dado que en la práctica todas las extensiones del lenguaje se realizan utilizando este potentísimo mecanismo. Mediante bibliotecas podemos definir componentes, funciones y procedimientos, es decir, unidades del lenguaje que pueden ser útiles en múltiples aplicaciones, siendo un elemento de reutilización del lenguaje. De esta manera, un componente de una librería ya analizada y sintetizada puede ser llamado en un código sin necesidad de tener que volver a declararlo como componente. Las librería se estructuran en paquetes (packages) que permiten una fácil clasificación de los elementos que las componen. La declaración de una librería sigue la siguiente sintaxis:
library MiLibreria; use MiLibreria.Paquete1.all; use MiLibreria.Paquete2.all; --Enmascara las funciones de Paquete1
De esta manera quedan accesibles todos (all) los elementos del Paquete1 y Paquete2 de la librería MiLibreria. En el capítulo seis nos dedicaremos en detalle a definir, declarar y construir nuestras librerías. Sin embargo nos detendremos en explicar algunos aspectos importantes de las librerías más utilizadas. Solo dos palabras para comentar que las funciones VHDL disponen del mecanismo de sobrecarga en sus llamadas, de forma que no solo se atiende a la coincidencia del nombre de la función en la llamada, sino que además se verifica la coicidencia de los tipos de argumento de las mismas. Finalmente, la presencia de funciones con igual nombre y tipo de argumentos en Paquete1 y Paquete2 hace que las funciones del primero queden enmascaradas por las del segundo, de ahí que si se desea utilizar parcialmente una de ellas, bien debemos cuidar el orden de declaración o bien sustituir la palabra all por las funciones que nos interesen. 7.1 La necesidad de la librería std_logic_1164 El VHDL posee un limitado número de tipos y funciones que resultan insuficientes a la hora de describir completamente el comportamiento de un circuito digital. Por tanto se hace preciso que la extensión del lenguaje contemple un número amplio de situaciones. En particular, los tipo de datos que maneja el VHDL se reflejan en la siguiente tabla: • • • • • • BIT , {0,1} BOOLEAN, {false, true} CHARACTER, {la tabla ASCII desde 0 a 127} INTEGER, {-2147483647, 2147483647} NATURAL, {0, 2147483647} POSITIVE, {1, 2147483647}
STRING, array {POSITIVE range <>} de CHARACTER BIT_VECTOR, array {NATURAL range <>}de BIT Tipos físicos, como TIME REAL, {-1E38, 1E28} POINTER, para accesos indirectos a datos. FILE, para accesos a ficheros y pilas de datos del disco duro.
Ni que decir tiene que muchos de ellos corresponden a estructuras del lenguaje que no son sintetizables. De echo, durante la síntesis de bloques VHDL casi nunca se utilizan de manera explícita y completa estos tipos de datos. Por tanto el VHDL de forma sistemática ha de extenderse mediante tipo de datos que presentan un campo de variabilidad mucho más cercano al funcionamiento normal de un circuito. Se trata del paquete std_logic_1164 de la librería IEEE. Normalmente esta librería aparece dando sentido a un nuevo tipo de datos, el std_logic, que es un tipo enumerado. Los detalles acerca de este tipo de datos se exponen en el capítulo cuarto de estos apuntes. La cabecera de librerías estándar es típicamente: library IEEE; use IEEE.std_logic_1164.all; En esta librería se introducen los nuevos operadores relacionales asociados al nuevo tipo de datos. 7.2 Librerías aritméticas El VHDL no tiene definidos de modo estándar operaciones aritméticas que permitan el uso de operadores. Es preciso, pues, la inclusión de librerías que faciliten la inclusión de operadores de tipo aritmético. La librería estándar para este caso es la std_logic_arith. En el capítulo dedicado a comentar la utilización de las funciones aritméticas desarrollaremos las referencias a esta librería. Se estudiará a fondo en los capítulos cuatro y cinco.
es decir. y tiene el mismo tratamiento que el ejemplo anterior. Nos obstante . todos ellos son concurrentes. ya que es en ellas donde más se utilizan. no existe un mecanismo inherente a la tecnología soporte que establezca precedencias en la actividad de sus bloques constituyentes. El más común es el proceso o process. Cuando se introducen sentencias o bloques (que más adelante llamaremos procesos). • Sentencias generate. pues muy útil la presencia de mecanismos que permitan introducir código secuencial. es decir. Generación de copias de bloques de hardware. no existe precedencia entre unos u otros y no importa el orden en que se escriban (en lo que afecta a su funcionalidad. • Instancias de componentes. A<=B and C. Un proceso es un bloque que contiene código secuencial pero externamente se contempla como un bloque concurrente. Los procedimientos son algoritmos combinacionales que computan y asignan valores a señales. Definen algoritmos secuenciales que leen valores de señales y asignan valores a señales. por naturaleza paralelo. cada vez que se produce la utilización de un componente se realiza de modo concurrente. En diseños estructurales. es equivalente a: D<=A and F.CAPÍTULO III. • Llamadas a procedimientos y funciones (procedure y function). que detallaremos en el siguiente apartado.
Un circuito electrónico es. D<=A and F. Concepto de concurrencia. y con el ánimo de ser formal existen en VHDL cinco tipos de elementos concurrentes: • Bloques (block). Estructura de un proceso
. Grupos de sentencias concurrentes. Esto significa que la descripción del mismo ha de preservar esta propiedad. Resulta. FUNCIONALIDAD
1. Suelen formar parte de librerías. que no es lo mismo que su legibilidad e interpretación). Las instancias de componentes se han tratado en el capítulo anterior y los procedimientos y las funciones se explicarán en el capítulo seis cuando se explican las librerías. 2. • Declaración y definición de procesos (process). sin embargo existen gran cantidad de situaciones en las que es muy fácil describir un comportamiento de un circuito de modo secuencial. Por ejemplo: A<=B and C. • Asignaciones de señales computadas a través de expresiones booleanas o aritméticas.
BEGIN --secuencia de ordenes END PROCESS etiqueta_proceso. Existen varias cuestiones que conviene aclarar: • La lista de sensibilidad debe contener todas las señales que afecten a la evaluación del proceso. ya que si una sentencia concurrente es evaluada cuando los argumentos varían. • Si una señal que se computa a la izquierda de una asignación dentro del proceso aparece en la lista de sensibilidad. hemos dicho que afecta decididamente a la imagen hardware que se representa. • Si no existe lista de sensibilidad el proceso se denomina infinito y se ejecuta constantemente. El mecanismo del proceso se entiende como una manera fácil de transferir algoritmos ensayados en lenguajes de alto nivel secuenciales a VHDL. Esto permite resolver el problema de la concurrencia mencionado.2 Lista de sensibilidad. Esta idea condiciona enormemente su sintaxis y sus posibilidades. Desde el punto de vista de síntesis conviene no olvidar que un proceso representa una porción de un circuito y que es preciso asociar una imagen hardware al conjunto de sentencias que lo componen. principalmente en simulación. señales que usualmente se ubican a la derecha en una sentencia de asignación. el proceso es evaluado completamente. Imaginamos el siguiente ejemplo:
pr1: PROCESS( a ) –omitimos la señal b
.. este se evaluará de nuevo.Para comprender el funcionamiento de un proceso conviene introducir una doble perspectiva del mismo: la simulación y la síntesis. El siguiente listado recoge todos los elementos de un proceso
etiqueta_proceso: PROCESS(lista de sensibilidad) VARIABLE . mediante un cambio en un cualquiera de ellas. • La omisión de una señal en la lista de sensibilidad afecta necesariamente a la morfología del circuito que representa. Desde el punto de vista de simulación el proceso contiene una secuencia de transformaciones sobre las señales que se producen una vez activado el mismo. La lista de sensibilidad es un artificio para realizar computacionalmente el paralelismo. y se producirá sucesivamente hasta que el valor de la señal se estabilice. 2. es decir. igualmente le ocurre a un proceso. Para su control se precisa el uso de sentencias tipo wait que son típicas de construcciones no sintetizables y se estudiarán en el capítulo correspondiente. aunque también es útil en síntesis.
Los procesos se introducen en la zona de arquitectura y no existe restricción alguna acerca de su número y extensión. es decir. Si en la lista de sensibilidad se omite una señal.. 2. La lista de sensibilidad es un conjunto de señales que activan el proceso.1 Elementos de un proceso.
con el valor que b tenga en ese instante.
Hemos omitido la señal b.3 Cláusula variable En la implementación secuencial se suele hacer uso de variables temporales que no trascienden fuera del proceso. END PROCESS asig. 2. Su uso está limitado a asignaciones en su interior. d<= a xor b. 2. El mecanismo de asignación es igual que el de una señal. ya que no está en la lista de sensibilidad. otras diferencias cualitativas que describiremos en el apartado siguiente. un proceso se activa con señales y resuelve los valores de señales. La figura representa un circuito equivalente a la situación expresada. El circuito activa el match es un detector de flanco. con la salvedad de que en la asignación se utilizan los símbolos ‘:=’ en lugar del ‘<=’. Sin embargo. De esta manera.BEGIN c<=a and b. Este recurso del lenguaje se le conoce como variable. es decir.4 Asignaciones dentro de un proceso
. Existen. Esta situación no es admisible desde el punto de vista de un diseño.
k b a k
Dado que este circuito no es aceptable casi todos los programas de síntesis producen un aviso de ausencia de una señal de la lista de sensibilidad. aviso que es preciso eliminar. que genera la forma de onda indicada en el punto k.c) VARIABLE a: std_logic. con un pulso de anchura el retardo del inversor. y dejan a que el diseñador. el circuito que produce el valor de c ha de almacenar el valor de b cuando se produzca una variación en a. que se basa en la presencia de un retardo en la entrada de la puerta XNOR. y es tan estrecho que es probable que viole las condiciones temporales de la entrada de habilitación E del Latch. si quiere implementar estructuras como estas. cuando b varía c no se actualizará. END PROCESS pr1. y tiene una misión aclaratoria. además. Cuando a varía el proceso se evaluará realizando la operación and de a y b. ya que el retardo del inversor es dependiente de la tecnología.
La variable a aparece en una situación transitoria. Por ejemplo:
asig: PROCESS(b. describa explícitamente el circuito. BEGIN a:= b and c.
END PROCESS ej. END IF. Ni siquiera la asignación incondicional afectaría a dicha evaluación. 2. IF(A=’1’) THEN q:=q+1.. Fuera de él carecen de significado.. IF(B=’1’) THEN q:=q+2. BEGIN ej: PROCESS(A. END PROCESS ej.. es decir. Esto significa que en la evaluación realizada en la estructura CASE el valor de q es el que tuviese antes de la evaluación del proceso. Son condiciones no concurrentes:
Sentencia IF THEN ELSIF ELSE
. END comport.B.. La principal diferencia en el tratamiento estriba en que el proceso se evalúa en un instante de tiempo cero. IF(B=’1’) THEN q<=q+2. END behav. De la misma manera las asignaciones a señales (que no a variables) dentro de un proceso no se hacen efectivas hasta que el proceso no se concluye.
El valor de q no se actualiza hasta que el proceso ha concluido.
Mediante esta modificación realizamos la asignación deseada y la funcionalidad que resulta es la requerida.En el cuerpo de un proceso se admiten asignaciones simples. END IF.. END IF... CASE q => WHEN 0 => . END CASE. Por ejemplo:
ARCHITECTURE comport OF ejemplo SIGNAL q : INTEGER RANGE 0 TO 3.. IF(A=’1’) THEN q<=q+1. END CASE. BEGIN q:=0. CASE q => WHEN 0 => .B. Para realizar una evaluación secuencial tal y como se realiza en un programa desarrollado para una CPU es preciso utilizar variables en vez de señales. END IF.) VARIABLE q : INTEGER RANGE 0 TO 3. es decir:
ARCHITECTURE behav OF ejemplo BEGIN ej: PROCESS(A.) BEGIN q<=0.5 Sentencias propias de un proceso Dentro de un proceso existen un conjunto de sentencias que son propias de su estructura.. que todas las asignaciones y condiciones se producen sin retraso..
>= de Ejemplo If (a = b) then If (a /= b) then If (a<b) then C Igualdad. Desigualdad Menor. Algo parecido ocurre con la siguiente estructura.. ELSE Consecuencia por defecto.
La diferencia entre ambas estructuras estriba en que en la segunda las consecuencias 2. mayor o igual
Inferencia de elementos de memoria Las sentencias condicionales tienen una particularidad que las hacen de especial interés en la síntesis de hardware secuencial.>. END IF. mayor.1 y 2. ELSE Consecuencia 2.
La condición puede ser lógica o aritmética. ELSIF . ELSE Consecuencia por defecto..1. En la primera de las estructuras la Consecuencia 1 tendría un camino crítico menor. Sea el ejemplo siguiente:
sec: PROCESS(ena. menor o igual. La condición 1 es previa a la condición 2. En la siguiente tabla se resumen los tipos de expresiones: Tipo condición = /= <. Su sintaxis es:
IF condición 1THEN Consecuencia 1.. Merece especial atención al concepto inherente de jerarquía que introduce la sentencia IF.<=. END IF..2.La resolución de una condición se resuelve mediante la sentencia IF. que nunca será evaluada en caso de cumplimiento de la primera. también válida:
IF condición 1THEN IF condición 2 THEN Consecuencia 2.d) BEGIN
. Las condiciones en una sentencia IF se evalúan a través de expresiones booleanas que devuelven los valores ‘verdadero’ o ‘falso’. THEN . END IF. ELSIF condición 2 THEN Consecuencia 2.2 se validan mediante un circuito que comprueba Condición 1 y Condición 2 encadenadas.
WHEN OTHERS representa la condición por defecto. el biestable es un elemento siempre deseado) suelen proporcionar un aviso de que se infiere. Del ejemplo se infiere un latch para la señal q y otro para la qz. END PROCESS sec. END CASE. Es importante que exista una asignación para todas las salidas en cada uno de los casos ya que de esta forma evitamos la formación de latches indeseables. Por tanto es recomendable que en las estructuras que dependen de la evaluación de una condición antecedente dispongan al menos de una valor por defecto para los consecuentes. Pero. Existe un dispositivo hardware que permite realizar la funcionalidad expuesta. consistente en un elemento de memoria activo por nivel o latch. es recomendable el uso de CASE antes que IF/ELSIF dado que el IF introduce un elemento de prioridad que puede resultar menos eficiente (más área). q permanece con el valor de d cuando ena valía ‘1’. Normalmente cuando los programas de síntesis detectan una estructura de un latch (no deseada. El modelo de inferencia de un latch se reproduce continuamente durante el proceso de diseño. ¿qué ocurre cuando ena vale ‘0’? Si cambia d. El latch rara vez se utiliza en diseño síncrono y suele ser una fuente de problemas. Un ejemplo típico de situación deseada es el biestable.
La estructura inferida hace que q tome el valor d cuando ena tiene el valor ‘1’. Sentencia CASE WHEN Una selección en función del valor que toma una señal se construye mediante la selección
CASE objeto IS WHEN caso1 => Código1. 32
. y por tanto se ha de utilizar un mecanismo para especificar el flanco del reloj. qz<=NOT d. mecanismo que se expondrá en el capítulo cuarto. No puede haber dos valores de selección iguales y la cláusula others debe aparecer si no se cubren todos los posibles valores de selección. WHEN OTHERS => Código para el resto de los casos.IF (ena=’1’) THEN q<=d. donde la señal ena es el reloj. END IF. En general es una estructura condicional que no tiene solución hardware para todas las posibles situaciones. WHEN caso2 => Código2. que en un posterior proceso de optimización sería agrupado en uno solo con la negación de q.
En los casos en que las dos formas son posibles. WHEN caso3 | caso4 => Código34. en situaciones deseadas y en situaciones no deseadas.
. --saltar el resto del bucle EXIT etiqueta WHEN condición. Sentencia Concurrente 2.
Normalmente un bloque no crea un nuevo nivel de jerarquía.
Etiqueta: FOR parámetro IN lista_de_valores LOOP Código.
i:=0. NEXT salta el resto del código secuencial dentro del bucle y obliga a la evaluación de un nuevo índice. i:=i+1.Bucles dentro de procesos VHDL permite la construcción de bucles para reducir el tamaño de código repetitivo. Bloques de sentencias Es una agrupación de sentencias concurrentes.
NEXT etiqueta WHEN condición. END LOOP Etiqueta. Etiqueta: WHILE condición LOOP Código. cuando la condición se satisface. Sentencia Concurrente 2. En ambos casos es posible interrumpir la evaluación normal con las instrucciones NEXT y EXIT. END LOOP.Dejamos el bit 6 como estaba Bus(i) <= ’0’. END LOOP Etiqueta.. continuando con la secuencia del proceso. no es precisa su declaración previamente.. EXIT salta el resto del código secuencial y obliga a la terminación del mismo.
3. END BLOCK etiqueta. Estas sentencias han de ir en dentro de un proceso. es decir. Su función es puramente aclaratoria y en la práctica es poco utilizado. --salir del bucle
FOR i IN 0 TO 7 LOOP NEXT WHEN i=6. no importa el orden en que han sido escritas. END LOOP... La sintaxis es:
etiqueta: BLOCK BEGIN Sentencia Concurrente 1. -.
Cuando el objeto a evaluar es un índice.. . WHILE i < 8 LOOP Bus(i) <= ’0’.
Tipo Operador lógico
a <= b AND c. Asignaciones concurrentes Es posible realizar operaciones de tipo asignación concurrente equivalentes a las que se han definido dentro de las estructuras secuenciales.XOR a <= b OR c. Su sintaxis es:
etiqueta : Señal Destino <= Señal Origen.
Donde la señal destino puede ser una señal declarada previamente mediante signal o bien una señal que se encuentra en el puerto (port) de la entidad (entity) como salida (out) . Estas operaciones han de estar previamente definidas en librerías. La señal origen puede ser una señal declarada previamente mediante signal o bien una señal que se encuentra en el puerto (port) de la entidad (entity) como entrada (in).NOR.
La expresión funcional representa una función booleana o aritmética que es combinación de señales de entrada o señales. entrada-salida (inout) ó buffer. en las que las restricciones a la hora de realizar una inferencia son exactamente las mismas que en las mencionadas estructuras.1 Asignación simple Es la sentencia concurrente más elemental y se realiza mediante el asignador ‘<=’. con la ventaja de que no es preciso la realización de una estructura del tipo proceso. Por ahora nos limitaremos a exponer una relación de las mismas: Operador * Uso a <= b * c. 4.
Asimismo se admiten operaciones aritméticas. Descripción Multiplicación
. NOTA: Realmente todos los elementos concurrentes son tratados dentro del complejo tratamiento informático del lenguaje como procesos concurrentes. entrada-salida (inout) ó buffer. Operadores lógicos Operadores lógicos
OR. La condición para una correcta asignación es la igualdad en los tipos de las señales que se asignan. La siguiente tabla representa las funciones booleanas que se admiten en una asignación: Operador NOT AND. NAND Ejemplo a <= NOT b.4. Además la asignación simple permite la evaluación de expresiones siguiendo una sintaxis igual:
etiqueta : Señal Destino <= Expresión Funcional. En el capítulo cuarto se tratan más en profundidad la manera de trabajar con estas funciones.
.... División (c ha de ser potencia de 2) Suma Resta
a <= b MOD Calcula b en modulo c c..3 Selección en forma concurrente También existe una sentencia equivalente a case en forma concurrente.. Existe una prioridad en la definición de las funciones... La forma IF admite. a <=b+c.. .. a <=b-c.. Su sintaxis es:
etiqueta: WITH expresión_selección SELECT Señal Destino <= Expresión1 WHEN Valor_Selección1. de modo mucho más legible. De la misma forma es posible encadenar la forma WHEN:
etiqueta: Señal Destino <= Expresión1 WHEN Condición1 ELSE Expresión2 WHEN Condición2 ELSE Expresión3 WHEN Condición3 ELSE
. Exponencial a <= b/c. ExpresiónN WHEN OTHERS. a <= b REM Calcula la resta entera de b / c c. Se resume en la siguiente tabla: Máxima: ** * + = AND ABS NOT / MOD REM (negación) & /= < <= > >= OR NAND NOR XOR
4.** / + MOD REM
a <= b ** 2.
No existen diferencias cualitativas entre ambos tipos de sentencias.2 Asignación condicional Es una expresión concurrente que realiza las mismas operaciones que la cláusula IF dentro de un proceso.
ExpresiónN WHEN CondiciónN ELSE Expresión.
4.. Su sintaxis es:
etiqueta: Señal Destino <= Expresión1 WHEN Condición ELSE Expresión2.. Expresión2 WHEN Valor_Selección2. más de una consecuencia y consecuencias mucho más complejas que la forma concurrente WHEN....
Es posible una asociación y una inferencia de jerarquía en las funciones jerarquía mediante la utilización de paréntesis..
. y genera 8 instancias del mismo con valores diferentes de los parámetros:
COMPONENT MiComp GENERIC(N: integer:=8).
En el ejemplo hemos jugado con diferentes posibilidades del mecanismo generate. Es local al bucle. en función del mismo. ya que en no existe en Verilog una forma equivalente. Hemos asignado a cada componente un valor diferente del parámetro. una o más copias de un conjunto de sentencias concurrentes en función de un parámetro que recorre un rango de valores. Bucle_generate: FOR i IN 0 TO 7 GENERATE copia: MiComp GENERIC MAP (N=>2*i) PORT MAP(X=>A(i). La sintaxis es como sigue:
etiqueta: FOR parámetro IN rango_de_valores GENERATE { Sentencias concurrentes asociadas al parámetro } END GENERATE etiqueta.. END GENERATE Bucle_generate.. END COMPONENT.No puede haber dos valores de selección iguales y la cláusula others debe aparecer si no se cubren todos los posibles valores de selección... El parámetro no se declara externamente. ya que se permite anidar bucles generate. . 5. PORT(X: in std_logic. Asimismo hemos realizado operaciones con el índice del vector B. 5. No es posible asignar un valor al parámetro ni este puede ser asignado. . Los detractores del Verilog utilizan esta sentencia como argumento de valor. El ejemplo representa la llamada múltiple a un componente.. Y: out std_logic )..
En este caso la etiqueta es obligatoria. SIGNAL A.
. con la idea de poner de manifiesto sus posibilidades.1 Bucles utilizando generate Mediante la sentencia generate podemos realizar cero. procesos o bloques.. Y=>B(7-i))...B: bit_vector (7 downto 0). El rango de valores se recorre en forma creciente o decreciente:
entero_menor TO entero_mayor entero_mayor DOWNTO entero_menor
El uso más corriente de la sentencia generate es la generación de copias de componentes. La sentencia generate Uno de los mecanismos de generación de hardware más potentes del VHDL es el basado en la sentencia generate.
Es preciso destacar que esta forma de IF se presenta como sentencia concurrente y la ausencia de una condición alternativa tipo ELSE ni ELSIF.2 Generate condicionado.5.
. Esta estructura tiene mejor uso anidada dentro de otro bucle generate. Mediante la evaluación de una expresión booleana es posible construir un componente:
Etiqueta: IF expresión GENERATE { Sentencias concurrentes } END GENERATE Etiqueta.
Dentro de la parte declarativa es posible escribir de manera explícita todos los posibles valores que puede tomar una señal de un determinado tipo. Huelva... TIPOS DE DATOS Y SEÑALES
En este capítulo vamos a presentar los tipos de datos más corrientes en VHDL y planteamos todos conceptos básicos necesarios para poder manejar el lenguaje. hasta Jerez el valor 7.
. El registro trata los valores negativos en complemento a 2. Málaga el valor 1. Por ejemplo:
TYPE puntos_liga IS RANGE 0 TO 144. Partimos de lo reseñado en el apartado 6.CAPÍTULO IV.. Jerez) . 1...
Realmente la señal ligaandaluza en un tipo enumerado porque realmente es un subtipo de INTEGER donde Sevilla representa el valor 0.EnumN). Tipo entero El VHDL admite en su forma estándar el uso del tipo entero. 2. Haremos un recorrido por todos los elementos típicos y la librería std_logic_1164 de gran importancia en la generación de códigos sintetizables. Definición de tipos de datos. De esta forma se obtiene una evaluación positiva de la condición:
Betis > Sevilla
Este mecanismo permite realizar operaciones con valores de las señales que están representados de una forma clara por un estado.. Internamente estas señales serán tratadas mediante registros de 8 bits. Por ejemplo:
TYPE equipo IS (Sevilla.
Todas las señales que sean definidas como puntos_liga podrán tomar valores dentro de este intervalo. Se le conoce como tipo enumerado:
TYPE nombre_tipo IS (Enum1.
El intervalo debe estar contenido entre los valores anteriormente expuesto. Málaga. Jaén. nombre o identificador. En el tema dedicado a las máquinas de estados finitos se comprenderá su potencia y utilidad. dejando a capítulos siguientes las particularizaciones sobre elementos más comunes. Una señal declarada como entero es un registro de 32 bits que recorre el rango desde -(231-1) hasta +(231-1).1 del capítulo segundo de estos apuntes. SIGNAL ligaandaluza: equipo. Betis.. Córdoba. Es posible definir un intervalo de enteros mediante la definición de un nuevo tipo:
TYPE nombre_tipo IS RANGE intervalo..
Donde Enum1 a EnumN puede ser un identificador (un nombre cualquiera) o bien un carácter. El VHDL admite la definición de nuevos tipos de datos de una forma muy simple.
• La manera de acceder a los valores de los atributos es la siguiente: 39
. Identifica el valor definido a la izquierda del intervalo de índices. Identifica el valor mínimo del intervalo de índices.. es decir. Identifica el valor total del intervalo de índices. Representa el mismo intervalo de índices pero en sentido inverso. Su sintaxis es:
TYPE matriz_nombre_tipo IS ARRAY(Tipo_predefinido RANGE <>) OF nombre_tipo. Son de gran utilidad en la elaboración de código que depende intensivamente de parámetros. Los atributos son valores asociados a una señal o variable que proporcionan información adicional. y no restringidos que pueden tomar valores en todo el rango de variabilidad de los enteros. Copia el intervalo de índices • REVERSE_RANGE.1 Atributos de las matrices. • HIGH. El acceso a uno de esos elementos se realiza a través de un índice. • LENGTH. • RIGTH. 3.3. El valor del intervalo de enteros permite la definición de tipos restringidos.. • RANGE. Por ejemplo:
TYPE Bit_Vector IS ARRAY (INTEGER RANGE <>) OF bit. como el del ejemplo. • LOW. .
VHDL soporta de matrices multidimensionales. La mayoría de programas de síntesis no contemplan esta posibilidad y se restringen al tratamiento de matrices unidimensionales.
Siendo la variable la que define finalmente el intervalo en el momento de su declaración. Tipo matriz Una matriz es un conjunto ordenados de elementos del mismo tipo. VARIABLE MiVector: Bit_Vector (-5 TO 5). En apartados posteriores se exponen otros atributos asociados al comportamiento de las señales. cuyos elementos dependen del valor de uno o más parámetros. Identifica el valor definido a la derecha del intervalo de índices.
TYPE clasificacion IS ARRAY (1 TO 7) OF equipo.
La ventaja de este mecanismo consiste el que dejamos a las herramientas de síntesis VHDL tomar las decisiones acerca del intervalo de variabilidad final. No obstante a través de varias declaraciones de tipo unidimensional se pueden construir. Identifica el valor máximo del intervalo de índices. En este apartado se exponen los atributos relacionados con el aspecto matricial. independientemente del valor que la señal o variable tenga en un instante dado. Un tipo matriz se define:
TYPE matriz_nombre_tipo IS ARRAY (intervalo de enteros) OF nombre_tipo. Estos son los atributos matriciales definidos en VHDL estándar: • LEFT.
Asignación de un ídice particular y<=”111000101000110”. Habitualmente estos tipos se predefinen con un tipo infinito para posteriormente se particularizado. ... --Vale 15 . MiSenal’left toma el valor 7 MiSenal’rigth toma el valor -3 MiSenal’high toma el valor 7 MiSenal’low toma el valor –3 MiSenal’length toma el valor 11 (El 0 también se cuenta!!!) MiSenal’range toma el valor (7 downto –3) MiSenal’reverse_range toma el valor (-3 to 7)
Podremos utilizar algunos de estos valores en el bucle en el código siguiente:
Bucle: FOR i IN MiSenal’reverse_range LOOP A(MiSenal’high .. x(3)<=a... tipo que representa físicamente un BUS o conjunto ordenado de líneas eléctricas.Asignación de un valor constante ...2 Tipo vector Probablemente el tipo más utilizado es la matriz unidimensional de bits. -... signal MiSenal : std_logic_vector (7 downto –3). IF(x=y)THEN ....... En la librería correspondiente está definido el tipo
TYPE Bit_Vector IS ARRAY (POSITIVE range <>) OF BIT. -.. aunque 40
.y : MiBus. Estos tipos predefinidos suelen caracterizarse por llevar el sufijo _VECTOR...
Esta función trabaja con una matriz con independencia de su tamaño..i)<=MiSenal(i) END LOOP Bucle..
En nuestro código podremos definir señales:
. hemos definido un subtipo (subconjunto de un tipo). MaxIndex:=x’HIGH. SIGNAL a : BIT.. SIGNAL x...nombre_de_señal’NOMBRE_ATRIBUTO
Veamos un ejemplo que presenta todos los valores de los atributos anteriormente expuestos:
En el ejemplo anterior se muestra un conjunto de asignaciones y manipulaciones posibles de un VECTOR...... . 3. VARIABLE MaxIndex : INTEGER.. SUBTYPE MiBus : Bit_Vector (15 downto 0).. ..
SIGNAL x.
En este ejemplo se han realizado una asignaciones parciales y completas del tipo definido. 4. . ya que podemos trabajar directamente con el tipo Bit_Vector(15 downto 0). EnteroI : INTEGER –100 TO 100. x.. .z : Entero_Complejo SIGNAL real.
La manera de acceder a los tipos individualmente es mediante una referencia al nombre del subtipo. Normalmente el índice que se asigna al bit más significativo debe ser el más alto y al bit menos significativo el más bajo..EnteroI... También se pueden realizar agregaciones:
X<=( EnteroR => 20. EnteroI => 40). Y<=(30... END RECORD.EnteroR <= real......... .-10).. Es por tanto muy recomendable utilizar la forma DOWNTO a la hora de definir buses y olvidar la forma TO. La asignación de un valor constante se realiza utilizando las dobles comillas en lugar de la comilla simple. Es norma del buen programador el ser sistemático a la hora de definir las formas de los buses. . Otra cuestión interesante es la forma que hemos dado al VECTOR: (15 downto 0). Si se utiliza la forma (0 to 15).. utilizado en el tipo std_logic.. . imaginaria : INTEGER –100 TO 100. imaginaria <=x. Definición de tipos compuestos Un tipo compuesto (record) consiste en una agregación de tipos que forman uno nuevo.no es preciso realizar tal operación.
En el ejemplo se pasan los argumentos por referencia y por orden. La razón estriba en que se asocian cadenas de caracteres. .. La manera de definirlos es:
TYPE nombre_de_tipo IS RECORD nombre_de_subtipo1 : tipo.... esta regla no se respeta y llevará seguro a confusiones..... nombre_de_subtipo2 : tipo..y.
. END RECORD.. y<=z. Por ejemplo:
TYPE Entero_Complejo IS RECORD EnteroR : INTEGER –100 TO 100.....
1 Los atributos de las señales. Los atributos predefinidos en VHDL son: • DELAYED(t). un subtipo del INTEGER que toma valores entre 0 y +(231-1). unidades de tiempo desde la última asignación. • EVENT. donde TRUE>FALSE. INTEGER que toma valores en el intervalo –(231-1) a +(231-1). tipo enumerado que toma valores TRUE ó FALSE. Todos los programas de simulación y síntesis VHDL proporcionan una librería de tipos y funciones que completan la librería estándar para describir de manera más precisa en comportamiento de circuitos digitales. verdadero si el proceso actual determina el valor de la señal. Se trata de la librería IEEE. están asociados a la evolución de la señal en el tiempo y son extremadamente útiles a la hora de describir situaciones reales. tipo bit. • LAST_ ACTIVE. La diferencia con los atributos asociados a una matriz estriba en que son dinámicos. • ACTIVE. • QUIET(t). unidades de tiempo desde el último evento. STRING. Estos tipos son: • • • • • • • • CHARACTER. • DRIVING. a ‘1’ cuando hay una asignación a la señal. 4. verdadero si ocurre una asignación a la señal en el paso de simulación. Sin embargo existe uno de ellos en particular extremadamente útil a la hora de describir 42
. Tipos simples Como se ha comentado el VHDL dispone de tipos de datos estándar que de manera natural soportan todas las posibilidades del lenguaje. un subtipo del INTEGER que toma valores entre 1 y +(231-1). BOOLEAN. Ni que decir tiene que la mayoría de estos atributos no se utilizan en el subconjunto de síntesis de VHDL. tipo enumerado que soporta toda la secuencia de caracteres ASCII desde 0 a 128. NATURAL. Son válidos para modelado de dispositivos. una matriz de intervalo no definido del tipo CHARACTER. BIT_VECTOR. valor anterior de la señal. tipo enumerado. verdadero si ocurre un cambio en la señal en el paso de simulación. • TRANSACTION. verdadero si la señal no ha recibido ninguna asignación en t unidades de tiempo. • LAST_EVENT. una matriz de intervalo no definido del tipo BIT. • DRIVING_VALUE. y describir adecuadamente la evolución de los sistemas digitales. • LAST_VALUE. Valor de la señal retrasada t unidades de tiempo. Las funciones lógicas devuelven también un valor del mismo tipo. BIT.
En la práctica ninguno de estos tipos se utiliza para describir hardware. es decir. • STABLE(t). POSITIVE.5. Independientemente del valor que una señal tenga en un instante dado el VHDL mantiene una serie de registros asociados a la señal llamados atributos. que toma valores ‘0’ ó ‘1’. verdadero si la señal permanece invariable durante t unidades de tiempo. valor que toma la señal tras el proceso. Se basan en el mecanismo comentado en el capítulo primero en el que se define una base de tiempos incremental (el tiempo mínimo es un paso de simulación) para emular el paralelismo inherente a un circuito.
Se trata del atributo EVENT. que estudiamos en detalle en la sección siguiente. END PROCESS sinc. Si este mecanismo lo aprovechamos para describir un elemento de memoria que se activa con el flanco:
sinc: PROCESS(CLK) BEGIN IF CLK’EVENT AND CLK=’1’ THEN Q<=D.2 El atributo EVENT Es de una gran importancia en la elaboración de código VHDL. Si se combina con una condición adicional podemos describir la transición de una señal a un valor concreto. X’EVENT significa que si una señal sufre una modificación se produce un valor ‘verdadero’ en el atributo EVENT durante el instante de evaluación de la señal. es decir:
X’EVENT AND X=’1’
es una manera de detectar un flanco de subida.
El atributo EVENT evalúa los cambios en CLK cada vez que se produce una transición valida la condición. es decir durante el paso de simulación. si ya no se produce cambio alguno. que en realidad son la práctica totalidad de los sistemas digitales. parecido al anterior:
sinc_mal: PROCESS(CLK) BEGIN IF CLK’EVENT THEN Q<=D. La existencia de atributos marcan claramente la diferencia entre un objeto tipo signal. END IF. El artificio EVENT tiene sentido a la hora de realizar una síntesis si va ligado al valor de la señal.
Mediante este código se describe un elemento de memoria que registra a través de un flanco de la señal clk.
. Después. el atributo toma el valor ‘falso’. La pregunta: ¿existe algún módulo hardware digital cuyo comportamiento coincida con la descripción del código anterior? Evidentemente no. END IF. de los tipo variable y constant. Lo más interesante es que este mecanismo nos permite describir de forma clara todos los sistemas digitales síncronos. Este atributo permite detectar como caso particular una transición de una señal ‘0 a 1’ y ‘1 a 0’. A este elemento se le conoce como biestable o flip-flop tipo D. Se recuerda que los elementos de port map tiene un tratamiento equivalente al de signal. ya que la señal X a cambiado y su valor de cambio es ‘1’. Aún así hay cuestiones que resultan interesantes de destacar. Veamos el siguiente código.sistema síncronos. END PROCESS sinc_mal. 4. Veamos por qué.
contemplando las situaciones a nivel de función lógica. 6. una señal con valor ‘L’ se conecta directamente a una con valor ‘1’ el resultado será una señal de valor ‘1’. desconocido. valor que no importa Las situaciones tipo débil suelen representar situaciones de tipo resistivo. De ahí que la librería IEEE proporciona un paquete llamado “std_logic_1164”. La librería extiende. Aunque es válido no recomendamos la generación de códigos como el anterior. valor lógico bajo débil.
En esta librería se define un nuevo tipo de señal enumerado. Esto es posible debido a que la evaluación tiene lugar en instantes muy precisos de tiempo que dependen sólo de CLK por tanto no tiene importancia el valor de D en el resto del tiempo. situación que es del todo válida. Finalmente es posible escribir este código:
sinc: PROCESS(CLK) BEGIN IF CLK’EVENT AND CLK=’1’ THEN CUENTA<=CUENTA + 1. END PROCESS sinc. estado desconocido débil. • ‘0’. el std_logic. El valor ‘z’ (¡¡minúscula!!) no existe. Es el valor que toma en casos de conflicto. En el capítulo cinco expondremos y analizaremos a fondo un el código de un contador. es el valor por defecto. Hemos descrito un contador.std_logic_1164.¿Realimentación combinacional? END IF. • ‘Z’. representa el estado de alta impedancia. En 44
. Es importante recordar cuales son estos valores y qué representan. el valor lógico bajo. • ‘-‘. • ‘H’. • ‘L’. ya que no está contemplado en este conjunto enumerado. el valor lógico alto. Por ejemplo. La librería IEEE Como se ha comentado la definición BIT resulta insuficiente para describir completamente el conjunto de valores que cualitativamente toma una señal digital.ALL.
En el apartado 6 del capítulo primero describimos como una realimentación combinacional la línea del código anterior. • ‘1’. Prácticamente es obligatorio disponer de una cabecera que declare el uso de esta librería en todos nuestros diseños:
LIBRARY IEEE. Este nuevo tipo de contempla los siguientes valores: • ‘U’. USE IEEE. Realmente el bucle existe pero está seccionado con un registro. • ‘W’.Otra cuestión es que intencionadamente hemos omitido el valor de D en la lista de sensibilidad. como se ha dicho. valor lógico alto débil. -. • ‘X’. el paquete estándar de VHDL. No existe un tratamiento a nivel de interruptor o switch (cosa que sí existe en Verilog). no inicializado.
ya que se limita a las funciones booleanas..<=. Mediante la inserción en la cabecera de
USE IEEE..e: std_logic_vector(8 downto 0). .b: UNSIGNED(8 downto 0). SIGNAL b... se han definido nuevos tipos de datos: UNSIGNED y SIGNED.c : BIT.la librería se contemplan las manipulaciones precisas que permiten el adecuado tratamiento de las señales y sus valores. SIGNAL d.-. SIGNAL x. Son tipos de datos std_logic_vector con la atribución de contemplar el valor de su contenido como entero sin signo el primero y entero con signo y representación en complemento a 2 el segundo.1 Los tipos SIGNED y UNSIGNED. La librería IEEE contiene un paquete de funciones. Asimismo proporciona mecanismos que permiten la conversión entre tipos.
Realizamos las asignaciones
a <= b. Por ejemplo:
SIGNAL x. --También funciona la función conv_signed. No disponemos con la librería std_logic_1164 de una manera de tratar esta situación..y. Por ejemplo podremos definir:
SIGNAL a.. La utilización del tipo std_logic_vector en un diseño en el que se realizan operaciones de cálculo tiene dos dificultades: La primera consiste en que la librería no contiene los operadores aritméticos necesarios para poder realizar los cálculos y la segunda es debida a que el valor que se representa plantea ciertas dificultades debido a la naturaleza ambigua de la representación binaria. También se incluyen las funciones de conversión correspondientes para realizar correctamente las asignaciones. Dentro del paquete se encuentran definidas las operaciones booleanas y los comparadores = y /=. --Se obtiene un error!! Diferente tipo x <= signed(a). para soportar conjuntos ordenados de del tipo std_logic.z : std_logic_vector (8 DOWNTO 0).
. Por ejemplo si un vector tiene el valor “1101” estamos representando ¿qué valor? ¡Depende! Si trabajamos en valores positivos tenemos el 13.y: SIGNED(8 downto 0).>=.. .ABS) y relacionales (<.>. c<=Conv_bit(z(3)). x(5)<=Conv_StdLogic(b).
6. x<=y xor z. De la misma manera están definidos los tipos VECTOR std_logic_vector. pero si trabajamos con representación en complemento a 2 tenemos el –3. Para la segunda dificultad.*.= y /=).ALL. la std_logic_arith que contiene las funciones aritméticas para resolver la primera parte del problema.
disponemos de todos los operadores aritméticos (+. --Son del mismo tipo y funciona x <= a..std_logic_arith.
Cuando se realizan conversiones de tipo en las que hay otros de naturaleza diferente. USE IEEE.
Donde señal2 es un tipo integer ó positive y señal1 es un tipo std_logic_vector.
Donde el tipo de la señal2 sobrecarga la función.2 Las funciones de conversión Como se ha indicado anteriormente. Obviamente el valor de señal2 ha de ser compatible con el número de bits de la señal1. efectivamente al tipo std_logic_vector. En las librerías se incluyen funciones que permiten la conversión de un tipo en otro.
La función tipo_señal1(·) se sobrecarga con el tipo de la señal2. Una cabecera del tipo:
LIBRARY IEEE. De la misma forma se pueden definir las funciones:
señal1 <= conv_unsigned(señal2.
Las funciones que realizan la conversión inversa son:
señal1 <= conv_to_integer(señal2).ALL.b<= unsigned(x) + unsigned(d). las asignaciones solamente se pueden realizar entre tipos idénticos.std_logic_arith.señal1’LENGTH). señal1 <= conv_signed(señal2. El capítulo cinco se dedica al uso de los operadores aritméticos y sus particularidades. USE IEEE.
Extiende.ALL. Existen unas librerías aritméticas reducidas que permiten operar directamente con tipos std_logic_vector dando un tratamiento global. todas las funciones aritméticas quedan definidas para el tipo std_logic_vector y se tratan de modo unsigned. Cuando se trata de convertir entre tipos signed. USE IEEE.std_logic_unsigned. 6. ya que hay que especificar el número de bits de la señal de destino:
señal1 <= conv_std_logic_vector(señal2. pero dentro de la librería std_logic_unsigned. --gracias al mecanismo de sobrecarga d <= std_logic_vector(a) * std_logic_vector(y) --Se obtiene un error!! Operador ambiguo
Mediante este procedimiento podemos definir y controlar la morfología del hardware de los operadores.std_logic_1164. No se obtendría el error del ejemplo anterior. como es el caso de los tipos integer y positive las funciones de conversión son diferentes.ALL.
.señal1’LENGTH). unsigned o std_logic_vector la función de conversión sigue la forma:
señal1 <= tipo_señal1(señal2).señal1’LENGTH).
más legible y más fácil de depurar. concretamente en los flancos activos (de subida o bajada). Todos los ejemplos que propondremos seguirán esta estructura. sucediéndose en instantes muy precisos. Ejemplo 1. clk : IN std_logic.clk) BEGIN IF (resetz=’0’) THEN Salida<=(OTHERS=>’0’). ya que si bien requiere la introducción de un número mayor de líneas de código la descripción es más clara. también llamado proceso de sincronismo.
. Nuestra experiencia nos aconseja mantener este esquema de codificación en dos procesos. por un lado los sistema síncronos y por otro. generador de un registro o banco de flip-flops. entrada : IN std_logic_vector (N-1 DOWNTO 0). EJEMPLOS DE DISEÑO. Se basan en la utilización de una señal de reloj que coordina los cambios en el circuito. Es más. salida : OUT std_logic_vector (N-1 DOWNTO 0) ). END comport. END registro_simple.
Este capítulo incide en aspectos prácticos relacionados con la codificación utilizando el lenguaje VHDL y se basa fundamentalmente en los conceptos introducidos en capítulos anteriores.CAPÍTULO V. PORT( resetz : IN std_logic. END PROCESS sinc. en los sistemas aritméticos. Finalmente proponemos un ejemplo de una memoria de tamaño variable. END IF. uno que recoge la funcionalidad característica del sistema y otro.std_logic_1164.all. Codificación de un registro simple El código es el siguiente:
LIBRARY IEEE. SUBSISTEMAS DIGITALES. Abordaremos dos aspectos esenciales en la codificación de sistemas digitales. ENTITY registro_simple IS GENERIC (N : INTEGER := 5). hemos detectado algunos sintetizadores que no admiten otra manera de introducir la descripción. ELSIF (clk’EVENT) AND (clk=’1’) THEN Salida <= entrada. Codificación de Sistemas Síncronos La descripción sistemas síncronos es una parte fundamental del diseño de sistemas digitales. 1. Todo sistema síncrono se puede descomponer en dos procesos concurrentes. USE IEEE. ARCHITECTURE comport OF registro_simple IS BEGIN Sinc: PROCESS(rstz.
La señal valor se puede quitar. El proceso sinc es una estructura idéntica a la del ejemplo1. ELSIF (clk’EVENT) AND (clk=’1’) THEN valor <= interna. BEGIN Mux: interna <= entrada WHEN (carga =‘1’) ELSE valor. ARCHITECTURE comport OF registro_ carga IS SIGNAL interna. que es más adecuado. Esto indica que el registro cargará un ‘0’ ante un valor ‘0’ de la señal resetz aunque clk fluctúe.std_logic_1164. En primer lugar la señal de reset asíncrono resetz es activa a nivel bajo. END comport. valor : std_logic_vector (N-1 DOWNTO 0). Podría construirse caminando el tipo inout o al tipo buffer. Finalmente hemos omitido la señal entrada de la lista de sensibilidad. clk : IN std_logic.En este ejemplo hemos introducido algunos elementos que merecen ser destacados. interna y valor. END IF. END PROCESS sinc. ya que su función es simplemente la de evitar que la realimentación se produzca sobre la señal salida. En segundo lugar la utilización siempre que sea posible de parámetros en generics ya que su impacto en la complejidad del código en prácticamente nula y permite la reutilización del mismo. ENTITY registro_carga IS GENERIC (N : INTEGER := 5). END registro_ carga. Hemos hecho uso de dos señales auxiliares. --realimentación Sinc: PROCESS(rstz. Codificación de un registro con señal de carga El código es el siguiente:
LIBRARY IEEE. La señal interna es la salida del multiplexor que realimenta el valor almacenado.clk) BEGIN IF (resetz=’0’) THEN valor<=(OTHERS=>’0’). Salida <= valor. Ejemplo 2. entrada : IN std_logic_vector (N-1 DOWNTO 0).
En éste ejemplo hemos utilizado la técnica de dos procesos concurrentes. Tampoco lo definimos tipo buffer porque existen algunos sintetizadores que tratan el
. No se utiliza en tipo inout porque no describe bien el tipo de la señal.1. que al ser de tipo out no puede aparecer a la derecha en una asignación. salida : OUT std_logic_vector (N-1 DOWNTO 0) ). USE IEEE. ya que solamente se actualiza en flancos de clk. de ahí que optemos por la terminación z.all. El análisis de la estructura de sincronismo indica prioridad en la señal de resetz sobre el flanco de reloj clk. PORT( resetz : IN std_logic. carga : IN std_logic. Es buena práctica que aquellas señales definidas como activas a nivel bajo lleven un distintivo.
std_logic_1164. ENTITY registro_carga IS GENERIC (N : INTEGER := 5). USE IEEE. lectura. ELSIF (clk’EVENT) AND (clk=’1’) THEN IF (carga =‘1’) THEN valor <= entrada. N : INTEGER := 5). la deja en alta impedancia. ARCHITECTURE comport OF registro_ carga IS SIGNAL valor : std_logic_vector (N-1 DOWNTO 0).std_logic_arith. END comport.all. pero una descripción más compleja y menos legible. Ejemplo 3.all. Codificación de un contador síncrono El código propuesto es:
LIBRARY IEEE. END IF. clk : IN std_logic. END PROCESS sinc. y en caso contrario. lectura: IN std_logic.
Este código realiza una función idéntica al anterior.std_logic_unsignaed. reservando la palabra buffer para forzar la inclusión de un circuito de amplificación de corriente. Esto es útil en el caso de la construcción de memorias.clk) BEGIN IF (resetz=’0’) THEN valor<=(OTHERS=>’0’).-.std_logic_1164. salida : INOUT std_logic_vector (N-1 DOWNTO 0) ).tipo buffer de una manera no estándar. PORT( resetz : IN std_logic. como la del ejemplo 8. La versión con un solo proceso y con salida en alta impedancia:
LIBRARY IEEE. ENTITY contador IS GENERIC (satur : : INTEGER := 13.poner en marcha el contador
. END IF. BEGIN salida<=valor WHEN lectura=’1’ ELSE (OTHERS=>’Z’). Sinc: PROCESS(rstz. Hemos introducido una señal. clk : IN std_logic. USE IEEE. carga : IN std_logic. entrada : IN std_logic_vector (N-1 DOWNTO 0).all. PORT( resetz : IN std_logic. que pone el valor a la salida. USE IEEE. habilita : IN std_logic.all. END registro_ carga. USE IEEE.
(p.clr: IN std_logic. ELSE interna<=valor + 1. c) El número de ciclos de reloj necesario para saturar el contador es satur +1. ARCHITECTURE comport OF contador IS SIGNAL interna. aunque podría incluirse en el campo port como señal.carga. es decir. se ha utilizado la librería std_logic_unsigned. BEGIN Cont: PROCESS(clr. función que existe en la librería también.puesta a ‘0’ síncrona salida : OUT std_logic_vector (N-1 DOWNTO 0) ). El operador ‘+’ representa la función suma entre los tipos unsigned y entero. Su comportamiento difiere del de resetz. END contador. -. END PROCESS sinc.
. END IF.valor) BEGIN IF (clr=’1’) THEN interna<=(OTHERS=>’0’). END IF. ELSIF (habilita=’1’) THEN IF (valor=satur) THEN -. b) La comparación se realiza entre un tipo unsigned y un entero. ya si clr toma el valor ‘1’. como parámetro.e. El contador dispone de una señal clr de ‘puesta a 0 síncrona’. Hay que puntualizar ciertos aspectos acerca de la comparación del valor corriente con el valor de saturación: a) La comparación se satisface cuando el contador alcanza el valor satur. que debe ser alcanzable por la señal valor. satur = 35 genera un error). Codificación de una máquina de estados finita tipo Moore.comparación de la saturación interna<=(OTHERS=>’0’). END PROCESS cont. En cuanto al operador suma hemos utilizado un esquema global de definición de tipos.habilita.clk) BEGIN IF (resetz=’0’) THEN valor<=(OTHERS=>’0’). el contador evolucionará al valor 0 en el siguiente flanco activo de reloj clk. ELSIF (clk’EVENT) AND (clk=’1’) THEN valor <= interna. Además hemos introducido varios elementos nuevos. Sinc: PROCESS(rstz. END comport. Salida <= valor. ELSE interna<=valor. END IF. El valor de saturación se ha introducido en el campo generic. Esta función está incluida en la librería. valor : std_logic_vector (N-1 DOWNTO 0).
En este ejemplo hemos mantenido la estructura de dos procesos concurrentes y el proceso síncrono es una copia del ejemplo 2. Ejemplo 4.
espera). El código correspondiente a este ejemplo es el siguiente:
LIBRARY IEEE. retorno) BEGIN --salida<=’0’. END comport. END IF.valor salida IF (activacion=’1’) THEN futuro<=activo. END PROCESS fsm. futuro: estado. --valor salida futuro<=espera. END PROCESS sinc. ENTITY maqMoore IS PORT( resetz : IN std_logic. activo. BEGIN fsm: PROCESS ( actual. USE IEEE.std_logic_1164. Sinc: PROCESS(rstz.valor salida IF (retorno=’0’) THEN futuro<=activo. habilita : IN std_logic.poner en marcha el contador clr: IN std_logic.all.Una máquina de estados finitos tipo Moore es una máquina de estados que evoluciona síncronamente en función del estado y las entradas y cuyas salidas toman valores en función del estado en que se encuentra. SIGNAL actual. ELSE futuro<=reposo. END maqMoore.-. activacion. ELSIF (clk’EVENT) AND (clk=’1’) THEN actual <= futuro. clk : IN std_logic. END IF. -. ARCHITECTURE comport OF MaqMoore IS TYPE estado IS (reposo.clk) BEGIN IF (resetz=’0’) THEN valor<=(OTHERS=>’0’). CASE actual IS WHEN reposo => salida<=’0’. sería un valor por defecto. END CASE. -. WHEN retorno => salida<=’0’. WHEN activo => salida<=’1’.
. -.puesta a ‘0’ síncrona salida : OUT std_logic_vector (N-1 DOWNTO 0) ). ELSE futuro<=reposo. ELSIF (activacion=’1’) THEN futuro<=espera. END IF.
En primer lugar los estados se definen como un tipo enumerado.std_logic_1164. Esto significa que la relación entre el código del estado y su nombre viene determinado por su ubicación en la lista de definición del tipo estado. Así el código de reposo es “00” (0). El código “11” (3) no es alcanzable.Este ejemplo muestra el método de resolución de una máquina de estados.-. habilita : IN std_logic. Codificación de una máquina de estados finita tipo Mealy Una máquina de estados finitos tipo Mealy es una máquina de estados que evoluciona síncronamente en función del estado y las entradas y cuyas salidas toman valores en función del estado en que se encuentra y de las propias entradas. el de activo es “01” (1) y el de espera es “10” (2).
ACTIVACION=0 RETORNO=?
REPOSO SALIDA=0
ACTIVACION=0 RETORNO=1 ACTIVACION=? RETORNO=0
ACTIVACION=1 RETORNO=?
ACTIVACION=1 RETORNO=1 ESPERA SALIDA=0
ACTIVO SALIDA=1
Figura 3. que tiene una estructura idéntica al de los ejemplos anteriores.
Finalmente la evolución se produce en flancos activos de reloj mediante el proceso de sincronismo. USE IEEE.poner en marcha el contador
. El código correspondiente a este ejemplo es el siguiente:
LIBRARY IEEE. El mecanismo de construcción es una selección mediante un CASE que define un multiplexor que selecciona el estado futuro en función del estado actual y de las entradas.all. clk : IN std_logic. Ejemplo de máquina de Moore
Ejemplo 5. ENTITY maqMealy IS PORT( resetz : IN std_logic.
clr: IN std_logic. futuro<=reposo. futuro<=activo. ARCHITECTURE comport OF maqMealy IS TYPE estado IS (reposo. espera). END IF. futuro<=espera. END IF. activo. Ejemplo de máquina de Mealy SALIDA=1
. futuro<=espera. -. END maqMealy.valor salida futuro<=reposo. ELSIF (clk’EVENT) AND (clk=’1’) THEN actual <= futuro. futuro: estado. ELSE salida<=’0’. END IF. SIGNAL actual.
ACTIVACION=0 RETORNO=? SALIDA=0
ACTIVACION=0 RETORNO=1 SALIDA=0
ACTIVACION=1 RETORNO=? SALIDA=1
ACTIVACION=1 RETORNO=1 SALIDA=0
ACTIVACION=? RETORNO=0 SALIDA=1
Figura 4.puesta a ‘0’ síncrona salida : OUT std_logic_vector (N-1 DOWNTO 0) ).clk) BEGIN IF (resetz=’0’) THEN valor<=(OTHERS=>’0’). activacion. Sinc: PROCESS(rstz. WHEN activo => salida<=’1’. END PROCESS fsm. END CASE. END PROCESS sinc. retorno) BEGIN CASE actual IS WHEN reposo => IF (activacion=’1’) THEN salida<=’1’. ELSIF (activacion=’1’) THEN salida<=’0’. WHEN retorno => IF (retorno=’0’) THEN salida<=’1’. BEGIN fsm: PROCESS ( actual. END comport. futuro<=activo. -. ELSE salida<=’0’.
En este apartado introducimos unos ejemplos de utilización de estos operadores y de cómo su utilización afectaría al resultado. END Sumador.std_logic_unsigned. B : IN std_logic_vector(S2-1 downto 0). Sin embargo este hecho supone una pérdida en el control de la topología de los propios circuitos. 2. La forma Mealy presenta problemas con los pulsos espúreos (glitches) en las entradas ya que los transfiere a la salida. Una de las grandes aportaciones de los lenguajes de descripción de hardware el la de poder trabajar con operadores aritméticos sin necesidad de preocuparse de su forma o estructura. ARCHITECTURE comport OF Sumador IS BEGIN SUMA <= A+B. que por regla general sigue un patrón regular. mediante la inserción de un signo + ó *. PORT( A : IN std_logic_vector(S1-1 downto 0). Codificación de sistemas aritméticos. USE IEEE. SUMA: OUT std_logic_vector(S1-1 downto 0) --suponiendo que S1>S2 ).std_logic_1164.std_logic_arith. En el caso de una declaración de la librería std_logic_signed obtendríamos un tratamiento equivalente pero las cantidades con MSB=1 se tratarían como complemento a 2.Desde un punto de vista puramente formal no existen razones para recomendar el uso de un tipo de máquina u otro. En este caso los tipos std_logic_vector se considerarán positivos.
El ejemplo propone un sumador totalmente basado en números sin signo. ENTITY Sumador IS GENERIC(S1: integer:=8. Operador aritmético con el signo tratado globalmente. En la era de los esquemáticos había que realizar una verificación exhaustiva del módulo en cuestión mediante un test funcional que prácticamente contemplara todas las posibles combinaciones de las entradas. De alguna manera.all.all. USE IEEE. La forma Moore presenta un filtro a este tipo de efectos. Proponemos un sumador:
LIBRARY IEEE. END comport. USE IEEE.
. pero desde la perspectiva de una buena implementación se recomienda la forma Moore. S2: integer:=5). dejamos que la herramienta de síntesis automática haga el “trabajo sucio”. Ejemplo 6.all.
Resulta. ARCHITECTURE comport OF Sumador IS SIGNAL sgA: signed(S1-1 downto 0).all.all. END comport. USE IEEE. USE IEEE. BEGIN auxA<=”0” & A. La función suma estándar no contempla la posibilidad de que el valor del resultado SUMA exceda de la capacidad de representación del mayor de los valores de A ó B. B : IN std_logic_vector(S2-1 downto 0). S2: integer:=5). USE IEEE. La concatenación se realizaría:
auxA<= A(S1-1) & A. Operador aritmético con el signo tratado localmente.all. END Sumador.
.Por otra parte es interesante observar el tratamiento del bit de acarreo. SUMA: OUT std_logic_vector(S1-1 downto 0) --suponiendo que S1>S2 ). ENTITY Sumador IS GENERIC(S1: integer:=8.std_logic_unsigned. El código del ejemplo anterior se puede escribir:
LIBRARY IEEE.std_logic_arith. SUMA <= auxA + B. sgB<=signed(B). ENTITY Sumador IS GENERIC(S1: integer:=8.
en el caso de trabajar con señales del tipo signed.all. B : IN std_logic_vector(S2-1 downto 0). USE IEEE. USE IEEE. BEGIN sgA<=signed(A). S2: integer:=5). SUMA: OUT std_logic_vector(S1 downto 0) --suponiendo que S1>S2 ). SIGNAL sgB: signed(S2-1 downto 0). --concatenar un cero por delante por ser unsigned.all.std_logic_1164.std_logic_arith. ARCHITECTURE comport OF Sumador IS SIGNAL auxA: std_logic_vector(S1 downto 0). PORT( A : IN std_logic_vector(S1-1 downto 0). muy útil revisar los códigos fuente de las librerías estándar para evitar problemas relacionados con los operadores de este tipo. pues. Es por tanto muy peligroso utilizar estas funciones sin haber protegido esta posibilidad. END Sumador.std_logic_1164. Ejemplo 7. Por tanto proponemos este código:
LIBRARY IEEE. PORT( A : IN std_logic_vector(S1-1 downto 0).
END IF. Para poder utilizar distintos tipos de operandos dentro de la misma operación habría que comprobar si existe la operación en la librería y qué tipo de vectores devuelve. 56
. Nbdirecc. address: IN std_logic_vector(N-1 DOWNTO 0).all. END comport. Utilizaremos tres parámetros libres. El código del decodificador de N entradas puede ser:
LIBRARY IEEE. Un ejercicio muy completo de codificación consiste en la creación de bloques de memoria parametrizados. Memoria RAM síncrona de tamaño genérico. respectivamente el tamaño del bus de direcciones. El mecanismo de sobrecarga se encargará de seleccionar la operación deseada.SUMA <=sgA + sgB. 3. En este caso podríamos mezclar los operandos dentro de la misma entidad. Ejemplo 8. para dimensionar la memoria. USE IEEE. END IF. el número efectivo de registros y el tamaño de cada uno de ellos. BEGIN aux<=CONV_INTEGER(address). Npalabras y Nbpalabra.
Hemos omitido en este caso la librería que trata los operandos globalmente. END decod. Codificación de módulos de memoria. Sin embargo utilizamos los tipos vector con atributo signed para definir el tipo de operando utilizado. END comport.aux) BEGIN IF (enable='1') THEN FOR i IN 0 TO 2**N-1 LOOP IF aux=i THEN pointers(i)<='1' .std_logic_1164. Además construiremos el decodificador de entrada y de salida. ELSE pointers(i)<='0' . END loop. ENTITY decod IS GENERIC(N: INTEGER :=2). dec: PROCESS(enable. END PROCESS dec. PORT ( enable : IN std_logic. ELSE pointers<=(others=>'0'). Con ellos definimos.
Ahora construimos un código para la memoria. ARCHITECTURE comport OF decod IS SIGNAL aux: INTEGER. pointers: OUT std_logic_vector (2**N-1 DOWNTO 0) ). Utilizaremos el registro del ejemplo 2 como un componente de este código.
PORT( resetz : IN std_logic. Dato: INOUT std_logic_vector(Nbpalabra -1 DOWNTO 0). COMPONENT registro_carga GENERIC (N : INTEGER := 5). address=>direccion. salida : OUT std_logic_vector (N-1 DOWNTO 0) ). END GENERATE. punteroescribe : std_logic_vector(2** Nbdirecc-1 DOWNTO 0). SIGNAL punterolee. SIGNAL lee : std_logic.LIBRARY IEEE. BEGIN decodEscr: decod GENERIC MAP(N=>Nbdirecc) PORT MAP(enable => escribe. lectura: IN std_logic. SIGNAL DatoIn. pointers: OUT std_logic_vector (2**N-1 DOWNTO 0) ). clk : IN std_logic. ARCHITECTURE comport OF memoria IS COMPONENT decod GENERIC(N: INTEGER :=2). entrada : IN std_logic_vector (N-1 DOWNTO 0). escribe: IN std_logic. USE IEEE. DatoOut: std_logic_vector(Nbitspalabra-1 DOWNTO 0). decodLect: decod GENERIC MAP(N=>Nbdirecc) PORT MAP(enable => lee.Npalabras: INTEGER :=2. pointers=> punteroescribe). carga : IN std_logic. salida =>Datoout). --Para evitar dejar las señales DatoOut a ‘Z’ mientras se escribe DatoOut <= (OTHERS=>’0’) WHEN(lee=’0’) ELSE (OTHERS=>’Z’). END COMPONENT. clk =>clk. END memoria. address: IN std_logic_vector(N-1 DOWNTO 0). rstz: IN std_logic. PORT ( clk: IN std_logic. entrada =>Datoin. pointers=> punterolee). lee<= NOT escribe. Direccion: IN std_logic_vector(Nbdirecc -1 DOWNTO 0) ). ENTITY memoria IS GENERIC(Nbdirecc: INTEGER :=2.std_logic_1164. END COMPONENT. carga => punteroescribe(i). Nbpalabra: INTEGER :=2). lectura=> punterolee(i).all. FOR i IN 0 TO Npalabras-1 GENERATE reg: registro_carga GENERIC MAP(N => Nbpalabra) PORT MAP(resetz =>rstz. address=>direccion. PORT ( enable : IN std_logic.
Las sentencias finales son un ejemplo de cómo realizar un bus bidireccional típico. --Entrada Dato <= DatoOut WHEN(lee=’1’) ELSE (OTHERS=>’Z’). En este caso el decodificador no se habilitaría y el bus de salida quedaría en alta impedancia. Esto se resuelve mediante las sentencias DatoIn<=Dato. --Salida END comport. Está construido implícitamente utilizando cada registro del bucle generate conectando sus salidas a la señal DatoOut. La activación se realiza mediante la presencia de un decodificador.
En este ejemplo hemos construido un multiplexor realizado con puertas triestado.
. Para este caso hemos puesto una salvaguarda de dejarlo a cero en caso de que se esté en proceso de escritura.--La entrada/salida de Dato es bidireccional. Sin embargo existe el riesgo de dejar el bus en alta impedancia.
. si bien es la más útil desde el punto de vista de un diseñador. Por ejemplo. Mecanismo de simulación. Simulación temporal Es una simulación característica de sistemas ya sintetizados donde se trabaja con circuitos descritos con primitivas y asociados a una tecnología de un fabricante. Por tanto podremos introducir modelos que describen un comportamiento real sin más que implementar sus respuestas funcionales y temporales. que se establece en el entorno de simulación. El objetivo de este capítulo es ofrecer un perspectiva diferente a la hasta el momento expuesta. como spikes. Los retardos inerciales consisten en que el retardo tiene inercia.
. este pulso no tendría suficiente tiempo para vencer la inercia. El VHDL así como el resto de los lenguajes de simulación utilizan un sistema basado en tabla de eventos para evaluar las sentencias del código.CAPÍTULO VI. A partir de una simulación de este tipo diversos comportamientos típicos se manifiestan. Este es el retardo por defecto en VHDL. etc.. Por ejemplo un registro de desplazamiento. El sistema de simulación se basa en la evolución de una variable tiempo que se incrementa en un tiempo mínimo de discretización o delta_time. Esa base de tiempo es el nivel máximo de detalle que permite discriminar la simulación. ya que la visión del VHDL sintetizable ofrece una perspectiva muy parcial del lenguaje. los tiempos de propagación de las señales a través de la lógica se consideran cero y por tanto solamente se tiene en cuenta su respuesta funcional. ya que podremos integrar en el mismo código Sistema y Circuito Digital.. es decir. si una puerta tiene un retardo inercial de 20ns y le llega un pulso en una entrada menor que 20ns. pulsos. por ejemplo 10ns. VHDL NO SIMULACIÓN Y MODELADO
SINTETIZABLE. Ahora podremos desarrollar una perspectiva completa de un sistema. coexistiendo ambos en igual ámbito de simulación. Para poder hacer funcionar la lógica secuencial es imprescindible dotar a los elementos de memoria con un retardo no nulo. Simulación funcional Es una simulación con retrasos en la lógica combinacional nulos. y en la lógica secuencial mayores que cero. 1. Hay dos tipos de retardos: inerciales y de transporte.
En este capítulo haremos una breve introducción a conceptos de VHDL relacionados con su capacidad para describir tecnologías y entornos. La lista de sensibilidad representa un mecanismo para vigilar la evaluación de un proceso cuando la señal sufre un cambio. En este caso la simulación genera formas de onda mucho más cercanas al comportamiento final. y esa ha de ser superada para que el circuito descrito manifieste su valor a la salida. Estas primitivas disponen de datos temporales. Es fácil ver que pasaría en caso de no proceder así.
’0’ AFTER 10 ns. valor AFTER tiempo. Existen tres formas de trabajar con la sentencia wait: 60
Por ejemplo una señal oscilante puede construirse:
clock <= NOT clock AFTER 30 ns. Para simular un retardo de transporte en el que el valor se manifiesta al cabo de un cierto tiempo:
b<=TRANSPORT a AFTER 10 ns.
Señal <= valor AFTER tiempo. END comport. Este modelo de retardo requiere una definición adicional: transport. es decir.. Los incrementos temporales han de ser variables del tipo time. Dado que establece un control sobre el mismo. END and2.
Un comportamiento realista de una primitiva de una puerta AND se describe en el siguiente ejemplo..
Sentencia WAIT Permite al diseñador suspender la ejecución secuencial de un proceso.
Una señal que realiza un pulso a nive bajo durante 1 microsegundo.
Si a sufre un pulso de tamaño menor que 5ns la puerta no sufriría ningún cambio incluso en el caso de que la función lógica obligara a un cambio en la salida. 2. Sentencia AFTER Se utiliza para controlar la evolución de una señal a lo largo del tiempo. ‘1’ AFTER 1 us. . b: IN std_logic. se simulan los retrasos de las puertas lógicas y se incorporan retardos de las líneas obtenidos del programa de ruteado siendo un comportamiento muy próximo al real. Y: OUT std_logic ). El control del flujo de simulación se realiza mediante los siguientes comandos no sintetizables AFTER y WAIT. representando un comportamiento inercial:
ENTITY and2 IS PORT(a. no exista la lista de sensibilidad. Sentencias para modelado. Es por tanto una sentencia que está siempre insertada dentro de la ejecución de un process. .
Rstz<=’1’. más bien referido a conexionados. es decir. ARCHITECTURE comport OF and2 IS BEGIN y <= a AND b AFTER 5 ns. es necesario que el proceso sea de ejecución infinita.El otro modelo de retardo es el de transporte.
¿por qué al final del proceso y no al principio? La respuesta es sencilla. Se vigilan cambios en las señales. Por ejemplo.
WAIT FOR tiempo. • WAIT UNTIL condición. WAIT ON lista de señales. ELSIF (clk’EVENT) AND (clk=’1’) THEN q<=d. se puede escribir:
WAIT UNTIL (a>b) AND (c=’1’). Por ejemplo. También se pueden introducir expresiones complejas que devuelven un valor del tipo time. WAIT ON rstz.b UNTIL (a=’1’) AND (b=’0’) FOR 5 ns. si a y b son del tipo time:
WAIT FOR (a-b). Durante la inicialización de los mecanismos de 61
. Se detiene el proceso a la espera que las señales que contiene la lista sufran algún evento. Se ha comentado el hecho de que la lista de sensibilidad y la sentencia wait on al final del proceso son equivalentes. END PROCESS. Se pueden realizar complejas combinando las diferentes formas anteriores. END IF. En este caso se realiza el and de todas las combinaciones:
WAIT ON a.• WAIT ON lista de señales.clk.
Se esperaría un cambio en a y b. Realmente cuando existe más de una señal se vigila el or de los atributos EVENT de las señales. La variable debe ser del tipo time. WAIT UNTIL condición. continuará cuando este cambio satisfaga la condición pero al cabo de 5 ns. Condiciones complejas.
Realizando la sentencia WAIT ON la tarea de la lista de sensibilidad. La condición que se vigila en este caso es el cumplimiento de una sentencia booleana. Pero.
es una expresión válida. • WAIT FOR tiempo. Por ejemplo el típico proceso de sincronismo se podría escribir:
PROCESS BEGIN IF rstz=’0’ THEN q<=’0’.1 Lista de sensibilidad y WAIT ON. Detiene el proceso durante un tiempo Igualmente es posible realizar combinaciones de distintas Veamos algunos conceptos asociados a estas sentencias. de lo contrario el proceso permanece suspendido. Se vigila el cumplimiento de una sentencia. 2. si a y b son cantidades numérica y c un std_logic.
WAIT ON a. que se estimula determinando los valores de las señales externas al mismo. Por tanto para evitar que no se detenga la ejecución del mismo durante los tiempos iniciales es preciso situar wait on al final. k no evaluará correctamente la expresión de b.
PROCESS BEGIN k<=0. END PROCESS. 3. Típicamente las dos señales más comunes son el reloj (clk) y la inicialización asíncrona (rstz). ya que se tomará el valor que k tuviese cuando se evalúa el proceso.
Para poder insertar la sentencia wait es preciso eliminar la lista de sensibilidad. El efecto es que se puede evaluar dicha sentencia debido a que se espera durante un paso de simulación y el simulador la evalúa. En la práctica una simulación se realiza en lo que se conoce como un “test bench”. END PROCESS. END IF. IF (k=’0’) THEN b<=a. La sentencia wait permite resolver este conflicto. WAIT FOR 0 ns. Una asignación de una señal dentro del proceso no es efectiva hasta la resolución del mismo al final. Obviamente la alternativa más elegante y correcta es la de transformar k en una variable. independientemente de su lista de sensibilidad. IF(a=’1’) THEN k<=’1’.simulación todos los procesos se ejecutan una vez. 2. ELSE b<=’0’. Además suele 62
. Esto no ocurre así con las variables temporales (tipo variable). si se inserta una sentencia wait on después de cada sentencia secuencial. ELSE b<=’0’. En el capítulo 3 se explica cómo se producen las asignaciones de señales (tipo signal) dentro de los procesos.
En este caso k no toma un nuevo valor hasta el final del proceso. es decir. Veamos un pequeño ejemplo:
PROCESS(a) BEGIN k<=0. Construir un “Test Bench”. WAIT FOR 0 ns. END IF. END IF. IF (k=’0’) THEN b<=a. IF(a=’1’) THEN k<=’1’. Éste consiste en un banco de pruebas de nuestro circuito. END IF.2 Concurrencia de procesos.
clk <= NOT clk AFTER 20 ns. por ejemplo. Una fuente de datos suelen ser los ficheros. un motor eléctrico.introducirse un modelo del sistema exterior al circuito. las valores de los pixeles de una imagen. 3.
Un segundo elemento es el reloj. Un entorno de simulación puede registrar señales internas a un circuito y representarlos en formas de onda. Modelo general de un "test bench" Típicamente un test bench es una entidad sin entradas ni salidas aparentes.. …. La figura representa un esquema de los posibles elementos de un “test bench”. una señal muestreada de un convertidor A/D. ….1 Modelo de “test bench”. etc. Al manejo de ficheros dedicaremos la sección 4.. Todo buen diseñador debe poner cuidado en conseguir que el circuito funcione con un estado inicial bien conocido. de ahí que sea aconsejable trabajar siempre de esta forma. Asimismo precisa de un valor inicial y éste se especifica en su declaración inicial.
Definimos clk como una señal que oscila a 50 Mhz.. El VHDL permite su lectura y el gobierno de la misma. CLK
UUT RSTZ
Ilustración 5. . La asignación es concurrente con el componente que simulamos.
SIGNAL rstz : std_logic. En nuestro caso lo denominamos clk:
SIGNAL clk : std_logic :=’0’.
. También un sistema de ficheros es un mecanismo útil para registrar resultados. que usualmente contienen medidas reales de un sistema. Asimismo se establecen condiciones temporales que gobiernan señales y modelos.
ENTITY tb IS END tb. El tercer elemento es la señal de inicialización asíncrona.
En ella existe el tipo básico FILE. Para poder acceder a un objeto del tipo fichero ha de declararse la librería estándar TextIO:
USE std. B=>Bi. ’0’ AFTER 100 ns. SIGNAL Ai. La librería TextIO Uno de los paquetes de librerías predefinidas es el que permite acceso a ficheros que almacenan datos y permite. Los ficheros han de ir formateados según especifique el usuario.
Básicamente hemos representado un monostable. datos separados por espacios. ’1’ AFTER 100 ns. …. Obviamente el cuarto elemento es el propio circuito objeto de diseño. ARCHITECTURE ej OF testbench IS COMPONENT nand PORT ( A. La línea es la unidad de transferencia fundamental.in”. El procesamiento de un fichero se produce dentro de un proceso. Y=>Yo).all. ha de repetirse la estructura de una línea. Una línea es una cadena de caracteres. Y: OUT std_logic). que concluye con un retorno de carro. La librería permite tanto escribir como leer datos formateados de ficheros.…. Yo: std_logic. por tanto la inserción de datos en el circuitos generados para la realización. BEGIN Uut: nand PORT MAP(A=>Ai. rstz <= ‘1’. Bi <= ’0’. ’1’ AFTER 150 ns. Son ficheros de caracteres ASCII. cuya ejecución ha de coordinarse cuidadosamente con señales que lo activan y los valores obtenidos del fichero. FILE outfile : TEXT IS OUT “fichero.textio. que se utiliza dentro de la sección declarativa de un proceso:
FILE infile : TEXT IS IN “fichero.out”. ’1’ AFTER 50 ns. que en este caso actúa como una unidad de jerarquía inferior. B: IN std_logic. END ARCHITECURE ej. ‘0’ AFTER 10 ns. es decir.
. Ai <= ’0’. Bi. END COMPONENT. Veamos un ejemplo completo:
ENTITY testbench IS END ENTITY. ‘1’ AFTER 40 ns. por ejemplo de pruebas complejas.
rst: IN std_logic. S_a: IN std_logic. SIGNAL t_rst : std_logic .y de la misma manera se declara la línea como una variable del tipo line:
VARIABLE lineaent. USE IEEE. t_sd: std_logic := '0'. TYPE luces IS (rojo. ARCHITECTURE tbench_1 OF testbench IS COMPONENT sf PORT ( clk: IN std_logic. t_sb.textio. lineaent). ENTITY testbench IS END testbench. WRITE(lineasal.B S_c: IN std_logic. SIGNAL rav0. -.all. END COMPONENT .
Para copiar una línea del fichero de entrada sobre la variable tipo line se utiliza la función READLINE y para escribir sobre el fichero de salida una línea se utiliza la función WRITELINE.D rav0: OUT std_logic _vector (2 DOWNTO 0). lineasal: LINE. amarillo.
Para controlar el fin de fichero se utiliza la función ENDFILE:
WHILE NOT( ENDFILE( infile )) LOOP ……. argumento2). Su sintaxis es:
READLINE(infile.
Finalmente para extraer un argumento de la línea leída se utiliza la función READ y para escribirlo WRITE:
READ(lineaent. verde. -.lineasal). READ(lineaent. SIGNAL t_clk : std_logic := '0'.
LIBRARY IEEE. argumento1).
Finalmente para escribir argumentos:
WRITE(lineasal. -. argumento1). USE std. WRITELINE(outfile.Luces calle 0 rav1: OUT std_logic _vector (2 DOWNTO 0) -. SIGNAL t_sa.C S_d: IN std_logic.all. -. END LOOP.Luces calle 1 ). argumento2).rav1: std_logic _vector (2 DOWNTO 0)..sensORes A S_b: IN std_logic. error). -.std_logic_1164. t_sc.
rav1) FILE fout: TEXT IS OUT "fout.str0). rav0=>rav0. WRITE (linea. calle1: luces. ELSE calle1 <= error. S_c=>t_sc. textOUT: PROCESS(rav0. rav1=>rav1 ). rst=>t_rst. S_a=>t_sa. t_sa <= '0'. rav1) BEGIN IF (rav0 = "100" ) THEN calle0 <= rojo. S_b=>t_sb. VARIABLE espacio: string(1 TO 5) := " ". ELSIF (rav1 = "010" ) THEN calle1 <= amarillo. ELSIF (rav0 = "010" ) THEN calle0 <= amarillo. WRITE (linea. BEGIN uut : sf PORT MAP ( clk=>t_clk.linea). BEGIN WRITE(linea.SIGNAL calle0. VARIABLE str1: string(1 TO 5) := "rav1=". t_clk <= NOT t_clk AFTER 50 ns.dat". IF (rav1 = "100" ) THEN calle1 <= rojo. WRITE (linea. ELSIF (rav1 = "001" ) THEN calle1 <= verde. espacio). WRITELINE(fout. VARIABLE linea: LINE. WRITE (linea. END PROCESS. '1' AFTER 55 ns. PROCESS(rav0.
. END PROCESS. rav0). END IF. VARIABLE str0: string(1 TO 5) := "rav0=".str1). ELSIF (rav0 = "001" ) THEN calle0 <= verde. ELSE calle0 <= error. END IF. rav1). t_rst <= '0'. '1' AFTER 1000 ns. S_d=>t_sd. END tbench_1.
More From This UserManual IdocsMetodo Expand ALVWeb Service en Sap13.12.18 taw 10.1Programacion de Dispositivos Movilesalvarojimenez descriptoresGranulometria en Speckleenfoques
19983234 Diseno de Sistemas Digitales Vhdl Dsd Vhdl by Carmen Cordera7.4K viewsEmbedDownloadRead on Scribd mobile: iPhone, iPad and Android.Copyright: Attribution Non-Commercial (BY-NC)List price: $0.00Download as PDF, TXT or read online from ScribdFlag for inappropriate contentMore informationShow less
RelatedLenguajes Hdlby Jesus VargasUNIDAD 4.docxby Jose Antonio VazquezProgramación de Circuitos Secuenciales con HDLby malibu_19Vhdl Tutorialby voltersasTutorial VHDLby Percy Julio Chambi PaccoMaquinas de Estados Mealy Vhdlby Francisco Javier Herrera HernandezProgramacion de Circuitos Combinacionales Con Hdlby Taz Hernandez DeVHDL Maxinezby santanas93Curso P Electricos y a Digitales_V_1_7by maleyojedaintvhdl.pdf (VHDL)by Erick CeballosLenguaje Hdlby Isacar Vela4.1 DISPOSITIVOS LOGICOS PROGRAMABLESby Eva VelazquezManual Vhdlby api-25916287UPM - Introducción al lenguaje VHDLby AldoAxelControl de un teclado mediante VHDLby Leger BlackCIRCUITOS COMBINACIONALESby chinguitoTaller de Programacion Concurrente 1 de 17by jlarico.comPrincipios Electricos y Aplicaciones Digitales ISCby Mario EscalanteVHDL - Descripción Serie Comportamentalby Erika ErikjaReloj Digitalby Sharito CastellonProgramacion en CUPLby api-27527336apuntes_vhdlby Gabo HernandezEjercicios Resueltos VHDL2006by elfrichDiseño de circuitos secuenciales en VHDLby aseraquilesIntro Vhdlby jolmos_77Unidad III y IV Lenguajes y Automatas iby José Del Carmen Mendez CandelariaDISEÑO LOGICO CON PLDSby Edwuard Valencia MendozaPrincipios electricos - Investigación unidad 3by Adair NavarroSimilar to diseño de sistemas digitales vhdl (dsd vhdl)Lenguajes HdlUNIDAD 4.docxProgramación de Circuitos Secuenciales con HDLVhdl TutorialTutorial VHDLMaquinas de Estados Mealy VhdlProgramacion de Circuitos Combinacionales Con HdlVHDL MaxinezCurso P Electricos y a Digitales_V_1_7intvhdl.pdf (VHDL)Lenguaje Hdl4.1 DISPOSITIVOS LOGICOS PROGRAMABLESManual VhdlUPM - Introducción al lenguaje VHDLControl de un teclado mediante VHDLCIRCUITOS COMBINACIONALESTaller de Programacion Concurrente 1 de 17Principios Electricos y Aplicaciones Digitales ISCVHDL - Descripción Serie ComportamentalReloj DigitalProgramacion en CUPLapuntes_vhdlEjercicios Resueltos VHDL2006Diseño de circuitos secuenciales en VHDLIntro VhdlUnidad III y IV Lenguajes y Automatas iDISEÑO LOGICO CON PLDSPrincipios electricos - Investigación unidad 3diseño de sistemas digitales vhdl (dsd vhdl)

References: resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución