Introduccion Al VHDL

TCNICAS DIGITALES 1
ING. JUAN E. COLLAZO
Introduccin al VHDL
Rv. 15
Pg. 1/50
INTRODUCCIN AL LENGUAJE VHDL
INTRODUCCIN.................................................................................................................3
ESQUEMA TPICO DE UN DISEO CAD ..........................................................................3
CONSTRUCCIONES BSICAS EN VHDL:.........................................................................4
Las Entidades (ENTITY): ............................................................................................................4
Las Arquitecturas (ARCHITECTURE): .......................................................................................4
Las Bibliotecas (LIBRARIES):.....................................................................................................5
Las Configuraciones (CONFIGURATION):.................................................................................6
Ejemplo 1: diseo de una compuerta And de 2 entradas. ................................................................................. 6
Puertos: ....................................................................................................................................................7
Modos:......................................................................................................................................................7
Distintos tipos de arquitecturas: ....................................................................................................8

- por comportamiento, ..............................................................................................................................8
-- algortmico,............................................................................................................................................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
Seales:..................................................................................................................................................11
Ejemplo 2: una suma de productos lgicos.................................................................................................... 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 seales:...........................................................................................................................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 asignacin simple....................................................................................19
Ejemplo 4: sea disear un circuito que realice la funcin lgica Y = C. A + C .B .................................... 19
Biblioteca IEEE (Paquete Std_logic_1164)...........................................................................................20
* Procesos concurrentes con asignacin condicionada (sentencia when .... else) .............................20
Ejemplo 5:........................................................................................................................................................ 21
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 2/50
* Procesos concurrentes con asignacin seleccionada.........................................................................21

Ejemplo 6:........................................................................................................................................................ 22
Ejemplo 7: se introduce una variante que contempla el caso de que C no sea slo 0 1. .............................. 22
* Procesos concurrentes con asignacin seleccionada y vector datos .................................................23
Ejemplo 8:........................................................................................................................................................ 23
Ejemplo 9: variante del ejemplo anterior usando representacin octal:.......................................................... 24
* Uso de sentencias secuenciales (Procesos) ............................................................................24

Uso de la sentencia WAIT dentro de un Process........................................................................24
* Procesos secuenciales con asignacin seleccionada.........................................................................26
Ejemplo 10: diseo de un Mux de 2 canales en forma secuencial seleccionada............................................. 26
Ejemplo 11: una forma ms simple de Mux de 2 canales que la anterior:...................................................... 28
* Procesos secuenciales con asignacin condicionada.........................................................................28
Ejemplo 12: diseo de un Mux de 2 canales en forma secuencial condicionada............................................ 28
Ejemplo 13: descripcin estructural del multiplexor simple de 2 entradas..................................................... 29
* Otros paquetes y sus tipos de datos. Funciones de conversin..............................................30

Paquete Numeric_std............................................................................................................................30
Ms operaciones con vectores: conversores de cdigos BCD.............................................................32
Ejemplo 14: diseo del conversor bcd nat a aiken usando el package Numeric_std ...................................... 32
A modo de ejemplo se transcriben la simulacin 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 creacin de tipo de datos ................................................. 34
Manejo de datos .....................................................................................................................................35
Ejemplo 17: diseo de un conversor de Cdigo Gray a Cdigo binario ......................................................... 35
Operaciones Lgicas sobre Vectores ....................................................................................................36
Ejemplo 18: Conversor de Cdigo Gray a Cdigo binario operando sobre vectores...................................... 36
DISEO ESTRUCTURAL :
Instanciacin 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 instanciacin ms amplia se ve a continuacin. ........................................................... 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 reiteracin 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 lneas) usando while ... loop...................................................... 41
Funciones de Resolucin ............................................................................................................42

Variables y Seales en procesos secuenciales .....................................................................................42
Ejemplo 23: asignaciones mltiples a variables y seales ............................................................................ 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 conversin..............................................................47
Plantillas de comandos de VHDL (Quartus II - Altera) ................................................................49
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 3/50
INTRODUCCIN
El avance del desarrollo tecnolgico en electrnica, determinante del incremento de componentes
que se integran en chips de silicio conduce a la creacin de circuitos integrados cada vez mas
complejos y que permiten a su vez la obtencin de mltiples y complejas funciones lgicas en un
slo dispositivo integrado.
Esto a su vez determina la necesidad de expresar esas funciones lgicas de una manera ms
cmoda y a la vez, proceder al diseo de los circuitos lgicos cambiando las maneras tradicionales
por otras acordes al volumen de componentes y expresiones. La herramienta para lograrlo, como
no podra 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 tambin 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 diseador verificar si lo que se est desarrollando cumple lo
que se pretende, para lo cual, un camino es poder simular comportamientos.
Estos antecedentes, sintticamente, marcan la aparicin de lenguajes descriptores de hardware
(Hardware Description Languages). As, en la dcada del 80 el Departamento de Defensa de los
EE.UU de Norteamrica 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 sntesis de circuitos, sirve tambin como
documentacin de desarrollos.
ESQUEMA TPICO DE UN DISEO CAD 1

El proceso de un desarrollo utilizando herramientas de software sigue, como lnea general, los
pasos que esquemticamente se muestran a continuacin los cuales, dependiendo de los distintos
fabricantes y diseadores pueden presentar ligeras variantes:
Especificacin
del circuito
S
Ajuste
Sntesis
Anlisis y
Simulacin
temporal
Simulacin
Funcional
No
No
Diseo
es OK?
Cumple requisitos
temporales?
S
Programacin y
Configuracin
Computer Aided Design = diseo asistido por computadora
fig. 1
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 4/50
En el mismo, se ve como primer estado la especificacin del circuito deseado, el cual se puede
hacer por medio de un diagrama esquemtico o bien por una descripcin mediante un lenguaje de
Hardware como Verilog o VHDL.
De ella se pasa a la sntesis (realizacin) del circuito, que se concreta mediante una lista de
elementos lgicos necesarios para realizarlo y tambin un detalle de sus interconexiones.
Para ver que todo est bien, se recurre en tercer instancia a una simulacin, que en principio no
toma en cuenta cuestiones temporales (retardos, etc.)
De estos pasos se hace una primer evaluacin para ver si todo funciona ok y si es as se contina.
El programa de diseo debe tener herramientas para hacer corresponder los elementos lgicos
que se encontraron necesarios en la sntesis con el chip (FPGA) que contiene las unidades fsicas.
De aqu se pasa a analizar las propagaciones de tiempo que esas unidades fsicas reales
presentarn a las distintas seales del circuito que se disea 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 configuracin de cableado
interno de los elementos lgicos de la FPGA, que materializan las seales que se acaban de
simular.
CONSTRUCCIONES BSICAS EN VHDL:

Para encarar el diseo de dispositivos en VHDL
existen estructuras de nivel superior que son los
denominados Archivos de diseo. En ellas se
engloban todos los programas que conducen a la
creacin de esos dispositivos, a nivel de software.
Estos archivos pueden estar compuestos por una o
ms unidades menores que se denominan
Unidades de diseo y que a su vez pueden formar
parte de otros archivos de diseo.
El diseo en VHDL en general puede emplear

cuatro bloques:
Las Entidades (ENTITY):
Archivo de diseo n
Archivo de diseo k
Unidad 1
Unidad
Unidad
1
2
Circuito
3
Unidad
2
Circuito
n
Circuito
3
Circuito n
Package NNN
Package
NNN
......................
Archivo de diseo......................
1
Entity PPP is ...
Entity
PPP is ...
Circuito 1
...................
Circuito 2
...................
Architecture XX
Circuito 3
Circuito n Architecture
XX is
of Entity PPP
of Entity
PPP is
...................
Package NNN
.........................................
Entity PPP is ...
...................
Architecture XX
of Entity PPP is
...................
fig. 2
Son la representacin de lo que se quiere disear en su relacin con el mundo exterior. Su

modelizacin se hace definiendo las puertas con el exterior y los parmetros de la entidad.
Esta forma que tiene el VHDL de presentar un circuito, se la podra 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 informacin que maneja la Entidad para cumplir su funcin.
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).
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 5/50
fig. 3
fig. 4
Las Bibliotecas (LIBRARIES):
Lugar donde se almacenan determinados componentes y elementos que se van a utilizar en los
diseos. Segn las caractersticas 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 (declaracin del paquete)
- Package Body (cuerpo del paquete)
A continuacin se muestra una parte del "cuerpo" de la librera Standard de la norma IEEE 1076.93
- Un package es lo que en C se llama Library: son las descripciones
TCNICAS DIGITALES 1
Introduccin al VHDL
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;
Rv. 15
Pg. 6/50
+
**
/
Compuertas
Funciones
Bloques
Type octeto is ...

Type palabra is ...
Type xxxxx is ...
fig. 5
Circuitos
Tipos
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 sntesis en VHDL).
Las unidades de diseo en VHDL siempre contendrn Entidades y Arquitecturas, pudiendo los
otros ser opcionales de declaracin. Si no se declara ninguna biblioteca, ni ningn paquete en
particular, se toma la denominada Standard y sus paquetes del mismo tipo.
Se ver un ejemplo sencillo de cmo hacer un diseo en VHDL. Antes se pueden destacar
algunas caractersticas del lenguaje que debern observarse para obtener el xito en la
programacin:
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 tamao de letra, por lo cual, los elementos del lenguaje pueden ser
enunciados tanto en mayscula como minscula y representarn al mismo.
El lenguaje admite la inclusin 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 lnea termina.
Deben conocerse las palabras reservadas del VHDL y evitar su uso en elementos y
sentencias que no sean aqullos para los cuales estn destinadas.
Ejemplo 1: diseo de una compuerta And de 2 entradas.
--Diseo de una And de 2 entradas
-- Definicin
ENTITY and2in
PORT (a :
b :
y :
END AND2IN;
de la
IS
IN
IN
OUT
entidad
BIT;
BIT;
BIT);
-- Definicin de la arquitectura
ARCHITECTURE comportamiento OF and2in IS
BEGIN
y<= a AND b;
END comportamiento;
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 7/50
De este primer ejemplo se puede ver lo siguiente:

Adems de los comentarios se pueden dejar renglones en blanco, que facilitan la lectura.
Este diseo contiene slo una Entidad y una Arquitectura.
Qu elementos se encuentran en esta descripcin?
1) Un bloque entidad: que tiene generalmente una estructura de declaracin como la que sigue:
entity <identificador> is
[cabecera]
[declaraciones]
[sentencias]
end [entity] <identificador>
el smbolo [ ] define que se trata de un campo o parmetro optativo.
Puertos: La entidad es la definicin de un diseo visto como "caja negra". Se declaran en ella dos
objetos: los puertos (o puertas) y los parmetros. En este ejemplo las puertas se declaran con la
palabra reservada PORT (es un identificador propio del VHDL; ms 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 seales 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 seal slo puede adoptar valores 0 y 1.
Declaraciones: en esta seccin se formulan tipos, subtipos y otros elementos del lenguaje que se
vern oportunamente. A veces se incluye la declaracin de parmetros especiales para mejorar
ciertos aspectos de diseo, 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 seales 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 direccin que tienen las seales con que el circuito se comunica con el
exterior. Se enumeran a continuacin y se detalla tambin las caractersticas que permiten la
conexin entre puertas, segn sea su modo:
- In: (entrada) corresponde a aqullas que slo pueden ser ledas 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 ledas por el circuito. Puede
conectarse a puertos out o inout
- Inout, (entrada/salida) corresponde a un puerto de tipo bidireccional (asociado a una salida tristate, por ejemplo); puede ser ledo y modificado. Puede asociarse slo a otros puertos del
mismo modo.
- Buffer, es una puerta de salida que est siempre activa. Puede ser leda y modificada. Slo
admite una sola fuente de escritura y puede asociarse slo 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)
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 8/50
La entidad finaliza su cuerpo con la palabra end y a continuacin el nombre de la entidad. En el

ejemplo ex-profeso, se la tipe en maysculas, a diferencia de la declaracin, 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 aparecern todos los elementos que abajo se
detallan:
ARCHITECTURE<identificador(de la arquit)>OF<identificador (de la entidad)>IS
declaracin de seales locales
declaracin de constantes locales
zona de
declaracin de tipos y subtipos
declaraciones
declaracin de componentes
(no van todas)
declaracin de atributos
declaracin y cuerpo de subprogramas
BEGIN
-- Asignaciones simples (opcional)
-- Process Statement (optional)
-- Concurrent Procedure Call (optional)
zona de sentencias
-- Concurrent Signal Assignment (optional)
(no van todas)
-- Conditional Signal Assignment (optional)
-- Selected Signal Assignment (optional)
-- Component Instantiation Statement (optional)
-- Generate Statement (optional)
END [ARCHITECTURE] <identificador (de la arq.)>;
Distintos tipos de arquitecturas: un dispositivo se puede describir en VHDL de diversas formas:
- por comportamiento,
Describe un circuito de manera abstracta, indicando cmo se comporta. Explica una relacin entre
entrada-salida del mismo sin entrar en los detalles de construccin de los elementos que
establecen esa relacin. Puede ser de dos formas dependiendo del nivel de abstraccin y de la
forma de ejecutar las instrucciones:
-- algortmico,
la descripcin algortmica detalla acciones que debe realizar el dispositivo para cumplir su
funcionalidad como si fuera un algoritmo de software.
-- flujo de datos:
existe una descripcin de las seales del circuito y su comportamiento en funcin de las entradas
por medio de expresiones lgicas. Tambin se la denomina de transferencia entre registros (RTL).
- estructural:
el nivel de descripcin estructural consiste en enumerar los componentes de un circuito y describir
sus interconexiones. Hay dos formas de hacerlo.
-- mediante esquemas (haciendo una descripcin grfica de los componentes del circuito)
-- mediante lenguaje (se hace una enumeracin 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 continuacin y en la misma sentencia, corresponde introducir (luego de
OF) el nombre de la entidad cuya arquitectura se va a establecer.
Como las nicas seales 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 cmo lo describe
alude a lo que se mencion ms arriba como comportamiento). El comienzo del cuerpo lo da la
sinnima palabra BEGIN. Lo que sigue es la asignacin a seal (en este caso de salida):
TCNICAS DIGITALES 1
y<= a AND b
Introduccin al VHDL
Rv. 15
Pg. 9/50
significa que a y se le asigna (operador relacional de asignacin <=) un estado

que surge de una operacin entre seales vinculadas por el operador lgico AND
El cierre se hace nuevamente con end y el nombre (identificador) de la arquitectura. Tambin se

destaca (y es muy comn 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 ms arriba se dijo que las arquitecturas representan el interior de la caja negra que define el
circuito, lo que en los dispositivos fsicos se conforman con compuertas, componentes y lneas de
conexin (hardware); en una construccin de software los elementos sern las sentencias
Un lenguaje que describa lo ms prximo a la realidad el comportamiento de los circuitos, deber
tener en cuenta que en ellos el procesamiento de las seales se hace en forma simultnea, a partir
de los cambios que se producen en las seales/ variables de entrada que le dan lugar y que slo
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 simultneamente en la simulacin, no
existiendo priorizaciones en la resolucin de unas sobre otras. Las seales 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 programacin 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 rengln de la misma.
Sea por ejemplo la implementacin de la funcin lgica Y = A . B. Se ver cmo responden las
sentencias segn sean concurrentes o bien secuenciales. Se parte de la asignacin inicial del
estado de las seales 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 seal.
estado inicial:
sentencia 1 :
sentencia 2:
sentencia 3:
A=B=Y=0
A=1
B=1
Y=A.B
Una estructura de programa (secuencial) tomara

un paso para ejecutar cada una. Dichos pasos
son instancias de tiempo. A la derecha se grafica
esta situacin, representando cada rengln un
instante de tiempo.
SECUENCIAL
CONCURRENTE
En el caso de sentencias concurrentes, se

2
1
1
0
1
1
1
evalan todas simultneamente. Eso determina
3
1
1
1
que en el instante t = 1 se asignan A y B
simultneamente.
Atencin: tambin se asigna Y = A.B, pero con el
valor que tenan antes de la ejecucin de la sentencia y por eso Y sigue siendo cero. En el
instante siguiente (t=2) se actualiza Y.
TCNICAS DIGITALES 1
Introduccin al VHDL
Se deja para el estudiante interesado, formular un planteo

de naturaleza similar de la evolucin de asignaciones a las
distintas seales y variables que aparecen en el circuito de
la figura, segn que las sentencias sean del tipo
concurrente o secuencial.
Rv. 15
C.A
Y
C
B
Pg. 10/50
C.B
Y = C.B + C.A
fig. 6
Para representar los procesos de la realidad, el VHDL utiliza tres tpos de objetos, las constantes,
las variables, y las seales . stas dos ltimas pueden variar su valor mientras se ejecuta el
programa, son las designadas por el lenguaje para manipular la informacin del circuito o sistema
en diseo. Pero tendrn una caracterstica distintiva: las seales 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: Cmo hace el VHDL para darle aspecto concurrente a sentencias
secuenciales? Y la respuesta es mediante los procesos explcitos, que se declaran como tales.
Procesos
Los procesos son estructuras concurrentes que se elaboran con sentencias de ejecucin
secuencial. Esa concurrencia determina que dentro de l las variables que intervienen se evalan
en forma inmediata, pero recin se actualizan cuando finaliza el proceso. Se materializan con la:
Sentencia Process (proceso)
Suele ir acompaada de una lista de sensibilidad (se escribe entre parntesis luego de su
declaracin). Dicha lista define las seales que al cambiar activan la ejecucin 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 bsicos:
1)
2)
3)
4)
5)
6)
7)
Identificadores
Objetos
Tipos de datos
Delimitadores
Comentarios
Literales
Operadores
1.- Identificadores:
reservadas.
pueden ser de dos tipos: genricos simples y extendidos- y palabras
Un identificador genrico es un conjunto de caracteres que se utilizan para nombrar distintos

elementos en VHDL. Est formado por las letras del abecedario, nmeros 0 a 9 y el carcter
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 mxima
establecida. VHDL no hace distincin entre maysculas y minsculas, o sea es case insensitive.
Tambin hay identificadores extendidos que se escriben entre smbolos \. Estos identificadores
extendidos admiten otros caracteres adems 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 especfico en
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 11/50
VHDL (se las utiliza en sentencias, objetos, tipos, etc) y por lo tanto no pueden ser utilizadas por el
usuario para otra funcin que la prevista en el lenguaje.
En el ejemplo aparecen en letras maysculas (slo para resaltar; en las bibliografas se las podr
encontrar en negrita. El AHDL Altera HDL- las muestra en color azul a medida que se las tipea)
2.- Objetos:
Son los elementos que define y utiliza el lenguaje para almacenamiento de informacin de un tipo
determinado. En funcin de ste, se le podrn 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 conversin de tipos. En VHDL existen cuatro clases de objetos:
1. constantes
2. variables
3. seales
4. archivos
Constantes:
Una constante es aquel objeto que mantiene el mismo valor a lo largo de la descripcin del circuito y
del proceso de simulacin. Se inicializan en el momento de su declaracin (excepto en el caso de las
denominadas constantes diferidas o aplazadas). Su sintaxis es:
CONSTANT constant_name : type := constant_value;
Un ejemplo es :
CONSTANT alfa : integer := 50
Variables:
Una variable es un dato en memoria de la computadora. Slo pueden ser declaradas y utilizadas en
estructuras secuenciales (procesos Process - o subprogramas); son locales a ellos (salvo las de tipo
compartido o globales). No tiene relacin directa con el hardware (como lo tiene la seal). Se le
puede asignar un valor inicial explcito al declarar su tipo. No tiene valores futuros. Cuando se
ejecuta la sentencia, se evala y se actualiza su valor, y ste puede ser utilizado por la lnea siguiente
de sentencias del programa. No se puede utilizar una variable fuera del Process (si se necesita su
valor o estado, se usar una seal a quien la variable le transfiere el mismo).
Si a una variable no se le asigna un valor inicial lo hace el simulador por default (para las de tipo
enumerado, el valor con que se inicializa es el del primer elemento del mismo)
Se les asigna un valor mediante el operador compuesto :=
Su sintaxis es:
Ejemplo:
VARIABLE <nombre> : <tipo> [:=<expresin>]
VARIABLE
num_bcd : bit_vector := 1001
Seales:
Una seal representa las conexiones o terminales fsicos de un circuito. Se la puede ver como uno o
ms 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 simulacin (no cuando se ejecuta la
sentencia, como la variable).
Las seales se declaran en sentencias de tipo concurrentes aunque se las puede usar en las
secuenciales, tambin. En este caso irn 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
lneas siguientes del programa) sino al finalizar el Proceso.
En las Arquitecturas, las seales se declaran antes de BEGIN.
Se les asigna un valor mediante el operador compuesto <= , pej. r <= 1
Atencin! tambin se puede utilizar el operador de asignacin usado para variables, pero slo para
inicializar el valor de una seal.
Su sintaxis es:
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 12/50
signal_declaration ::=
signal identifier_list : subtype_indication [ signal_kind ] [ := expression ] ;
Ejemplo 2: una suma de productos lgicos

A
sea el circuito de fig. 6 donde se declar la entity con 3

entradas (A,B,C) y una salida (Y). Se ver una arquitectura
posible. Se supone que en dicho circuito se consideran las
funciones lgicas internas V=/C.A y W = C.B. En VHDL se
crean dos seales para representarlas y procesarlas:
......
ARCHITECTURE estruct OF suma2nivel IS
SIGNAL v, w : bit ; -- dos seales y su tipo
BEGIN
V<= a AND NOT c
W<= c AND b;
Y<= V OR w;
END ESTRUCT; -- maysculas o minsculas es indistinto
C.A
Y
C
B
C.B
Y = C.B + C.A
A
Proceso 1
Proceso 3
Proceso 2
Archivos (files):
se usan para el intercambio de info con el ambiente externo. A este objeto se le asigna un archivo de
todos los que pertenecen al sistema.
file <identificador>: tipo [:=expresin]
3.- Tipos de datos

El tipo de datos es el elemento que caracteriza cules son los valores, estados, asignaciones y
operaciones que pueden ser asumidos por los objetos. Existen tipos predefinidos - o nativos - cuya
informacin se guarda en la denominada biblioteca standard en paquetes homnimos (se definen en
ella los tipos lgicos y numricos bsicos) 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 segn las variantes de lenguajes VHDL.
Para utilizar objetos que sean de tipos creados por los usuarios, slo se lo puede hacer a posteriori de
su declaracin. 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
diseo) y luego invocarla antes de declarar la entity mediante la sentencia use. work....
Hay cuatro tipos bsicos de datos:
1. escalares
2. compuestos
3. de acceso (punteros)
4. archivos
Se pueden declarar subtipos dentro de un tipo (subtypes). Cada tipo es distinto de los otros; los
objetos creados con diferentes tipos son incompatibles, esto es, no pueden ser sometidos a
operaciones entre ellos, a menos que se proceda a la conversin de uno de los tipos, lo cual se hace
mediante la definicin de una funcin para transformarlos. Los objetos de un subtipo son compatibles
con objetos del tipo que le da origen.
Dentro de los escalares se encuentran:
Tipos enumerados: en ellos el conjunto de valores que los caracterizan se enuncian mediante una
lista taxativa (nombra a cada uno). El primer identificador es el nombre del tipo y sirve para
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 13/50
referenciarlo, y entre parntesis y separados por comas se adjuntan todos los valores legales del tipo.
TYPE vocales IS ('a', 'e', 'i', 'o', 'u');
TYPE semforo IS (rojo, amarillo, verde);
Esta forma de especificar un tipo de dato hace que cuando se opere con un objeto de este tipo, si no
se lo inicializa (si no se le da un valor inicial) asumir el valor ms a la izquierda de los especificados
en la declaracin del tipo. Esto es, si se trabaja con un objeto tipo semforo va a asumir que est en
rojo, a falta de una asignacin distinta cuando se lo invoque por primera vez.
En el ejemplo de la And, el tipo es BIT, cuyos componentes por enumeracin son 0 y 1. Otro es:
TYPE std_logic IS ('X','0','1','Z','W','L','H','U',-);
El tipo std_logic es uno de los ms usados en VHDL y se encuentra en el paquete STD_LOGIC_1164.
Una seal de este tipo puede tomar uno de varios estados, mientras que si fuera del tipo bit slo
podra tener dos (0 1). El significado de cada tipo es.
* X : desconocido fuerte
* 0 : cero fuerte
* 1 : uno fuerte
* Z : alta impedancia
* W : desconocido dbil
* L : cero dbil
* H : uno dbil
* U : no inicializado
* - : indiferente
Tipos enteros / reales: En VHDL vienen definidos el tipo integer (entero), que corresponde a valores
comprendidos 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:
TYPE hora IS range (0 to 23);
TYPE dias IS range (31 downto 0);
(se lee de 0 a 23, en forma ascendente)

(se lee de 31 a 0, en forma descendente)
Si no se especifica un valor inicial, el objeto se inicializa con el valor ms a la izquierda de los

especificados en la declaracin 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).
Tipos fisicos: se utilizan para representar
magnitudes que corresponden a variables
fsicas como el tiempo, peso, distancia, etc,...
Se los especifica agregando al rango de
valores, las unidades con que miden las
magnitudes fsicas a que corresponde.
TYPE distancia IS RANGE 0 TO 1E16

UNITS
A;
nm=10A;
um=1000nm;
mm=1000um;
cm=10mm;
m =1000mm;
km=1000m;
END UNITS
--utilizacin
a<=10cm;
b<=1m;
c<=a+b; --c valdra 110cm
El uso da unidades no tiene mucho sentido en los tipos de descripcin vistos anteriormente. Pero s
son muy tiles a la hora de las simulaciones y para ayudar a la depuracin.
Los tipos compuestos son aqullos que se forman con el agregado de varios elementos. Estos
pueden ser del mismo tipo o de distinto tipo. En el primer caso se dice que es un tipo homogneo y se
denomina array. El otro, es de tipo heterogneo y se llama record. Un elemento de tipo array, tiene
un ndice que es entero.
Un array sera:
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 14/50
TYPE bus_direcciones IS ARRAY (0 TO 63) OF BIT;

Una matriz:
TYPE matriz IS ARRAY (1 TO 10, 1 TO 20) OF REAL;
TYPE memoria IS ARRAY (2**N-1 DOWNTO 0) OF STD_LOGIC_VECTOR(K-1 DOWNTO 0);
Un record:
TYPE fecha is RECORD
dia: INTEGER RANGE 1 TO 31;
mes: INTEGER RANGE 1 TO 12;
otro: BIT;
END RECORD;
Dentro de los tipos predefinidos en la biblioteca standard ms importantes se encuentran:
TIPO
RANGO DE VALORES
Natural
0 a Maxint *
Positive
1 a Maxint
Integer
- Maxint a Maxint
Real
-Maxreal a Maxreal **
Bit
0,1
Bit_vector
conjunto de bits
Boolean
True, False
Character
(variado) ***
String
conjunto de caracteres
Time
- Maxint a Maxint [unidad]
*
**
***
Qu representa?
nmeros naturales
nmeros positivos
nmeros enteros
nmeros reales
valores binarios
cadenas de bits
valores booleanos
caracteres
cadenas de caracteres
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 bibliografa
fig. 7
4.- Delimitadores: son smbolos especiales que se utilizan con funciones diferentes y especficas,
Algunos de ellos se los va a utilizar como Operadores (ver ms adelante). Otros tienen diversas
funciones como por ejemplo el smbolo "- -" 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.
Los delimitadores en VHDL son:
+ - / ( ) . , : ; & ' < > = | # <= => := --
5.- Comentarios: son oraciones libres y sin ninguna sintaxis preestablecida, como no sea que deben
comenzar con - -;
se hacen para que el usuario logre mayor claridad, orientacin, etc en el
desarrollo de su programa; para establecer los pasos que va dando, reconocer distintas etapas,
sirven para documentacin, etc. El programa omite su procesamiento al detectar - - y salta a la
siguiente sentencia vlida del lenguaje. En el ejemplo visto, se lo utiliz como ttulo.
6.- Los Literales pueden ser:
nmeros, caracteres
o strings
Los nmeros son un texto que representa un valor numrico. Pueden ser enteros (5, -33, etc), reales
(2.71828
0.69), admiten notacin exponencial (3.23E-4; 8.43E9), admiten representacin en una
base distinta de 10 utilizando dos caracteres # (uno para la base y el otro para el nmero -en
decimal- ). y tambin la separacin con guiones bajos para mayor claridad de nmeros grandes en
lugar del punto reservado para los reales- (10_983_145 ; 3.141_592_7)
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 15/50
2#1011# significa representacin en base 2 del nmero 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 nmeros tienen una descripcin implcita (su valor numrico), los caracteres se
describen en VHDL por enumeracin 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
Tambin 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. Segn sea sta, se colocan los
caracteres B, O, X respectivamente a la izquierda del string: B0110 1011, O153 y X6b.
Atencin: un nmero expresado en octal es asociado a 3 bits, mientras que uno en hexa, se asocia a
4, por lo cual las expresiones anteriores, como nmeros, no son equivalentes.
7.- Los operadores pueden ser de cinco tipos:
* aritmticos
* relacionales
* lgicos
* de desplazamiento
* Los artimticos son:

OPERADOR
+
*
/
**
OPERACIN
suma
resta
producto
cociente
exponente
MOD
REM
ABS
mdulo
resto
valor absoluto
* otro tipo
* Los relacionales son:

TIPO DE DATOS
tipo numrico
tipo numrico
entero, real
entero, real
entero, real
(expon'te entero)
ambos enteros
ambos enteros
tipo numrico
Los operadores lgicos son:

OPERADOR
OPERACIN
AND
y
OR
o
NAND
y negado
NOR
o negado
XOR
o exclusiva
XNOR
o exclusiva negada
NOT
negacin
OPERADOR
=
/=
>
>=
<
<=
fig. 8
OPERACIN
igualdad
distinto
mayor que
mayor o igual
menor que
menor o igual (y
asign seales)
fig. 9
Los operadores de desplazamientos son:
fig. 10
OPERADOR
OPERACIN
SLL
desplazamiento lgico a la izquierda
SRL
desplazamiento lgico a la derecha
SLA
desplazamiento aritmtico a la izquierda
SRA
desplazamiento aritmtico a la derecha
ROL
rotacin a la izquierda
ROR
rotacin a la derecha
fig. 11
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 16/50
Ejemplos con los operadores de desplazamiento: dado un dato A cuyo valor inicial es 1100 1101, se
ver qu resultado arroja la compilacin 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 (extensin del ltimo bit: similar a SSL pero el lugar de los bits
que se desplazan es ocupado por rplicas del ltimo bit que que se desplaz en negrita- )
A SRA 4 --el resultado es 1111 1100 (anlogo 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 (anlogo a ROL, en sentido contrario)
y finalmente, los otros operadores son:
OPERADOR OPERACIN
+
signo positivo
signo negativo
&
concatenacin
1.
2.
3.
4.
5.
6.
El orden de prioridad con que el lenguaje los toma, de

mayor a menor es el que se muestra a la izquierda.
**, ABS, NOT

*, /, MOD, REM
+, - (signo)
+, -, & (operaciones)
=, /=, <, <=, >, >=
AND, OR, NAND, NOR, XOR
Atencin: no todos pueden operar con todos los tipos

de datos.
Atributos
Son caractersticas aplicables a algunos elementos del lenguaje que permiten obtener de ellos
informacin adicional. Entre los elementos que pueden tener atributos estn:
Entidades
Arquitecturas
Configuraciones
Paquetes
Subprogramas
Tipos y subtipos
Objetos
Componentes
Etiquetas
Literales
Unidades de un tipo fsico
Para denotar la aplicacin de un atributo, la sintaxis utiliza un apstofre () 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 seales
Atributos predefinidos para funciones
Atributos predefinidos para tipo de dato
Atributos para arrays:

Atributo 'left: refiere al elemento ms a la izquierda de un vector.
Atributo 'right: refiere al elemento ms 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 aplicacin: se ha definido una seal: signal num_bcd : std_logic_vector (3 downto 0);
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 17/50
Si se aplican los atributos anteriores, se indica la respuesta que brinda el VHDL:

num_bcdlenght,
num_bcdleft,
num_bcdright,
num_bcdrange,
=> devuelve valor 4

=> devuelve 3
=> devuelve 0
=> dev. 3 downto 0
largo de un vector o array

valor izq. de ndice de array
valor der. de ndice de array
rango del vector
Atributos para seales:

Ejemplo: Sea la seal set : in std_logic.
Algunos atributos son:
setdelayed(T) => genera una rplica de set con una demora T

setstable(T)
=> devuelve true si set no cambi durante un lapso T anterior
setlast_event => devuelve el tiempo transcurrido desde el ltimo evento en set
setevent
=> devuelve true si set ha cambiado
En la figura que sigue se ve un ejemplo de

aplicacin de atributos sobre la seal Set
Atributos para tipos de datos enumerados
Ejemplo: se ha definido por enumeracin 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 continuacin:
codigossucc(aiken)
codigospred(aiken)
codigoslow
codigoshigh
codigospos(aiken)
codigosval(3)
codigoslenght
devuelve
devuelve
devuelve
devuelve
devuelve
devuelve
devuelve
gray
sucesor
bcd
predecesor
bcd
equivale a izquierda
Johnson equivale a derecha
1 (*)
(las posiciones se numeran de izq a der empezando en 0)
xs3 (*) valor en la posicin 3
5
largo: cantidad de componentes del tipo
(*) pos y val dependen del tipo de objeto al que se aplican.

De los vistos, los ms importantes son range, event y length .
Ejemplo 3: la compuerta AND empleando otro tipo de datos

-- Diseo 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);
-- seal y, en modo salida tipo de datos es bit
END and2_bitvector;
-- se termino de declarar la "entidad"
-- rengln en blanco para separar
-- DISEO POR COMPORTAMIENTO
--
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 18/50
ARCHITECTURE comporta_and2 OF and2_bitvector IS

BEGIN
y <= '1' WHEN A = B"11" -- un bit se encierra en comilla simple; ms
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 simultneamente 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 ningn detalle de construccin.
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 tambin 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
3
4
5
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use ieee.std_logic_arith.all;
6
7
8
9
10
11
-entity comod is
port (dato : in std_logic_vector (3 downto 0);
dato_ham : out std_logic_vector (6 downto 0));
end comod;
--
12
13
14
15
architecture mascandfor of comod is

signal paridad : std_logic_vector (2 downto 0);
type mascara is array (1 to 3) of std_logic_vector (3 downto 0);
signal ma : mascara;
16
17
18
19
20
21
22
23
24
25
26
27
begin
process (dato)
begin
ma(1)<=dato and "1101";
ma(2)<=dato and "1011";
ma(3)<=dato and "1110";
lazo_bitpar:
FOR i IN 1 TO 3 LOOP
paridad(i)<= ma(i)(3) xor ma(i)(2) xor ma(i)(1) xor ma(i)(0);
END LOOP lazo_bitpar;
dato_ham <= dato & paridad;
end process;
28 END architecture mascandfor;
zona de paquetes: lo
que hay ac puede ser
visto por las entidades
y las arquitecturas
entidades: lo
declarado en ellas
se ve en las
arquitecturas
arquitecturas: lo
declarado en ellas es
visible slo en ellas
los procedimientos
declarados ac no
son infludos por
asignacin a seales
proceso: las
declaraciones en l slo
se ven en su interior
proceso: los
procedimientos
declarados en l slo
pueden influir en seales y
puertos del circuito
fig. 12
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 19/50
Se vern a continuacin diversos ejemplos donde se pondrn de manifiesto los diferentes tipos de
sentencias (concurrentes y secuenciales) y de descripciones.
* Uso de Sentencias Concurrentes

* Procesos concurrentes con asignacin simple
Ejemplo 4: sea disear un circuito que realice la funcin lgica Y = C. A + C .B
Se muestra a continuacin el circuito y su tabla de verdad. En funcin de esta ltima se plantea una
descripcin en VHDL como la que sigue:
C.A
Y
C
B
C.B
Y = C.B + C.A
1
2
3
4
5
6
7
8
9
10
11
C
0
0
0
0
1
1
1
1
fig. 13
--Circuito Suma de Productos sencillo

library ieee;
entity sumaprod is
--sumaprod_2niv_assign.txt
port (A, B, C : in std_logic;
Y: out std_logic);
end SUMAPROD;
architecture COMPORTA of SUMAPROD is
begin
Y<=(A and not C) or (C and B);
end COMPORTA;
B
0
0
1
1
0
0
1
1
A
0
1
0
1
0
1
0
1
C.B /C.A
1
1
1
1
comentario (ttulo)
bloque de "packages"
entidad
arquitectura
La lnea 10 muestra la asignacin simple. Una seal (en este caso un puerto del circuito) se le
asigna el estado que debe tomar por medio de una expresin lgica.
Este es un ejemplo de descripcin por comportamiento.
Algunas preguntas
- por qu se ponen C and B entre parntesis ?
- qu sucedera si se hubiera definido la salida Y como tipo BIT?
Una vez compilada la descripcin anterior, el
Quartus II entrega un esquema circuital a nivel de
Transferencia entre registros (RTL) de cmo
interpret las sentencias includas en ella. La
misma adems es funcin de los componentes
que tiene el dispositivo programable seleccionado
cuando se corri la compilacin.
Vista RTL con FPGA o con CPLD arroja:

C
B
A
0
1
MAX II EPM240F100C4 y Stratix II EP2S15F484C3
Aparecen en este ejemplo un nuevo tipo de datos que es std_logic. stos estn definidos en la:
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 20/50
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 ms abarcadoras. As, se definen:
-- 'U', Uninitialized para designar una variable o seal 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 seal.
-- W', Weak Unknown, similar al X pero dbil.
-- 'L', o Cero dbil, representa un estado bajo que no alcanza a coincidir con la masa del circuito.
-- 'H', o Uno dbil, 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)
Tambin 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 lgica irresuelta. Esta irresolucin proviene del
hecho de que el tipo no establece ninguna prevalencia u orden de prioridad en el caso de confluencia
en un circuito entre seales de distintos tipos. Para solucionar esta indefinicin, el mismo paquete
incorpora lo que se denomina Funciones de Resolucin (se vern en detalle ms adelante) para
establecer la solucin a un conflicto entre distintos tipos, y por tal razon, se adoptar como el tipo
usado en los ejemplos que se vern a continuacin: el std_logic y el std_logic_vector en formato
vectorizado.
Retomando la descripcin anterior, se puede mejorar la forma de efectuar las asignaciones
estableciendo, por ejemplo, que las mismas tengan lugar si se cumple una dada condicin. Otra
forma es asignar en forma selectiva el estado de un puerto o de una seal.
* Procesos concurrentes con asignacin 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 expresin_j representa tanto un valor, como una expresin lgica o de otro tipo que permita
generar un valor o estado que se asigna a la seal en cuestin.
boolean expresin_j es la condicin que debe cumplirse para tal asignacin. Es booleana pues lo que
dice la expresin admite slo dos posibilidades: es Verdadera o Falsa. Si es verdad, se produce la
asignacin. De no cumplirse, se evala(n) la(s) expresin(es) que sigue(n). Es decir, hay una
priorizacin en la consideracin de las condiciones.
La estructura de la sentencia presentada arriba tiene un correlato ms entendible en el siguiente:
signal
<= valor1 WHEN condicin1 ELSE

valor2 WHEN condicin2 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 expresin_j) Por ello no debe
omitirse el else.
Las condiciones no necesariamente deben ser excluyentes entre ellas; se ejecutan slo las
sentencias que involucran el valor correspondiente a la primer condicin satisfecha. Por ello el orden
en que se ordenan las condiciones es el que da la prioridad con que se asignar valor a la seal.
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 21/50
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
0
0
0
0
1
1
1
1
B
0
0
1
1
0
0
1
1
A
0
1
0
1
0
1
0
1
Y
0
1
0
1
0
0
1
1
C=0
X=A
C=1
X=B
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?
Tratndose de puertos que manejan seales 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 debera 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 expresin o valor simple, un rango de valores o un grupo
de valores distintos sin ningn 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 condicin toma un rango de valores contnuos)
- When valor 1 | valor 3 | valor k (cuando la condicin toma unos valores especficos)
* Procesos concurrentes con asignacin seleccionada
Se utiliza la sentencia WITH .... SELECT ... WHEN cuya estructura es:
WITH expressin SELECT
signal <= expression1
expression2
expressionN
WHEN constant_value1, (caso 1)

WHEN constant_value2, (caso 2)
WHEN constant_valueN; (caso N)
que significa que de acuerdo al valor constante_j que toma una expresin, se asigna a una seal la
expresin_j de entre varias diferentes.
Otra forma de presentar el formato de esta sentencia es:
WITH expresin SELECT
signal <= valor1 WHEN valor de expresin1
valor2 WHEN valor de expresin2
valorN WHEN valor de expresinN
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 22/50
Ejemplo 6:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
Suma de Productos sencillo

library ieee;
-entity AND_OR is
Y: out std_logic);
end AND_OR;
-architecture behave of AND_OR is
begin
with C select
Y <= A when '0',
B when '1';
end BEHAVE;
Se obtienen las mismas vistas que antes (arch mux_2in_concusele.txt)
Uso de la clusula 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 slo 0 1.
Por ello la sentencia with .... select cambia como se ver:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
Suma de Productos sencillo en forma algortmica

library ieee;
-entity AND_OR is
Y: out std_logic);
end AND_OR;
-architecture ALGORIT of AND_OR is
begin
with C select
Y <= A when '0',
B when others ;
end ALGORIT;
En este ejemplo, la lnea 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 dbiles, desconocidos fuertes y dbiles, etc)
WITH .... SELECT ... WHEN se aplica a casos donde los valor de expresin_j son mutuamente
excluyentes. Esto lo hace til para representar tablas de verdad.
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 23/50
* Procesos concurrentes con asignacin seleccionada y vector datos

Ejemplo 8:
--Suma de Productos sencillo asignacin concurrente seleccionada
library ieee;
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;
Las vistas RTL y mapa techno son las mismas . La simulacin arroja:
Y
1
1
arch. sumaprod_cba_y.vwf
Vista RTL con CPLD:

La vista que entrega el mapeo tecnolgico del Quartus II:
C
B
A
Y~0
con FPGA Cyclone II EP2C5AT144A7:
C
B
Mux0
A
ABC[0..2]
SEL[2..0]
8' hCA --
DATA[7..0]
OUT
MUX
Como se vi ms arriba se puede abreviar la asignacin a Y que se repite para varias combinaciones
de CBA utilizando el operador | (operador o)
13.
14.
17.
Y <= '0' when "000" | "010" | "100" | "101",

'1' when "001" | "011" | "110" | "111",
'X' when others ;
Si en este ejemplo se hubiera utilizado la notacin binaria, tambin la hubiera interpretado bien:
12. with CBA select
13.
Y <= '0' when B"000", '1' when B"001", --etctera
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 24/50
Ejemplo 9: variante del ejemplo anterior usando representacin 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", --etctera
Nota: si se observa las expresiones usadas en el diseo en los ejemplos 6 y 7 se puede concluir que
el circuito realizado es un Mux de 2 canales, actuando C como seal de seleccin. As se lo
considerar en los prximos ejemplos.
* Uso de sentencias secuenciales (Procesos)

Se mencion en pgina 11 que en los Procesos las instrucciones se ejecutan en forma secuencial (se
aproximan ms a la estructura de programas), pero en un tiempo nulo. Para la ejecucin de las
mismas debe declarrselos mediante una instruccin explcita 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 ms 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 parntesis aparece la denominada lista sensible; es el conjunto de seales 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 evalan
y se actualizan sus valores, y stos pueden ser utilizados por la lnea 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 seal a quien la variable le transfiere el mismo).
Si se utilizan seales dentro de un process, se actualizan al finalizar el mismo. Si se hacen mltiples
lineas de asignacin a una misma seal, se actualizan todas a la vez al finalizar el proceso, (no como
las variables que lo hacen en cada rengln de sentencia) por lo tanto asumirn el estado de la ltima
asignacin. Las seales se declaran en la arquitectura antes del process y antes del begin. A
diferencia de las variables, una seal 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 ms seales dadas en una lista.
- se produzca una condicin o
- transcurra un tiempo
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 25/50
[identificador:]
WAIT [ON lista sensible] [UNTIL condicin] [FOR lapso de tiempo]
Ejemplo:
WAIT ON clock;
WAIT UNTIL clock =1 ;
WAIT FOR 10 us ;
Se pueden usar combinadas:
WAIT FOR se usa

especialmente en Simulacin,
en la elaboracin de Test
Benches
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 evalan y se actualizan sus valores
- Estos pueden ser utilizados por la lnea siguiente de sentencias del programa.
- No se puede utilizar una variable fuera del Process (no son visibles fuera de l). Las seales s.
Si se necesita su valor, se usar una seal a quien la variable le transfiere el mismo dentro del
process.
- Las seales dentro de un process, se actualizan al finalizar el mismo.
- Si se hacen mltiples lineas de asignacin a una misma seal, vale la ltima asignacin.
Si se asignan varias seales en un process, se actualizan todas a la vez al finalizar el proceso, (no se
pueden usar en la lnea siguiente del programa como las variables)
Sobre asignacin de variables y seales en un Process

Ejemplo: suponer que las seales b, c, d (tipo integer) antes del inicio de un ciclo de simulacin
toman los valores: b=2, c=3, d=1
...
architecture secuencia of ejemplo is
signal s1, s2, b, c, d : integer;
-- se declaran cinco seales 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 simulacin
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
seales, 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 seales s1,
s2. b, c y d no cambian por lo tanto se termina
la simulacin ya que las seales de la lista
sensible no cambian y no vuelve a ejecutarse el
Process.
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 26/50
Otro ejemplo: Ahora considrese a d como variable. Suponer los mismos valores iniciales antes del
inicio de un ciclo de simulacin: b=2, c=3, d=1
...
architecture secuencia of ejemplo is
signal s1, s2, b, c : integer;
-- se declaran cuatro seales integer
begin
proce1:
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 seales 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
asignacin (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 simulacin ya que las seales 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 mltiples canales de entrada a una nica salida,
mediante entradas adicionales denominadas de seleccin.
En la figura de la izquierda se esquematiza un Multiplexor
(Mux) de dos entradas.
Mediante la entrada S se selecciona cul 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 asignacin seleccionada
MUX
B
Y
A
C.B
S
0
0
0
0
1
1
1
1
B
0
0
1
1
0
0
1
1
A
0
1
0
1
0
1
0
1
Y
0
1
0
1
0
0
1
1
Ejemplo 10: diseo de un Mux de 2 canales en forma secuencial seleccionada

-- Multiplexor de 2 canales en forma secuencial seleccionada
library ieee;
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
C.A
C
0
0
0
0
1
1
1
1
B
0
0
1
1
0
0
1
1
A
0
1
0
1
0
1
0
1
Y
0
1
0
1
0
0
1
1
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 27/50
CASE cba IS
WHEN "000" => Y <='0'; -- el smbolo => 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 simulacin arroja:
1) El RTL viewer sobre una FPGA

Cyclone II EP2C5AF256A7 es:
3) abriendo la caja obtenida en 2) se puede ver:
Mux0
Mux0~0
CBA[2..0]
SEL[2..0]
8' hCA --
DATA[7..0]
OUT
CBA[0..2]
MUX
2) el post-mapping es:
Mux0~0
CBA[0..2]
DATAB
DATAC
COMBOUT
DATAD
Lo mismo sobre un CPLD EPM240F100C4.
LOGIC_CELL_COMB (F3C0)
En el ejemplo anterior se utiliza la sentencia CASE cuya estructura es:

CASE expresin 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 expressin IS
WHEN constant_value1 => statement1;
statement2;
statement4;
WHEN OTHERS => statement5;
statement6;
END CASE;
Case es ms potente que el WITH ... SELECT pues cada valor evaluado de la expresin puede
derivar en ms de una instruccin, 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 expresin, por lo cual es
conveniente el uso del Others para agrupar en uno solo todos los casos no considerados
previamente.
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Hay diversas formas para escribir los casos en base a los cuales se seleccionan el
grupo de instrucciones a ejecutar. Si la seleccin se hace en base a un dato o
condicin nica, se consigna sta.
Cuando los datos o condiciones son mltiples se puede utilizar un rango de valores
(creciente o decreciente mediante el uso de las palabras TO o DOWNTO)
Ejemplo genrico: 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;
when 3 | 4 => y <= E;
when 5
=> y <= 0;
when 9 downto 6 => y <= 1;
when others => y <= Z;
END CASE ejem_case;
-- cuando ent va de 0 a 2 la salida Y vale 0

-- cuando ent es 3 4 la salida Y vale E
-- cuando ent vale 5 la salida Y vale 0
-- cuando ent va de 6 a 9 la salida Y vale 1
-- para los dems valores de ent Y vale Z
Pg. 28/50
ent
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Y
0
0
0
E
E
0
1
1
1
1
Z
Z
Z
Z
Z
Z
Ejemplo 11: una forma ms simple de Mux de 2 canales que la anterior:

-- Mux 2 ent forma secuencial seleccionada
library ieee;
entity sum_prod is
Y: out std_logic);
end sum_prod;
architecture sec_sel of sum_prod is
begin
mux: process (A, B, C) is
begin
CASE C IS
WHEN '0' => Y<=A;
WHEN others => Y<=B;
END CASE;
end process mux;
end sec_sel;
* Procesos secuenciales con asignacin condicionada

Ejemplo 12: diseo de un Mux de 2 canales en forma secuencial condicionada
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
library ieee;
entity sum_prod is
Y: out std_logic);
end sum_prod;
architecture secucondi of sum_prod is
begin
process (A, B, C) is -- no tiene etiqueta el proceso
begin
IF C='0' THEN Y<=A;
ELSIF C ='1' THEN Y<=B;
ELSE Y <= 'X';
END IF;
end process;
-- no lleva etiqueta al final tampoco
end secucondi;
Nota: a propsito de los renglones 12 y 13, hay que prestar atencin al escribir las sentencias. Un
error muy comn es confundir el operador de relacin (=) con los operadores de asignacin a seales
o variables (<= o :=) . Otra equivocacin se produce al confundir C = 0 (C es un bit o un std_logic)
con C = 0 (sin entrecomillar), donde C es un integer.
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 29/50
Se utiliza la sentencia IF... THEN .. ELSE cuya estructura es:

IF condicin 1 THEN
instrucciones ;
ELSIF condicin 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 condicin da origen a la ejecucin de una o ms

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 sntesis circuital que hacen
aconsejable que se concluya la instruccin con un ELSE que cierre todas las posibilidades de
evaluacin de condiciones. De no hacerse, habr una inferencia indeseada de elementos de memoria
para almacenar la informacin que no se especifica.
En cambio en el diseo de circuitos secuenciales es habitual la omisin de la clusula ELSE, lo que da
lugar a circuitos tipo registro (guardan informacin previa). Es decir si no se le dice al compilador
qu valor toma el objeto para la ltima condicin, 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 condicin que evala cada IF (o Elsif) puede ser nica o bien un conjunto de condiciones
relacionados por algn 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.
* DISEO FUNCIONAL (CUASI-ESTRUCTURAL)

Este tipo de diseo tiene en cuenta la estructura del circuito a nivel de seales, pero no como
estructura de conexiones ni a nivel de terminales. Se definen seales que hacen operaciones
intermedias entre las entradas y las salidas y dan una idea de la evolucin circuital entre ellas.
Ejemplo 13: descripcin estructural del multiplexor simple de 2 entradas

Se van a considerar dos seales V y W a las salidas de las compuertas de primer nivel tras lo cual la
asignacin de salida se remite a una operacin OR entre seales V y W
-- Multiplexor de 2 entradas (estructural)
library ieee;
entity sum_prod is
Y : out std_logic);
end sum_prod;
V
Y
C
B
Y = V + W = C.B + C.A
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 30/50
architecture estruct of sum_prod is

signal V,W: std_logic;
-- se define seales 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 diseo anterior con la sencillez
del ejemplo 4
Un par de preguntas:
*que tipo de proceso es? R= implicito
Al hacer la simulacin se obtiene:
*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;
fig. 14
* R= S. No importa el orden en que estn

escritas, las sentencias concurrentes, se
ejecutan todas a la vez.
* Otros paquetes y sus tipos de datos. Funciones de conversin.

- En un diseo pueden coexistir distintos tipos de datos
- Las operaciones entre seales 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 combinacin de estados de un array de elementos binarios, es leer
el nmero binario que representa.
- El compilador no interpreta una seal bit_vector (o std_logic_vector) como nmero 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 estn 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 interpretacin 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 recomendacin es trabajar con este ltimo.
Paquete Numeric_std
Incorpora los tipos de datos signed y unsigned (como el std_logic_arith). Permite realizar operaciones
aritmticas a estos tipos (pero no al Std_logic_vector) con las siguientes caractersticas:
- tipo unsigned
- tipo signed
- se utiliza para operaciones entre ellos y/o magnitudes. El resultado es un

unsigned de una longitud igual a la del operando ms largo.
- para operaciones entre ellos y enteros; se obtiene un signed de longitud igual a
la del operando ms largo.
En sntesis:
op1 & op2 = op1
op1 = uns (sig) ; op2 = uns, nat (sig, int)
op1 # op2 = boolean
& operaciones + - * / rem y mod (los dems smbolos, son los ya vistos)
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 31/50
type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;

type SIGNED is array (NATURAL range <>) of STD_LOGIC;
Cada unsigned es interpretado como un nmero binario con el dgito a la izquierda como el MSB.
Ejs: unsigned("0110") representa +6 ;
unsigned("1010") representa +10
Los tipos signed representan valores numricos signados que pueden ser positivos, cero o negativos.
El compilador interpreta cada tipo signed como una representacin 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: supngase 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 simblico y lgico, pero no numrico.
B es visto como un array 1010, que tiene un equivalente numrico = + 10
C es visto como un array 1010, que tiene un equivalente numrico = - 6
Si se hace B <= 1100 y se la tiene que vincular con A que es la salida de un circuito lgico, 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 sntesis del circuito)
- El paquete Numeric_std tiene las siguientes funciones de conversin:
- TO_INTEGER (arg)
- TO_UNSIGNED (nat,n)
- TO_SIGNED (int,n)
- SIGNED (uns)
- UNSIGNED (sig)
- SIGNED (slv)
- UNSIGNED (slv)
- Std_Logic_Vector (arg)
=> convierte un argumento de tipo unsigned a natural (nat) y de tipo

signed a entero (int)
=> convierte un nmero natural a un array de n bits
=> convierte un nmero entero (integer) a un array de n bits
=> convierte un array de bits considerado nmero sin signo a un array de
bits equivalente a un nro entero (o sea, con signo); el argumento conserva
el valor numrico. La apariencia del argumento antes y despus de la
conversin 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)
=> convierte un array de bits considerado nm. entero a otro equivalente
a un nmero natural (valen los dems comentarios del caso anterior)
=> convierte un vector en un array de bits que representa un nro. entero
=> convierte un vector en un array de bits que representa a su magnitud
=> convierte un argumento de tipo unsigned o signed (tienen valor
numrico como magnitud o entero) a su forma vectorial (tiene la misma
apariencia pero es un array de bits sin valor numrico)
En sntesis, 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 numrico (con o sin signo,
respectivamente):
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 32/50
Ms operaciones con vectores: conversores de cdigos BCD

Ejemplo 14: diseo del conversor bcd nat a aiken usando el package Numeric_std
Recurdese las caractersticas del Cdigo 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 diseo que consiste en convertir una
palabra a otra sumando, pero esa suma debe ser selectiva pues debe
hacerse slo si la entrada representa un nmero entre 5 y 9. Esto lleva
a un esquema de trabajo como se ilustra en la figura:
(std_logic_vector)
(std_logic_vector)
nat
aik
Proceso 1
Proceso 2
num_bcd
(integer)
Proceso 3
num_aik
(integer)
Entity
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
D
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
Natural
C B A
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
V
0
0
0
0
0
1
1
1
1
1
X
X
X
X
X
X
Aiken
X Y
0 0
0 0
0 1
0 1
1 0
0 1
1 0
1 0
1 1
1 1
X X
X X
X X
X X
X X
X X
Z
0
1
0
1
0
1
0
1
0
1
X
X
X
X
X
X
Esta arquitectura se basa en convertir las palabras de entrada al equivalente numrico del vector de
entrada para generar un dato intermedio que sea la suma de ese valor a 6 cuando el dato de entrada
vale ms 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 seales

num_bcd, num_aik para darles el
valor entero representado por el
slv ya que la librera 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 ms 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 seal 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 rengln 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 seal num_bcd que es un
numero entero, sumarla y luego convertirla a vector.
Nota: en negrita las funciones de conversin por tener nombres similares a los tipos de datos.
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 33/50
A modo de ejemplo se transcriben la simulacin efectuada y las salidas obtenidas:
en cuanto a los esquemas que entrega el compilador, el diagrama RTL es:

Add0
28' h0000000 -A[30..0]
nat[3..0]
31' h00000003 --
B[30..0]
num_aik~[2..0]
SEL
DATAA
DATAB
OUT0
aik[3..0]
ADDER
LessThan0
28' h0000000 -A[31..0]
32' h00000005 --
B[31..0]
MUX21
<
LESS_THAN
y la vista tecnolgica:
num_aik~2
nat[0..3]
aik[0..3]
num_aik~1
num_aik~0
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 34/50
Ejemplo 15: Conversor BCD natural a Aiken con sentencias secuenciales

library ieee;
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 creacin de tipo de datos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
--conversor bcd/aiken + tipo matriz

library ieee;
entity Bnat2aik is
port ( ent : in std_logic_vector (3 downto 0);
sal : out std_logic_vector (3 downto 0));
end Bnat2aik;
architecture converse of Bnat2aik is
type codigo is array (0 to 15) of std_logic_vector (3 downto 0);
constant AIKEN : codigo := ("0000","0001","0010",X"3",X"4",
X"B",X"C",X"D",X"E",X"F",others=>"0000");
begin
sal <= aiken (to_integer(unsigned(ent));
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 descripcin:
10: se cre el tipo cdigo: es un array de vectores (array de dos dimensiones 1D x 1D) = 16
palabras por 4 elementos std logic. En sntesis, es una tabla.
11: se define una constante Aiken, como tipo cdigo. O sea Aiken es una tabla de los 16 nmeros
binarios naturales que se forman con 4 bits.
- Ex-profeso, se escriben sus valores como string y en notacin hexadecimal.
- Atencin: como cdigo 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 instruccin others => que significa a los restantes (otros) se les asigna el valor
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 35/50
13: la salida sal toma el valor de aiken en la posicin dada por un entero igual al binario
representado por el array con valor numrico que surge de pasar a unsigned el vector de std_logic de
la seal de entrada (ent); p.ej, si ent = 0110, al ejecutarse (unsigned(ent) el compilador lo lee como
el nmero natural 6; luego aiken en la posicin 6 es el dato hexadecimal B, que es el array 1011,
o sea es un array de bits, que es la caracterstica que tiene un std_logic_vector.
Manejo de datos
Se presentan a continuacin algunos datos que se expresan en una dimensin (el caso de un vector
de elementos), en una dimensin por una dimensin (sera el caso de un vector de vectores) y en dos
dimensiones (tienen la apariencia del anterior pero los elementos se ubican individualmente en funcin
de dos coordenadas). Para hacer un ejemplo se crean los siguientes tipos:
type word is array (3 downto 0) of std_logic;
type memo1 is array (15 downto 0) of

std_logic_vector (3 downto 0);
-- 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 caractersticas.
Son datos de dimensin (1D x 1D)
type memo2 is array (0 to 15, 3 downto 0)

of std_logic;
-- memo2 tiene caractersticas distintas: es de dos

dimensiones (2D) ;
type memo is array (0 to 15) of word;
Sean las siguientes seales

signal E, F : word ;
signal G : memo;
signal H : memo1;
signal J : memo2;
2
1
1
1
0
0
0
0
0
0
0
0
0
0
1
0
1
0
G, H
1
1
1
1
0
1
14
G15 H0
0
...
1
1
1
0
0
0
0
1
0
1
1
1
0
1
(word is array (3 downto 0) of std_logic)

(memo is array (0 to 15) of word)
(memo1 is array (15 downto 0) of
std_logic_vector (3 downto 0))
(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:
G0 H15
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) ;
0
0
1
1
1
2
0
0
...
1
1
1
1
2
15
0
1
13
14
15
Ejemplo 17: diseo de un conversor de Cdigo Gray a Cdigo binario

Recordando que la expresin que permite calcular las palabras equivalentes es Bn = Gn Bn+1
1
2
3
4
5
6
7
--Conversor Gray a binario

library ieee;
entity gray2bin is
port (ent : in std_logic_vector (3 downto 0);
end gray2bin;
Gray =
Binario = 0 =
0 = 1 = 1
TCNICAS DIGITALES 1
Introduccin al VHDL
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
14
15
sal <= ssal;
16 end comporta;
Rv. 15
Pg. 36/50
Renglones 11-14: se usa la seal

ssal en lugar de trabajar con la
salida sal pues cada bit de ssal se
calcula leyendo el bit ssal en la
posicin siguiente.
Sal es un
puerto de modo out, por lo cual no
podra ser ledo (slo escrito). En
cambio una seal puede ser leda
y escrita.
Para identificar un bit en particular de un vector, se lo invoca con el nombre y entre parntesis la
posicin del bit buscado: ent(2) = bit del vector ent en la posicin 2 (como fue definido es la 2da.
ms significativa).
Al simular la descripcin anterior se obtiene::
Haciendo un repaso de aspectos vistos, podr el lector indicar por qu son equivalentes estas:
10
11
12
13
14
15
begin
ssal (3) <= ent(3);
sal <= ssal;
10
11
12
13
14
15
begin
ssal (3) <= ent(3);
sal <= ssal;
R = Porque se trata de asignaciones simples que son concurrentes y como tal se ejecutan
simultneamente, y no una despus de otra. Supngase 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);
end process;
sal<=vsal;
la compilacin 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);
sal<=vsal;
end process;
Operaciones Lgicas sobre Vectores

Los vectores admiten operaciones lgicas entre bits en igual posicin. Un diseo ms simple ser
realizar una sola operacin xor entre operandos:
Ejemplo 18: Conversor de Cdigo Gray a Cdigo binario operando sobre vectores
TCNICAS DIGITALES 1
Introduccin al VHDL
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
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;
DISEO ESTRUCTURAL :
Rv. 15
Pg. 37/50
A3
A2
A1
A0
B3
B2
B1
B0
A.B=
Instanciacin de componentes
Para algunos diseos puede ser de utilidad definir un componente que se va a reiterar en la
descripcin y llamarlo cuantas veces sea necesario adaptando eventualmente los nombres de las
seales 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 instanciacin 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;
i1
o
i2
Nand2pref
A
C
B
i1 Nand1
o
i2
V i1
o Y
i2
i1
o
Nand3
i2
W
Nand2
Y = C.B + C.A
i1
i2
i1
i2
C
V i1
i2
o Y
o
W
Y = C.B + C.A
En la arquitectura se declara un componente con la sentencia homnima (en ingls) y el circuito se

construye con instancias (rplicas) de l. Dicho componente debe ser declarado como un circuito
ms, o sea como un diseo aparte, y figurar en el directorio del mismo proyecto del multiplexor:
-- NAND de 2 entradas a replicar
LIBRARY ieee;
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 38/50
-- Definicin 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;
Cmo 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 disear, el puerto i2 se conectar
a la seal Cneg y la salida a la seal V. (atencin: esta seal 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 instanciacin ms amplia se ve a continuacin.

Ejemplo 20: describir un Mux de 16 entradas en
base a instancias de un Mux de 4 entradas
Mux_16ent
Mux4pref
ent(15)
I3
I2
I1 3 O
I0
A1 A0
Out3
--Circuito Multiplexor 16 canales con instanciacin

LIBRARY ieee;
Mux4pref
ent(11)
I3 Mux4
pref
I3
I2
ENTITY mux16_pref is
Out2
I2 4
I1 2 O
I1
O
PORT (ent : IN std_logic_vector (15 downto 0);
I0
I0
A1 A0
dir : IN std_logic_vector (3 downto 0);
A1 A0
sal : OUT std_logic);
I3 Mux4
ent(7)
END mux16_pref;
pref
I2
I1 1 O
ARCHITECTURE instancia OF mux16_pref is
Out1
I0
ent(4)
A1 A0
COMPONENT mux4_pref
2
PORT (I : IN std_logic_vector (3 downto 0);
I3 Mux4
A : IN std_logic_vector (1 downto 0);
pref
I2
O : OUT std_logic);
I1 0 O
Out0
I0
ent(0)
END component;
A1 A0
2
SIGNAL S_O : std_logic_vector (3 downto 0);
BEGIN
Muxn3 : mux4_pref
A3 A2 A1 A0
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));
Muxn4 : mux4_pref PORT MAP (I => S_O , A => dir(3 downto 2), O => sal);
END instancia;
--Componente Multiplexor de 4 canales
LIBRARY ieee;
ENTITY mux4_pref is
sal
Al igual que antes, el componente que se

instancia debe ser declarado como un circuito
ms y figurar en el directorio del mismo
proyecto del multiplexor.
TCNICAS DIGITALES 1

O : OUT std_logic);
END mux4_pref;
ARCHITECTURE compo OF mux4_pref is
begin
O <= I(to_integer(unsigned(A)));
END compo;
Introduccin al VHDL
Rv. 15
Pg. 39/50
al correr la simulacin aparece:
Sentencias iterativas
En algunos casos puede ser til disponer de sentencias que permitan la reiteracin de pasos o de
partes del programa una determinada cantidad de veces. Las hay del tipo concurrente y tambin
secuenciales, o sea van escritas dentro de un Proceso.
Ejemplo 21:
Mux de 16 entradas por reiteracin 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
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 rtulo
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;
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 40/50
Esta sentencia genera la repeticin de la porcin de cdigo comprendida entre FOR ... GENERATE y
END GENERATE, un nmero de veces dado por el rango de la sentencia (igual a la diferencia de
valores extremos del rango). Lleva necesariamente un rtulo, etiqueta o label.
Precauciones del For Generate: generalmente no es sintetizable. Hay que prestar atencin de no
hacer mltiples asignaciones a una misma seal. El rango puede ir de menos a ms o viceversa. No
pueden utilizarse valores no estticos como extremos del rango (por ejemplo el valor de una seal,
variable, o puerto). S se puede utilizar un generic (ver ejemplo ms adelante).
el diagrama RTL del diseo es:
mux4_pref:Muxn3
mux4_pref:Muxn4
ent[15..0]
dir[3..0]
I[3..0]
A[1..0]
O
I[3..0]
mux4_pref:Muxn2
I[3..0]
A[1..0]
A[1..0]
mux4_pref:Muxn1
I[3..0]
A[1..0]
Cada rectngulo
contiene:
O
Mux0
A[1..0]
I[3..0]
mux4_pref:Muxn0
I[3..0]
A[1..0]
sal
SEL[1..0]
DATA[3..0]
OUT
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
efecta si se cumple alguna condicin. Su sintaxis es:
identificador:
IF condicin 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 vlido
usar la opcin ELSE. Se pueden hacer anidados entre sentencias For ... generate e If ... generate y
viceversa.
Ms adelante se vern 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 aqulla, 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).
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 41/50
Se propone un ejemplo de uso en la descripcin de otros circuitos que surgen como una aplicacin
especfica de lgica combinacional.
Codificadores
Un codificador es un dispositivo lgico que
detecta una seal activa en una de sus
entradas (numeradas decimalmente) y coloca
en sus salidas el cdigo binario correspondiente
al nmero de esa entrada. (1)
Un codificador ms completo debe incluir lo
siguiente (2):
I3
I2
I1
I0
I3
I2
I1
I0
O1
O0
CODER
Ei
O1
O0
CODER
I3 I2 I1 I0 O1 O0
(1)
0
0
0
1
0
0
1
0
0
1
0
0
-posibilidad de distinguir entre la entrada I0

activa de la ausencia de entradas activas (en
ambos casos las salidas sern 00).
1
0
0
0
0
0
1
1
0
1
0
1
Eo
GS
Ei I3 I2 I1 I0 O1 O0 GS Eo
(2)
0
1
1
1
1
1
X
0
0
0
0
1
X
0
0
0
1
X
X
0
0
1
X
X
X
0
1
X
X
X
0
0
0
0
1
1
0
0
0
1
0
1
0
0
1
1
1
1
0
1
0
0
0
0
- posibilidad de dar prioridad a una sla entrada en el caso en

que se activen ms de una a la vez (se disean a tal fin los
denominados Codificadores de Prioridad)
- posibilidad de habilitar su funcionamiento: se crea la
habilitacin de entrada Ei. sta se complementa con una
habilitacin 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 ms entradas y permitir priorizar a
una de ellas (ver Expansin de codificadores ms adelante).
Ejemplo 22: codificador de prioridad (8 a 3 lneas) usando while ... loop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
-- Codific. de prioridad de 8 a 3 con while loop

library ieee;
entity cod_prio_loop is
port (ent : in std_logic_vector(7 downto 0);
sal : out std_logic_vector(2 downto 0));
end cod_prio_loop;
architecture whiloop of cod_prio_loop is
begin
process (ent) is
variable i : integer range -1 to 7;
begin
i := 7;
while ent(i) = '0' loop
i := i-1;
exit when i = -1;
end loop;
sal <= std_logic_vector (to_unsigned(i,3));
end process;
end whiloop;
Comentarios:
El lazo while (15) establece que
mientras el bit en la posicin (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 (i1). En cuanto encuentre un bit = 1 considrese en un paso j - como el
orden en que la descripcin
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 cdigo binario
correspondiente a j (19).
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 42/50
- Sentencia WHILE ... LOOP

loop_label:
WHILE boolean_expressin LOOP
sentencia secuencial1;
...
sentencia secuencial_n;
END LOOP loop_label;
Tiene la estructura que se muestra.

Cuando se ejecuta, las instrucciones includas
dentro del lazo se repiten mientras se cumple la
condicin, esto es, mientras la expresin
booleana sea verdad.
- Sentencia FOR ... IN ... LOOP

tiene una estructura como la que sigue. Cuando se ejecuta, las instrucciones includas dentro del lazo
se repiten un nmero 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;
Ms 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 situacin o condicin:
[etiqueta del exit] : EXIT [etiqueta del loop] WHEN [condicin]
[etiqueta del exit] : EXIT [etiqueta del loop] WHEN [condicin]
Funciones de Resolucin
Cuando dos seales std_logic se asignan simultneamente 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 resolucin, que pautan el
estado que tomar una seal cuando se produce un conflicto en su asignacin. El resultado se
puede ilustrar en la tabla que se muestra a continuacin. Para entenderla, se parte de la base de que
una seal no inicializada (U) tendr preeminencia sobre cualquier otra con la que confluya. Con una
prioridad menor estarn las seales 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) lgico? La respuesta es: no se
U X 0 1 Z W L H puede asegurar, es decir, resulta en otro estado desconocido, o
U
U U U U U U U U U
sea ste prevalece al uno (o al cero). Resulta aceptable que
X
U
X X X X X X X X
los estados fuertes (X, O, 1) prevalecern sobre los dbiles (W,
0 U X 0 X 0 0 0 0 X
L, H). Por otra parte, el estado de alta impedancia (Z) ser el
1 U X X 1 1 1 1 1 X
ms dbil de todos.
Z U X 0 1 Z W L H X
Finalmente, el dont care (-), o no importa el valor que tome,
W U X 0 1 W W W W X
en colisin con cualquier otro, genera una situacin similar a la
L U X 0 1 L W L W X
colisin que provoca un estado desconocido (X).
H U X 0 1 H W W H X
-
U X
Variables y Seales en procesos secuenciales

Se presenta a continuacin un cuadro que sintetiza las principales caractersticas comparativas entre
ambas:
TCNICAS DIGITALES 1
VARIABLES
Son datos en memoria, se usan para proceso
de informacin
Se declaran dentro del Process antes del begin
Cuando se ejecuta una sentencia, se evalan y
se actualizan sus valores y pueden ser
utilizados por la lnea siguiente de sentencias
Son locales al Process; no se pueden usar
fuera de l (debe copiarse su valor a una seal)
Si se hacen mltiples lineas de asigna cin a la
misma variable, vale la ltima
Introduccin al VHDL
Rv. 15
Pg. 43/50
SEALES
Estn asociadas al hardware. Son lneas de
conexin
Se declaran en la arquitectura antes del begin
Las seales dentro de un process, se
actualizan al finalizar el mismo (no pueden ser
usadas en lineas subsiguientes dentro de l)
Son visibles fuera del process (de hecho se
usan para transferir los valores de las variables)
Si se hacen mltiples lineas de asignacin a
una misma seal, vale la ltima
Atencin: mltiples asignaciones a una misma
seal fuera de un process = ERROR
La tabla precedente sintetiza las principales caractersticas de seales y variables, mencionadas

precedentemente en este documento. Servirn para comprender mejor los siguientes ejemplos:
Ejemplo 23: asignaciones mltiples a variables y seales
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 rengln 19 se inicializan las variables. En el rengln siguiente v1 toma el valor 3+2=5, razn 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 seal (s1) dos valores distintos. Hay conflicto?. No:
En un proceso secuencial, si a una misma seal se le asignan dos o mas valores, toma el valor de la
ltima asignacin (que sobreescribe a las anteriores).
o sea, s1 toma el valor de b. Pero atencin, que en el rengln 25 se inicia un nuevo proceso y en el
rengln 29 se le asigna un nuevo valor a s1, por lo cual aparece conflicto con el asignado en proce1.
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
-- (en la entidad se declararon a, b entradas y sal, sal0 salidas todas tipo std_logic)
architecture concu_vs_secu of comod is
signal s1, s2 : std_logic;
-- se declaran un par de seales
begin
proce1:
process (a, b) is
-- se inicia una sentencia concurrente
variable v1, v2 : integer range 2 to 15;
--se declaran 2 variables
begin
v1 := 3; v2 := 4;
-- se inicializan las variables
v1 := v1 + 2;
-- v1 valdr 5 luego de ejecutarse esta sentencia
v2 := v1 + v2;
s1 <= a;
-- se asigna un valor a S1
s1 <= b;
-- se asigna otro valor a s1 (valdr este ltimo, no hay conflicto)
end process proce1;
proce2:
process (a,b) is
-- arranca un nuevo proceso
begin
s2 <= a;
-- se asigna un nuevo valor a s1. Al ejecutarse proce2
s1 <= s2;
-- surgir conflicto con el valor asignado
end process proce2;
sal <= s1;
sal0 <= s1 and s2;
end concu_vs_secu;
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 44/50
Finalmente, cmo 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 ledas fuera de ellos. De ser
necesario, debe asignarse su valor a una seal creada o a crear a tal efecto.
Ejemplo 24:
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
variante sacando variables fuera del Process
-- (en la entidad se declararon sal1, sal2 salidas tipo integer y sal3 salida tipo std_logic)
architecture concu_vs_secu of algo is
-- se declaran un par de seales
signal s1, s2 : std_logic;
-- se declaran dos nuevas seales
signal sig1, sig2: integer range 0 to 15;
begin
--(sigue prxima hoja)
proce1: process (a, b) is
-- se inicia una sentencia concurrente
-- se declaran un par de variables
variable v1, v2 : integer range 0 to 15;
begin
v1 := 3; v2:= 4
-- se inicializan las variables
v1 := v1 + 2 ;
v2 := v2 + v1;
s1 <= a;
-- se asigna valor a S1
s1 <= b;
-- se asigna otro valor a s1 (valdr este ltimo, no hay conflicto)
sig1 <= v1;
-- se transfiere el valor de V1 a la seal sig1
-- al terminar el proceso se actualizan los valores de v1, v2, s1 y sel1
end proce1;
-- se transfiere el valor que tena v1, a travs de sig1, a la salida sal1
sal1 <= sig1;
sal2 <= v2;
-- habr indicacin de error. Fuera del process no se reconoce a V2
sal3 <= s1;
-- s1 es una seal, puede leerse fuera de un process (igual que sig1)
...
Arrays, arrays numricos 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 numrico (sin signo) = 14
B es un vector de bits que tiene valor numrico (con signo) = - 2
C es un vector de bits que no tiene valor numrico pero tiene la misma apariencia que A y B.
D fue definida como entero = 14 pero an teniendo valor numrico 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
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 45/50
Tabla sntesis de paquetes, operaciones permitidas y tipos de datos involucrados (operandos)
Paquete
Numeric_std
Oper 1 Operacin Oper 2 Resultado

Observaciones
(izq.)
(der.)
&
op1
& significa operaciones + - * / rem y
uns
uns,
mod
nat
sig
uns
sig, int
vs.
sig
Std_logic_unsigned
slv
uns,
nat
boolean
sig, int
+
slv
slv
+ significa operaciones de suma y

resta
(*) el int equivale ac a la magnitud
boolean
vs significa operacin de
comparacin
op1, slv
# significa operaciones de producto

y cociente
int (*)
sul/sl
vs.
slv
int
Std_logic_arith
uns,sig
sig
slv=std_logic_vector
sul=std_ulogic
sl = std_logic
uns
sig
uns,sig
int,
sul, sl
op1, slv
uns,sig
vs.
op.1,
int
boolean
int = integer
uns= unsigned
sig = signed
nat = natural
op1 = tipo de dato del operando
del lado izquierdo
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 46/50
Sentencias Secuenciales y Concurrentes

Concurrentes
Secuenciales
Asignacin a seal
Signal <= expression;
Asignacin a seal seleccionada
- With ... Select
- Case ... When
label:
signal <= expression1 WHEN constant_value1,
expression2 WHEN constant_value2,
expressionN WHEN constant_valueN;
CASE expressin IS
WHEN constant_value1 => statement1; stamt2;
WHEN constant_value2 => statement3; stamt4;
WHEN OTHERS => statement5; statement6;
END CASE;
Asignacin condicional
When ... Else
- If then elsif/else
IF expression1 THEN statement1; statement2;

label:
signal
<=
expression1
WHEN ELSIF expression2 THEN statement3; statemt4;
ELSE statement5; statement6;
boolean_expression1
ELSE expression2 WHEN boolean_expression2 END IF;
ELSE expression3;
Generacin de descripcin iterativa
- For generate
Lazos iterativos
- For ... Loop
loop_label:
generate_label:
FOR index_variable IN range_low TO range_high FOR index_variable IN range_low TO range_high
LOOP
GENERATE
END GENERATE;
Generacin descriptiva condicional
Se puede salir de un lazo con dos sentencias:

a. next (salta del paso de iteracin i al siguiente)
b. exit, sale del lazo en el paso que est.
c. NEXT ( EXIT) WHEN condicin booleana
(hacen lo mismo si se cumple esa condicin)
Lazo condicional iterativo
- If generate
- while ... loop
generate_label:
IF expressin GENERATE
statement1;
statement2;
END GENERATE;
loop_label:
statement1;
statement2;
Lazo simple
- Loop
LOOP
expresiones ;
END LOOP;
(necesita una sentencia exit para salir del lazo)
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 47/50
Tabla de Paquetes, tipos de datos y funciones de conversin

Packages
std_logic_1164
Tipos de datos, funciones de conversin y ejemplos

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 entre
operandos de distinto estado que confluyen en una misma seal.
- std_logic_vector opera con objetos tipos std_logic_vector pero no como nmero
std_logic_signed - tiene funciones aritmticas para tipo std_logic_vector con signo
std_logic_unsigned - opera std_logic_vector y/o magnitudes (sin signo) en forma aritmtica
- la suma no computa el carry
- tiene funciones de conversin:
- CONV_INTEGER (slv) 3
=> convierte un std_logic_vector en entero (=int)
- conv_integer (1110) => 14
std_logic_arith
- overload de funciones aritmticas y de funciones de conversin
- tipos signed (=sig) y unsigned (=uns) -parecidos al std_logic_vector- funciones de conversin:
F(x|y,N) => c ::= la funcin F convierte un dato tipo x o tipo y a tipo c de tamao 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
numeric_std
- CONV_INTEGER(sig|uns) => int

idem anterior a un nmero 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
el argumento 0110 es sig
-conv_std_logic_vector (0110,4) => 0110
arg = sig
arg = sig
arg = uns
arg = int
-conv_std_logic_vector (6,4)
=> 0110
arg = int
-conv_std_logic_vector (-6,5)
=> 11110
- tipos signed y unsigned (como el std_logic_arith)
- realiza operaciones aritmticas 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 ms largo.
- tipo signed
- para operaciones entre ellos y enteros
- funciones de conversin:
- TO_INTEGER (uns)
- TO_INTEGER (sig)
- TO_UNSIGNED (nat,n)
- TO_SIGNED (int,n)
=> convierte un unsigned a natural (=nat)

- TO_INTEGER (1110) => 14
=> convierte un signed a entero
- TO_INTEGER (1110) => - 2
=> convierte nro. natural a array de n bits
- TO_UNSIGNED (5,4) => 0101
=> convierte nro. integer a array de n bits
- TO_SIGNED (-4,6) => 111100
Expresiones o valores entre parntesis representan los argumentos de la funcin de que se trate. Al presentar un
tipo de datos se incluye tambin la abreviatura con que se lo simboliza entre parntesis y con el signo =, para
diferenciarlo. P.ej. signed (=sig) [No confundir funcin SIGNED con tipo signed !!]. Cuando se presentan las
funciones de conversin se lo hace en maysculas; para los ejemplos pueden aparecer en minsculas.
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 48/50
numeric_std (cont.) - SIGNED (uns) => da un array de bits que equivale a un nmero entero
(argumento conserva valor numrico)
- 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 nmero natural
(argumento conserva valor numrico)
- 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
B1 = unsigned (A1)
B2 = signed (A1)
=> B1 = 1110;
=> B2 = 1110;
A1 es visto como un array de bits
B1 es visto como una magnitud

B2 es visto como un nmero con signo
Si se hace:
C1 = To_integer (B1) => C1 = 14
C2 = To_integer (B2) => C2 = -2
al ser B1 sin signo (unsigned) se la toma como magnitud binaria

al ser B2 con signo (signed) se la toma como nmero con signo,
y segn lo conocido, es un nmero negativo = Ca2 (magnitud)
Si se hace:
B3 = signed (B1)
=> B3 = 1110 ;
B4 = unsigned (B2) => B4 = 1110 ;
B3 es visto con signo, o sea equivale a B2

B4 es visto como magnitud, o sea equivale a B1
Si en estas condiciones se hace:

C3 = To_integer (B3) => C3 = -2
C4 = To_integer (B4) => C4 = 14
Otro ejemplo: Sea CONSTANT A2 : Unsigned := 1101
(equivale al decimal 13)
Si se hace:
B5 = std_logic_vector (A2) => B5 = 1101
aqu B5 es un simple array de bits. No tiene valor numrico.
Si se hace:
C5 = To_integer (B5)
=> error
esta funcin no opera con tipos std_logic_vector, y B5 lo es.
Si se hace:
B6 = Conv_integer (B5)
=> B6 = - 3
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
anlogamente al caso anterior, B7 es un simple array de

bits. No tiene valor numrico.
Si se hace:
B8 = Conv_integer (B7)
la funcin convirti un std_logic_vector en entero y es

negativo. Igual que el caso anterior.
=> B6 = - 3
Por qu los dos ltimos ejemplos dan igual? Porque al hacer la conversin de las constantes (de distinto
tipo) a std_logic_vector, se uniformiza su tipo: dejan de tener valor numrico para pasar a ser array de bits.
Debe quedar claro que: un dato tipo std_logic_vector es un vector de datos std_logic (datos lgicos que asumen
uno de nueve estados posibles); un vector de bits es un array de bits, que tienen significado lgico; un signed es
un array de bits con significado numrico como entero (el unsigned, como nmero natural pues es sin signo).
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 49/50
Plantillas de comandos de VHDL (Quartus II - Altera)

LIBRARY library_name;
(copia de plantillas modelo tomadas del Quartus II Altera)
USE library_name.package_name.ALL;
==========================================
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)
Algunas libreras, tipos de datos y
ARCHITECTURE arch_name OF entity_name IS
funciones de conversin:
-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 Procedure Call (optional)

Concurrent Signal Assignment (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 expressin GENERATE
-statement1;
-statement2;
--END GENERATE;
END arch_name;
================================
SIGNAL signal_name : type;
signal <= expression;
tipos bsicos: 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 aritmtica
- conv_integer (slv) => int
std_logic_arith
- tipos signed (=sig) y unsigned (=uns)
- 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
- 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
TCNICAS DIGITALES 1
Introduccin al VHDL
Rv. 15
Pg. 50/50
======================================
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:
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
ELSE
END IF;
==========================================
CASE expressin IS
statement2;
statement4;
WHEN OTHERS => statement5;
statement6;
END CASE;
==========================================
loop_label:
FOR index_variable IN range_low TO range_high LOOP
statement 1;
statement n;
=========================================
loop_label:
================================================
Nota: recordar que estas son copias de plantillas modelo; sirven para abreviar la escritura. las sentencias que
en la arquitectura ms arriba comienzan con - - significa que son opcionales, y se muestran como ejemplo de
las que pueden integrar una arquitectura. Los modos de las seales de entrada salida y/o los tipos de datos,
tambin se ilustran como ejemplo, debiendo aplicarse los convenientes al diseo correspondiente.

Introduccion Al VHDL

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Introduccion Al VHDL

Enviado por

Direitos autorais:

Formatos disponíveis

TCNICAS DIGITALES 1

ING. JUAN E. COLLAZO

INTRODUCCIN AL LENGUAJE VHDL

Distintos tipos de arquitecturas: ....................................................................................................8

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

3.- Tipos de datos........................................................................................................................12

Visibilidad de elementos en la estructura de un programa VHDL...............................................18

ING. JUAN E. COLLAZO

* Procesos concurrentes con asignacin seleccionada.........................................................................21

* Uso de sentencias secuenciales (Procesos) ............................................................................24

* Otros paquetes y sus tipos de datos. Funciones de conversin..............................................30

Instanciacin de componentes ....................................................37

Sentencias iterativas ...................................................................................................................39

Funciones de Resolucin ............................................................................................................42

Palabras reservadas del VHDL ...................................................................................................44

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

ING. JUAN E. COLLAZO

ESQUEMA TPICO DE UN DISEO CAD 1

Computer Aided Design = diseo asistido por computadora

ING. JUAN E. COLLAZO

CONSTRUCCIONES BSICAS EN VHDL:

El diseo en VHDL en general puede emplear

Son la representacin de lo que se quiere disear en su relacin con el mundo exterior. Su

ING. JUAN E. COLLAZO

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

ING. JUAN E. COLLAZO

Type octeto is ...

Las Configuraciones (CONFIGURATION):

ING. JUAN E. COLLAZO

De este primer ejemplo se puede ver lo siguiente:

ING. JUAN E. COLLAZO

La entidad finaliza su cuerpo con la palabra end y a continuacin el nombre de la entidad. En el

ING. JUAN E. COLLAZO

significa que a y se le asigna (operador relacional de asignacin <=) un estado

El cierre se hace nuevamente con end y el nombre (identificador) de la arquitectura. Tambin se

Sentencias en VHDL: concurrencia y secuencialidad

Una estructura de programa (secuencial) tomara

En el caso de sentencias concurrentes, se

ING. JUAN E. COLLAZO

Se deja para el estudiante interesado, formular un planteo

Elementos del lenguaje

pueden ser de dos tipos: genricos simples y extendidos- y palabras

Un identificador genrico es un conjunto de caracteres que se utilizan para nombrar distintos

ING. JUAN E. COLLAZO

CONSTANT alfa : integer := 50

VARIABLE <nombre> : <tipo> [:=<expresin>]

num_bcd : bit_vector := 1001

ING. JUAN E. COLLAZO

Ejemplo 2: una suma de productos lgicos

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

3.- Tipos de datos

ING. JUAN E. COLLAZO

(se lee de 0 a 23, en forma ascendente)

Si no se especifica un valor inicial, el objeto se inicializa con el valor ms a la izquierda de los

TYPE distancia IS RANGE 0 TO 1E16

ING. JUAN E. COLLAZO

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

depende del compilador pero en general ser = 2 31 - 1

+ - / ( ) . , : ; & ' < > = | # <= => := --

ING. JUAN E. COLLAZO

2#1011# significa representacin en base 2 del nmero 1011 = 11 en decimal

* Los artimticos son:

* Los relacionales son: