introduccion al vhdl

TÉCNICAS DIGITALES 1 ING. JUAN E. COLLAZO Introducción al VHDL Rv. 15 Pág. 1/50

INTRODUCCIÓN AL LENGUAJE VHDL

INTRODUCCIÓN.................................................................................................................3

ESQUEMA TÍPICO DE UN DISEÑO CAD ..........................................................................3

CONSTRUCCIONES BÁSICAS EN VHDL:.........................................................................4

Las Entidades (“ENTITY”): ............................................................................................................4 Las Arquitecturas (“ARCHITECTURE”): .......................................................................................4 Las Bibliotecas (“LIBRARIES”):.....................................................................................................5 Las Configuraciones (“CONFIGURATION”):.................................................................................6

Ejemplo 1: diseño de una compuerta And de 2 entradas. ................................................................................. 6 Puertos: ....................................................................................................................................................7 Modos:......................................................................................................................................................7

Distintos tipos de arquitecturas: ....................................................................................................8 - por comportamiento, ..............................................................................................................................8 -- algorítmico,............................................................................................................................................8 -- flujo de datos:........................................................................................................................................8 - estructural:..............................................................................................................................................8 Sentencias en VHDL: concurrencia y secuencialidad .............................................................................9 Procesos.................................................................................................................................................10 Sentencia Process (proceso) .................................................................................................................10

Elementos del lenguaje......................................................................................................10

1.- Identificadores:.......................................................................................................................10 2.- Objetos:..................................................................................................................................11

Constantes: ............................................................................................................................................11 Variables:................................................................................................................................................11 Señales:..................................................................................................................................................11

Ejemplo 2: una suma de productos lógicos.................................................................................................... 12 Archivos (files): .......................................................................................................................................12

3.- Tipos de datos........................................................................................................................12 4.- Delimitadores: ........................................................................................................................14 5.- Comentarios:..........................................................................................................................14 6.- Los Literales...........................................................................................................................14 7.- Los operadores ......................................................................................................................15 Atributos ......................................................................................................................................16

Atributos para arrays: .............................................................................................................................16 Atributos para señales:...........................................................................................................................17 Atributos para tipos de datos enumerados ............................................................................................17

Ejemplo 3: la compuerta AND empleando otro tipo de datos ........................................................................ 17 Visibilidad de elementos en la estructura de un programa VHDL...............................................18 * Uso de Sentencias Concurrentes .............................................................................................19

* Procesos concurrentes con asignación simple....................................................................................19 Ejemplo 4: sea diseñar un circuito que realice la función lógica BCACY .. += .................................... 19

Biblioteca IEEE (Paquete Std_logic_1164)...........................................................................................20 * Procesos concurrentes con asignación condicionada (sentencia when .... else) .............................20

Ejemplo 5:........................................................................................................................................................ 21


* Procesos concurrentes con asignación seleccionada.........................................................................21 Ejemplo 6:........................................................................................................................................................ 22 Ejemplo 7: se introduce una variante que contempla el caso de que C no sea sólo 0 ó 1. .............................. 22

* Procesos concurrentes con asignación seleccionada y vector datos .................................................23 Ejemplo 8:........................................................................................................................................................ 23 Ejemplo 9: variante del ejemplo anterior usando representación octal:.......................................................... 24

* Uso de sentencias secuenciales (Procesos) ............................................................................24 Uso de la sentencia WAIT dentro de un Process........................................................................24

* Procesos secuenciales con asignación seleccionada.........................................................................26 Ejemplo 10: diseño de un Mux de 2 canales en forma secuencial seleccionada............................................. 26 Ejemplo 11: una forma más simple de Mux de 2 canales que la anterior:...................................................... 28

* Procesos secuenciales con asignación condicionada.........................................................................28 Ejemplo 12: diseño de un Mux de 2 canales en forma secuencial condicionada............................................ 28 Ejemplo 13: descripción estructural del multiplexor simple de 2 entradas..................................................... 29

* Otros paquetes y sus tipos de datos. Funciones de conversión..............................................30 Paquete Numeric_std............................................................................................................................30 Más operaciones con vectores: conversores de códigos BCD.............................................................32

Ejemplo 14: diseño del conversor bcd nat a aiken usando el package Numeric_std ...................................... 32 A modo de ejemplo se transcriben la simulación efectuada y las salidas obtenidas:....................................... 33 Ejemplo 15: Conversor BCD natural a Aiken con sentencias secuenciales.................................................... 34 Ejemplo 16: Conversor BCD natural a Aiken con creación de tipo de datos ................................................. 34

Manejo de datos.....................................................................................................................................35 Ejemplo 17: diseño de un conversor de Código Gray a Código binario ......................................................... 35

Operaciones Lógicas sobre Vectores ....................................................................................................36 Ejemplo 18: Conversor de Código Gray a Código binario operando sobre vectores...................................... 36

DISEÑO ESTRUCTURAL : Instanciación de componentes ....................................................37 Ejemplo 19: describir un Mux de 2 canales en base a instancias de una Nand de 2 entradas........................ 37 Otro ejemplo con una instanciación más amplia se ve a continuación. ........................................................... 38 Ejemplo 20: describir un Mux de 16 entradas en base a instancias de un Mux de 4 entradas ..................... 38

Sentencias iterativas ...................................................................................................................39 Ejemplo 21: Mux de 16 entradas por reiteración de instancias de un Mux de 4 entradas............................ 39

Sentencia iterativa concurrente FOR ... GENERATE ............................................................................39 Sentencia iterativa concurrente IF ... GENERATE.................................................................................40 Sentencia iterativa secuencial LOOP (lazo)..........................................................................................40 Codificadores..........................................................................................................................................41

Ejemplo 22: codificador de prioridad (8 a 3 líneas) usando while ... loop...................................................... 41 Funciones de Resolución ............................................................................................................42

Variables y Señales en procesos secuenciales .....................................................................................42 Ejemplo 23: asignaciones múltiples a variables y señales ............................................................................ 43 Ejemplo 24: variante sacando variables fuera del Process........................................................................... 44

Palabras reservadas del VHDL ...................................................................................................44 Sentencias Secuenciales y Concurrentes..............................................................................................46 Tabla de Paquetes, tipos de datos y funciones de conversión..............................................................47

Plantillas de comandos de VHDL (Quartus II - Altera) ................................................................49


INTRODUCCIÓN El avance del desarrollo tecnológico en electrónica, determinante del incremento de componentes que se integran en chips de silicio conduce a la creación de circuitos integrados cada vez mas complejos y que permiten a su vez la obtención de múltiples y complejas funciones lógicas en un sólo dispositivo integrado. Esto a su vez determina la necesidad de expresar esas funciones lógicas de una manera más cómoda y a la vez, proceder al diseño de los circuitos lógicos cambiando las maneras tradicionales por otras acordes al volumen de componentes y expresiones. La herramienta para lograrlo, como no podría ser pensado de otra manera, es recurrir a desarrollos de software. Se comenzó a comprobar lo engorroso de obtener descripciones de circuitos digitales complejos mediante esquemas y se pensó en la conveniencia de lograr también mediante programas, la manera de obtener descripciones circuitales (hardware). Por otra parte, la complejidad de los circuitos que se van logrando hacen necesario a la vez incorporar procesos que permitan al diseñador verificar si lo que se está desarrollando cumple lo que se pretende, para lo cual, un camino es poder simular comportamientos. Estos antecedentes, sintéticamente, marcan la aparición de “lenguajes descriptores de hardware” (Hardware Description Languages). Así, en la década del ’80 el Departamento de Defensa de los EE.UU de Norteamérica promovió el desarrollo del VHDL, luego normalizado por el IEEE. cuya sigla corresponde a VHSIC HDL, esto es Very High Speed Integrated Circuits HDL (lenguaje descriptor de hardware para circuitos integrados de muy alta velocidad) Este lenguaje, a la vez de utilizarse para el modelado y síntesis de circuitos, sirve también como documentación de desarrollos.

ESQUEMA TÍPICO DE UN DISEÑO CAD 1 El proceso de un desarrollo utilizando herramientas de software sigue, como línea general, los pasos que esquemáticamente se muestran a continuación los cuales, dependiendo de los distintos fabricantes y diseñadores pueden presentar ligeras variantes:

Especificacióndel circuito

Síntesis

SimulaciónFuncional

Diseñoes OK?

No Sí

Programación yConfiguración

Análisis ySimulaciòntemporal

Cumple requisitostemporales?

Ajuste

Sí

No

Sí

fig. 1

1 Computer Aided Design = diseño asistido por computadora


En el mismo, se ve como primer estadío la especificación del circuito deseado, el cual se puede hacer por medio de un diagrama esquemático o bien por una descripción mediante un lenguaje de Hardware como Verilog o VHDL. De ella se pasa a la síntesis (realización) del circuito, que se concreta mediante una lista de elementos lógicos necesarios para realizarlo y también un detalle de sus interconexiones. Para ver que todo esté bien, se recurre en tercer instancia a una simulación, que en principio no toma en cuenta cuestiones temporales (retardos, etc.) De estos pasos se hace una primer evaluación para ver si todo funciona ok y si es así se continúa. El programa de diseño debe tener herramientas para hacer corresponder los elementos lógicos que se encontraron necesarios en la síntesis con el chip (FPGA) que contiene las unidades físicas. De aquí se pasa a analizar las propagaciones de tiempo que esas unidades físicas reales presentarán a las distintas señales del circuito que se diseña y se cotejará si cumplen con expectativas previas de performance del circuito, si las hubiera. Se lo prueba y se verifica que así sea. Si esto anda bien, se pasa a la última etapa en que se programa la configuración de cableado interno de los elementos lógicos de la FPGA, que materializan las señales que se acaban de simular.

CONSTRUCCIONES BÁSICAS EN VHDL: Para encarar el diseño de dispositivos en VHDL existen estructuras de nivel superior que son los denominados Archivos de diseño. En ellas se engloban todos los programas que conducen a la creación de esos dispositivos, a nivel de software. Estos archivos pueden estar compuestos por una o más unidades menores que se denominan Unidades de diseño y que a su vez pueden formar parte de otros archivos de diseño. El diseño en VHDL en general puede emplear cuatro bloques: Las Entidades (“ENTITY”):

Unidad 1Unidad 2

Circuito 3Circuito n

Package NNN......................Entity PPP is ......................

Architecture XXof Entity PPP is...................

Archivo de diseño n

Unidad 1Unidad 2




Archivo de diseño k

Archivo de diseño 1

Circuito 1Circuito 2




fig. 2 Son la representación de lo que se quiere diseñar en su relación con el mundo exterior. Su modelización se hace definiendo las “puertas” con el exterior y los parámetros de la entidad. Esta forma que tiene el VHDL de presentar un circuito, se la podría asimilar a la forma que tienen los fabricantes de circuitos integrados de presentarlos en sus hojas de datos en las que, entre otros aspectos, introducen un esquema como caja negra con entradas y salidas (ver fig. 3). Las Arquitecturas (“ARCHITECTURE”): Definen la funcionalidad del dispositivo y la manera que adopta dicha funcionalidad. Establecen una forma de procesar la información que maneja la Entidad para cumplir su función. En definitiva, el bloque de arquitecturas representa lo que hay en el interior de la “caja negra”. Haciendo el paralelo con la forma de presentar el circuito por parte de quien lo fabrica, equivale a escribir las Tablas de verdad, con que se especifica lo que hace el circuito o bien al Diagrama circuital, que vincula las entradas con las salidas (ver fig. 4).


fig. 3

fig. 4

Las Bibliotecas (“LIBRARIES”): Lugar donde se almacenan determinados componentes y elementos que se van a utilizar en los diseños. Según las características de esos elementos, se agrupan en paquetes (“PACKAGES”) 2 que son (grupos de) declaraciones e informaciones que los bloques anteriores toman como referencia para armar el modelo. Tiene dos partes: - Package Declaration (declaración del paquete) - Package Body (cuerpo del paquete) A continuación se muestra una parte del "cuerpo" de la librería Standard de la norma IEEE 1076.93

2 - Un package es lo que en C se llama Library: son las descripciones


package standard is type boolean is (false,true); ... type character is ( nul, soh, stx, etx, eot, enq, ack, bel, ... ' ', '!', '"', '#', '$', '%', '&', ''', ... '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', ... ; type severity_level is (note, warning, error, failure); type integer is range -2147483647 to 2147483647; ... end standard; fig. 5

Compuertas Funciones

+

**

/

Circuitos Tipos

Type octeto is ...

Type palabra is ...

Type xxxxx is ...

Bloques

Las Configuraciones (“CONFIGURATION”): Son descripciones que establecen una manera por la cual se vinculan la entidad y la arquitectura. (no en todos los paquetes disponibles para síntesis en VHDL). Las unidades de diseño en VHDL siempre contendrán Entidades y Arquitecturas, pudiendo los otros ser opcionales de declaración. Si no se declara ninguna biblioteca, ni ningún paquete en particular, se toma la denominada Standard y sus paquetes del mismo tipo. Se verá un ejemplo sencillo de cómo hacer un diseño en VHDL. Antes se pueden destacar algunas características del lenguaje que deberán observarse para obtener el éxito en la programación:

• Los objetos en VHDL deber estar claramente definidos con nombre y tipo antes de ser invocados. Las operaciones que con ellos se hagan deben respetar el tipo de operandos y de resultados.

• VHDL no es sensible al tamaño de letra, por lo cual, los elementos del lenguaje pueden ser enunciados tanto en mayúscula como minúscula y representarán al mismo.

• El lenguaje admite la inclusión de comentarios junto con las sentencias y declaraciones, en la misma linea u otra, para lo cual deben tipearse dos guiones sucesivos previo al texto correspondiente. Finalizan cuando la línea termina.

• Deben conocerse las palabras reservadas del VHDL y evitar su uso en elementos y sentencias que no sean aquéllos para los cuales están destinadas.

Ejemplo 1: diseño de una compuerta And de 2 entradas. --Diseño de una And de 2 entradas -- Definición de la entidad ENTITY and2in IS PORT (a : IN BIT; b : IN BIT; y : OUT BIT); END AND2IN; -- Definición de la arquitectura ARCHITECTURE comportamiento OF and2in IS BEGIN y<= a AND b; END comportamiento;


De este primer ejemplo se puede ver lo siguiente:

• Además de los comentarios se pueden dejar renglones en blanco, que facilitan la lectura. • Este diseño contiene sólo una Entidad y una Arquitectura.

¿Qué elementos se encuentran en esta descripción? 1) Un bloque entidad: que tiene generalmente una estructura de declaración como la que sigue: entity <identificador> is [cabecera] [declaraciones] [sentencias] end [entity] <identificador> el símbolo [ ] define que se trata de un campo o parámetro optativo. Puertos: La entidad es la definición de un diseño visto como "caja negra". Se declaran en ella dos objetos: los puertos (o puertas) y los parámetros. En este ejemplo las puertas se declaran con la palabra reservada PORT (es un identificador propio del VHDL; más adelante se verá que hay otros identificadores que se utilizan para nombrar otros objetos). Tiene la siguiente sintaxis: port <identificador>: [modo] tipo [:=valor inicial] Como cabecera se definen las señales a, b como entradas (IN) e y como salida (OUT) y el tipo de datos (tema que se desarrollará en el punto 3 del tema “Elementos del Lenguaje”) asociados a ambas, en este ejemplo es BIT. Éste significa que la señal sólo puede adoptar valores 0 y 1. Declaraciones: en esta sección se formulan tipos, subtipos y otros elementos del lenguaje que se verán oportunamente. A veces se incluye la declaración de parámetros especiales para mejorar ciertos aspectos de diseño, versatilidad, etc. Se introduce mediante la palabra reservada GENERIC (ver anexo Sintaxis VHDL). Sentencias: es un espacio en el que se incluyen un tipo especial de sentencias. a, b, y son los identificadores IN es el modo de las señales a, b (modo entrada), OUT es el de y (modo salida). Al definirse puertas (sentencia PORT) inmediatamente corresponde asignarle un modo. Modos: se refieren a la dirección que tienen las señales con que el circuito se comunica con el exterior. Se enumeran a continuación y se detalla también las características que permiten la conexión entre puertas, según sea su modo: - In: (entrada) corresponde a aquéllas que sólo pueden ser leídas pero no pueden ser modificadas (corresponde a terminales de entrada de un circuito). Es un modo por defecto, esto es, se adjudica si no se especifica. Se puede conectar a otros puertos de modo in, inout o buffer. - Out: (salida) corresponde a las que pueden ser modificadas pero no leídas por el circuito. Puede conectarse a puertos out o inout - Inout, (entrada/salida) corresponde a un puerto de tipo bidireccional (asociado a una salida tri-state, por ejemplo); puede ser leído y modificado. Puede asociarse sólo a otros puertos del mismo modo. - Buffer, es una puerta de salida que está siempre activa. Puede ser leída y modificada. Sólo admite una sola fuente de escritura y puede asociarse sólo a otro puerto buffer. - Linkage, es un modo de lectura y escritura, pero solo puede ser asociado a puertos del mismo modo. (no se lo usará)


La entidad finaliza su cuerpo con la palabra “end” y a continuación el nombre de la entidad. En el ejemplo –ex-profeso, se la tipeó en mayúsculas, a diferencia de la declaración, y fue reconocida. 2) Un bloque de Arquitectura: a ésta se la declara siguiendo un esquema particular dentro del modelo que sigue, o sea, no necesariamente aparecerán todos los elementos que abajo se detallan: ARCHITECTURE<identificador(de la arquit)>OF<identificador (de la entidad)>IS declaración de señales locales declaración de constantes locales declaración de tipos y subtipos declaración de componentes declaración de atributos declaración y cuerpo de subprogramas BEGIN -- Asignaciones simples (opcional)

-- Process Statement (optional) -- Concurrent Procedure Call (optional) -- Concurrent Signal Assignment (optional) -- Conditional Signal Assignment (optional) -- Selected Signal Assignment (optional) -- Component Instantiation Statement (optional) -- Generate Statement (optional) END [ARCHITECTURE] <identificador (de la arq.)>;

zona de

declaraciones (no van todas)

zona de sentencias (no van todas)

Distintos tipos de arquitecturas: un dispositivo se puede describir en VHDL de diversas formas: - por comportamiento, Describe un circuito de manera abstracta, indicando cómo se comporta. Explica una relación entre entrada-salida del mismo sin entrar en los detalles de construcción de los elementos que establecen esa relación. Puede ser de dos formas dependiendo del nivel de abstracción y de la forma de ejecutar las instrucciones: -- algorítmico, la descripción algorítmica detalla acciones que debe realizar el dispositivo para cumplir su funcionalidad como si fuera un algoritmo de software. -- flujo de datos: existe una descripción de las señales del circuito y su comportamiento en función de las entradas por medio de expresiones lógicas. También se la denomina de transferencia entre registros (RTL). - estructural: el nivel de descripción estructural consiste en enumerar los componentes de un circuito y describir sus interconexiones. Hay dos formas de hacerlo. -- mediante esquemas (haciendo una descripción gráfica de los componentes del circuito) -- mediante lenguaje (se hace una enumeración de los componentes y su conexionado) Volviendo al ejemplo de la And x 2 in: se puede ver que presenta una arquitectura muy simple y por lo tanto tiene pocos opcionales. En primer lugar, corresponde decir que como identificador de la misma (“comportamiento”) se buscó una palabra que tiene que ver con una de las formas de definir una arquitectura. A continuación y en la misma sentencia, corresponde introducir (luego de OF) el nombre de la entidad cuya arquitectura se va a establecer. Como las únicas señales que va a tener el circuito son las dos entradas (a, b) y la salida (y) que ya fueron introducidas en la cabecera, no se hacen declaraciones y se pasa al cuerpo de la arquitectura que es la parte de ella donde se describe lo que hace el circuito (el cómo lo describe alude a lo que se mencionó más arriba como “comportamiento”). El comienzo del cuerpo lo da la sinónima palabra “BEGIN”. Lo que sigue es la asignación a señal (en este caso de salida):


y<= a AND b significa que a “y” se le asigna (operador relacional de asignación “<=”) un estado que surge de una operación entre señales vinculadas por el operador lógico AND El cierre se hace nuevamente con “end” y el nombre (identificador) de la arquitectura. También se destaca (y es muy común olvidar), el cierre de arquitectura, entidad, y sentencias con un operador “;” . De no hacerse, aparecerá como error al compilar el programa. Sentencias en VHDL: concurrencia y secuencialidad Si más arriba se dijo que las arquitecturas representan el interior de la caja negra que define el circuito, lo que en los dispositivos físicos se conforman con compuertas, componentes y líneas de conexión (hardware); en una construcción de software los elementos serán las sentencias Un lenguaje que describa lo más próximo a la realidad el comportamiento de los circuitos, deberá tener en cuenta que en ellos el procesamiento de las señales se hace en forma simultánea, a partir de los cambios que se producen en las señales/ variables de entrada que le dan lugar y que sólo hay una demora en dicho proceso, producto de los retardos propios de los elementos de circuito. O sea debe reflejar la propiedad de un circuito de estar permanentemente activo en todas sus etapas. En VHDL esto tiene su correlato con un grupo de sentencias denominadas concurrentes. Las sentencias son concurrentes cuando se ejecutan simultáneamente en la simulación, no existiendo priorizaciones en la resolución de unas sobre otras. Las señales que forman parte de una sentencia concurrente actualizan su valor todas a la vez, una vez ejecutada la misma. El concepto de secuencialidad, por su parte, se puede asemejar al de algunos procesos de software en los que la programación se caracteriza por un flujo de sentencias por etapas (es el caso de sentencias como case, if, while, loop, etc). Las variables que forman parte de este tipo de sentencias actualizan su valor a medida que se ejecuta cada renglón de la misma. Sea por ejemplo la implementación de la función lógica Y = A . B. Se verá cómo responden las sentencias según sean concurrentes o bien secuenciales. Se parte de la asignación inicial del estado de las señales o variables intervinientes. Se las hace cero. Luego cada sentencia va a representar las distintas asignaciones de estados que se hacen a cada variable o señal. estado inicial: A = B = Y = 0 sentencia 1 : A = 1 sentencia 2: B = 1 sentencia 3: Y = A . B Una estructura de programa (secuencial) tomaría un paso para ejecutar cada una. Dichos pasos son instancias de tiempo. A la derecha se grafica esta situación, representando cada renglón un instante de tiempo. En el caso de sentencias concurrentes, se evalúan todas simultáneamente. Eso determina que en el instante t = 1 se asignan A y B simultáneamente.

SECUENCIAL CONCURRENTE

t A B Y A B Y

0 0 0 0 0 0 0

1 1 0 0 1 1 0

2 1 1 0 1 1 1

3 1 1 1

Atención: también se asigna Y = A.B, pero con el valor que tenían antes de la ejecución de la sentencia y por eso Y sigue siendo cero. En el instante siguiente (t=2) se actualiza Y.


Se deja para el estudiante interesado, formular un planteo de naturaleza similar de la evolución de asignaciones a las distintas señales y variables que aparecen en el circuito de la figura, según que las sentencias sean del tipo concurrente o secuencial.

C

B C.B

A

Y

Y = C.B + C.A

C.A

fig. 6 Para representar los procesos de la realidad, el VHDL utiliza tres típos de objetos, las constantes, las variables, y las señales . Éstas dos últimas pueden variar su valor mientras se ejecuta el programa, son las designadas por el lenguaje para manipular la información del circuito o sistema en diseño. Pero tendrán una característica distintiva: las señales pueden utilizarse dentro de cualquier parte del programa (son globales) mientras que las variables lo hacen dentro de un "proceso" (son locales). Surge entonces la pregunta: ¿Cómo hace el VHDL para darle aspecto concurrente a sentencias secuenciales? Y la respuesta es mediante los procesos explícitos, que se declaran como tales. Procesos Los procesos son estructuras concurrentes que se elaboran con sentencias de ejecución secuencial. Esa concurrencia determina que dentro de él las variables que intervienen se evalúan en forma inmediata, pero recién se actualizan cuando finaliza el proceso. Se materializan con la: Sentencia Process (proceso) Suele ir acompañada de una lista de sensibilidad (se escribe entre paréntesis luego de su declaración). Dicha lista define las señales que al cambiar activan la ejecución del proceso. Esta lista es opcional. De no utilizarse, debe incorporarse dentro del proceso la sentencia wait.

Elementos del lenguaje Para analizar las Entidades y Arquitecturas se deben conocer los elementos básicos:

1) Identificadores 2) Objetos 3) Tipos de datos 4) Delimitadores 5) Comentarios 6) Literales 7) Operadores

1.- Identificadores: pueden ser de dos tipos: genéricos –simples y extendidos- y palabras reservadas. Un identificador genérico es un conjunto de caracteres que se utilizan para nombrar distintos elementos en VHDL. Está formado por las letras del abecedario, números 0 a 9 y el carácter underscore (“_”), pero hay restricciones a su uso: el identificador debe comenzar con una letra, no puede finalizar con el underscore ni admite dos de ellos seguidos. No tienen una longitud máxima establecida. VHDL no hace distinción entre mayúsculas y minúsculas, o sea es “case insensitive”. También hay identificadores extendidos que se escriben entre símbolos “\”. Estos identificadores extendidos admiten otros caracteres además de los ya mencionados. No se pueden emplear las “palabras reservadas” como identificadores. Las palabras reservadas son un conjunto de identificadores que tienen un significado específico en


VHDL (se las utiliza en sentencias, objetos, tipos, etc) y por lo tanto no pueden ser utilizadas por el usuario para otra función que la prevista en el lenguaje. En el ejemplo aparecen en letras mayúsculas (sólo para resaltar; en las bibliografías se las podrá

.- Objetos: tos que define y utiliza el lenguaje para almacenamiento de información de un tipo

. constantes 3. señales

onstantes: es aquel objeto que mantiene el mismo valor a lo largo de la descripción del circuito y

ONSTANT constant_name : type := constant_value;

CONSTANT alfa : integer := 50

ariables: es un dato en memoria de la computadora. Sólo pueden ser declaradas y utilizadas en

default (para las de tipo

e les asigna un valor mediante el operador compuesto “:=”

u sintaxis es:

encontrar en negrita. El AHDL –Altera HDL- las muestra en color azul a medida que se las tipea) 2Son los elemendeterminado. En función de éste, se le podrán efectuar determinadas operaciones. No es posible realizar operaciones entre dos objetos que pertenezcan a tipos distintos salvo que se le aplique a alguno de ellos un programa de conversión de tipos. En VHDL existen cuatro clases de objetos: 12. variables 4. archivos CUna constantedel proceso de simulación. Se inicializan en el momento de su declaración (excepto en el caso de las denominadas constantes diferidas o aplazadas). Su sintaxis es: C

ejemplo es : Un VUna variableestructuras secuenciales (procesos – Process - o subprogramas); son locales a ellos (salvo las de tipo compartido o globales). No tiene relación directa con el hardware (como lo tiene la señal). Se le puede asignar un valor inicial explícito al declarar su tipo. No tiene valores futuros. Cuando se ejecuta la sentencia, se evalúa y se actualiza su valor, y éste puede ser utilizado por la línea siguiente de sentencias del programa. No se puede utilizar una variable fuera del Process (si se necesita su valor o estado, se usará una señal a quien la variable le transfiere el mismo). Si a una variable no se le asigna un valor inicial lo hace el simulador por enumerado, el valor con que se inicializa es el del primer elemento del mismo) S S VARIABLE <nombre> : <tipo> [:=<expresión>] Ejemplo: VARIABLE num_bcd : bit_vector := “1001”

eñales: representa las conexiones o terminales físicos de un circuito. Se la puede ver como uno o

sentencias de tipo concurrentes aunque se las puede usar en las

n las Arquitecturas, las señales se declaran antes de “BEGIN”. j. r <= 1

variables, pero sólo para

SUna señal más cables. No se circunscribe al proceso. Puede utilizarse para interconectar componentes y activar o detener procesos. Toma su valor luego de finalizado el ciclo de simulación (no cuando se ejecuta la sentencia, como la variable). Las señales se declaran en secuenciales, también. En este caso irán dentro de un Process pero no se actualizan en el momento en que se ejecuta(n) la(s) sentencia(s) que las invoca(n) (no se puede usar su nuevo valor en las líneas siguientes del programa) sino al finalizar el Proceso. ESe les asigna un valor mediante el operador compuesto “<=” , peAtención! también se puede utilizar el operador de asignación usado parainicializar el valor de una señal. Su sintaxis es:


signal_declaration ::= _listsignal identifier : subtype_indication [ signal_kind ] [ := expression ] ;

jemplo 2: una suma de productos lógicos

ea el circuito de fig. 6 donde se declaró la entity con 3

ITECTURE estruct OF suma2nivel IS

a AND NOT c

-- mayúsculas o minúsculas es indistinto

E sentradas (A,B,C) y una salida (Y). Se verá una arquitectura posible. Se supone que en dicho circuito se consideran las funciones lógicas internas V=/C.A y W = C.B. En VHDL se crean dos señales para representarlas y procesarlas: ...... ARCHSIGNAL v, w : bit ; -- dos señales y su tipoBEGIN V<= W<= c AND b; Y<= V OR w; END ESTRUCT;

C

B C.B

A

Y

Y = C.B + C.A

C.A

A

B

YC

Proceso 1 V

Proceso 2

Proceso 3

W

Archivos (files):

tercambio de info con el ambiente externo. A este objeto se le asigna un archivo de se usan para el intodos los que pertenecen al sistema. file <identificador>: tipo [:=expresión]

.- Tipos de datos el elemento que caracteriza cuáles son los valores, estados, asignaciones y

i de

ay cuatro tipos básicos de datos:

. escalares

nteros)

eclarar subtipos dentro de un tipo (subtypes). Cada tipo es distinto de los otros; los

entro de los escalares se encuentran:

ipos enumerados: en ellos el conjunto de valores que los caracterizan se enuncian mediante una

3El tipo de datos esoperaciones que pueden ser asumidos por los objetos. Existen tipos predefinidos - o nativos - cuya información se guarda en la denominada biblioteca standard en paquetes homónimos (se definen en ella los tipos lógicos y numéricos básicos) y los que pueden ser creados por los usuarios, que se guardan en la biblioteca de trabajo (“work”). En este caso, se los debe “declarar” mediante una sentencia adecuada (“TYPE”), un identificador y el conjunto de datos que lo integran. Existen otros tipos de datos en diversas bibliotecas, las cuales difieren según las variantes de lenguajes VHDL. Para utilizar objetos que sean de tipos creados por los usuarios, sólo se lo puede hacer a posteriorsu declaración. Si el tipo se usa en la arquitectura, se define en ella, si se va a usar en la entidad, debe declararse un package en la biblioteca work (es la biblioteca donde se guardan los archivos de diseño) y luego invocarla antes de declarar la entity mediante la sentencia use. work.... H 12. compuestos3. de acceso (pu4. archivos Se pueden dobjetos creados con diferentes tipos son incompatibles, esto es, no pueden ser sometidos a operaciones entre ellos, a menos que se proceda a la “conversión” de uno de los tipos, lo cual se hace mediante la definición de una función para transformarlos. Los objetos de un subtipo son compatibles con objetos del tipo que le da origen. D Tlista taxativa (nombra a cada uno). El primer identificador es el nombre del tipo y sirve para


referenciarlo, y entre paréntesis y separados por comas se adjuntan todos los valores legales del tipo. TYPE vocales IS ('a', 'e', 'i', 'o', 'u');

son 0 y 1. Otro es:

YPE std_logic IS ('X','0','1','Z','W','L','H','U',’-‘);

STD_LOGIC_1164.

X : desconocido fuerte * Z : alta impedancia il

* H : uno débil ado

ipos enteros / reales: En VHDL vienen definidos el tipo integer (entero), que corresponde a valores

YPE hora IS range (0 to 23); (se lee “de 0 a 23, en forma ascendente”) 0 ;

con el valor más a la izquierda de los

ipos fisicos: se utilizan para representar TYPE distancia IS RANGE 0 TO 1E16

0A; ;

--utilización

-- valdría 110cm

sentido en los tipos de descripción vistos anteriormente. Pero sí

os tipos compuestos son aquéllos que se forman con el agregado de varios elementos. Estos

n array sería:

TYPE semáforo IS (rojo, amarillo, verde);

sta forma de especificar un tipo de dato hace que cuando se opere con un objeto de este tipo, si noEse lo inicializa (si no se le da un valor inicial) asumirá el valor más a la izquierda de los especificados en la declaración del tipo. Esto es, si se trabaja con un objeto tipo semáforo va a asumir que está en rojo, a falta de una asignación distinta cuando se lo invoque por primera vez. En el ejemplo de la And, el tipo es BIT, cuyos componentes por enumeración T

tipo std_logic es uno de los más usados en VHDL y se encuentra en el paquete ElUna señal de este tipo puede tomar uno de varios estados, mientras que si fuera del tipo bit sólo podría tener dos (0 ó 1). El significado de cada tipo es. * * 0 : cero fuerte * 1 : uno fuerte

* W : desconocido déb* L : cero débil

* U : no inicializ* - : indiferente

Tcomprendidos entre -2147483674 y 2147483674, y el tipo real (desde -1.0e38 hasta 1.0e38). Si se quiere crear o definir un tipo o subtipo de esta naturaleza se debe especificar un rango de valores que podrá asumir los objetos que a él pertenezcan o se quieran adjudicar: TTYPE dias IS range (31 downto ) (se lee “de 31 a 0, en forma descendente”)

i no se especifica un valor inicial, el objeto se inicializaSespecificados en la declaración del tipo. En el caso de los ejemplos vistos, hay que ser cuidadoso pues uno de los tipos (hora) va de menor a mayor (valor inicial = 0) y el otro a la inversa (inicial = 31). Tmagnitudes que corresponden a variables físicas como el tiempo, peso, distancia, etc,... Se los especifica agregando al rango de valores, las unidades con que miden las magnitudes físicas a que corresponde.

UNITS A; nm=1 um=1000nm mm=1000um; cm=10mm; m =1000mm; km=1000m; END UNITS

a<=10cm; b<=1m; c<=a+b; cEl uso da unidades no tiene muchoson muy útiles a la hora de las simulaciones y para ayudar a la depuración. Lpueden ser del mismo tipo o de distinto tipo. En el primer caso se dice que es un tipo homogéneo y se denomina array. El otro, es de tipo heterogéneo y se llama record. Un elemento de tipo array, tiene un índice que es entero. U


TYPE bus_direcciones IS ARRAY (0 TO 63) OF BIT;

S ARRAY (1 TO 10, 1 TO 20) OF REAL; Una matriz: TYPE matriz ITYPE memoria IS ARRAY (2**N-1 DOWNTO 0) OF STD_LOGIC_VECTOR(K-1 DOWNTO 0);

n record:

YPE fecha is RECORD 1 TO 31;

entro de los tipos predefinidos en la biblioteca standard más importantes se encuentran:

U T dia: INTEGER RANGE mes: INTEGER RANGE 1 TO 12; otro: BIT; END RECORD; D

TIPO RANGO DE VALORES ¿Qué representa?Natural 0 a Maxint * números naturalesPositive 1 a Maxint números positivosInteger - Maxint a Maxint números enteros

Real -Maxreal a Maxreal ** números realesBit 0 , 1 valores binarios

Bit_vector conjunto de bits cadenas de bitsBoolean True, False valores booleanos

Character (variado) *** caracteresString conjunto de caracteres cadenas de caracteresTime - Maxint a Maxint [unidad] nros. reales con unidades de tiempo

* depende del compilador pero en general será = 2 31 - 1** depende del compilador pero en general será = 1.0E38*** ver la bibliografìa fig. 7

.- Delimitadores: son símbolos especiales que se utilizan con funciones diferentes y específicas,

os delimitadores en VHDL son: + - / ( ) . , : ; & ' < > = | # <= => := --

.- Comentarios: son oraciones libres y sin ninguna sintaxis preestablecida, como no sea que deben

.- Los Literales pueden ser: números, caracteres o strings

os números son un texto que representa un valor numérico. Pueden ser enteros (5, -33, etc), reales

4Algunos de ellos se los va a utilizar como Operadores (ver más adelante). Otros tienen diversas funciones como por ejemplo el símbolo "- -" que, como en el ejemplo visto, se utiliza para marcar la zona del programa que es empleada para que el usuario introduzca comentarios. Otro, que es fundamental, y causa de errores frecuentes al “compilar” un programa es el “;” con el cual debe concluir cada sentencia y algunos renglones intermedios de algunas de ellas. L 5comenzar con “- -“; se hacen para que el usuario logre mayor claridad, orientación, etc en el desarrollo de su programa; para establecer los pasos que va dando, reconocer distintas etapas, sirven para documentación, etc. El programa omite su procesamiento al detectar “- -“ y salta a la siguiente sentencia válida del lenguaje. En el ejemplo visto, se lo utilizó como título. 6 L(2.71828 0.69), admiten notación exponencial (3.23E-4; 8.43E9), admiten representación en una base distinta de 10 utilizando dos caracteres “#” (uno para la base y el otro para el número -en decimal- ). y también la separación con guiones bajos para mayor claridad de números grandes –en lugar del punto reservado para los reales- (10_983_145 ; 3.141_592_7)


• 2#1011# significa representación en base 2 del número 1011 = 11 en decimal • 4#13#E2 significa el equivalente de (13 en base 4) mulltiplicado por 10 elevado al cuadrado: (1.41 + 3.40) . 10 2 = 700

Los caracteres son literales que se encierran entre comillas simples. Son los caracteres ASCII que son imprimibles: Ejemplo: ‘A’, ‘_’, ‘9’ Mientras que los números tienen una descripción implícita (su valor numérico), los caracteres se describen en VHDL por enumeración en el denominado “package STANDARD”, que es el paquete de datos nativo del lenguaje. Los strings (cadenas) son un conjunto de caracteres. Si los strings son constantes se los encierra entre comillas dobles (“):

Ejemplo: “VHDL”, “Horario”, etc También hay bit_strings o cadenas de bits (los bits valen 0 ó 1): Ejemplo: “0110 1011” Se los puede representar en forma binaria, octal o hexadecimal. Según sea ésta, se colocan los caracteres B, O, X respectivamente a la izquierda del string: B“0110 1011”, O”153” y X”6b”. Atención: un número expresado en octal es asociado a 3 bits, mientras que uno en hexa, se asocia a 4, por lo cual las expresiones anteriores, como números, no son equivalentes. 7.- Los operadores pueden ser de cinco tipos: * aritméticos * relacionales * lógicos * de desplazamiento * otro tipo * Los artiméticos son: OPERADOR OPERACIÓN TIPO DE DATOS

+ suma tipo numérico - resta tipo numérico * producto entero, real / cociente entero, real ** exponente entero, real

(expon'te entero)

MOD módulo ambos enteros REM resto ambos enteros ABS valor absoluto tipo numérico fig. 8

* Los relacionales son: OPERADOR OPERACIÓN

= igualdad /= distinto > mayor que

>= mayor o igual < menor que

<= menor o igual (y asign señales)

fig. 9

Los operadores lógicos son: OPERADOR OPERACIÓN

AND y OR o

NAND y negado NOR o negado XOR o exclusiva

XNOR o exclusiva negada NOT negación

fig. 10

Los operadores de desplazamientos son: OPERADOR OPERACIÓN

SLL desplazamiento lógico a la izquierdaSRL desplazamiento lógico a la derechaSLA desplazamiento aritmético a la izquierdaSRA desplazamiento aritmético a la derechaROL rotación a la izquierdaROR rotación a la derecha

fig. 11


Ejemplos con los operadores de desplazamiento: dado un dato A cuyo valor inicial es 1100 1101, se verá qué resultado arroja la compilación en VHDL al ejecutarse las sentencias que se ilustran: A SLL 4 --el resultado es 1101 0000 (se desplazan 4 bits a izquierda: 1100 salen de la palabra; 1101 se mueven a izquierda y sus lugares son ocupados por ceros que ingresan por la derecha) A SRL 4 --el resultado es 0000 1100 (1101 salen; 1100 a la derecha; ingresan 4 ceros por izquierda) A SLA 4 --el resultado es 1101 1111 (extensión del último bit: similar a SSL pero el lugar de los bits que se desplazan es ocupado por réplicas del último bit que que se desplazó –en negrita- ) A SRA 4 --el resultado es 1111 1100 (análogo a SLA, en sentido contrario) A ROL 4 --el resultado es 1101 1100 (cada bit desplazado sale de la palabra por la izquierda e ingresa a ocupar los lugares dejados en blanco por la derecha) A ROR 4 --el resultado es 1101 1100 (análogo a ROL, en sentido contrario) y finalmente, los otros operadores son: OPERADOR OPERACIÓN

+ signo positivo - signo negativo & concatenación

1. **, ABS, NOT 2. *, /, MOD, REM 3. +, - (signo) 4. +, -, & (operaciones) 5. =, /=, <, <=, >, >= 6. AND, OR, NAND, NOR, XOR

El orden de prioridad con que el lenguaje los toma, de mayor a menor es el que se muestra a la izquierda. Atención: no todos pueden operar con todos los tipos de datos.

Atributos Son características aplicables a algunos elementos del lenguaje que permiten obtener de ellos información adicional. Entre los elementos que pueden tener atributos están:

• Entidades • Arquitecturas • Configuraciones • Paquetes

• Subprogramas • Tipos y subtipos • Objetos • Componentes

• Etiquetas • Literales • Unidades de un tipo físico

Para denotar la aplicación de un atributo, la sintaxis utiliza un apóstofre (´) y un identificador. Existen atributos predefinidos en VHDL y otros que pueden ser definidos por el usuario. Entre los primeros:

Atributos predefinidos para arrays Atributos predefinidos para señales Atributos predefinidos para funciones Atributos predefinidos para tipo de dato

Atributos para arrays: Atributo 'left: refiere al elemento más a la izquierda de un vector. Atributo 'right: refiere al elemento más a la derecha de un vector. Atributo 'length: refiere a la longitud de un vector. Atributo 'range: refiere al rango de valores de un vector. Atributo 'event: se usa para saber si una variable ha cambiado o no. Ejemplo de aplicación: se ha definido una señal: signal num_bcd : std_logic_vector (3 downto 0);


Si se aplican los atributos anteriores, se indica la respuesta que brinda el VHDL: num_bcd’lenght, => devuelve valor 4 largo de un vector o array num_bcd’left, => devuelve 3 valor izq. de índice de array num_bcd’right, => devuelve 0 valor der. de índice de array num_bcd’range, => dev. 3 downto 0 rango del vector Atributos para señales: Ejemplo: Sea la señal set : in std_logic. Algunos atributos son: set’delayed(T) => genera una réplica de set con una demora T set’stable(T) => devuelve true si set no cambió durante un lapso T anterior set’last_event => devuelve el tiempo transcurrido desde el último evento en set set’event => devuelve true si set ha cambiado En la figura que sigue se ve un ejemplo de aplicación de atributos sobre la señal Set Atributos para tipos de datos enumerados Ejemplo: se ha definido por enumeración un tipo de datos denominado “codigos”:

type codigos is (“bcd”, “aiken”, “gray”, “xs3”, “Johnson”); Los atributos aplicables a este tipo y la respuesta que brinda el VHDL se indica a continuación: codigos’succ(“aiken”) devuelve “gray” sucesor codigos’pred(“aiken”) devuelve “bcd” predecesor codigos’low devuelve “bcd” equivale a izquierda codigos’high devuelve “Johnson” equivale a derecha codigos’pos(“aiken”) devuelve 1 (*) (las posiciones se numeran de izq a der empezando en 0) codigos’val(3) devuelve “xs3” (*) valor en la posición 3 codigos’lenght devuelve 5 largo: cantidad de componentes del tipo (*) pos y val dependen del tipo de objeto al que se aplican. De los vistos, los más importantes son ‘range, ‘event y ‘length . Ejemplo 3: la compuerta AND empleando otro tipo de datos -- Diseño de una compuerta And de 2 entradas (tipo datos bit_vector) ENTITY and2_bitvector IS -- se declara la entidad PORT -- define las "puertas" (A : IN BIT_VECTOR (0 TO 1); -- A ahora en un vector de 2 elementos y : OUT BIT); -- señal y, en modo salida tipo de datos es bit END and2_bitvector; -- se termino de declarar la "entidad" -- renglón en blanco para separar -- DISEÑO POR COMPORTAMIENTO --


ARCHITECTURE comporta_and2 OF and2_bitvector IS BEGIN y <= '1' WHEN A = B"11" -- un bit se encierra en comilla simple; más ELSE '0' ; -- de uno se encierra en comillas dobles END comporta_and2; Aparecen en este ejemplo lo siguiente:

• las entradas tienen un nuevo tipo de datos: son vectores de bits. Los vectores representan un conjunto de valores que se dan simultáneamente representando cada uno un componente del vector (en este caso cada entrada)

• la arquitectura describe el comportamiento del circuito (diciendo que la salida vale 1 cuando las entradas toman ese valor) sin exponer ningún detalle de construcción.

• recordar que un bit se muestra entre comillas simples mientras que un vector de bits va entrecomillado doble.

Visibilidad de elementos en la estructura de un programa VHDL Es conocido que en muchos lenguajes de software hay que declarar sus elementos (variables, por ejemplo) antes de invocarlos para operar con ellos. Una vez declarados, los mismos pueden ser utilizados a lo largo de todo el programa, en muchos casos. En VHDL también hay que declarar los elementos antes de invocarlos, pero puede suceder que el mismo elemento (o mejor dicho, elementos distintos pero que utilizan el mismo nombre -identificador-) pueda ser declarado e invocado en distintas partes del programa y asumir distintos valores en ellos. El esquema siguiente pretende ilustrar en forma muy simplificada, las distintas regiones que componen un programa VHDL y los distintos ámbitos donde los elementos que se declaran tienen incidencia o pueden “ser vistos” para ser operados y utilizados.

2 library ieee;

3 use ieee.std_logic_1164.all;4 use ieee.std_logic_unsigned.all; 5 use ieee.std_logic_arith.all;

6 --7 entity comod is8 port (dato : in std_logic_vector (3 downto 0);9 dato_ham : out std_logic_vector (6 downto 0));

10 end comod;11 --

12 architecture mascandfor of comod is13 signal paridad : std_logic_vector (2 downto 0);14 type mascara is array (1 to 3) of std_logic_vector (3 downto 0);15 signal ma : mascara;

16 begin17 process (dato) 18 begin19 ma(1)<=dato and "1101";20 ma(2)<=dato and "1011";21 ma(3)<=dato and "1110";22 lazo_bitpar:23 FOR i IN 1 TO 3 LOOP24 paridad(i)<= ma(i)(3) xor ma(i)(2) xor ma(i)(1) xor ma(i)(0);25 END LOOP lazo_bitpar;26 dato_ham <= dato & paridad; 27 end process;

28 END architecture mascandfor;

zona de paquetes: loque hay acá puede servisto por las entidades

y las arquitecturas

entidades: lodeclarado en ellas

se ve en lasarquitecturas

arquitecturas: lodeclarado en ellas esvisible sólo en ellas

los procedimientosdeclarados acá noson influídos por

asignación a señales

proceso: losprocedimientos

declarados en él sólopueden influir en señales y

puertos del circuito

proceso: lasdeclaraciones en él sólo

se ven en su interior

fig. 12


Se verán a continuación diversos ejemplos donde se pondrán de manifiesto los diferentes tipos de sentencias (concurrentes y secuenciales) y de descripciones. * Uso de Sentencias Concurrentes * Procesos concurrentes con asignación simple Ejemplo 4: sea diseñar un circuito que realice la función lógica BCACY .. += Se muestra a continuación el circuito y su tabla de verdad. En función de esta última se plantea una descripción en VHDL como la que sigue:

C

B C.B

A

Y

Y = C.B + C.A

C.A

fig. 13

C B A C.B /C.A Y0 0 00 0 1 1 10 1 00 1 1 1 11 0 01 0 11 1 0 1 11 1 1 1 1

1 --Circuito Suma de Productos sencillo comentario (título) 2 library ieee; 3 use ieee.std_logic_1164.all; bloque de "packages"

4 entity sumaprod is --sumaprod_2niv_assign.txt 5 port (A, B, C : in std_logic; 6 Y: out std_logic); 7 end SUMAPROD;

entidad

8 architecture COMPORTA of SUMAPROD is 9 begin

10 Y<=(A and not C) or (C and B); 11 end COMPORTA;

arquitectura

La línea 10 muestra la asignación simple. Una señal (en este caso un puerto del circuito) se le asigna el estado que debe tomar por medio de una expresión lógica.

Este es un ejemplo de descripción por comportamiento. Algunas preguntas - ¿ por qué se ponen C and B entre paréntesis ? - ¿qué sucedería si se hubiera definido la salida Y como tipo BIT? Una vez compilada la descripción anterior, el Quartus II entrega un esquema circuital a nivel de Transferencia entre registros (RTL) de cómo interpretó las sentencias incluídas en ella. La misma además es función de los componentes que tiene el dispositivo programable seleccionado cuando se corrió la compilación.

Vista RTL con FPGA o con CPLD arroja:

0

1ABC

Y

Y

MAX II EPM240F100C4 y Stratix II EP2S15F484C3 Aparecen en este ejemplo un nuevo tipo de datos que es “std_logic”. Éstos están definidos en la:


Biblioteca IEEE (Paquete Std_logic_1164) este paquete incorpora el tipo de datos std_ulogic que agrega siete estados al tipo bit para expresar realidades circuitales y de contexto más abarcadoras. Así, se definen: -- 'U', Uninitialized para designar una variable o señal sin valor inicial; -- 'X', Forcing Unknown, se asigna un valor desconocido “fuerte” al objeto. (no es la X de A.de Boole) -- '0', y '1', son los 0 y 1 “fuertes” (coinciden con los valores de fuente y masa) usados hasta acá -- 'Z', High Impedance , estado para asignar un estado de alta impedancia a una señal. -- W', Weak Unknown, similar al ‘X’ pero “débil”. -- 'L', o Cero débil, representa un estado bajo que no alcanza a coincidir con la masa del circuito. -- 'H', o Uno débil, representa un estado alto que no alcanza a coincidir con la fuente del circuito. -- '-' Don't care, o estado irrelevante. (es lo que en Alg. de Boole se vió como X) También se incorpora el tipo std_ulogic_vector, que agrupa varios elementos std_ulogic en una palabra o vector. Std_ulogic se la puede entender como standard de lógica irresuelta. Esta irresolución proviene del hecho de que el tipo no establece ninguna prevalencia u orden de prioridad en el caso de confluencia en un circuito entre señales de distintos tipos. Para solucionar esta indefinición, el mismo paquete incorpora lo que se denomina Funciones de Resolución (se verán en detalle más adelante) para establecer la solución a un conflicto entre distintos tipos, y por tal razon, se adoptará como el tipo usado en los ejemplos que se verán a continuación: el std_logic y el std_logic_vector en formato vectorizado. Retomando la descripción anterior, se puede mejorar la forma de efectuar las asignaciones estableciendo, por ejemplo, que las mismas tengan lugar si se cumple una dada condición. Otra forma es asignar en forma selectiva el estado de un puerto o de una señal. * Procesos concurrentes con asignación condicionada (sentencia when .... else) Se utiliza la sentencia WHEN .... ELSE cuya estructura es: signal <= expression1 WHEN boolean_expression1 ELSE expression2 WHEN boolean_expression2 ELSE expression3; donde expresión_j representa tanto un valor, como una expresión lógica o de otro tipo que permita generar un valor o estado que se asigna a la señal en cuestión. boolean expresión_j es la condición que debe cumplirse para tal asignación. Es booleana pues lo que dice la expresión admite sólo dos posibilidades: es Verdadera o Falsa. Si es verdad, se produce la asignación. De no cumplirse, se evalúa(n) la(s) expresión(es) que sigue(n). Es decir, hay una priorización en la consideración de las condiciones. La estructura de la sentencia presentada arriba tiene un correlato más entendible en el siguiente: signal <= valor1 WHEN condición1 ELSE valor2 WHEN condición2 ELSE valor3; El tipo de sentencias condicionales en VHDL, es conveniente que contemplen todas las posibilidades de valores o estados que pueda tomar una variable (en este caso, la expresión_j) Por ello no debe omitirse el else. Las condiciones no necesariamente deben ser excluyentes entre ellas; se ejecutan sólo las sentencias que involucran el valor correspondiente a la primer condición satisfecha. Por ello el orden en que se ordenan las condiciones es el que da la prioridad con que se asignará valor a la señal.


Ejemplo 5: -- Suma de Productos sencillo en forma concurrente condicional library ieee; use ieee.std_logic_1164.all; -- entity sum_prod is --mux_2in_concucond.txt port (A,B,C : in std_logic; Y: out std_logic); end sum_prod; -- architecture concucondi of sum_prod is begin Y <= A when C='0' else B; end concucondi;

C B A Y0 0 0 00 0 1 1 C=00 1 0 0 X=A0 1 1 11 0 0 01 0 1 0 C=11 1 0 1 X=B1 1 1 1

En este caso “si es verdad que C=0, entonces Y = A, de lo contrario Y toma el valor B”. Pregunta: ¿qué sucede si en la entrada C aparece un X o un W? Tratándose de puertos que manejan señales del tipo std_logic, los estados que pueden asumir no se limitan a 0 y 1. Una posibilidad es la que se plantea en la pregunta. En este caso se puede asignar un valor desconocido a la salida, para lo cual al ejemplo anterior se lo debería modificar así: -- architecture concucondi of sum_prod is begin Y <= A WHEN C='0' ELSE B WHEN C='1' ELSE 'X'; end concucondi; Las condiciones a cumplir pueden ser una expresión o valor simple, un rango de valores o un grupo de valores distintos sin ningún orden entre ellos. La sentencia WHEN en ese caso puede adoptar las siguientes formas: - When valor ... (es lo visto hasta ahora) - When valor1 a valor n (cuando la condición toma un rango de valores contínuos) - When valor 1 | valor 3 | valor k (cuando la condición toma unos valores específicos)

* Procesos concurrentes con asignación seleccionada Se utiliza la sentencia WITH .... SELECT ... WHEN cuya estructura es: WITH expressión SELECT signal <= expression1 WHEN constant_value1, (caso 1) expression2 WHEN constant_value2, (caso 2) expressionN WHEN constant_valueN; (caso N) que significa que de acuerdo al valor constante_j que toma una expresión, se asigna a una señal la expresión_j de entre varias diferentes. Otra forma de presentar el formato de esta sentencia es: WITH expresión SELECT

signal <= valor1 WHEN valor de expresión1 valor2 WHEN valor de expresión2

valorN WHEN valor de expresiónN


Ejemplo 6: 1. Suma de Productos sencillo 2. library ieee; 3. use ieee.std_logic_1164.all; 4. -- 5. entity AND_OR is 6. port (A,B,C : in std_logic; 7. Y: out std_logic); 8. end AND_OR; 9. -- 10. architecture behave of AND_OR is 11. begin 12. with C select 13. Y <= A when '0', 14. B when '1'; 15. end BEHAVE;

Se obtienen las mismas vistas que antes (arch mux_2in_concusele.txt) Uso de la cláusula When others: Al igual que con las sentencias condicionales, en VHDL es conveniente que se contemplen todas las posibilidades de valores o estados que pueda tomar una variable Ejemplo 7: se introduce una variante que contempla el caso de que C no sea sólo 0 ó 1. Por ello la sentencia with .... select cambia como se verá: 1. Suma de Productos sencillo en forma algorítmica 2. library ieee; 3. use ieee.std_logic_1164.all; 4. -- 5. entity AND_OR is 6. port (A,B,C : in std_logic; 7. Y: out std_logic); 8. end AND_OR; 9. -- 10. architecture ALGORIT of AND_OR is 11. begin 12. with C select 13. Y <= A when '0', 14. B when others ; 15. end ALGORIT;

En este ejemplo, la línea 14 utiliza la palabra “others” para denotar todos los otros 8 valores de C que no sean el ya considerado C=0 (cual es C=1, o bien cualquiera de los otros estados previstos en el std_logic como 0 y 1 débiles, desconocidos fuertes y débiles, etc) WITH .... SELECT ... WHEN se aplica a casos donde los valor de expresión_j son mutuamente excluyentes. Esto lo hace útil para representar tablas de verdad.


* Procesos concurrentes con asignación seleccionada y vector datos Ejemplo 8: --Suma de Productos sencillo asignación concurrente seleccionada library ieee; use ieee.std_logic_1164.all; entity sumAprod is -- sumaprod_witselecx8.txt port (CBA : in std_logic_vector (2 downto 0); Y : out std_logic); end sumAprod; architecture concusel of sumaprod is begin with CBA select Y <='0' when "000", '1' when "001", '0' when "010", '1' when "011", '0' when "100", '0' when "101", '1' when "110", '1' when "111", 'X' when others; --considera desconocido para otros estados de CBA end concusel;

C B A Y0 0 00 0 1 10 1 00 1 1 11 0 01 0 11 1 0 11 1 1 1

Las vistas RTL y mapa techno son las mismas . La simulación arroja: arch. sumaprod_cba_y.vwf

Vista RTL con CPLD:

0

1ABC

Y

Y

con FPGA Cyclone II EP2C5AT144A7:

SEL[2..0]

DATA[7..0]OUT

La vista que entrega el mapeo tecnológico del Quartus II:

Y~0

BC

Y

MUX

YABC[0..2]

Mux0

A

8' hCA --

Como se vió más arriba se puede abreviar la asignación a Y que se repite para varias combinaciones de CBA utilizando el operador “|” (operador o) 13. Y <= '0' when "000" | "010" | "100" | "101", 14. '1' when "001" | "011" | "110" | "111", 17. 'X' when others ; Si en este ejemplo se hubiera utilizado la notación binaria, también la hubiera interpretado bien: 12. with CBA select 13. Y <= '0' when B"000", '1' when B"001", --etcétera


Ejemplo 9: variante del ejemplo anterior usando representación octal: se obtiene lo mismo si la arquitectura cambia a: 10. architecture concusel of sum_prod is 11. begin 12. with CBA select 13. Y <= '0' when O"0", '1' when O"1", '0' when O"2", --etcétera Nota: si se observa las expresiones usadas en el diseño en los ejemplos 6 y 7 se puede concluir que el circuito realizado es un Mux de 2 canales, actuando C como señal de selección. Así se lo considerará en los próximos ejemplos. * Uso de sentencias secuenciales (Procesos) Se mencionó en página 11 que en los Procesos las instrucciones se ejecutan en forma secuencial (se aproximan más a la estructura de programas), pero en un tiempo nulo. Para la ejecución de las mismas debe declarárselos mediante una instrucción explícita en tal sentido (Process). Un Proceso equivale a una única sentencia de tipo concurrente formada por varias instrucciones secuenciales. Hay sentencias similares a las vistas para los procesos concurrentes estudiados hasta acá, y se verá que son más poderosas, excepto las asignaciones simples. Un proceso tiene una estructura descriptiva como sigue: etiqueta: Process (lista sensible) declaraciones Begin sentencias serie End Process etiqueta; un mejor detalle de la sentencia se muestra a la derecha, mostrando la plantilla que utiliza el Quartus II de Altera.

[process_label:] [POSTPONED] PROCESS [(signal1, signal2, signal3)] [IS] -- Local variables VARIABLE variable1 : STD_LOGIC; VARIABLE variable2 : STD_LOGIC; BEGIN -- Signal Assignment Statement (optional) -- Variable Assignment Statement (opt.) -- Procedure Call Statement (optional) -- If Statement (optional) -- Case Statement (optional) -- Loop Statement (optional) END [POSTPONED] PROCESS [process_label];

Entre paréntesis aparece la denominada “lista sensible”; es el conjunto de señales que disparan el proceso: cuando una de ellas cambia, se ejecutan las instrucciones contenidas en él. Las variables, como se ve en la plantilla, se declaran dentro del process. Cuando se ejecuta la sentencia, se evalúan y se actualizan sus valores, y éstos pueden ser utilizados por la línea siguiente de sentencias del programa. No se puede utilizar una variable fuera del Process (no son “visibles” fuera de él; si se necesita su valor o estado, se usará una señal a quien la variable le transfiere el mismo). Si se utilizan señales dentro de un process, se actualizan al finalizar el mismo. Si se hacen múltiples lineas de asignación a una misma señal, se actualizan todas a la vez al finalizar el proceso, (no como las variables que lo hacen en cada renglón de sentencia) por lo tanto asumirán el estado de la última asignación. Las señales se declaran en la arquitectura antes del process y antes del begin. A diferencia de las variables, una señal en un process es visible fuera de él. Uso de la sentencia WAIT dentro de un Process Si un proceso no tiene lista sensible, debe incorporarse una sentencia WAIT (espera) que detiene el proceso hasta que: - se produzca un cambio en una o más señales dadas en una lista. - se produzca una condición o - transcurra un tiempo


[identificador:] WAIT [ON lista sensible] [UNTIL condición] [FOR lapso de tiempo] Ejemplo:

WAIT FOR se usa especialmente en Simulación,

en la elaboración de TestBenches

WAIT FOR se usa especialmente en Simulación,

en la elaboración de TestBenches

WAIT ON clock; WAIT UNTIL clock =’1’ ; WAIT FOR 10 us ; Se pueden usar combinadas: WAIT ON clock FOR 1 us ; WAIT ON sensor UNTIL motor = encendido FOR 30 min ; - Las variables se declaran dentro del process antes del begin. - Cuando se ejecuta una sentencia, se evalúan y se actualizan sus valores - Estos pueden ser utilizados por la línea siguiente de sentencias del programa. - No se puede utilizar una variable fuera del Process (no son “visibles” fuera de él). Las señales sí. Si se necesita su valor, se usará una señal a quien la variable le transfiere el mismo dentro del process. - Las señales dentro de un process, se actualizan al finalizar el mismo. - Si se hacen múltiples lineas de asignación a una misma señal, vale la última asignación. Si se asignan varias señales en un process, se actualizan todas a la vez al finalizar el proceso, (no se pueden usar en la línea siguiente del programa como las variables) Sobre asignación de variables y señales en un Process Ejemplo: suponer que las señales b, c, d (tipo integer) antes del inicio de un ciclo de simulación toman los valores: b=2, c=3, d=1 ... architecture secuencia of ejemplo is signal s1, s2, b, c, d : integer; -- se declaran cinco señales integer begin proce1: -- esta es una etiqueta process (b,c,d) -- inicia la sentencia concurrente begin d <=c; -- d vale 1 en este instante, valdrá 3 al fin del ciclo de simulación s1<= d+5; --se asigna el valor 1+5 = 6 a s1 luego de ejecutarse esta sentencia d <=b; -- se asigna a d el valor 2 luego de ejecutarse esta sentencia s2 <= d+1; -- se asigna 1+1 = 2 a S2 end process proce1; al terminar el proceso se actualizan todas las señales, entre ellas d por lo cual se dispara nuevamente el Process. b y c valen lo mismo que en el ciclo anterior pero d se actualizó a 2 (de las dos asignaciones se mantiene la última). Por ello s1 = 2+5 = 7 y s2 = 2+1 = 3. Finalizado el ciclo se actualizan las señales s1, s2. b, c y d no cambian por lo tanto se termina la simulación ya que las señales de la lista sensible no cambian y no vuelve a ejecutarse el Process.


Otro ejemplo: Ahora considérese a d como variable. Suponer los mismos valores iniciales antes del inicio de un ciclo de simulación: b=2, c=3, d=1 ... architecture secuencia of ejemplo is signal s1, s2, b, c : integer; -- se declaran cuatro señales integer begin proce1: -- esta es una etiqueta process (b,c) -- no aparecen las variables en la lista sensible begin d :=c; -- d toma el valor de c (=3); aunque se actualice al final, ya queda disponible para su uso en las siguientes sentencias s1<= d+5; -- se asigna el valor 3+5 = 8 a s1 (se actualiza al final del ciclo) d :=b; -- d cambia su valor a 2 (se sobreescribe) y queda disponible para su uso en las siguientes sentencias s2 <= d+1; -- se asigna el valor 2+1 = 3 a S2 (se actualiza al final del ciclo) end process proce1; al terminar el proceso se actualizan las señales s1, s2; la variable d queda con el último valor asignado (=2) que se utilizó para asignar a s2, pero se hizo uso de la primer asignación (d=3) para calcular s1. Por ello s1 = 2+5 = 7 y s2 = 2+1 = 3. Finalizado el ciclo b y c no cambian por lo tanto se termina la simulación ya que las señales de la lista sensible no cambian y no vuelve a ejecutarse el Process. Multiplexor de 2 canales en forma secuencial seleccionada: Un multiplexor es un dispositivo que permite volcar las informaciones que llegan por múltiples canales de entrada a una única salida, mediante entradas adicionales denominadas “de selección”. En la figura de la izquierda se esquematiza un Multiplexor (Mux) de dos entradas. Mediante la entrada S se selecciona cuál de las entradas pasa a la salida. Si S=0 se puede ver que la columna Y replica a A, o sea A pasa a la salida. En cambio si S=1, es B la que pasa a la salida. Ahora bien, si se denominara C la entrada S, queda la tabla que se ha venido analizando hasta acá (a la derecha), de donde se desprende que el circuito ya visto representa el esquema interno de un multiplexor de dos canales. * Procesos secuenciales con asignación seleccionada

S B A Y0 0 0 00 0 1 10 1 0 00 1 1 11 0 0 01 0 1 01 1 0 11 1 1 1

MUXB

AY

S

C B A Y0 0 0 00 0 1 10 1 0 00 1 1 11 0 0 01 0 1 01 1 0 11 1 1 1

C

B

A

Y

C.B

C.A

Ejemplo 10: diseño de un Mux de 2 canales en forma secuencial seleccionada -- Multiplexor de 2 canales en forma secuencial seleccionada library ieee; use ieee.std_logic_1164.all; entity sum_prod is port (CBA : in std_logic_vector (2 downto 0); Y : out std_logic); end sum_prod; architecture secusele of sum_prod is begin KEIS: process (CBA) begin


CASE cba IS WHEN "000" => Y <='0'; -- el símbolo “=>” significa “se hace”

WHEN "001" => Y <='1'; --(se usó sumaprod_2niv_secusele.txt en el WHEN "010" => Y <='0'; -- proyecto sumaprod_2niv que aparece como WHEN "011" => Y <='1'; -- comod en el quartus y comod_mux2in.qwf para WHEN "100" => Y <='0'; -- simular) WHEN "101" => Y <='0'; WHEN "110" => Y <='1'; WHEN others => Y <='1'; -- notar el uso de when others para cubrir los 722 valores END CASE; -- restantes que pueden tomar las entradas end process keis ; end secusele; se puede comparar este ejemplo con el equivalente hecho con sentencias concurrentes (Ejemplo 8) la simulación arroja:

1) El RTL viewer sobre una FPGA Cyclone II EP2C5AF256A7 es:

SEL[2..0]

DATA[7..0]OUT

3) abriendo la caja obtenida en 2) se puede ver:

MUX

YCBA[2..0]

Mux0Mux0~0

YCBA[0..2]8' hCA --

2) el post-mapping es:

DATAB

DATAC

DATAD

COMBOUT YCBA[0..2]

Mux0~0

Lo mismo sobre un CPLD EPM240F100C4. LOGIC_CELL_COMB (F3C0)

En el ejemplo anterior se utiliza la sentencia CASE cuya estructura es: CASE expresión IS WHEN caso 1 => instrucciones 1; instrucciones 2; WHEN caso 2 => instrucciones 3; ... ; WHEN Others => instrucciones n, n+i; END CASE; a la derecha la plantilla del Quartus II

CASE expressión IS WHEN constant_value1 => statement1; statement2; WHEN constant_value2 => statement3; statement4; WHEN OTHERS => statement5; statement6; END CASE;

Case es más potente que el WITH ... SELECT pues cada valor evaluado de la expresión puede derivar en más de una instrucción, mientras que en la sentencia concurrente derivaba en una sola. En el CASE no se pueden duplicar los casos pues se produce error. Tambien como se ve, al igual que con With ... select, deben contemplarse todos los casos posibles de la expresión, por lo cual es conveniente el uso del Others para agrupar en uno solo todos los casos no considerados previamente.


Hay diversas formas para escribir los casos en base a los cuales se seleccionan el grupo de instrucciones a ejecutar. Si la selección se hace en base a un dato o condición única, se consigna ésta. Cuando los datos o condiciones son múltiples se puede utilizar un rango de valores (creciente o decreciente mediante el uso de las palabras TO o DOWNTO) Ejemplo genérico: sea un circuito de una entrada ent y una salida Y, que debe cumplir lo indicado en la TdeV siguiente ejem_case: CASE ent IS when 0 to 2 => y <= ‘0’; -- cuando ent va de 0 a 2 la salida Y vale 0 when 3 | 4 => y <= ‘E’; -- cuando ent es 3 ó 4 la salida Y vale E when 5 => y <= ‘0’; -- cuando ent vale 5 la salida Y vale 0 when 9 downto 6 => y <= ‘1’; -- cuando ent va de 6 a 9 la salida Y vale 1 when others => y <= ‘Z’; -- para los demás valores de ent Y vale Z END CASE ejem_case;

ent Y0 01 02 03 E4 E5 06 17 18 19 1

10 Z11 Z12 Z13 Z14 Z15 Z

Ejemplo 11: una forma más simple de Mux de 2 canales que la anterior:

begin -- Mux 2 ent forma secuencial seleccionada mux: process (A, B, C) is library ieee; begin use ieee.std_logic_1164.all; CASE C IS entity sum_prod is WHEN '0' => Y<=A; port (A,B,C : in std_logic; WHEN others => Y<=B; Y: out std_logic); END CASE; end sum_prod; end process mux; architecture sec_sel of sum_prod is end sec_sel;

* Procesos secuenciales con asignación condicionada Ejemplo 12: diseño de un Mux de 2 canales en forma secuencial condicionada 1 library ieee; 2 use ieee.std_logic_1164.all; 3 entity sum_prod is 4 port (A,B,C : in std_logic; 5 Y: out std_logic); 6 end sum_prod; 7 architecture secucondi of sum_prod is 8 begin 9 process (A, B, C) is -- no tiene etiqueta el proceso 10 begin 11 IF C='0' THEN Y<=A; 12 ELSIF C ='1' THEN Y<=B; 13 ELSE Y <= 'X'; 14 END IF; 15 end process; -- no lleva etiqueta al final tampoco 16 end secucondi; Nota: a propósito de los renglones 12 y 13, hay que prestar atención al escribir las sentencias. Un error muy común es confundir el operador de relación (=) con los operadores de asignación a señales o variables (<= o :=) . Otra equivocación se produce al confundir C = ‘0’ (C es un bit o un std_logic) con C = 0 (sin entrecomillar), donde C es un integer.


Se utiliza la sentencia IF... THEN .. ELSE cuya estructura es: IF condición 1 THEN instrucciones ; ELSIF condición 2 THEN instrucciones; . . . ELSE instrucciones ; END IF; a la derecha la plantilla del Quartus II

IF expression1 THEN statement1; statement2; ELSIF expression2 THEN statement3; statement4; ELSE statement5; statement6; END IF;

A semejanza del CASE, el cumplimiento de cada condición da origen a la ejecución de una o más instrucciones. Tambien se pueden evaluar el cumplimiento de varias condiciones mediante sucesivos IF (si) que aparecen bajo el nombre “ELSIF”. Tanto esta última, como el ELSE pueden omitirse, pero eso genera situaciones que tienen que ver con el uso de recursos para la síntesis circuital que hacen aconsejable que se concluya la instrucción con un ELSE que cierre todas las posibilidades de evaluación de condiciones. De no hacerse, habrá una inferencia indeseada de elementos de memoria para almacenar la información que no se especifica. En cambio en el diseño de circuitos secuenciales es habitual la omisión de la cláusula ELSE, lo que da lugar a circuitos tipo “registro” (guardan información previa). Es decir si no se le dice al compilador qué valor toma el objeto para la última condición, debe interpretar que no cambia y por lo tanto debe guardar en memoria su último valor. Por otro lado, debe evitarse el anidamiento excesivo de IF then ... La condición que evalúa cada IF (o Elsif) puede ser única o bien un conjunto de condiciones relacionados por algún operador: If (a=‘1’ and c=‘0’) then ... Equivalencia con la sentencia concurrente When ... else ... : se produce para el caso en que el If ... then contenga asignaciones simples: If c=‘0’ then y <= a; elsif c=‘1 then y <= b; else y <= unaffected; end if;

≡

y <= a when c = ‘0’ else b when c=‘1 else unaffected;

unaffected es una palabra (clave) que se utiliza para indicar que no se haga nada. Usada para asignar valor, no lo hace.

* DISEÑO FUNCIONAL (CUASI-ESTRUCTURAL) Este tipo de diseño tiene en cuenta la estructura del circuito a nivel de señales, pero no como estructura de conexiones ni a nivel de terminales. Se definen señales que hacen operaciones intermedias entre las entradas y las salidas y dan una idea de la evolución circuital entre ellas. Ejemplo 13: descripción estructural del multiplexor simple de 2 entradas Se van a considerar dos señales V y W a las salidas de las compuertas de primer nivel tras lo cual la asignación de salida se remite a una operación OR entre señales V y W -- Multiplexor de 2 entradas (estructural) library ieee; use ieee.std_logic_1164.all; entity sum_prod is port (A,B,C : in std_logic; Y : out std_logic); end sum_prod;

C

B W

A

YV

= C.B + C.AY = V + W


architecture estruct of sum_prod is signal V,W: std_logic; -- se define señales y su tipo begin V<= not C and A; -- comparar con A and not C W<= C and B; Y<= V or W; end estruct; Nota: comparar el diseño anterior con la sencillez del ejemplo 4 Al hacer la simulación se obtiene:

fig. 14

Un par de preguntas: *¿que tipo de proceso es? R= implicito *¿que sucede si se invierte el orden de las asignaciones?¿Se puede hacer lo siguiente?: Y <= V or W; W <= C and B; V <= not C and A; * R= Sí. No importa el orden en que están escritas, las sentencias concurrentes, se ejecutan todas a la vez.

* Otros paquetes y sus tipos de datos. Funciones de conversión. - En un diseño pueden coexistir distintos tipos de datos - Las operaciones entre señales de tipos distintos son inaceptables en VHDL. - De tener que hacerse se recurrirá a convertir el tipo de alguna de ellas. - Un ejemplo: una forma de ver la combinación de estados de un array de elementos binarios, es leer el número binario que representa. - El compilador no interpreta una señal bit_vector (o std_logic_vector) como número si se usan los paquetes Standard o Std_logic_1164. Para hacerlo debe recurrirse a otros como los Std_logic_unsigned, Std_logic_arith o Numeric_std Nota: los paquetes Std_logic_unsigned y Std_logic_Arith no están normalizados por el IEEE por lo que en general se desaconseja su uso. En cambio sí lo está el Numeric_Std. La dificultad con el uso de los primeros es la distinta interpretación que pueden hacer de ellos algunos compiladores. Para quienes trabajen con Quartus II si se utilizan en forma conjunta los dos primeros paquetes pueden resolver perfectamente algunas conversiones con mayor facilidad que el Numeric_Std. No obstante ello, la recomendación es trabajar con este último. Paquete Numeric_std Incorpora los tipos de datos signed y unsigned (como el std_logic_arith). Permite realizar operaciones aritméticas a estos tipos (pero no al Std_logic_vector) con las siguientes características: - tipo unsigned - se utiliza para operaciones entre ellos y/o magnitudes. El resultado es un unsigned de una longitud igual a la del operando más largo. - tipo signed - para operaciones entre ellos y enteros; se obtiene un signed de longitud igual a la del operando más largo. En síntesis:

op1 & op2 = op1 op1 # op2 = boolean

op1 = uns (sig) ; op2 = uns, nat (sig, int)

& ≡ operaciones + - * / rem y mod (los demás símbolos, son los ya vistos)


type UNSIGNED is array (NATURAL range <>) of STD_LOGIC; type SIGNED is array (NATURAL range <>) of STD_LOGIC; Cada unsigned es interpretado como un número binario con el dígito a la izquierda como el MSB. Ejs: unsigned("0110") representa +6 ; unsigned("1010") representa +10 Los tipos signed representan valores numéricos signados que pueden ser positivos, cero o negativos. El compilador interpreta cada tipo signed como una representación binaria en complemento a 2; el bit extremo izquierdo indica si el valor es positivo o negativo. Ejemplos: signed("0110") representa +6 ; signed("1010") representa -6 Ejemplo: supóngase las siguientes sentencias: ... signal A : std_logic_vector (3 downto 0) <= “1010”; signal B : unsigned (3 downto 0) <= “1010”; variable C: signed (3 downto 0) := “1010”; .... Luego de ejecutadas los objetos se interpretan así: A es visto como un array 1010, que tiene significado simbólico y lógico, pero no numérico. B es visto como un array 1010, que tiene un equivalente numérico = + 10 C es visto como un array 1010, que tiene un equivalente numérico = - 6 Si se hace B <= “1100” y se la tiene que vincular con A que es la salida de un circuito lógico, debe convertirse B de unsigned a std_logic_vector (son tipos de datos que parecen iguales pero tienen significaciones distintas y distintos usos en la síntesis del circuito) - El paquete Numeric_std tiene las siguientes funciones de conversión: - TO_INTEGER (arg) => convierte un argumento de tipo unsigned a natural (nat) y de tipo

signed a entero (int) - TO_UNSIGNED (nat,n) => convierte un número natural a un array de n bits - TO_SIGNED (int,n) => convierte un número entero (integer) a un array de n bits - SIGNED (uns) => convierte un array de bits considerado número sin signo a un array de

bits equivalente a un nro entero (o sea, con signo); el argumento conserva el valor numérico. La apariencia del argumento antes y después de la conversión es la misma (un array de bits) pero distinta la forma en que es tomado por compilador (esto se aprecia si se lo convierte a entero)

- UNSIGNED (sig) => convierte un array de bits considerado núm. entero a otro equivalente a un número natural (valen los demás comentarios del caso anterior)

- SIGNED (slv) => convierte un vector en un array de bits que representa un nro. entero - UNSIGNED (slv) => convierte un vector en un array de bits que representa a su magnitud - Std_Logic_Vector (arg) => convierte un argumento de tipo unsigned o signed (tienen valor

numérico como magnitud o entero) a su forma vectorial (tiene la misma apariencia pero es un array de bits sin valor numérico)

En síntesis, hasta ahora tenemos los siguientes paquetes para trabajar: - Paquete Standard: provee tipos bit; bit_vector; character; integer; real; time; string; etc. - Paquete Std_logic_1164: agrega std_logic (sl), std_logic_vector (slv) y los ulogic, std_ulogic (sul) y std_ulogic_vector (suv). - Paquete Numeric_std: incorpora datos signed (sig) y unsigned (uns); tienen formato de cadena de bits, muy parecidos al std_logic_vector, pero se los interpreta con valor numérico (con o sin signo, respectivamente):


Más operaciones con vectores: conversores de códigos BCD Ejemplo 14: diseño del conversor bcd nat a aiken usando el package Numeric_std Recuérdese las características del Código Aiken, el cual tiene sus primeras cinco palabras equivalentes a las del BCD y las últimas cinco, equivalentes a las últimas 5 palabras del binario natural de 4 bits. Se puede decir que éstas últimas se pueden obtener si se les suma el valor 6 al equivalente decimal de la binaria natural equivalente. Se plantea entonces una forma de diseño que consiste en convertir una palabra a otra “sumando”, pero esa suma debe ser selectiva pues debe hacerse sólo si la entrada representa un número entre 5 y 9. Esto lleva a un esquema de trabajo como se ilustra en la figura:

EntityProceso 1

nat

Proceso 2 Proceso 3

aik

D C B A V X Y Z0 0 0 0 0 0 0 0 01 0 0 0 1 0 0 0 12 0 0 1 0 0 0 1 03 0 0 1 1 0 0 1 14 0 1 0 0 0 1 0 05 0 1 0 1 1 0 1 16 0 1 1 0 1 1 0 07 0 1 1 1 1 1 0 18 1 0 0 0 1 1 1 09 1 0 0 1 1 1 1 1

10 1 0 1 0 X X X X11 1 0 1 1 X X X X12 1 1 0 0 X X X X13 1 1 0 1 X X X X14 1 1 1 0 X X X X15 1 1 1 1 X X X X

Natural AikenNº

(std_logic_vector) (std_logic_vector)

(integer) (integer)num_bcd num_aik

Esta arquitectura se basa en convertir las palabras de entrada al equivalente numérico del vector de entrada para generar un dato intermedio que sea la suma de ese valor a 6 cuando el dato de entrada vale más de cuatro. Pero luego es necesario pasar el valor entero obtenido a formato vector de bits, pues así está definida la salida. 1 --uso del paquete numeric_std 2 library ieee; 3 use ieee.std_logic_1164.all; 4 use ieee.numeric_std.all; 5 entity bnat2aik is 6 port ( nat : in std_logic_vector (3 downto 0); 7 aik : out std_logic_vector (3 downto 0)); 8 end bnat2aik; 9 architecture num_std of bnat2aik is 10 signal num_bcd, num_aik : integer; 11 begin 12 num_bcd <= to_integer (unsigned (nat)); 13 num_aik <= num_bcd when num_bcd < 5 else (num_bcd+6); 14 aik <= std_logic_vector (to_unsigned(num_aik,4)); 15 end num_std;

en 10 se crean las señales num_bcd, num_aik para darles el valor entero representado por el slv ya que la librería numeric std no lee el slv como magnitud. en 12 se pasa la entrada vector a valor entero. en 13 se crea el valor entero de la palabra aiken equivalente en 14 se pasa éste valor al vector de salida

Las sentencias 12, 13 y 14 representan los Procesos 1, 2 y 3 de la figura superior respectivamente. Sin embargo, hay una forma ligeramente más simple de formular la arquitectura ya que las 13 y 14 pueden agruparse en una única sentencia: 9 architecture num_std of convn2aik is 10 signal num_bcd : integer; -- no se hace necesario crear la señal num_aik 11 begin 12 num_bcd <= to_integer (unsigned (nat)); 13 aik <= nat when num_bcd < 5 else std_logic_vector (to_unsigned (num_bcd+6)); 14 end num_std; En renglón 13 se igualan salida y entrada cuando su valor es menor que cinco directamente, ya que ambas son vectores. Si no lo es, se suma 6 y para ello debe involucrarse la señal num_bcd que es un numero entero, sumarla y luego convertirla a vector. Nota: en negrita las funciones de conversión por tener nombres similares a los tipos de datos.


A modo de ejemplo se transcriben la simulación efectuada y las salidas obtenidas:

en cuanto a los esquemas que entrega el compilador, el diagrama RTL es:

+A[30..0]

B[30..0]

ADDER

<A[31..0]

B[31..0]

LESS_THAN

SELDATAA

DATABOUT0

MUX21

Add028' h0000000 --

31' h00000003 --

LessThan028' h0000000 --

32' h00000005 --

nat[3..0]

aik[3..0]

num_aik~[2..0]

y la vista tecnológica:

num_aik~2

num_aik~1

num_aik~0

aik[0..3]

nat[0..3]


Ejemplo 15: Conversor BCD natural a Aiken con sentencias secuenciales library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity Bnat2aik is port(nat : in std_logic_vector (3 downto 0); aik : out std_logic_vector (3 downto 0)); end Bnat2aik; architecture conversor of Bnat2aik is begin process (nat) variable : vnat : integer range 0 to 15; begin vnat := to_integer (unsigned(nat)); IF VNAT < 5 THEN aik<= nat; ELSE AIK <= std_logic_vector (unsigned(vnat + 6,4)); END IF; END PROCESS; END architecture conversor; Ejemplo 16: Conversor BCD natural a Aiken con creación de tipo de datos 1 --conversor bcd/aiken + tipo matriz 2 library ieee; 3 use ieee.std_logic_1164.all; 4 use ieee.numeric_std.all; 5 entity Bnat2aik is 6 port ( ent : in std_logic_vector (3 downto 0); 7 sal : out std_logic_vector (3 downto 0)); 8 end Bnat2aik; 9 architecture converse of Bnat2aik is 10 type codigo is array (0 to 15) of std_logic_vector (3 downto 0); 11 constant AIKEN : codigo := ("0000","0001","0010",X"3",X"4", X"B",X"C",X"D",X"E",X"F",others=>"0000"); 12 begin 13 sal <= aiken (to_integer(unsigned(ent)); 14 end converse; Los elementos no especificados en la entidad que forman parte de la arquitectura deben declararse en ésta antes de comenzar (begin) a construirla. En este caso se declara un tipo de datos (codigo) y un objeto (la constante Aiken). Comentarios sobre algunos renglones de la descripción: 10: se creó el tipo “código”: es un array de vectores (array de dos dimensiones 1D x 1D) = 16 palabras por 4 elementos std logic. En síntesis, es una tabla. 11: se define una constante “Aiken”, como tipo código. O sea “ Aiken” es una tabla de los 16 números binarios naturales que se forman con 4 bits. - Ex-profeso, se escriben sus valores como string y en notación hexadecimal. - Atención: como “código” es un tipo de datos de 16 valores, al escribir la constante aiken, deben escribirse 16 valores. Se quiso asignar a las 6 palabras no Aiken el valor “0000”. Una forma simple emplea la instrucción “others =>” que significa “a los restantes (otros) se les asigna el valor”


13: la salida “sal” toma el valor de “ aiken” en la posición dada por un entero igual al binario representado por el array con valor numérico que surge de pasar a unsigned el vector de std_logic de la señal de entrada (ent); p.ej, si ent = “0110”, al ejecutarse (unsigned(ent) el compilador lo lee como el número natural 6; luego “aiken” en la posición 6 es el dato hexadecimal “B”, que es el array “1011”, o sea es un array de bits, que es la característica que tiene un std_logic_vector. Manejo de datos Se presentan a continuación algunos datos que se expresan en una dimensión (el caso de un vector de elementos), en una dimensión por una dimensión (sería el caso de un vector de vectores) y en dos dimensiones (tienen la apariencia del anterior pero los elementos se ubican individualmente en función de dos coordenadas). Para hacer un ejemplo se crean los siguientes tipos: type word is array (3 downto 0) of std_logic; type memo is array (0 to 15) of word; type memo1 is array (15 downto 0) of std_logic_vector (3 downto 0); type memo2 is array (0 to 15, 3 downto 0) of std_logic;

-- crea el tipo word que será una palabra de 4 bits de datos std_logic (1D) -- el tipo memo que son 16 elementos de palabra (1D X 1D) -- memo1 y memo tienen las mismas características. Son datos de dimensión (1D x 1D) -- memo2 tiene características distintas: es de dos dimensiones (2D) ;

Sean las siguientes señales signal E, F : word ; (word is array (3 downto 0) of std_logic) signal G : memo; (memo is array (0 to 15) of word) signal H : memo1; (memo1 is array (15 downto 0) of std_logic_vector (3 downto 0)) signal J : memo2; (memo2 is array (0 to 15, 3 downto 0) of std_logic) Si se asume que se asignaron de modo que toman los valores que se ven en la figura, valen las siguientes relaciones: G(1) = H(14) ; G(3) = F ; G(3)(1) = H(12)(1) = F(1) ; H(1) = E ; G(14) = E ; H(1)(0) = E(0) = J(14,0) ;

3 2 1 0E 1 1 1 0

F 0 0 1 1

G0 H15 0 0 0 0 00 0 0 1 10 0 1 0 20 0 1 1 3

...1 1 1 0 14

G15 H0 1 1 1 1 15

3 2 1 00 0 0 0 0

J 0 0 0 1 1...

1 1 0 1 131 1 1 0 141 1 1 1 15

G, H

Ejemplo 17: diseño de un conversor de Código Gray a Código binario Recordando que la expresión que permite calcular las palabras equivalentes es Bn = Gn ⊕ Bn+1

1 --Conversor Gray a binario 2 library ieee; 3 use ieee.std_logic_1164.all; 4 entity gray2bin is 5 port (ent : in std_logic_vector (3 downto 0); 6 sal : out std_logic_vector (3 downto 0)); 7 end gray2bin;

Binario = 0 1 0 1 1

Gray = 1 1 1 0

+

=

+

=

+

=

+

=


8 architecture comporta of gray2bin is 9 signal ssal : std_logic_vector (3 downto 0);

10 begin 11 ssal (3) <= ent(3); 12 ssal (2) <= ent(2) xor ssal(3); 13 ssal (1) <= ent(1) xor ssal(2); 14 ssal (0) <= ent(0) xor ssal(1); 15 sal <= ssal; 16 end comporta;

Renglones 11-14: se usa la señal ssal en lugar de trabajar con la salida sal pues cada bit de ssal se calcula “leyendo” el bit ssal en la posición siguiente. Sal es un puerto de modo out, por lo cual no podría ser leído (sólo escrito). En cambio una señal puede ser leída y escrita.

Para identificar un bit en particular de un vector, se lo invoca con el nombre y entre paréntesis la posición del bit buscado: ent(2) = bit del vector ‘ent’ en la posición 2 (como fue definido es la 2da. más significativa). Al simular la descripción anterior se obtiene::

Haciendo un repaso de aspectos vistos, podrá el lector indicar por qué son equivalentes estas: 10 begin 11 ssal (3) <= ent(3); 12 ssal (2) <= ent(2) xor ssal(3); 13 ssal (1) <= ent(1) xor ssal(2); 14 ssal (0) <= ent(0) xor ssal(1); 15 sal <= ssal;

10 begin 11 ssal (0) <= ent(0) xor ssal(1); 12 ssal (1) <= ent(1) xor ssal(2); 13 ssal (2) <= ent(2) xor ssal(3); 14 ssal (3) <= ent(3); 15 sal <= ssal;

R = Porque se trata de asignaciones simples que son concurrentes y como tal se ejecutan simultáneamente, y no una después de otra. Supóngase ahora hacer lo mismo pero con variables: architecture comporta of gray2bin is signal ssal : std_logic_vector (3 downto 0); begin process(ent) variable vsal : std_logic_vector (3 downto 0); begin vsal(3) := ent(3); vsal(2) := ent(2) xor vsal(3); vsal(1) := ent(1) xor vsal(2); vsal(0) := ent(0) xor vsal(1); end process; sal<=vsal;

la compilación arrojará un error porque se lee la variable vsal luego de terminado el process y las variables son invisibles fuera de él. Lo correcto es: process(ent) variable vsal : std_logic_vector (3 downto 0); begin vsal(3) := ent(3); vsal(2) := ent(2) xor vsal(3); vsal(1) := ent(1) xor vsal(2); vsal(0) := ent(0) xor vsal(1); sal<=vsal; end process;

Operaciones Lógicas sobre Vectores Los vectores admiten operaciones lógicas entre bits en igual posición. Un diseño más simple será realizar una sola operación xor entre operandos: Ejemplo 18: Conversor de Código Gray a Código binario operando sobre vectores


1 -- Conversor Gray a binario vectorial 2 library ieee; 3 use ieee.std_logic_1164.all; 4 entity gray2bin_vect is 5 port ( ent : in std_logic_vector (3 downto 0); 6 sal : out std_logic_vector (3 downto 0)); 7 end gray2bin_vect; 8 architecture comportamto of gray2bin_vect is 9 signal sbin : std_logic_vector (4 downto 0); 10 begin 11 sbin (4) <= '0'; 12 sbin (3 downto 0) <= ent(3 downto 0) xor sbin(4 downto 1); 13 sal <= sbin (3 downto 0); 14 end comportamto;

A3 A2 A1 A01 1 0 0

B3 B2 B1 B01 0 1 0

A . B = 1 0 0 0

Α ⊕ Β = 0 1 1 0

DISEÑO ESTRUCTURAL : Instanciación de componentes Para algunos diseños puede ser de utilidad definir un componente que se va a reiterar en la descripción y llamarlo cuantas veces sea necesario adaptando eventualmente los nombres de las señales que van a corresponder a sus entradas y salidas. Ejemplo 19: describir un Mux de 2 canales en base a instancias de una Nand de 2 entradas --Multiplexor con instanciación de componentes LIBRARY ieee; USE ieee.std_logic_1164.all; -------- ENTITY mux_2ent is PORT (A, B, C : IN std_logic; Y: OUT std_logic); END mux_2ent ; -------- ARCHITECTURE instancia OF mux_2ent is COMPONENT Nand2pref PORT (i1,i2 : IN std_logic; o : OUT std_logic); END component; SIGNAL Cneg, V, W : std_logic; BEGIN Cneg <= NOT C; Nand1 : Nand2pref PORT MAP (i1=>A, i2=>Cneg, o=>V); Nand2: Nand2pref PORT MAP (i1=>B, i2=>C, o=>W); Nand3: Nand2pref PORT MAP (i1=>V, i2=>W, o=>Y); END instancia;

i2i1 o

Nand2pref

C

B

A

Y

Y = C.B + C.A

i2i1 o

i2i1 o

i2i1 oV

WNand2

Nand1

Nand3

C

B

A

Y

Y = C.B + C.A

i2i1 o

i2i1 o

i2i1 oV

W

En la arquitectura se declara un componente con la sentencia homónima (en inglés) y el circuito se construye con instancias (réplicas) de él. Dicho componente debe ser declarado como un circuito más, o sea como un diseño aparte, y figurar en el directorio del mismo proyecto del multiplexor: -- NAND de 2 entradas a replicar LIBRARY ieee; USE ieee.std_logic_1164.all;


-- Definición de la entidad ENTITY Nand2pref IS PORT (i1, i2 : IN std_logic; o : OUT std_logic); END Nand2pref; ARCHITECTURE comportamiento OF Nand2pref IS BEGIN o <= i1 NAND i2; END comportamiento; Cómo se entienden algunas sentencias de la arquitectura: Nand1 : Nand2pref significa que se abre la primer instancia del componente Nand2pref y se la llama Nand1. Luego debe establecerse como se conectan las entradas y salidas de ese componente. Para ello se incorpora la sentencia Port Map (mapa de puertos) PORT MAP (i1=>A, i2=>Cneg, o=>V); significa que el puerto i1 de la instancia 1 del componente Nand creado se afecta a la entrada A del circuito a diseñar, el puerto i2 se conectará a la señal Cneg y la salida a la señal V. (atención: esta señal que es salida de un componente aparecerá como entrada de otro denominado Nand3, que actua como Nand de salida (ver circuito arriba)). Otro ejemplo con una instanciación más amplia se ve a continuación. Ejemplo 20: describir un Mux de 16 entradas en base a instancias de un Mux de 4 entradas --Circuito Multiplexor 16 canales con instanciación LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY mux16_pref is PORT (ent : IN std_logic_vector (15 downto 0); dir : IN std_logic_vector (3 downto 0); sal : OUT std_logic); END mux16_pref; ARCHITECTURE instancia OF mux16_pref is COMPONENT mux4_pref PORT (I : IN std_logic_vector (3 downto 0); A : IN std_logic_vector (1 downto 0); O : OUT std_logic); END component; SIGNAL S_O : std_logic_vector (3 downto 0); BEGIN Muxn3 : mux4_pref

Mux_16ent

A1 A0

Mux4pref

I3I2I1I0

OA1 A0

I3I2I1I0

O

A1 A0

Mux4pref

I3I2I1I0

O

A1 A0

I3I2I1I0

O

A1 A0

I3I2I1I0

O

Out2

Out3

Out1

Out0

sal

ent(11)

ent(15)

ent(0)

ent(4)

ent(7)

3

Mux4pref

Mux4pref

Mux4pref

2

2

A3 A2 A1 A0

2 4

1

0

PORT MAP (I => ent(15 downto 12), A => dir(1 downto 0), O => S_O(3)); Muxn2 : mux4_pref PORT MAP (I => ent(11 downto 8), A => dir(1 downto 0), O => S_O(2)); Muxn1 : mux4_pref PORT MAP (I => ent(7 downto 4), A => dir(1 downto 0), O => S_O(1)); Muxn0 : mux4_pref PORT MAP (I => ent(3 downto 0), A => dir(1 downto 0), O => S_O(0)); Muxn4 : mux4_pref PORT MAP (I => S_O , A => dir(3 downto 2), O => sal); END instancia; --Componente Multiplexor de 4 canales LIBRARY ieee; USE ieee.std_logic_1164.all; use ieee.numeric_std.all; ENTITY mux4_pref is PORT (I : IN std_logic_vector (3 downto 0);

Al igual que antes, el componente que se instancia debe ser declarado como un circuito más y figurar en el directorio del mismo proyecto del multiplexor.


A : IN std_logic_vector (1 downto 0); O : OUT std_logic); END mux4_pref; ARCHITECTURE compo OF mux4_pref is begin O <= I(to_integer(unsigned(A))); END compo;

al correr la simulación aparece:

Sentencias iterativas En algunos casos puede ser útil disponer de sentencias que permitan la reiteración de pasos o de partes del programa una determinada cantidad de veces. Las hay del tipo concurrente y también secuenciales, o sea van escritas dentro de un Proceso. Ejemplo 21: Mux de 16 entradas por reiteración de instancias de un Mux de 4 entradas -- Mux16 entradas por instancias for...generadas library ieee ; use ieee.std_logic_1164.all ; entity mux16to1 is -- mux16to1_inst.txt port ( ent : in std_logic_vector(15 downto 0) ; dir : in std_logic_vector(3 downto 0) ; sal : out std_logic ) ; end mux16to1 ; architecture estructural of mux16to1 is COMPONENT mux4_pref PORT (I : IN std_logic_vector (3 downto 0); A : IN std_logic_vector (1 downto 0); O : OUT std_logic); END component; signal s : std_logic_vector(3 downto 0) ; begin g1: for j in 3 downto 0 generate -- recorder que g1 es un rótulo muxes: mux4_pref port map (I (3) => ent (4*j+3), I (2) =>ent (4*j+2), I (1) =>ent (4*j+1), I (0) =>ent (4*j), A(1 downto 0) => dir (1 downto 0), O => s(j) ) ; end generate ; mux5: mux4_pref port map (I(3) => s(3), I(2) => s(2), I(1) => s(1), I(0) => s(0), A (1 downto 0) => dir (3 downto 2), O => sal ) ; end estructural ; Sentencia iterativa concurrente FOR ... GENERATE generate_label: FOR index_variable IN range_low TO range_high GENERATE statement1; statement2; END GENERATE;


Esta sentencia genera la repetición de la porción de código comprendida entre FOR ... GENERATE y END GENERATE, un número de veces dado por el rango de la sentencia (igual a la diferencia de valores extremos del rango). Lleva necesariamente un rótulo, etiqueta o “label”. Precauciones del For Generate: generalmente no es sintetizable. Hay que prestar atención de no hacer múltiples asignaciones a una misma señal. El rango puede ir de menos a más o viceversa. No pueden utilizarse valores no estáticos como extremos del rango (por ejemplo el valor de una señal, variable, o puerto). Sí se puede utilizar un “generic” (ver ejemplo más adelante). el diagrama RTL del diseño es:

I[3..0]

A[1..0]O

I[3..0]

A[1..0]O

I[3..0]

A[1..0]O

I[3..0]

A[1..0]O

I[3..0]

A[1..0]

O

mux4_pref:Muxn3

mux4_pref:Muxn1

mux4_pref:Muxn0

dir[3..0]

sal

mux4_pref:Muxn4

mux4_pref:Muxn2

ent[15..0]

SEL[1..0]

DATA[3..0]OUT

Mux0

OI[3..0]

A[1..0]

Cada rectángulocontiene:

MUX

Sentencia iterativa concurrente IF ... GENERATE Es una variante de la sentencia anterior en la cual el conjunto de sentencias o pasos a repetir se efectúa si se cumple alguna condición. Su sintaxis es: identificador: IF condición GENERATE [declaraciones BEGIN] statement1; statementN; END GENERATE [identificador:]; A pesar de tener un IF, se trata de una sentencia concurrente. En la IF ... GENERATE no es válido usar la opción ELSE. Se pueden hacer anidados entre sentencias For ... generate e If ... generate y viceversa. Más adelante se verán ejemplos de su uso. Sentencia iterativa secuencial LOOP (lazo) Igual que la Generate, la sentencia Loop se caracteriza por ejecutar las sentencias contenidas dentro del lazo, que se define con un inicio y fin. A diferencia de aquélla, se aplica en forma secuencial, esto es, debe ejecutarse dentro de un Process o dentro de una Function o un Procedure Hay 3 tipos de lazos: for ... loop , while ... loop y loop (simple).


Se propone un ejemplo de uso en la descripción de otros circuitos que surgen como una aplicación específica de lógica combinacional. Codificadores Un codificador es un dispositivo lógico que detecta una señal activa en una de sus entradas (numeradas decimalmente) y coloca en sus salidas el código binario correspondiente al número de esa entrada. (1) Un codificador más completo debe incluir lo siguiente (2): -posibilidad de distinguir entre la entrada I0 activa de la ausencia de entradas activas (en ambos casos las salidas serán 00).

(1)

CODER

O1

O0

I3I2I1I0

I3 I2 I1 I0 O1 O00 0 0 1 0 00 0 1 0 0 10 1 0 0 1 01 0 0 0 1 1

(2)

CODER

I3I2I1I0

O1O0

EoGS

Ei

Ei I3 I2 I1 I0 O1 O0 GS Eo0 X X X X 0 0 0 01 0 0 0 0 0 0 0 11 0 0 0 1 0 0 1 01 0 0 1 X 0 1 1 01 0 1 X X 1 0 1 01 1 X X X 1 1 1 0

- posibilidad de dar prioridad a una sóla entrada en el caso en que se activen más de una a la vez (se diseñan a tal fin los denominados Codificadores de Prioridad) - posibilidad de habilitar su funcionamiento: se crea la habilitación de entrada Ei. Ésta se complementa con una habilitación de salida Eo que se activa si Ei= activa y no hay entradas activas; esto facilita el encadenamiento de varios coders para armar uno de más entradas y permitir priorizar a una de ellas (ver Expansión de codificadores más adelante). Ejemplo 22: codificador de prioridad (8 a 3 líneas) usando while ... loop

1 -- Codific. de prioridad de 8 a 3 con while loop 2 library ieee; 3 use ieee.std_logic_1164.all; 4 use ieee.numeric_std.all; 5 entity cod_prio_loop is 6 port (ent : in std_logic_vector(7 downto 0); 7 sal : out std_logic_vector(2 downto 0)); 8 end cod_prio_loop; 9 architecture whiloop of cod_prio_loop is

10 begin 11 process (ent) is 12 variable i : integer range -1 to 7; 13 begin 14 i := 7; 15 while ent(i) = '0' loop 16 i := i-1; 17 exit when i = -1; 18 end loop; 19 sal <= std_logic_vector (to_unsigned(i,3)); 20 end process; 21 end whiloop;

Comentarios: El lazo while (15) establece que mientras el bit en la posición (i) del vector de entrada sea cero, ejecute las instrucciones del lazo, (una en este caso -16-) que consiste en decrementar el valor de la variable i y vuelve a ejecutar el lazo, en este caso examinando ahora la entrada (i-1). En cuanto encuentre un bit = ‘1’ - considérese en un paso “j” - como el orden en que la descripción considera a las entradas es de mayor a menor, tendrá prioridad respecto de otros ‘1’ que pudieran aparecer en los pasos siguientes, por lo que debe proceder a sallir del lazo (17) y colocar a la salida el código binario correspondiente a “j” (19).


- Sentencia WHILE ... LOOP loop_label: WHILE boolean_expressión LOOP sentencia secuencial1; ... sentencia secuencial_n; END LOOP loop_label;

Tiene la estructura que se muestra. Cuando se ejecuta, las instrucciones incluídas dentro del lazo se repiten mientras se cumple la condición, esto es, mientras la expresión booleana sea verdad.

- Sentencia FOR ... IN ... LOOP tiene una estructura como la que sigue. Cuando se ejecuta, las instrucciones incluídas dentro del lazo se repiten un número “n” de veces, siendo n el rango de valores que se le da a una variable índice: loop_label: FOR index_variable IN range_low TO range_high LOOP statement1; statement2; END LOOP loop_label; Más adelante se verá un ejemplo empleando esta sentencia. Complementariamente existen las sentencias Exit para salir del lazo y Next, que permite saltear un paso del lazo y pasar al que le sigue. Ambas tienen la posibilidad de ejecutarse en forma absoluta o bien cuando se alcanza una determinada situación o condición: [etiqueta del exit] : EXIT [etiqueta del loop] WHEN [condición] ; [etiqueta del exit] : EXIT [etiqueta del loop] WHEN [condición] Funciones de Resolución Cuando dos señales std_logic se asignan simultáneamente a una tercera, puede haber conflicto entre ellas (como interconectar la salida de dos compuertas entre ellas, cuando una está en uno y la otra en cero). El VHDL soluciona estos inconvenientes definiendo funciones de resolución, que pautan el estado que tomará una señal cuando se produce un conflicto en su asignación. El resultado se puede ilustrar en la tabla que se muestra a continuación. Para entenderla, se parte de la base de que una señal no inicializada (U) tendrá preeminencia sobre cualquier otra con la que confluya. Con una prioridad menor estarán las señales asignadas con un valor desconocido (X). Se puede entender esto si se pregunta: ¿Qué estado surge en un circuito en el que confluyen al mismo cable un estado desconocido y un “1” (o un “0”) lógico? La respuesta es: no se puede asegurar, es decir, resulta en otro estado desconocido, o sea éste prevalece al uno (o al cero). Resulta aceptable que los estados fuertes (X, O, 1) prevalecerán sobre los débiles (W, L, H). Por otra parte, el estado de alta impedancia (Z) será el más débil de todos. Finalmente, el “don’t care” (-), o “no importa el valor que tome”, en colisión con cualquier otro, genera una situación similar a la colisión que provoca un estado desconocido (X).

U X 0 1 Z W L H -U U U U U U U U U UX U X X X X X X X X0 U X 0 X 0 0 0 0 X1 U X X 1 1 1 1 1 XZ U X 0 1 Z W L H XW U X 0 1 W W W W XL U X 0 1 L W L W XH U X 0 1 H W W H X- U X X X X X X X X

Variables y Señales en procesos secuenciales Se presenta a continuación un cuadro que sintetiza las principales características comparativas entre ambas:


VARIABLES SEÑALES Son datos en memoria, se usan para proceso de información

Están asociadas al hardware. Son líneas de conexión

Se declaran dentro del Process antes del begin Se declaran en la arquitectura antes del begin Cuando se ejecuta una sentencia, se evalúan y se actualizan sus valores y pueden ser utilizados por la línea siguiente de sentencias

Las señales dentro de un process, se actualizan al finalizar el mismo (no pueden ser usadas en lineas subsiguientes dentro de él)

Son locales al Process; no se pueden usar fuera de él (debe copiarse su valor a una señal)

Son visibles fuera del process (de hecho se usan para transferir los valores de las variables)

Si se hacen múltiples lineas de asigna ción a la misma variable, vale la última

Si se hacen múltiples lineas de asignación a una misma señal, vale la última

Atención: múltiples asignaciones a una misma señal fuera de un process = ERROR

La tabla precedente sintetiza las principales características de señales y variables, mencionadas precedentemente en este documento. Servirán para comprender mejor los siguientes ejemplos: Ejemplo 23: asignaciones múltiples a variables y señales En el ejemplo que sigue, se asume que se declaró una entidad que tiene entradas a y b. Una variable se asigna luego de ejecutada la sentencia (aunque se actualiza al final del proceso) En el renglón 19 se inicializan las variables. En el renglón siguiente v1 toma el valor 3+2=5, razón por la cual v2 valdrá 4+5 = 9, luego de ejecutarse (aunque se asigna al final). En 22 y 23 se le asigna a la misma señal (s1) dos valores distintos. ¿Hay conflicto?. No:

En un proceso secuencial, si a una misma señal se le asignan dos o mas valores, toma el valor de la última asignación (que sobreescribe a las anteriores).

o sea, s1 toma el valor de b. Pero atención, que en el renglón 25 se inicia un nuevo proceso y en el renglón 29 se le asigna un nuevo valor a s1, por lo cual aparece conflicto con el asignado en proce1. 11 -- (en la entidad se declararon a, b entradas y sal, sal0 salidas todas tipo std_logic) 12 architecture concu_vs_secu of comod is 13 signal s1, s2 : std_logic; -- se declaran un par de señales 14 begin 15 proce1: -- esta es una etiqueta 16 process (a, b) is -- se inicia una sentencia concurrente 17 variable v1, v2 : integer range 2 to 15; --se declaran 2 variables 18 begin 19 v1 := 3; v2 := 4; -- se inicializan las variables 20 v1 := v1 + 2; -- v1 valdrá 5 luego de ejecutarse esta sentencia 21 v2 := v1 + v2; -- v2 valdrá 9 luego de ejecutarse esta sentencia 22 s1 <= a; -- se asigna un valor a S1 23 s1 <= b; -- se asigna otro valor a s1 (valdrá este último, no hay conflicto) 24 end process proce1; 25 proce2: 26 process (a,b) is -- arranca un nuevo proceso 27 begin 28 s2 <= a; -- se asigna un nuevo valor a s1. Al ejecutarse proce2 29 s1 <= s2; -- surgirá conflicto con el valor asignado 30 end process proce2; 31 sal <= s1; 32 sal0 <= s1 and s2; 33 end concu_vs_secu;


Finalmente, ¿cómo se procede si se quiere extraer fuera de un Process el valor de una variable? Las variables se resuelven dentro de un Process. No pueden ser leídas fuera de ellos. De ser necesario, debe asignarse su valor a una señal creada o a crear a tal efecto. Ejemplo 24: variante sacando variables fuera del Process 10 -- (en la entidad se declararon sal1, sal2 salidas tipo integer y sal3 salida tipo std_logic)11 12 architecture concu_vs_secu of algo is13 signal s1, s2 : std_logic; -- se declaran un par de señales 14 signal sig1, sig2: integer range 0 to 15; -- se declaran dos nuevas señales 15 begin --(sigue próxima hoja)16 proce1: process (a, b) is -- se inicia una sentencia concurrente 17 variable v1, v2 : integer range 0 to 15; -- se declaran un par de variables 18 begin 19 v1 := 3; v2:= 4 -- se inicializan las variables20 v1 := v1 + 2 ; -- v1 valdrá 5 luego de ejecutarse esta sentencia 21 v2 := v2 + v1; -- v2 valdrá 9 luego de ejecutarse esta sentencia 22 s1 <= a; -- se asigna valor a S123 s1 <= b; -- se asigna otro valor a s1 (valdrá este último, no hay conflicto)24 sig1 <= v1; -- se transfiere el valor de V1 a la señal sig1 25 end proce1; -- al terminar el proceso se actualizan los valores de v1, v2, s1 y sel126 sal1 <= sig1; -- se transfiere el valor que tenía v1, a través de sig1, a la salida sal1 27 sal2 <= v2; -- habrá indicación de error. Fuera del process no se reconoce a V228 sal3 <= s1; -- s1 es una señal, puede leerse fuera de un process (igual que sig1)29 ... Arrays, arrays numéricos y enteros: Sean los siguientes datos: signal A : unsigned (3 downto 0) <= “1110” ; signal B : signed (3 downto 0) <= “1110” ; signal C : std_logic_vector (3 downto 0) <= “1110” ; signal D : integer range -8 to 15 ; D <= 14 ; luego de ejecutadas el compilador interpreta lo siguiente. A, B y C se definieron como distintos tipos de datos, pero fueron asignadas y valen: A es un vector de bits que tiene valor numérico (sin signo) = 14 B es un vector de bits que tiene valor numérico (con signo) = - 2 C es un vector de bits que no tiene valor numérico pero tiene la misma apariencia que A y B. D fue definida como entero = 14 pero aún teniendo valor numérico no es verdad que D = A. Palabras reservadas del VHDL abs access after alias all and architecture array asser attribute begin block body buffer bus case component configuration constant disconnect downto else elsif end entity exit file for function generate generic guarded if in inout is label library linkage loop

map mod nand new next nor not null of on open or others out package port procedure process range record register rem report return select severity signal subtype then to transport type units until use variable wait when while with xor


Tabla síntesis de paquetes, operaciones permitidas y tipos de datos involucrados (operandos)

Paquete Oper 1 (izq.)

Operación Oper 2(der.)

Resultado Observaciones

uns uns, nat

sig

&

sig, int

op1 & significa operaciones + - * / rem y mod

uns uns, nat

Numeric_std

sig

vs.

sig, int

boolean

slv

int (*)

+

sul/sl

slv + significa operaciones de suma y resta

(*) el int equivale acá a la magnitud

slv

Std_logic_unsigned slv

vs.

int

boolean vs significa operación de comparación

uns,sig uns

sig

#

sig

op1, slv # significa operaciones de producto y cociente

uns,sig + int, sul, sl

op1, slv

Std_logic_arith

uns,sig vs. op.1, int

boolean

slv=std_logic_vector sul=std_ulogic sl = std_logic

int = integer uns= unsigned sig = signed

nat = natural op1 = tipo de dato del operando del lado izquierdo


Sentencias Secuenciales y Concurrentes

Concurrentes Secuenciales

Asignación a señal Signal <= expression;

Asignación a señal seleccionada

- With ... Select label: WITH expressión SELECT signal <= expression1 WHEN constant_value1, expression2 WHEN constant_value2, expressionN WHEN constant_valueN;

- Case ... When CASE expressión IS WHEN constant_value1 => statement1; stam’t2; WHEN constant_value2 => statement3; stam’t4; WHEN OTHERS => statement5; statement6; END CASE;

Asignación condicional

When ... Else label: signal <= expression1 WHEN boolean_expression1 ELSE expression2 WHEN boolean_expression2 ELSE expression3;

- If then elsif/else IF expression1 THEN statement1; statement2; ELSIF expression2 THEN statement3; statem’t4; ELSE statement5; statement6; END IF;

Generación de descripción iterativa Lazos iterativos

- For generate generate_label: FOR index_variable IN range_low TO range_high GENERATE statement1; statement2; END GENERATE;

- For ... Loop loop_label: FOR index_variable IN range_low TO range_high LOOP statement1; statement2; END LOOP loop_label;

Se puede salir de un lazo con dos sentencias: a. next (salta del paso de iteración i al siguiente) b. exit, sale del lazo en el paso que esté. c. NEXT (ó EXIT) WHEN condición booleana

(hacen lo mismo si se cumple esa condición) Generación descriptiva condicional Lazo condicional iterativo

- If generate generate_label: IF expressión GENERATE statement1; statement2; END GENERATE;

- while ... loop loop_label: WHILE boolean_expressión LOOP statement1; statement2; END LOOP loop_label;

Lazo simple

- Loop LOOP expresiones ; END LOOP; (necesita una sentencia exit para salir del lazo)


Tabla de Paquetes, tipos de datos y funciones de conversión

Packages Tipos de datos, funciones de conversión y ejemplos std_logic_1164 contiene los tipos: - std_ulogic (=sul) ('U','X','0','1','Z','W','L','H',’-‘),

- std_ulogic_vector (=suv) es un vector de elementos std_ulogic - std_logic (=sl) subtipo de std_ulogic - std_logic_vector (=slv) vector de elementos std_logic

- std_logic es un subtipo de std_ulogic que resuelve los conflictos entreoperandos de distinto estado que confluyen en una misma señal. - std_logic_vector opera con objetos tipos std_logic_vector pero no como número

std_logic_signed - tiene funciones aritméticas para tipo std_logic_vector con signo std_logic_unsigned - opera std_logic_vector y/o magnitudes (sin signo) en forma aritmética

- la suma no computa el carry - tiene funciones de conversión: - CONV_INTEGER (slv) 3 => convierte un std_logic_vector en entero (=int) - conv_integer (1110) => 14 - overload de funciones aritméticas y de funciones de conversión - tipos signed (=sig) y unsigned (=uns) -parecidos al std_logic_vector- - funciones de conversión: F(x|y,N) => c ::= la función F convierte un dato tipo x o tipo y a tipo c de tamaño N - SIGNED(uns|slv) => sig convierte tipos sin signo y st_log_vector a tipo signado - UNSIGNED(sig|slv) => uns idem anterior con signo ... a sin signo - STD_LOGIC_VECTOR(sig|uns) => slv convierte tipos sig o uns a st_log_vector - CONV_INTEGER(sig|uns) => int idem anterior a un número entero - CONV_SIGNED(sig|uns|int|sul,N) => sig | estas 3 func hacen lo mismo- CONV_UNSIGNED(sig|uns|int|sul,N) => uns } que las 3 primeras dando el- CONV_STD_LOGIC_VECTOR (sig|uns|int|sul,N) => slv | resultado con N bits

std_logic_arith

-conv_std_logic_vector (0110,4) => 0110 -conv_std_logic_vector (1110,4) => 1110 -conv_std_logic_vector (1110,5) => 11110 -conv_std_logic_vector (0110,4) => 0110 -conv_std_logic_vector (6,4) => 0110 -conv_std_logic_vector (-6,5) => 11110

el argumento 0110 es sigarg = sig arg = sig arg = uns arg = int arg = int

numeric_std - tipos signed y unsigned (como el std_logic_arith) - realiza operaciones aritméticas a estos tipos, pero NO a Std_logic_vector - tipo unsigned - para operaciones entre ellos y/o magnitudes. Da unsigned de un largo L = L del operando más largo. - tipo signed - para operaciones entre ellos y enteros

- funciones de conversión: - TO_INTEGER (uns) => convierte un unsigned a natural (=nat) - TO_INTEGER (1110) => 14 - TO_INTEGER (sig) => convierte un signed a entero - TO_INTEGER (1110) => - 2 - TO_UNSIGNED (nat,n) => convierte nro. natural a array de n bits - TO_UNSIGNED (5,4) => 0101 - TO_SIGNED (int,n) => convierte nro. integer a array de n bits - TO_SIGNED (-4,6) => 111100

3 Expresiones o valores entre paréntesis representan los argumentos de la funciòn de que se trate. Al presentar un tipo de datos se incluye también la abreviatura con que se lo simboliza entre paréntesis y con el signo =, para diferenciarlo. P.ej. signed (=sig) –[No confundir función SIGNED con tipo signed !!]. Cuando se presentan las funciones de conversión se lo hace en mayúsculas; para los ejemplos pueden aparecer en minúsculas.


numeric_std (cont.) - SIGNED (uns) => da un array de bits que equivale a un número entero (argumento conserva valor numérico) - signed (1110) => 1100 4 la apariencia es igual pero diferente la forma en que es tomado por el programa (pej se aprecia si se lo convierte a entero) - UNSIGNED (sig) => da un array de bits que equivale a un número natural (argumento conserva valor numérico) - unsigned (1110) => 1100 (vale comentario anterior)- SIGNED (slv) => convierte un vector en un entero - signed (1110) => 1100 (idem) - UNSIGNED (slv) => convierte un vector a su magnitud - unsigned (1110) => 1100 (idem) - STD_LOGIC_VECTOR (uns/sig) => pasa magnitud o entero a forma vector - std_logic_vector (1110) => 1100 (idem)

Ejemplo: Sea CONSTANT A1 : std_logic_vector := 1110 A1 es visto como un array de bits B1 = unsigned (A1) => B1 = 1110; B2 = signed (A1) => B2 = 1110; Si se hace: C1 = To_integer (B1) => C1 = 14 C2 = To_integer (B2) => C2 = -2 Si se hace: B3 = signed (B1) => B3 = 1110 ; B4 = unsigned (B2) => B4 = 1110 ; Si en estas condiciones se hace: C3 = To_integer (B3) => C3 = -2 C4 = To_integer (B4) => C4 = 14

B1 es visto como una magnitud B2 es visto como un número con signo al ser B1 sin signo (unsigned) se la toma como magnitud binaria al ser B2 con signo (signed) se la toma como número con signo, y según lo conocido, es un número negativo = Ca2 (magnitud) B3 es visto con signo, o sea equivale a B2 B4 es visto como magnitud, o sea equivale a B1

Otro ejemplo: Sea CONSTANT A2 : Unsigned := 1101 (equivale al decimal 13) Si se hace: B5 = std_logic_vector (A2) => B5 = 1101 Si se hace: C5 = To_integer (B5) => error Si se hace: B6 = Conv_integer (B5) => B6 = - 3

aquí B5 es un simple array de bits. No tiene valor numérico. esta función no opera con tipos std_logic_vector, y B5 lo es. la func convirtió un std_logic_vector en entero y es negativo

Otro ejemplo: Sea CONSTANT A3 : signed := 1101 (equivale al entero -3) Si se hace: B7 = std_logic_vector (A3) => B7 = 1101 Si se hace: B8 = Conv_integer (B7) => B6 = - 3

análogamente al caso anterior, B7 es un simple array de bits. No tiene valor numérico. la función convirtió un std_logic_vector en entero y es negativo. Igual que el caso anterior.

¿Por qué los dos últimos ejemplos dan igual? Porque al hacer la conversión de las constantes (de distinto tipo) a std_logic_vector, se uniformiza su tipo: dejan de tener valor numérico para pasar a ser array de bits.

4 Debe quedar claro que: un dato tipo std_logic_vector es un vector de datos std_logic (datos lógicos que asumen uno de nueve estados posibles); un vector de bits es un array de bits, que tienen significado lógico; un signed es un array de bits con significado numérico como entero (el unsigned, como número natural pues es sin signo).


Plantillas de comandos de VHDL (Quartus II - Altera)

LIBRARY library_name; USE library_name.package_name.ALL;

(copia de plantillas modelo tomadas del Quartus II – Altera)

========================================== ENTITY entity_name IS GENERIC(parameter1 : string := default_value1; parameter2 : integer:= default_value2); PORT(input1, input2 : IN STD_LOGIC; input3 : IN STD_LOGIC_VECTOR(range_msb DOWNTO range_lsb); bidir1, bidir2 : INOUT STD_LOGIC; output1, output2 : OUT STD_LOGIC); END entity_name; ======================================================

- Arquitectura desplegada (Incluye varios opcionales)

ARCHITECTURE arch_name OF entity_name IS -- SIGNAL signal_name1 : STD_LOGIC; -- SIGNAL signal_name2 : STD_LOGIC; BEGIN -- Process Statement (optional) --process_label: --PROCESS (signal1, signal2, signal3) -- -- Local variables -- VARIABLE variable1 : STD_LOGIC; -- VARIABLE variable2 : STD_LOGIC; --BEGIN -- WAIT UNTIL clk_signal = '1'; -- Signal Assignment Statement (optional) -- Variable Assignment Statement (optional) -- Procedure Call Statement (optional) -- If Statement (optional) -- Case Statement (optional) -- Loop Statement (optional) --END PROCESS process_label; -- -- Concurrent Signal Assignment (optional)

-- Concurrent Procedure Call (optional)

-- Conditional Signal Assignment (optional) -- Selected Signal Assignment (optional) -- Component Instantiation Statement (optional) --instance_name : component_name -- GENERIC MAP(parameter1 => value1, -- parameter2 => value2) -- PORT MAP(component_port1 => signal1, -- component_port2 => signal2); -- Generate Statement (optional) -- For generate: --generate_label: --FOR index_variable IN range_low TO range_high GENERATE -- statement1; -- statement2; --END GENERATE; -- If generate: --generate_label: --IF expressión GENERATE -- statement1; -- statement2; --END GENERATE;

END arch_name;

Algunas librerías, tipos de datos y

funciones de conversión: tipos básicos: entero (int), natural (nat), Bit, bit_vector, bool, character, etc std_logic_1164 - tipos std_ulogic (=sul), std_ulogic_vector (=suv), std_logic (=sl) y std_logic_vector (=slv) std_logic_unsigned - opera std_logic_vector y/o magnitudes (sin signo) en forma aritmética - conv_integer (slv) => int std_logic_arith - tipos signed (=sig) y unsigned (=uns) - funciones de conversión: - signed(uns|slv) => sig - unsigned(sig|slv) => uns - std_logic_vector(sig|uns) => slv - conv_integer(sig|uns) => int - conv_signed(sig|uns|int|sul,n) => sig - conv_unsigned(sig|uns|int|sul,n) => uns- conv_std_logic_vector(sig|uns|int|sul,n) => slv numeric_std - tipos unsigned y signed - funciones de conversión: - to_integer (uns) => int - to_integer (sig) => int - to_unsigned (nat,n) => uns - to_signed (int,n) => sig - signed (uns) => sig - unsigned (sig) => uns - signed (slv) => sig - unsigned (slv) => uns - std_logic_vector (uns,sig) => slv

================================ SIGNAL signal_name : type; signal <= expression;


====================================== TYPE enumerated_type_name IS (enum1, enum2,enum3); TYPE range_type_name IS RANGE low_range TO high_range; TYPE array_type_name IS ARRAY (INTEGER RANGE <>) OF type; TYPE array_type_name IS ARRAY (high_range DOWNTO low_range) OF type; ========================================== COMPONENT component_name GENERIC(parameter1 : string := default_value1; parameter2 : integer := default_value2); PORT(input1, input2 : IN STD_LOGIC; bidir1, bidir2 : INOUT STD_LOGIC; output1, output2 : OUT STD_LOGIC); END COMPONENT; =========================================== instance_name : component_name GENERIC MAP(parameter1 => value1, parameter2 => value2) PORT MAP(component_port1 => signal1, component_port2 => signal2); =========================================== label: WITH expressión SELECT signal <= expression1 WHEN constant_value1, expression2 WHEN constant_value2, expressionM WHEN constant_valueM; ========================================== label: signal <= expression1 WHEN boolean_expression1 ELSE expression2 WHEN boolean_expression2 ELSE expression3; ========================================== IF expression1 THEN statement1; statement2; ELSIF expression2 THEN statement3; statement4; ELSE statement5; statement6; END IF; ========================================== CASE expressión IS WHEN constant_value1 => statement1; statement2; WHEN constant_value2 => statement3; statement4; WHEN OTHERS => statement5; statement6; END CASE; ========================================== loop_label: FOR index_variable IN range_low TO range_high LOOP statement 1; statement n; END LOOP loop_label; ========================================= loop_label: WHILE boolean_expressión LOOP statement1; statement2; END LOOP loop_label; ================================================

Nota: recordar que estas son copias de plantillas modelo; sirven para abreviar la escritura. las sentencias que en la arquitectura más arriba comienzan con - - significa que son opcionales, y se muestran como ejemplo de las que pueden integrar una arquitectura. Los modos de las señales de entrada salida y/o los tipos de datos, también se ilustran como ejemplo, debiendo aplicarse los convenientes al diseño correspondiente.

introduccion al vhdl

Documents