VHDL c02

CIME
INTRODUCCIÓN AL LENGUAJE DE
DESCRIPCION DE HARDWARE VHDL
CAPÍTULO 2
Autor: Dr. Alberto Hernández Pérez, Profesor Consultante
Centro de Investigaciones en Microelectrónica

Facultad de Ingeniería Eléctrica
CUJAE
2004
Introducción al Lenguaje de Descripción de Hardware VHDL.
Autor: Dr. Alberto Hernández Pérez, Profesor Consultante, CIME, CUJAE, 2004.
Capítulo 2. Lenguajes de Descripción de Hardware.
Capítulo 2. Lenguajes de descripción de hardware

Introducción. 3
Lenguajes de descripción de hardware. Introducción al VHDL. 3
Estructura de VHDL. 4
Sintaxis para la declaración de la entidad. 5
Sintaxis para la definición de la arquitectura. 6
Objetos en VHDL. 7
Modo de las señales. Tipo de las señales. 9
Operadores en VHDL. 10
Asignaciones condicionales en VHDL. 10
Bibliotecas y paquetes en VHDL. 13
Sintaxis para la definición de un paquete. 14
Componentes en VHDL. Sintaxis para la declaración de un componente. 14
Funciones y procedimientos en VHDL. 17
Sintaxis para la definición de una función en VHDL. 17
Sintaxis para la definición de un procedimiento en VHDL. 18
Extensión (Overload) de los operadores en VHDL. 22
Diseño jerárquico en VHDL. 23
Bloques en VHDL. 27
Arreglos en VHDL. 28
Procesos en VHDL. Sintaxis para declarar un proceso. 29
Sentencia condicional IF… THEN… en VHDL. 30
Sintaxis para la declaración de la sentencia condicional IF... THEN... en VHDL. 30
CASE en VHDL. Sintaxis para declarar un CASE. 30
Sentencias WAIT en VHDL. Sintaxis de las sentencias WAIT. 34
Lazos en VHDL. Sintaxis para los diferentes lazos. 36
Sentencia GENERATE en vhdl. Sintaxis de las sentencias generate. 43
Operadores de desplazamiento. 45
Señales bidireccionales en VHDL. 48
Assert-Report-Severity en VHDL. 49
Bancos de prueba en VHDL. 51
Retardos en VHDL. 53
Atributos en VHDL. 53
Ejercicios. 60
2
Introducción.-
A partir de los años 80 del siglo pasado, el diseño digital ha cambiando considerablemente
incorporando cada vez más los dispositivos lógicos programables (PLD) debido a sus
ventajas sobre los dispositivos tradicionales. La programación de los SPLD, CPLD y FPGA
se realiza utilizando un lenguaje de descripción de hardware Un lenguaje de descripción de
hardware (HDL) es una herramienta que sirve para describir el comportamiento y la
arquitectura de un circuito o sistema electrónico utilizando diferentes niveles de abstracción
y en muchos casos el modo jerárquico. En esto texto se estudia solamente el VHDL ya que
éste es un estándar y es el de mayor uso a nivel mundial. En este capítulo se presentan los
aspectos fundamentales del VHDL los cuales se ilustran con ejemplos y ejercicios para
facilitar su asimilación. En el capítulo 3 se presentan otros ejemplos y ejercicios
relacionados con el diseño de circuitos combinacionales utilizando VHDL; en el capítulo 4
los ejemplos y ejercicios se destinan al diseño de circuitos secuenciales. Este conjunto de
ejemplos y ejercicios ayudarán en el desarrollo de habilidades a los interesados en el
aprendizaje de VHDL.
Lenguajes de descripción de hardware. Introducción al VHDL.

La utilización de los PLD en el diseño digital requiere, además del dispositivo programable,
de un programador y del lenguaje de descripción de hardware (HDL) correspondiente.
Existen distintos tipos de HDL, generalmente se clasifican en tres niveles:
• HDL de bajo nivel: Permiten definir un circuito a nivel de su arquitectura con poco
nivel de abstracción. Ejemplos de esto son ABEL y PALASM. En la Referencias
[2, 5] pueden encontrarse algunas de las características del lenguaje ABEL y
numerosos ejemplos de diseño digital empleando este lenguaje. En el Capítulo 4 de
la Referencia [9] hay varios ejemplos de CLC diseñados con PALASM.
• HDL de nivel medio: Permiten definir un circuito con mayor nivel de abstracción y
utilizar el modo jerárquico. Un lenguaje de este tipo es el AHDL de Altera.
• HDL de alto nivel: Permiten definir un circuito o sistema con un gran nivel de
abstracción, además de utilizar el modo jerárquico. Lenguajes de este tipo son
VERILOG y VHDL, ambos han alcanzado una gran difusión a nivel internacional y
son estándares de la IEEE. En este texto se utiliza el VHDL debido a su importancia
creciente.
VHDL.
Es un lenguaje de descripción de hardware concebido para el diseño de circuitos integrados
de muy alta velocidad. Surgió a mediados de los años 80 y desde 1987 se convirtió en un
estándar de la IEEE. Los diseños se pueden descomponer en forma jerárquica de arriba
abajo (top down). Cada modelo posee una interfase (entidad) que permite su conexión con
otros elementos y una arquitectura donde se especifica su funcionamiento lo que permite su
3
simulación. El diseño jerárquico permite diseñar los componentes de un sistema en forma
paralela por distintos equipos de diseñadores ubicados incluso en lugares geográficos
distantes donde cada grupo diseña la parte que le corresponda de acuerdo a los requisitos
que se le establezcan sin necesidad de conocer el resto del sistema (compartimentación) lo
que es una gran ventaja desde muchos puntos de vista. Un grupo central se encarga de
concebir el sistema, trazar las directivas de trabajo para los restantes grupos y reunir los
diferentes componentes que lo constituyen cuando los mismos están listos.
Utilizando VHDL se puede diseñar, simular y sintetizar desde un CLC sencillo, como los
ejemplos que se muestran en este libro de texto, hasta sistemas digitales de gran
complejidad tal como un microprocesador [3].
Estructura de VHDL. Como se planteó anteriormente, VHDL está formado por la

pareja Entidad-Arquitectura (Entity-Architecture). A esta pareja se le llama modelo en
VHDL. En la entidad se declaran los terminales de entrada y de salida (puertos), del
circuito o sistema que se desea diseñar.
En la arquitectura se define qué hace el circuito o cómo lo hace.
Por lo tanto, un diseño en VHDL es un fichero texto (no un dibujo), escrito en cualquier
editor, donde en la primera parte aparece la declaración de la entidad (entity) y a
continuación la definición de la arquitectura (architecture). La definición de la arquitectura
puede hacerse con un gran nivel de abstracción como se requiere en el diseño de sistemas o
circuitos muy complicados donde el diseñador, generalmente, lo único que sabe es lo que
necesita pero no qué circuito lo hace. Compare esto con otros programas empleados en el
diseño electrónico, por ejemplo Pspice, donde el diseñador tiene que conocer de antemano
el circuito que presumiblemente sirve para resolver su problema. En la Figura 2-1 se ilustra
la estructura de un modelo en VHDL
File texto (nombre.vhd)
Declaración de la
Entidad.
Definición de la
Arquitectura.
Figura 2-1. Estructura de un modelo en VHDL
4
Sintaxis para la declaración de la entidad.

La sintaxis para la declaración de la entidad es la siguiente (aparecen en mayúscula las
palabras reservadas del lenguaje VHDL, pero esto no es necesario):
ENTITY nombre_entidad IS
GENERIC (
Nombre de la constante genérica: tipo :=Valor de la constante ;
...
Nombre de la constante genérica: tipo :=Valor de la constante
) ;
PORT (
Nombre de señal: modo tipo de la señal ;
...
Nombre de señal: modo tipo de la señal
) ;
END nombre_entidad ;
La declaración de las constantes genéricas dentro de la entidad antecede a la declaración del

port y pueden aparecer o no.
Ejemplo 2-1. Escriba la declaración de la identidad para un circuito digital con dos
entradas (a, b) y una salida f, como el mostrado:
ENTITY
a
f
b
Solución:
ENTITY ejemplo1 IS
PORT ( a, b: IN bit ;
f: OUT bit ) ;
END ejemplo1 ;
En este caso ejemplo1 es el nombre asignado a la entidad, a y b son los nombres de las
señales de entrada, IN es el modo de estas señales, OUT es el modo de la señal de salida,
Bit es el tipo de las señales de entrada y de salida.
5
Sintaxis para la definición de la arquitectura.

La sintaxis para la definición de la arquitectura es la siguiente:
ARCHITECTURE nombre_arquitectura OF nombre_entidad IS

Declaración de tipos
Declaración de señales
Declaración de constantes
Declaración de componentes
Definición de funciones
Definición de procedimientos
BEGIN
Sentencia concurrente
...
END nombre_arquitectura ;
Las declaraciones y definiciones que preceden a BEGIN pueden estar presentes todas,
algunas o ninguna, esto depende del tipo de diseño que se esté realizando. No obstante la
declaración de señales se utiliza mucho pues contribuye, entre otras cosas, a la claridad del
diseño.
Ejemplo 2-2. Escriba la definición de arquitectura para la entidad del Ejemplo 2-1.
Suponga que el circuito es una compuerta AND.
Solución:
ARCHITECTURE and_2ent OF ejemplo1 IS

BEGIN
f <= a AND b ;
END and_2ent ;
En VHDL hay una gran flexibilidad para escribir la arquitectura de una identidad
determinada. Otra forma es la siguiente:
ARCHITECTURE and_2ent OF ejemplo1 IS

BEGIN
f <= ‘1’ WHEN a = ‘1’ AND b =’1’ ELSE
‘0 ;
END and_2ent ;
En VHDL las letras mayúsculas y las minúsculas tienen el mismo significado. En los
ejemplos 1 y 2, se escribieron las palabras reservadas del lenguaje (vea anexo 2) con letras
mayúsculas sólo para resaltarlas.
6
Ejemplo 2-3. Veamos ahora, otra situación donde tenemos un circuito con dos entradas
(a, b) y una salida f. La entidad es igual a la del Ejemplo 2-1; pero supongamos que la
función que realiza el circuito es tal que la salida será 0 sólo si las entradas son iguales (el
circuito realiza la operación XOR). Escriba el programa en VHDL para sintetizar este
circuito.
Solución:
La entidad es la misma del Ejemplo 2_1, solamente es necesario cambiar la arquitectura.
Esta es una forma posible de escribir el programa:
ENTITY ejemp2_3 IS -- Se cambió el nombre de la entidad

PORT (a, b: IN bit ;
f: OUT bit ) ;
END ejemp2_3 ;
ARCHITECTURE dos_ent OF ejemp2_3 IS

BEGIN
f <= '1' WHEN a / = b ELSE -- También podíamos escribir:
'0' ; -- f <= a xor b ;
END dos_ent ;
En VHDL lo que se escribe después de -- es un comentario
Los resultados de la simulación confirman que se trata de la operación XOR:
Objetos en VHDL.
En VHDL hay cuatro tipos de objetos: Constantes, señales variables y ficheros.
Constantes: Se declaran en la arquitectura antes de begin. Tienen tipo y no poseen modo.

La sintaxis para la declaración de una constante es la siguiente:
Constant < identificador > : tipo := Valor asignado ;
Ejemplo de declaración de una constante:

Constant D : std_logic_vector (2 downto 0):= "011" ;
7
En el ejemplo anterior D es el nombre que identifica a la constante, std_logic_vector (2
downto 0) es el tipo de la misma y:= "011" es el valor asignado. Note que la asignación a
una constante se realiza mediante :=
Señales: Se declaran en la arquitectura antes de begin. Tienen tipo y no poseen modo.
La sintaxis para la declaración de las señales es la siguiente:
Signal < identificador > : tipo ;
Ejemplo de declaración de una señal:

Signal suma: integer range 6 downto 0 ;
La asignación del valor a una señal se realiza mediante <=

Ejemplo suma <= a + b ;
Variable: Se declaran en un proceso o en subprograma (función o procedimiento) antes del

begin
La sintaxis para la declaración de una variable es la siguiente:

Variable < identificador > : tipo ;
Ejemplo de declaración de una variable:

Variable Ys : integer range 35 downto 0 ;
La asignación del valor a una variable se realiza mediante :=

Ejemplo Ys:= 0 ;
Fichero (File) se utiliza para intercabiar información con el exterior. En su declaración se le

asigna un archivo existente.
La sintaxis para la declaración de un fichero es la siguiente:
File < identificador > : tipo abrir_modo is < archivo > ;
El tipo está determinado por el tipo de los datos que contiene.

El modo indica si el fichero se abre para leer (read_mode), para escribir (write_mode) o,
para añadir información (append_mode).
Ejemplo de declaración de un fichero:
File informe : Text open write_mode is C:\Trabajo\Monografia.txt ;
El fichero informe se abre en el modo de escritura con el objetivo de escribir información.
Si se omite el modo en la declaración del fichero, este se abrirá en el modo de lectura.
8
El tipo Text está predefinido como una cadena en el paquete Textio contenido en la
biblioteca STD.
Para utilizar un tipo diferente al Text, es necesario que el mismo sea definido previamente
por el usuario.
Modo de las señales.

En VHDL las señales pueden tener cuatro modos diferentes:
IN, OUT, BUFFER, INOUT
IN En este modo las señales sólo entran en la entidad.

OUT En este modo las señales salen de la entidad
BUFFER Este modo se utiliza para las señales que además de salir de la entidad pueden
usarse como entradas realimentadas.
INOUT Este modo se utiliza para las señales bidireccionales. Se puede asignar como
sustituto de los tres modos restantes; pero no es aconsejable ya que dificulta la
comprensión del programa.
Cuando se omite el modo de una señal en la declaración de la entidad se sobreentiende que

es de entrada. En VHDL existe un quinto modo para las señales llamado LINKAGE; pero
generalmente no se menciona en la literatura debido a que está en desuso.
Tipo de las señales.

En VHDL hay varios tipos de señales predefinidos por el lenguaje, tales como:
Bit, boolean, std_logic, bit_vector, integer, std_logic_vector
Además el usuario puede definir otros tipos, lo que resulta conveniente en algunos casos,
como por ejemplo en el diseño de máquinas de estado.
El lenguaje VHDL concede máxima importancia a los tipos de las señales, por ejemplo no
se admite realizar una asignación mezclando tipos diferentes. Algunas características de los
tipos predefinidos están dadas en la tabla siguiente:
Tipo Características
Bit En este tipo las señales sólo toman los valores ‘1’ y ‘0’
Boolean En este tipo las señales sólo toman los valores True y False
Std_logic En este tipo las señales toman nueve valores, entre ellos
tenemos: ‘1’, ‘0’, ‘Z’ (para el tercer estado),
‘-’ (para los opcionales)
Integer En este tipo las señales toman valores enteros. Los 1 y 0
aquí van sin ‘’
Bit_vector En este tipo los valores de las señales son una cadena de
unos y ceros. Una cadena se escribe entre comillas.
Ejemplo: “1000”
9
Std_logic_vector En este tipo los valores de las señales son una cadena de los
nueve valores permisibles para el tipo std_logic. Ejemplo:
“1-0Z”
Tabla 2-1. Algunas características de los tipos predefinidos en VHDL.
Operadores en VHDL.
En VHDL existen diferentes operadores entre ellos tenemos: operadores lógicos, de
relación, aritméticos y de concatenación.
Debajo se muestran algunos de ellos:
Operadores Definidos en el lenguaje VHDL para los

tipos:
Lógicos: AND, OR, Bit y Boolean
XOR, NOT, NAND, NOR
y XNOR
De relación: = , /= , < , Integer, Bit y Bit_vector
>, >= , <=
Aritméticos: + , - , Integer
* (multiplicación sólo por
potencias de 2)
Concatenación: & Bit, Bit_vector y para las cadenas
Tabla 2-2. Algunos operadores en VHDL.
Asignaciones condicionales en VHDL.
En VHDL hay varias asignaciones que se realizan en forma condicionada. En los ejemplos
2-4, 2-5 y 2-6 se utilizan dos de ellas:
WITH ..... SELECT ... WHEN ... OTHERS
WHEN ... ELSE ...
Esta última ya se empleó en los ejemplo 2-2 y 2-3 y será utilizada nuevamente en el
siguiente:
10
Ejemplo 2-4. Escriba en VHDL un programa para obtener una compuerta NOR de dos
entradas. Utilice señales tipo boolean y asignaciones condicionales de la forma when ...
else
-- Solución. fichero: boole2_4.vhd
Entity boole4 is port (a, b: in boolean ;

y: out boolean ) ;
End boole4 ;
architecture boole4_a of boole4 is begin

y <= true when a = false and b = false else
false ;
End boole4_a ;
Ejemplo 2-5. Repita el diseño anterior; pero utilice asignaciones condicionales de la forma
With ..... select ... when ... others
-- Solución. fichero: boole2_5.vhd
Entity boole5 is port (a, b : in boolean ;

y : out boolean ) ;
End boole5 ;
Architecture boole5_a of boole5 is begin

With a select
y <= false when true ,
not b when others ;
End boole5_a ;
Note la diferencia entre las arquitecturas de estos dos ejemplos; sin embargo en ambos
casos se obtiene el mismo resultado, la operación NOR.
En el Ejemplo 2-6 se ilustra la utilizacion en el mismo programa de las dos sentencias

condicionales estudiadas anteriormente. También se puede apreciar en este diseño, el uso
de señales (signal) para facilitar la escritura y claridad del programa.
Ejemplo 2-6. Escriba un programa en VHDL para obtener un circuito en cuyas entradas se
aplican dos números (a, b) enteros de dos bit cada uno y que brinde en sus salidas la suma
de los mismos, su producto, el módulo de su diferencia o el cuadrado de su suma de
acuerdo al valor que tomen dos entradas adicionales de selección S1 y S0, según la tabla
siguiente:
11
Entradas de selección Salidas

S1 S0 Salida
0 0 Suma de a y b
0 1 Producto de a y b
1 0 Módulo de la diferencia de a y b
1 1 Cuadrado de la suma de a y b
-- Solución: fichero: aritmet1.vhd

Entity aritmet1 is
Port ( a, b: in integer range 3 DOWNTO 0 ;
s1, s0 : in bit ;
Salida: out integer range 36 DOWNTO 0 ) ;
End aritmet1 ;
Architecture aritmet1 of aritmet1 is

Signal suma: integer range 6 DOWNTO 0 ;
Signal prod: integer range 9 DOWNTO 0 ;
Signal modulo: integer range 3 DOWNTO 0 ;
Signal cuadrado: integer range 36 DOWNTO 0 ;
begin
modulo <= (a - b ) when a >= b else
(b - a) ;
suma <= a + b ;
with b select
prod <= a when 1,
a*2 when 2,
a*2 + a when 3,
0 when others ;
with suma select

cuadrado <= 1 when 1,
4 when 2,
9 when 3,
16 when 4,
25 when 5,
36 when 6,
0 when others ;
Salida <= suma when S1= '0' AND S0= '0' else
prod when S1= '0' AND S0= '1' else
modulo when S1= '1' AND S0= '0' else
cuadrado ;
End aritmet1 ;
12
Después de compilar exitosamente el diseño realizado se procede a su simulación. Los
resultados de la simulación se muestran a continuación:
Bibliotecas y paquetes en VHDL.
Bibliotecas. Una biblioteca en VHDL es un lugar donde se guarda la información

relacionada con un diseño determinado. Al comienzo de cada diseño el compilador crea
automáticamente una biblioteca de trabajo (WORK) con este objetivo. Además de la
biblioteca de trabajo hay otras bibliotecas de tipo general que contienen un conjunto de
definiciones que pueden utilizarse en cualquier diseño. Entre estas tenemos las bibliotecas
llamadas IEEE y STD que contienen definiciones estándar para VHDL. Para utilizar la
biblioteca IEEE es necesario escribir su nombre al inicio del programa, por eso es muy
común que en la primera línea de un diseño en VHDL aparezca escrito Library ieee. De
esta forma dicha biblioteca se hace visible para el diseño de que se trate. En el caso de las
bilotecas WORK y STD siempre están visibles por lo que no es necesario escribir
explícitamente las sentencias library work ni library std; cuya escritura sería redundante.
Paquetes. En los paquetes se guardan definiciones de tipos y objetos que pueden ser
utilizados en los diferentes diseños que invoquen su utilización. Un paquete muy utilizado
es el paquete estándar IEEE.STD_LOGIC_1164. En general, el empleo de un paquete en un
diseño se realiza invocando su empleo mediante la cláusula: Use < identificador del
paquete>. Un ejemplo de esto es la siguiente línea:
Use IEEE.STD_LOGIC_1164.ALL ;
En la sentencia anterior IEEE es el nombre de la biblioteca que contiene el paquete cuyo
nombre es: STD_LOGIC_1164. La terminación .ALL escrita a continuación del nombre
del paquete permite utilizar todas las definiciones y objetos que contiene dicho paquete.
Además del STD_LOGIC_1164 existen otros paquetes de uso general tal como el paquete
nombrado STANDARD que está contenido en la bibioteca STD. Para utilizar este paquete
13
no es necesario escribir la sentencia Use STD.STANDARD.ALL debido a que el mismo
siempre está visible.
Los diseñadores que trabajan con VHDL pueden definir sus propios paquetes lo que les
permite utilizar diseños realizados anteriormente como parte de otros nuevos.
Sintaxis para la definición de un paquete.

La sintaxis para la definición de un paquete es la siguiente:
PACKAGE nombre_paquete IS
Declaración de señales
Declaración de componentes
Declaración de funciones
Declaración de procedimientos
END nombre_paquete ;
PACKAGE BODY nombre_paquete IS

END nombre_paquete ;
En la sintaxis del paquete existen dos zonas, la primera es la zona de declaraciones y la

segunda es la correspondiente al cuerpo (body) del paquete. Esta segunda zona es la que
aparece entre los dos END y puede o no existir. En el caso de existir las declaraciones y
definiciones contenidas en la misma son locales, visibles sólo dentro del paquete; mientras
que las declaraciones contenidas en la primera parte del paquete, son visibles para todos los
diseños que lo utilicen.
Las funciones y procedimientos declarados en la primera zona del paquete son definidos en
la segunda zona del mismo. En cambio la definición de los componentes declarados en un
paquete no se realiza en el cuerpo del paquete sino en un diseño independiente que contiene
la entidad y la arquitectura correspondiente al componente.
Componentes en VHDL.
Un componente puede declararse dentro de una arquitectura, en ese caso solo puede
utilizarse dentro de ella. También puede declararse dentro de un paquete, en este caso se
puede utilizar en todas las arquitecturas que utilicen dicho paquete.
Los componentes siempre están asociados a otros circuitos o sistemas diseñados
previamente. Son de mucha utilidad en el diseño jerárquico.
14
Sintaxis para la declaración de un componente en VHDL.
La sintaxis para la declaración de un componente es la siguiente:
COMPONENT nombre_componente
GENERIC (
Nombre de la constante genérica: tipo :=Valor de la constante ;
...
Nombre de la constante genérica: tipo :=Valor de la constante
);
PORT (
Nombre de señal: modo tipo de la señal ;
...
Nombre de señal: modo tipo de la señal
);
END COMPONENT ;
Después que el componente ha sido definido, para utilizarlo dentro de una arquitectura debe
ser llamado (“instanciado”); la instancia de un componente se realiza de la manera
siguiente:
Etiqueta: nombre del componente

GENERIC MAP (listado de constantes con sus nombres y valores reales) ;
PORT MAP (listado de señales con sus nombres reales) ;
El nombre asignado a la etiqueta es arbitrario; pero su uso es obligatorio.
Los valores reales de las constantes genéricas se sobrescriben a los valores formales
declarados para las mismas. Por omisión se asignan los valores formales.
El listado de las constantes genéricas y de las señales se puede escribir de dos formas
diferentes:
a) Listado posicional. En este caso las constantes y señales reales se escriben en el mismo
orden en que fueron escritas las constantes y señales formales.
b) Listado explícito. En este caso se escribe explícitamente la asoción realizada entre cada
constante o señal formal con su correspondiente real. El orden en que se escriben es
arbitrario.
Se realiza así: Parámetro formal => Parámetro real
En los ejemplos que siguen se ilustra la utilización de un componente declarado en la zona

de declaraciones de una arquitectura y el otro declarado dentro de un paquete; así como los
dos tipos de asociación entre los parámetros formales y los reales.
15
Ejemplo 2-7. Escriba un programa en VHDL para diseñar un circuito igual al dado en el
ejemplo 2-6 utilizando un componente declarado en la zona de declaraciones de la
arquitectura.
-- Solución: fichero: A_ARITM.VHD
Library STD ; -- Es redundante ya que la biblioteca STD siempre está visible.

Use STD.standard.all ; -- Es redundante ya que el paquete Standar siempre está visible.
Library IEEE ;
Use IEEE.std_logic_1164.all ;
ENTITY A_ARITM IS
PORT (
x, y: in integer range 3 DOWNTO 0 ;
sel1, sel0 : in bit ;
w: out integer range 36 DOWNTO 0
) ;
END A_ARITM ;
ARCHITECTURE A_ARITM_ARCH OF A_ARITM IS

-- Declaración del componente aritmet1 (su definición está dada en la entidad y la
-- arquitectura correspondiente al Ejemplo 2-6):
COMPONENT aritmet1 -- El nombre del componente tiene que ser igual al de

-- la entidad que lo define, en este ejemplo es aritmet1
PORT (
a, b: in integer range 3 DOWNTO 0 ;
s1, s0 : in bit ;
Salida: out integer range 36 DOWNTO 0
) ;
END COMPONENT ;
BEGIN
C0: ARITMET1 PORT MAP (x, y, sel1, sel0, w) ;

-- "Llama" al componente aritmet1 declarado en esta arquitectura. La asociación entre las
-- señales reales (x, y, sel1, sel0 y w) y las formales (a, b, s1, s0 y salida) es posicional.
END A_ARITM_ARCH ;
16
Funciones y procedimientos en VHDL.
Al igual que ocurre con los componentes, las funciones y procedimientos (llamados sub
programas en VHDL) pueden definirse en la zona de declaraciones de una arquitectura en
este caso solamente pueden ser utilizados en esa arquitectura. También pueden definirse
dentro de un paquete y serán visibles para todos los diseños que utilicen el paquete.
A continuación se presenta la sintaxis para la definición de las funciones y de los
procedimientos así como algunos ejemplos en los que se ilustra la utilización de los
mismos.
Sintaxis para la definición de una función en VHDL.
Function nombre (
señal: tipo ;
…
señal: tipo
)
Return tipo IS
Declaraciones de tipos, de constantes, de variables.
Definición de funciones, de procedimientos
Begin
Sentencia secuencial
…
End nombre ;
Para utilizar la función, que ha sido definida previamente, se realiza su llamada dentro del
cuerpo de una arquitectura, de la siguiente forma:
Nombre de una señal <= nombre de la función (Listado de señales reales) ;
Se asigna a la señal, cuyo nombre se especifica, el valor retornado por la función que ha
sido llamada. Las señales reales y formales se asocian de la misma manera que la utilizada
para el caso de lo componentes.
Ejemplo 2-8. Escriba un programa en VHDL para diseñar un multiplexor de 2 a 1

utilizando una función (function) definida en la zona de declaraciones de la arquitectura.
-- Solución: fichero: mux_func.VHD
Library IEEE;
Entity mux is port (a,b,s: in STD_LOGIC ;
w: buffer STD_LOGIC ) ;
End mux ;
17
Architecture mux_AR of mux is
FUNCTION mux1 (x, y, s: STD_LOGIC )

RETURN STD_LOGIC IS
Begin
Return ((x and not s) or (y and s)) ;
-- o también así:
-- if s = '1' then return y ;
-- else return x ;
-- end if ;
End mux1 ;
BEGIN -- De la arquitectura
w <= mux1 (s => s, y => b, x => a) ; -- "Llama" la función mux1 definida en esta
-- arquitectura. La asociación entre los parámetros formales de la función (x, y, s) y los
-- reales (a, b, s) es explícita.
END mux_AR ;
Sintaxis para la definición de un procedimiento en VHDL.
Procedure nombre (
señal: modo tipo ;
…
señal: modo tipo
) IS
Zona de declaraciones
Begin
...
End procedure ;
Para utilizar el procedimiento, que ha sido definido previamente, se realiza su llamada

dentro del cuerpo de una arquitectura, de la siguiente forma:
Nombre del procedimiento (Listado de señales reales) ;

En los procedimientos, las señales reales y formales se asocian de manera posicional o
explícita, de la misma forma que la utilizada para el caso de los componentes y las
funciones.
Ejemplo 2-9. Escriba un programa en VHDL para diseñar un flip flop tipo D utilizando un
procedimiento (procedure) definido en la zona de declaraciones de la arquitectura.
-- Solución: fichero: DFF_PRO.VHD
Library IEEE ; Use IEEE.std_logic_1164.all ;
ENTITY DFF_PRO IS
PORT (CLK, D: IN STD_LOGIC ;
18
Q : OUT STD_LOGIC ) ;
END DFF_PRO ;
ARCHITECTURE DFF_PRO_ARCH OF DFF_PRO IS

PROCEDURE D_FF (
SIGNAL CK, DATO: IN STD_LOGIC ;
SIGNAL Q : OUT STD_LOGIC
) IS
BEGIN
IF RISING_EDGE (CLK) THEN Q <= D ;
END IF;
END PROCEDURE ;
BEGIN -- De la arquitectura
D_FF (CK => CLK, Q => Q, DATO => D) ;

-- "Llama" al procedimiento D_FF definido en esta arquitectura. La asociación entre los
-- parámetros formales del procedimiento (CK, DATO, Q) y los reales (CLK, D, Q) es
-- explícita..
END DFF_PRO_ARCH ;
Definición de funciones y procedimientos y declaración de un componente en un

paquete:
Como sabemos, de acuerdo a la sintaxis del paquete en VHDL, la definicón de funciones y

procedimientos dentro de un paquete se realiza en el cuerpo del mismo utilizando la
sintaxis ya conocida para su definición; pero es necesario, además, que dichas funciones y
procedimientos sean declarados previamente en la primera zona del paquete, donde también
se declaran los componentes. Todo lo anterior se muestra en el ejemplo que sigue:
Ejemplo 2-10. Escriba en VHDL un paquete que contenga la declaración del componente
aritmet1 correspondiente al circuito diseñado en el Ejemplo 2-6, la definición de una
función para un multiplexor de 2 a 1 y la definición de un procedimiento que permita
diseñar un flip flop tipo D.
-- Solución. fichero: C_F_P_KG.VHD
Library IEEE ;
Package C_F_P_KG IS
-- Zona de declaraciones del paquete C_F_P_KG:
-- Declaración del componente aritmet1 (su definición está dada en la entidad y la
19
-- arquitectura correspondiente al Ejemplo 2-6):
COMPONENT aritmet1 -- El nombre del componente tiene que ser igual al de

-- la entidad que lo define, en este ejemplo es aritmet1
PORT (
a, b: in
integer range 3 DOWNTO 0 ;
s1, s0 :bit ;in
Salida: out
integer range 36 DOWNTO 0
);
END COMPONENT ;
-- Declaración de la función mux2:

FUNCTION mux2 (
x, y, s: STD_LOGIC
)
RETURN STD_LOGIC ;
-- Declaración del procedimiento DFF:

PROCEDURE DFF (
SIGNAL CLK, D: IN STD_LOGIC ;
) ;
END C_F_P_KG ;
-- Cuerpo del paquete C_F_P_KG:

Package body C_F_P_KG IS
-- Definición de la función mux2:
FUNCTION mux2 (
x, y, s: STD_LOGIC
)
RETURN STD_LOGIC IS
Begin
Return ((x and not s) or (y and s)) ;
End mux2 ;
-- Definición del procedimiento DFF:

PROCEDURE DFF (
SIGNAL CLK, D: IN STD_LOGIC ;
) IS
BEGIN
IF RISING_EDGE (CLK) THEN Q <= D ;
END IF ;
END PROCEDURE ;
20
END C_F_P_KG ;
Ejemplo 2-11. Utilice el componente aritmet1 declarado en el paquete c_f_p_kg y diseñe

un circuito igual al dado en el Ejemplo 2-6.
-- Solución: fichero: C_ARITM.VHD
Library IEEE ;
Use work.c_f_p_kg.all ; -- Hace visible todo (all) el contenido del paquete C_F_P_KG.
ENTITY C_ARITM IS
PORT (
x, y: in integer range 3 DOWNTO 0 ;
sel1, sel0 : in bit ;
Salida: out integer range 36 DOWNTO 0
) ;
END C_ARITM ;
ARCHITECTURE C_ARITM_ARCH OF C_ARITM IS

BEGIN
C1: ARITMET1 PORT MAP (a => x, salida => salida, b => y, s1 => sel1,
s0 => sel0) ;
-- "Llama" al componente aritmet1 declarado en el paquete c_f_p_kg. La asociación entre -
-- las señales reales (x, y, sel1, sel0 y salida) y las formales (a, b, s1, s0 y salida) es
-- explícita.
END C_ARITM_ARCH ;
Ejemplo 2-12. Utilice la función definida en el paquete C_F_P_KG y diseñe un

multiplexor de 2a1.
-- Solución: fichero: mux_2a1.VHD

Library IEEE ; use IEEE.std_logic_1164.all ;
Use work.C_F_P_KG.ALL ; -- Hace visible todo (all) el contenido del paquete
C_F_P_KG.
Entity mux_2a1 is
Port (a, b, s: in STD_LOGIC ;
w: buffer STD_LOGIC ) ;
End mux_2a1 ;
Architecture mux_2a1_ARCH of mux_2a1 is
BEGIN
w <= mux2 (a, b, s) ; -- "Llama" la función mux2 definida en el paquete C_F_P_KG.

-- La asociación de los párametros formales y reales es posicional.
21
END mux_2a1_ARCH ;
Ejemplo 2-13. Utilice el procedimiento definido en el paquete C_F_P_KG y diseñe un

flip flop tipo D.
-- Solución: fichero: D_FLFLOP.VHD
Library IEEE ;
Use work.c_f_p_kg.all ; -- Hace visible todo (all) el contenido del paquete C_F_P_KG.
ENTITY D_FLFLOP IS
PORT (CLK, D: IN STD_LOGIC ;
Q: OUT STD_LOGIC ) ;
END D_FLFLOP ;
ARCHITECTURE D_FLFLOP_ARCH OF D_FLFLOP IS

BEGIN
DFF (CLK, D, Q) ; -- "Llama" al procedimiento DFF definido en el paquete c_f_p_kg.
-- La asociación de los párametros formales y reales es posicional.
END D_FLFLOP_ARCH ;
Extensión (Overload) de los operadores en VHDL.
La validez de los operadores dados en la Tabla 2-2 se ha extendido a otros tipos para los
que no estaban originalmente definidos Por ejemplo el paquete estándar
IEEE.std_logic_1164 define la extensión de los operadores lógicos y de concatenación para
los tipos std_logic y std_logic_vector; sin embargo la extensión de los operadores de
relación y aritméticos para los tipos std_logic y std_logic_vector no están definidos en el
paquete IEEE.std_logic_1164.
Ejemplo 2-14. Diseñe un buffer con tercer estado cuyo comportamiento se corresponda
con la tabla funcional siguiente:
Entradas Salida
EN_L A Y
1 – Tercer estado
0 0 0
0 1 1
Solución:
-- Fichero Ejem2_14.vhd
22
Library ieee ;
Use ieee.std_logic_1164.all ;
Entity ejem2_14 is port (EN_L, A: in STD_LOGIC ;

Y: out STD_LOGIC ) ;
End ejem2_14 ;
Architecture ejem2_14 of ejem2_14 is

Begin
Y <= A when EN_L = '0' else
'Z' ;
End ejem2_14 ;
Diseño jerárquico en VHDL.
En VHDL un diseño puede utilizar componentes. Como se dijo antes, esto constituye una
gran ventaja pues facilita el trabajo en equipo y la distribución de tareas entre distintos
grupos de diseñadores. A medida que se sube hacia el nivel de jerarquía máxima, la
arquitectura se hace más general mientras que en los niveles inferiores el grado de detalle
es mayor. En la Figura 2-2 se presenta un esquema que ilustra los diferentes niveles
jerárquicos.
Entidad 1 (Nivel de jerarquía máxima)
Arquitectura 1
Entidad 2 Entidad 3
Arquitectura Arquitectura
Entidad 4
Arquitectura 4
Figura 2-2. Niveles jerárquicos en VHDL
En los Ejemplos 2-15, 2-16 y 2-17, que aparecen a continuación, se ilustra la utilización del
diseño jerárquico en VHDL.
23
Ejemplo 2-15. Utilice VHDL y diseñe un CLC con tres entradas a, b, c y una salida T que
realice la función mostrada en la tabla siguiente:
Entradas Salida
a b c T
0 0 - 0
0 1 0 0
0 1 1 1
1 0 - 1
1 1 - 0
Solución:
-- fichero t.vhd
entity T is port (a, b ,c : in bit ;
T : out bit) ;
end T ;
architecture T of T is begin
T <= '1' WHEN a = '0' and b = '1' and c = '1' ELSE
'1' WHEN a = '1' and b = '0' ELSE
'0' ;
end T ; -- Note el tratamiento dado a los opcionales.
-- Ahora se empaqueta para reutilizarlo en otro diseño:

PACKAGE TPKG IS
COMPONENT T -- El nombre del componente tiene que ser igual al de la
-- identidad que se empaqueta
port (a, b, c : in bit ;
T : out bit ) ;
END COMPONENT ;
END TPKG ;
Ejemplo 2-16. Utilice VHDL y diseñe un CLC con tres entradas a, b, c y una salida W que
realice la función mostrada en la tabla siguiente:
24
Entradas Salida
a b c W
0 - - 1
1 0 - 0
1 1 0 0
1 1 1 1
Solución:
-- fichero W.vhd
entity W is port (a, b, c : in bit ;
W : out bit) ;
end W ;
architecture W of W is begin
W <= '1' WHEN a = '0' ELSE
'1' WHEN b = '1' and c = '1' ELSE
'0' ;
end W ;
-- Note el tratamiento dado a los opcionales.
-- Ahora lo empaquetamos para reutilizarlo en otro diseño:

PACKAGE WPKG IS
COMPONENT W -- El nombre del componente tiene que ser igual al de la
-- identidad que se empaqueta
port (a, b, c : in bit ;
W : out bit ) ;
END COMPONENT ;
END WPKG ;
Ejemplo 2-17. Utilice el diseño jerárquico en VHDL y diseñe un CLC con tres entradas
a,b,c y una salida F que realice la función T dada en el Ejemplo 2-15 ó la función W dada
en el Ejemplo 2-16, de acuerdo al valor que tome una entrada adicional de selección, S .
Cuando S = '0' la salida debe ser F = T y para S = '1' será F = W.
Solución:
Un diagrama en bloques ayuda a visualizar los requerimientos del sistema que se desea
diseñar. En este caso el diagrama es el siguiente:
25
Los circuitos correspondientes a los bloques T y W ya fueron diseñados en los Ejemplos 2-

15 y 2-16 y se dispone de ellos en forma de componentes, definidos dentro de los paquetes
TPKG y WPKG que aparecen al final de los ejemplos citados. Por tanto, solamente
quedaría escribir el programa principal en el que se utilizarán estos componentes, como se
muestra a continuación:
-- Programa principal para el diseño jerárquico.

-- fichero pprincip.vhd
USE WORK.TPKG.ALL ; -- Hace visible el paquete tpkg
USE WORK.WPKG.ALL ; -- Hace visible el paquete wpkg
Entity pprincip is port (s, a, b, c: in bit ;

F: out bit ) ;
End pprincip ;
Architecture pprincip of pprincip is

Signal S0, S1: bit ;
Begin
T0: T port map (a, b, c, S0) ;
W0: W port map (a, b, c, S1) ;
F <= S0 WHEN S = '0' ELSE

S1 ;
End pprincip ;
-- Note la falta de detalles en el programa principal.
Los resultados de la simulación permiten comprobar que el circuito funciona de acuerdo a

lo deseado:
26
Bloques en VHDL.
Los bloques se pueden utilizar dentro de una arquitectura.
La sintaxis de los bloques es la siguiente:
Etiqueta: BLOCK -- La etiqueta es obligatoria.

PORT ( ) ;
-- Declaracion de variables
PORT MAP ( ) ;
Begin
Sentencias concurrentes
End block ;
Ejemplo 2-18. Escriba un programa en VHDL para realizar el diseño de un circuito que
realice la función lógica y = a.b + c utilizando dos bloques.
-- Solución: fichero: bloques.vhd

Entity bloques is
Port (
a, b, c: in bit ;
y: out bit
) ;
end bloques ;
architecture bloques_arch of bloques is
signal y1, y2 : bit ;
begin
and1: block -- Inicio del bloque and1.

Port (
x, y: in bit ;
w: out bit) ;
port map (a, b, y1) ;
begin
27
y1 <= a and b ;
End block and1 ; -- Final del bloque and1.
or1: block -- Inicio del bloque or1.

port (
x, y: in bit ;
w: out bit
);
Port map (y1, c, y2) ;
begin
y2 <= y1 or c ;
End block or1 ; -- Final del bloque or1.
y <= y2 ;
End bloques_arch ;
Los resultados de la simulación son los siguientes:
Arreglos en VHDL.
Los arreglos son tipos que pueden ser definidos por el usuario de VHDL.
La sintaxis de un arreglo es la siguiente:
Type nombre IS ARRAY (Comienzo DOWNTO Final) OF Type ;

Type nombre IS ARRAY (Comienzo TO Final) OF Type ;
Type nombre IS ARRAY (Rango) OF Type ;
Type nombre IS ARRAY (Rango RANGE Comienzo DOWNTO Final) OF Type ;
Type nombre IS ARRAY (Rango RANGE Comienzo TO Final) OF Type ;
Ejemplos de utilización de arreglos:
Ejemplo 2-19. Escriba un programa en VHDL para obtener un CLC que tenga dos
entradas de 4 bit cada una (C1, C0), una entrada de selección, S, y dos salidas (Y1, Y0).
Las salidas del circuito deben comportarse de la forma siguiente:
28
Entrada de selección Salidas

S Y1 Y0
0 Alta impedancia C0
1 C1 Alta impedancia
-- Solución fichero: mux2_arr.vhd
Library IEEE ;
ENTITY mux2_arr IS
PORT (S : in std_logic ;
C1, C0: in std_logic_vector (3 downto 0) ;
Y1,Y0 : buffer std_logic_vector (3 downto 0) ) ;
END mux2_arr ;
ARCHITECTURE mux2_arr OF mux2_arr IS

Type TIPO_ARREGLO is array (1 downto 0) of std_logic_vector (3 downto 0) ;
signal salida: tipo_arreglo ;
begin
salida(1) <= c1 when S = '1' ELSE
"ZZZZ"; -- En este caso las Z tienen que ser mayúsculas pues representan
-- uno de los nueve valores posibles de las señales del tipo std_logic
salida(0) <= c0 when S = '0' ELSE
(Others => 'Z' ) ; -- (Others => 'Z' ) aquí es equivalente a "ZZZZ"
y1 <= salida(1) ;
y0 <= salida(0) ;
end mux2_arr ;
Procesos en VHDL.
Un proceso (process) es equivalente a una sentencia que es tratada en forma concurrente,
simultánea, con otros process. Cada process contiene un conjunto de sentencias que son
analizadas en forma secuencial, una después de otra. Un process tiene una lista de
sensibilidad formada por un conjunto de señales cuya variación dá lugar a la activación del
process.
La sintaxis para declarar un process es la siguiente:
Process (nombre de señal, nombre de señal,..., nombre de señal)
-- Lo que está dentro del paréntesis es la lista de sensibilidad del process.
29
Declaración de variables
Begin
...
Sentencias secuencial
End Process ;
Se puede utilizar una etiqueta, opcional, para identificar un process.
Sentencia condicional IF… THEN… en VHDL.

Sólo se puede utilizar dentro de un proceso o de un subprograma.
La sintaxis para la declaración de la sentencia condicional IF... THEN... es la

siguiente:
If expresión booleana Then sentencia secuencial

Else sentencia secuencial
End If ;

Elsif expresión booleana Then sentencia secuencial
...
End If ;

...
Else sentencia secuencial
End If ;
CASE en VHDL.
Opera a partir de una sentencia que habilita o no el procesamiento de otras sentencias. Sólo
se puede utilizar dentro de un proceso o de un subprograma.
30
La sintaxis para declarar un CASE es la siguiente:
CASE expresión IS
When selección = > sentencia secuencial

...
When selección = > sentencia secuencial
End CASE ;
A continuación se muestra un ejemplo donde se ilustra la utilización de un PROCESS, la

sentencia IF…THEN… y un CASE:
Ejemplo 2-20. Diseñe un circuito lógico combinacional que funcione de acuerdo a la tabla
siguiente:
----------------------------------------------
-- ENTRADAS SALIDA
----------------------------------------------
-- G S Y
----------------------------------------------
-- 0 - Alta impedancia
-- 1 0 C0
-- 1 1 C1
-- 1 2 C2
-- 1 3 C3
----------------------------------------------
-- SOLUCIÓN. Fichero: MUX4.VHD
Library IEEE;
Entity mux4 is
Port (G, C3, C2, C1, C0 : in std_logic ;
S : in integer range 3 downto 0 ;
Y : out std_logic ) ;
end mux4 ;
Architecture mux4_arch of mux4 is
Begin
Process (G, S, C3, C2, C1, C0)
Begin
IF G = '0' THEN y <= 'Z' ;
ELSE
CASE S IS
When 0 => y <= C0 ;
When 1 => y <= C1 ;
31
When 2 => y <= C2 ;
When OTHERS => y <= C3 ;
END CASE ;
END IF ;
End process ;
End mux4_arch ;
Los resultados de la simulación confirman que el circuito diseñado funciona de acuerdo a la

tabla dada:
Ejemplo 2-21. Escriba un programa en VHDL para obtener un CLC que funcione según
la Tabla de la Verdad siguiente:
Entradas Salida
G B A Y
0 0 0 “0000”
0 0 1 “0000”
0 1 0 “0000”
0 1 1 “0000”
1 0 0 “0001”
1 0 1 “0010”
1 1 0 “0100”
1 1 1 “1000”
-- Solución: Fichero: Dec_case.vhd

Library ieee ;
Entity Dec_case IS
PORT (G, B, A : in std_logic ;
Y: BUFFER std_logic_vector (3 DOWNTO 0 ) ) ;
End Dec_case ;
32
ARCHITECTURE Dec_case_arch OF Dec_case IS
begin
Process (G, B, A)
Variable Entradas: std_logic_vector (2 downto 0) ;
Begin
Entradas := G & B & A ;
CASE Entradas IS
When "000"|"001"| "010"| "011" => Y <= ( others => ‘0’ ) ;
When "100" => Y <= "0001" ;
When "101" => Y <= "0010" ;
When "110" => Y <= "0100" ;
When "111" => Y <= "1000" ;
When others => NULL ; -- No hacer nada.
End case ;
End process ;
End dec_case_arch ;
Ejemplo 2-22. Escriba un programa en VHDL para obtener un contador binario

ascendente de 3 bit. Debe tener la posibilidad de realizar la carga paralelo en forma
sincrónica.
-- Solución fichero : C3BIT.VHD
LIBRARY ieee ;
USE ieee.std_logic_1164.all ;
ENTITY C3BIT IS
PORT (
CLK, LD_L : in std_logic ;
A : in integer range 7 downto 0 ;
Q : buffer integer range 7 downto 0
) ;
END C3BIT ;
ARCHITECTURE C3BIT OF C3BIT IS

BEGIN
Process (CLK)
Begin
if rising_edge (clk) then
if LD_L = '0' then q <= a ; -- Carga paralelo
else q <= q + 1 ; -- Conteo ascendente
end if ;
end if ;
end process ;
end C3BIT ;
33
Library ieee ;
Package C3BITPKG is
Component C3BIT PORT (
CLK, LD_L : in std_logic ;
A : in integer range 7 downto 0 ;
Q : buffer integer range 7 downto 0
) ;
End component ;
End C3BITPKG ;
Los resultados de la simulación permiten comprobar el funcionamiento del contador

diseñado:
SENTENCIAS WAIT EN VHDL.
En VHDL hay tres tipos de sentencias wait: WAIT ON, WAIT UNTIL y WAIT FOR.
Se pueden utilizar dentro de un proceso o de un procedimiento.
Sintaxis de la sentencia WAIT:
WAIT ON señal 1, ... señal n ;

WAIT UNTIL ( condición) ;
WAIT FOR ( Expresión temporal) ;
La sentencia WAIT detiene la ejecución de sentencias secuenciales contenidas dentro de un

proceso o un procedimiento hasta que se cumpla las condiciones dadas en el enunciado del
WAIT:
34
En el caso del wait on se activa la ejecución de las sentencias secuenciales cuando ocurre
un cambio de cualquier tipo en alguna de las señales que aparecen a continuación de wait
on.
Para el wait until se activa la ejecución de las sentencias secuenciales cuando se produce
el cambio de la condicón de falsa a verdadera en la condición escrita a continuación de wait
until.
En el wait for se activa la ejecución de las sentencias secuenciales después que transcurre
el tiempo especificado que aparece escrito a continuación de wait for.
A continuación se muestran dos ejemplos donde se utiliza la sentencia WAIT:
Ejemplo 2-23. Escriba un programa en VHDL que permita diseñar un selector de datos de
2 a 1 con salida activa en el nivel alto. Utilice la sentencia wait on.
-- Solución. fichero: muxproc.vhd

library IEEE ;
use IEEE.std_logic_1164.all ;
ENTITY mux2a1 IS PORT (
s,a,b : in std_logic ; Y: out std_logic ) ;
END mux2a1 ;
ARCHITECTURE mux2a1 OF mux2a1 IS

begin
process begin
WAIT ON s, a, b ; case s is
when '0' => y <= a ;
when others => y <= b ;
end case ;
end process ;
end mux2a1 ;
Ejemplo 2-24. Escriba un programa en VHDL para obtener un flip flor tipo D con preset
sincrónico. Utlice la sentencia wait until.
-- Solución. Fichero: FFD_WAIT.VHD

LIBRARY ieee ;
ENTITY FFD_WAIT IS
PORT (d, pr_l, clk : in std_logic ;
q : buffer std_logic ) ;
END FFD_WAIT ;
ARCHITECTURE FFD_WAIT OF FFD_WAIT IS

BEGIN
Process
35
Begin
WAIT UNTIL (clk ='1' and clk'event) ;
If pr_l = '0' then q <= '1' ;
Else q <= d ;
End if ;
END Process ;
END FFD_WAIT ;
El wait for se utiliza mucho en los bancos de prueba, como se ilustra en el ejemplo 2-36.
Lazos en VHDL.
Son enunciados secuenciales, y por tanto, se utilizan dentro de un proceso o de un
subprograma. Hay tres tipos de lazos
a) El simple: Loop
b) El for loop (que es el más utilizado)
c) El while loop.
En la declaración de un lazo es opcional la utilización de etiquetas. La sintaxis de cada uno

de ellos es la siguiente:
a) Sintaxis para un loop sencillo:

Loop
...
End loop ;
b) Sintaxis para un For loop.

For identificador en un rango Loop
...
End loop ;
c) Sintaxis para un While loop:

While condicion Loop
...
End loop ;
En la ejecución de un lazo puede ordenarse la cancelación de una iteración y pasar a la

siguiente mediante la sentencia NEXT, cuya sintaxis es: Next When < condición > ;
36
También puede abandonarse la ejecución del lazo mediante la sentencia EXIT, cuya
sintaxis es la siguiente: Exit When < condición > ;
En los ejemplos 2-25 al 2-29 se muestra el empleo de los lazos en VHDL.
Ejemplo 2-25. Diseñe un CLC que cuente el número de unos que exista en una palabra de
n bit. Utilice For Loop.
-- Solución fichero: con_loop.vhd
ENTITY CON_LOOP is
GENERIC (K: integer := 4) ; -- K es una constante genérica.

PORT (n: in bit_vector (0 to K-1) ;
unos: buffer integer range 0 to K ) ;
END CON_LOOP ;
Architecture CON_LOOP_arch of CON_LOOP is
begin
process(n)
variable n_unos: integer range 0 to K ;
begin
n_unos := 0 ;
for j in n'range loop
if n(j)='1' then n_unos := n_unos + 1 ;
end if ;
end loop ;
unos <= n_unos ;
end process ;
end CON_LOOP_arch ;
Los resultados de la simulación confirman la validez del diseño realizado:
37
Ejemplo 2-26. Diseñe un CLC que cuente el número de unos que exista en una palabra de
n bit. Utilice While Loop.
-- Solución fichero: wh_loop.vhd
ENTITY wh_loop is
GENERIC (K: integer := 4) ; -- K es una constante genérica.
PORT (n: in bit_vector (0 to K-1) ;

unos: buffer integer range 0 to K ) ;
END WH_LOOP ;
Architecture WH_LOOP_arch of WH_LOOP is
begin
process(n)
variable n_unos: integer range 0 to K ;
variable J: integer range 0 to K ;
begin
n_unos := 0 ;
j := 0 ;
While j < k loop
if n(j ) = '1' then n_unos := n_unos + 1 ;
end if ;
j := j + 1 ;
end loop ;
unos <= n_unos ;
end process ;
end WH_LOOP_arch ;
Comparando la solución anterior con la correspondiente al ejemplo 2-25, se aprecia que la

utilización del for loop es más sencilla.
Ejemplo 2-27. Diseñe un CLC que cuente el número de unos que exista en el primer y
último nibble de una palabra de n bit. Utilice while loop, for loop, next y exit.
-- Solución fichero: nextexit.vhd
ENTITY nextexit is
GENERIC (K: integer :=9) ; -- K es una cte. genérica
38
PORT (n: in bit_vector (0 to K ) ;
p_nibble : buffer integer range 0 to 4 ;
u_nibble : buffer integer range 0 to 4 ) ;
END nextexit ;
architecture nextexit_arch of nextexit is
begin
process(n)
variable primero : integer range 0 to 4 ;

variable ultimo : integer range 0 to 4 ;
variable J: integer range 0 to K ;
begin
primero := 0 ;
j := 0 ;
While j < k loop
EXIT WHEN j = 4 ; -- Sale del lazo cuando j = 4.
if n(j)='1' then primero := primero + 1 ;
end if ;
j := j + 1 ;
end loop ;
p_nibble <= primero ;
ultimo := 0 ;
For j in 4 to k loop
NEXT WHEN j = 4 ; -- Pasa a la iteración siguiente.
NEXT WHEN j = 5 ; -- Pasa a la iteración siguiente.
if n(j) = '1' then ultimo := ultimo + 1 ;

end if ;
end loop ;
u_nibble <= ultimo ;
end process ;
end nextexit_arch ;
Ejemplo 2-28. Escriba un programa en VHDL para diseñar un CLC que funcione como un
conversor de código binario de 7 bit a código Hamming de 7 bit.
Vea otra solución y algunos aspectos relacionados con el código Hamming de 7 bit en el
Capítulo 3 (Ejemplo 3-18).
-- Solución fichero: c_bi_ha7.vhd
39
library IEEE ;
ENTITY c_bi_ha7 is
GENERIC (K: integer :=7) ; -- K es una cte. genérica
PORT ( h: in std_logic_vector (1 to K ) ;
hs: buffer std_logic_vector (1 to K ) ;
C, B, A : buffer std_logic ) ;
END c_bi_ha7 ;
architecture c_bi_ha7_arch of c_bi_ha7 is

begin
process (h)
variable Ci, Bi, Ai : std_logic ;

variable error : std_logic_vector (2 downto 0) ;
variable nh1, nh2, nh3, nh4, nh5, nh6, nh7: std_logic ;
begin
error := Ci & Bi & Ai ;
nh1 := not h(1) ; nh2 := not h(2) ; nh3 := not h(3) ;
nh4 := not h(4) ; nh5 := not h(5) ; nh6 := not h(6) ;
nh7 := not h(7) ;
Ai := h(1) ;
NEXT WHEN j = 4 ;
NEXT WHEN j = 6 ;
if h(j) = '1' then Ai:= not Ai ;
end if ;
end loop ;
Bi := h(2) ;
NEXT WHEN j=4 ;
NEXT WHEN j=5 ;
if h(j) = '1' then Bi:= not Bi ;
end if ;
end loop ;
Ci := h (4) ;
if h(j)= '1' then Ci:= not Ci ;
end if ;
40
end loop ;
A <= Ai ;
B <= Bi ;
C <= Ci ;
CASE error is
When "000" => hs <= h ;
When "001" => hs <= nh1 & h(2 to k) ;
When "010" => hs <= h(1)& nh2 & h(3 to k) ;
When "011" => hs <= h(1 to 2) & nh3 & h(4 to k) ;
When "110" => hs <= h(1 to 5) & nh6 & h(k) ;
When "111" => hs <= h(1 to 6) & nh7 ;
When others => NULL ; -- No hacer nada.
end case ;
end process ;
end c_bi_ha7_arch ;
Después de compilado, se realiza la simulación, que se muestra a continuación:
Ejemplo 2-29. Escriba un programa en VHDL para diseñar un CLC que permita obtener
en sus salidas el producto de una constante genérica por un número entero a, de tres bit.
-- Solución:
Library IEEE;
Entity producto is
GENERIC (
n : integer := 5 ; -- n es una constante genérica
41
m: integer := 7 ; -- m es una constante genérica
p: integer := 35 -- p es una constante genérica
);
Port (
a: in integer range 0 to m ;
Producto: out integer range 0 to p
) ;
end producto ;
Architecture producto_arch of producto is
begin
process (a)
variable ys: integer range 0 to p ;
variable j: integer range 0 to n ;
Begin
j:= 0 ;
ys:= 0 ;
WHILE j < n LOOP
ys := ys + a ;
j:= j + 1 ;
end loop ;
Producto <= ys ;
end process ;
end producto_arch ;
Después de compilar exitosamente el fichero anterior se realiza la simulación, cuyos

resultados son los esperados:
42
Sentencia GENERATE en vhdl.

La sentencia generate es útil para realizar un conjunto de sentencias concurrentes que sean
repetitivas.
La sintaxis para un for-GENERATE loop es la siguiente:
Etiqueta: for < identificador > in rango GENERATE

End Generate ;
En el ejemplo siguiente se ilustra la utilización de la sentencia generate:
Ejemplo 2-30. Utilice la sentencia generate y escriba un programa en VHDL para generar
un buffer de 8 líneas con tercer estado a partir de un buffer simple con tercer estado. El
circuito debe tener dos líneas de habilitación independientes que sirvan para manejar el
tercer estado de cada uno de los “nibbles” que constituyen los 8 bit de salida.
Solución:
-- Primero se escribe y se compila el programa correspondiente al buffer simple con tercer -

-- estado: fichero tri.vhd
Library IEEE ;
entity Tri is port (a, oe: in std_logic ;
y : out std_logic ) ;
end Tri ;
architecture Tri_arch of Tri is begin

y <= a WHEN oe = '1' ELSE
'Z' ;
end Tri_arch ;
-- Ahora se define un componente del buffer anterior, dentro de un paquete que llamaremos
– tripkg:
Library IEEE ;
PACKAGE tripkg IS
COMPONENT Tri port (a, oe : in std_logic ;
y : out std_logic ) ;
END COMPONENT ;
END TRIPKG ;
43
-- Finalmente se escribe el programa para generar las salidas deseadas.

-- fichero: buff_gen.vhd
library IEEE ;
use work.TRIPKG.all ; -- Hace visible el paquete que contiene el componente del buffer
-- simple.
entity buff_gen is
port ( rd : in STD_LOGIC_VECTOR (1 downto 0) ;
vin : in STD_LOGIC_VECTOR (7 downto 0) ;
vout : out STD_LOGIC_VECTOR (7 downto 0) ) ;
end buff_gen ;
architecture buff_gen_arch of buff_gen is

begin
gen: FOR j IN 0 to 3 GENERATE

u0: tri port map (vin(j), rd(0), vout(j) ) ;
u1: tri port map (vin(j+4), rd(1), vout(j+4) ) ;
end generate ;
end buff_gen_arch ;
Los resultados de la simulación de este circuito son los siguientes:
44
Operadores de desplazamiento
En VHDL hay seis operadores de desplazamiento que se identifican por las palabras claves:
ROR, ROL, SRL, SRA, SLA y SLL. Los dos primeros son de tipo circular y los cuatro
últimos son no circulares.
Se aplican a cadenas de tipo bit, la sintaxis para su empleo es la siguiente:

Cadena1 de bit <= Cadena2 de bit <Operador de desplazamiento> n ;
Donde n es un entero (positivo o negativo) que indica el número de bit que deben
desplazarse dentro de la cadena.
Las Cadena1 y Cadena2 pueden ser diferentes o iguales, como se ilustra en los Ejemplos 2-
31 y 2-32.
La acción que realiza cada uno de los operadores anteriores es la siguiente:
ROR n implica realizar una rotación hacia la derecha de n bit.
ROL n implica realizar una rotación hacia la izquierda de n bit.
SRL n implica realizar el desplazamiento hacia la derecha de n bit, insertando por la

izquierda n '0'.
SRA n implica realizar el desplazamiento hacia la derecha de n bit, insertando por la

izquierda n bit de igual valor al primer bit de la palabra original.
SLA n implica realizar el desplazamiento hacia la izquierda de n bit, insertando por la

derecha n bit de igual valor al primer bit de la palabra original.
SLL n implica realizar el desplazamiento hacia la izquierda de n bit, insertando por la

izquierda n '0'.
Lo anterior se resume en la tabla siguiente:
B A -- Resultado
B := "1100" ; A <= B ROR 6 ; -- “0011”
B := "1100" ; A <= B ROL 1 ; -- “1001”
B := "1100" ; A <= B SRL 2 ; -- “0011”
B := "1100" ; A <= B SRA 2 ; -- “1111”
B := "1100" ; A <= B SLA 2 ; -- “0000”
B := "1100" ; A <= B SLL 2 ; -- “0000”
B := "1100" ; A <= B ROR -1 ; -- “1001”
B := "1100" ; A <= B SRA -2 ; -- “0000”
45
Ejemplo 2-31. Escriba un programa en VHDL para comprobar los resultados dados en la
tabla anterior.
-- Solución: fichero: DES_ROT.VHD

Library IEEE ;
ENTITY DES_ROT IS
PORT (S: in bit_vector (2 DOWNTO 0) ;
A: out bit_vector (3 DOWNTO 0)) ;
END DES_ROT ;
ARCHITECTURE DES_ROT_ARCH OF DES_ROT IS

BEGIN
PROCESS (S)
VARIABLE B: bit_vector (3 DOWNTO 0):= "1100" ;
BEGIN
IF S = "000" THEN A <= B ROR 6 ; -- "0011"
ELSIF S = "001" THEN A <= B ROL 1 ; -- "1001"
ELSIF S = "010" THEN A <= B SRL 2 ; -- "0011"
ELSIF S = "011" THEN A <= B SRA 2 ; -- "1111"
ELSIF S = "100" THEN A <= B SLA 2 ; -- "0000"
ELSIF S = "101" THEN A <= B SLL 2 ; -- "0000"
ELSIF S = "110" THEN A <= B ROR -1 ; -- "1001"
ELSE A <= B SRA -2 ; -- "0011"
END IF;
END PROCESS ;
END DES_ROT_ARCH ;
La simulación confirma los resultados esperados:
46
Ejemplo 2-32. Escriba un programa en VHDL para obtener un contador de anillo de 4

estados, sin auto corrección, con un “uno” circulante, cuya tabla de funcionamiento es la
siguiente:
Q3 Q2 Q1 Q0
0 0 0 1
0 0 1 0
0 1 0 0
1 0 0 0
-- Solución: fichero: anillo_4.vhd
library IEEE;
use IEEE.std_logic_1164.all;
entity anillo_4 is
port (
CLK, CLR_L, PR_L : IN STD_LOGIC ;
Q: OUT BIT_VECTOR (3 downto 0)
) ;
end anillo_4 ;
architecture anillo_4_arch of anillo_4 is

signal IQ: BIT_VECTOR (3 downto 0) ;
begin
process (CLK, CLR_L)
begin
IF CLR_L = '0' then IQ <= X"0" ; --Reset asincrónico.
ELSIF rising_edge (CLK) then
IF PR_L = '0' then IQ <= X"1" ; --Preset sincrónico.
ELSE IQ <= IQ ROL 1 ;
END IF ;
END IF ;
End process;
Q <= IQ ;
end anillo_4_arch ;
La simulación permite comprobar el funcionamiento esperado:
47
Señales bidireccionales en VHDL.
Como se sabe el modo INOUT se utiliza en VHDL para las señales bidireccionales. En el
ejemplo que aparece a continuación se ilustra su utilización:
Ejemplo 2-33. Escriba un programa en VHDL para obtener un registro de desplazamiento

de 8 bit cuyas salidas sean bidireccionales y tengan la posibilidad de tercer estado.
LD 8 8
Reg q
CLK
SER
OE_L
-- Solución. Fichero: ent_sal.vhd

LIBRARY ieee ;
Entity ent_sal is
PORT (
LD_L, OE_L, SER, CLK : in std_logic ;
Q : inout std_logic_vector (7 downto 0)
) ;
End ent_sal ;
ARCHITECTURE ent_sal OF ent_sal is

SIGNAL reg : std_logic_vector (7 downto 0) ;
BEGIN
Process (clk)
Begin
If (clk = '1' and clk'event) then
48
if ld_l = '0' then reg <= q ;
else reg <= ser & reg (7 downto 1) ;
end if ;
end if ;
end process ;
with oe_l select

q <= (others => 'Z') WHEN '1',
reg WHEN OTHERS ;
End ent_sal ;
Los resultados de la simulación se muestran a continuación:
Assert-Report-Severity en VHDL.
Las palabras reservadas assert, report y severity en VHDL están asociadas con sentencias
que sirven para el control de la simulación.
La sintaxis para la sentencia assert-report es como sigue:
Assert <Condición>
Report “texto”
Severity Note, Warning, Error o Failure ;
Si la condición es falsa, se muestra en la pantalla el mensaje contenido en la cadena “texto”

y se envía un mensaje al simulador que incluso puede detener la ejecución de la simulación
de acuerdo a la palabra escrita en el programa después de Severity.
49
Assert-report se puede escribir tanto en el cuerpo de una arquitectura como de una entidad,
según se ilustra en los ejemplos siguientes:
Ejemplo 2-34. Escriba un programa en VHDL para diseñar un multiplexor como el

mostrado en la tabla siguiente:
Entradas de Salida
selección (Y)
(S)
00 C0
01 C1
10 C2
11 C3
-- Solución: MUX_A_R.VHD
Library IEEE;
Entity MUX_A_R is
Port (S: in bit_vector (1 downto 0) ;
C3, C2, C1, C0: in bit ;
salida : buffer bit ) ;
begin
assert (S = "00" or S = "01" or S = "10" or S = "11")
report "Las entradas S tienen un valor no permisible"
severity error ;
end MUX_A_R ;
Architecture MUX_A_R_arch of MUX_A_R is

begin
process (S, C3, C2, C1, C0)
begin
CASE S IS
When "00" => salida <= C0 ;
When OTHERS => salida <= C3 ;
END CASE ;
-- Assert report también pueden escribirse aquí:
-- assert (S = "00" or S = "01" or S = "10" or S = "11")
-- report "Las entradas S tienen un valor no permisible"
-- severity error ;
50
end process ;
end MUX_A_R_arch ;
Ejemplo 2-35. Repita el ejemplo anterior utilizando en la arquitectura sólo sentencias

concurrentes.
Solución:
-- fichero: mux_a_rc.vhd
library IEEE ;
ENTITY mux_a_rc IS
PORT ( S: in bit_vector (1 downto 0) ;
C3, C2, C1, C0: in bit ;
salida: buffer bit ) ;
begin
assert (S = "00" or S = "01" or S = "10" or S = "11")

report "Las entradas S tienen un valor desconocido"
severity error ;
END mux_a_rc ;
ARCHITECTURE mux_a_rc OF mux_a_rc IS

Begin
With S select
Salida <= C0 when “00”,
C1 when “01”,
C2 when “10”,
C3 when OTHERS ;
-- Assert-report también puede escribirse aquí:

-- assert (S = "00" or S = "01" or S = "10" or S = "11")
-- report "Las entradas S tienen un valor desconocido"
-- severity error ;
end mux_a_rc ;
Bancos de prueba en VHDL.
Entre las ventajas de VHDL se encuentra la posibilidad de escribir programas que actúen
como bancos de prueba para la simulación de los circuitos diseñados. Un banco de prueba
es un programa que permite aplicar los estímulos deseados al componente que está
sometido a prueba. En el caso de un componente sencillo el banco de prueba también será
muy simple; pero si el componente es complejo la escritura del banco apropiado puede
51
resultar incluso más difícil que el diseño del componente en sí mismo. Para aplicar el
banco de prueba es necesario disponer de un simulador VHDL.
A continuación se presenta un banco de pruebas muy simple que sirve, no obstante, para
ilustrar algunos aspectos básicos relacionados con los mismos:
Ejemplo 2-36. Escriba un fichero en VHDL para crear un banco de pruebas

correspondiente al diseño dado en el programa siguiente:
Entity and2 IS
PORT (A, B : in bit ;
Y : out bit ) ;
End and2 ;
Architecture and2_arch of and2 is

begin
y <= ‘1’ when a = ‘1’ and b = ‘1’ else
‘0’ ;
End and2_arch ;
-- Solución
-- Programa para el banco de prueba:
Entity banco IS
End banco ;
Architecture banco_arch of banco is
Component and2 PORT (A, B : in bit ;

Y : out bit ) ;
End component ;
Signal AT, BT, YT: bit ;
Begin
DUT : and2 PORT MAP (AT, BT, YT ) ;
Process
Begin
AT <= ‘0’ ;
BT <= ‘0’ ;
WAIT FOR 20 NS ;
AT <= ‘1’ ;
BT <= ‘0’ ;
WAIT FOR 20 NS ;
52
AT <= ‘0’ ;
BT <= ‘1’ ;
WAIT FOR 20 NS ;
AT <= ‘1’ ;
BT <= ‘1’ ;
WAIT ;
End Process ;
End banco_arch ;
En las referencias [3, 5, 6, 12] pueden encontrarse otros ejemplos de bancos de prueba.
Retardos en VHDL.
En VHDL se pueden introducir retardos durante la simulación de un modelo de manera que
éste refleje lo mejor posible el comportamiento real del circuito diseñado. Para ello se
utilizan las palabras reservadas AFTER, WAIT, INERTIAL, TRANSPORT y REJECT.
Ejemplo 2-37. Escriba un fichero en VHDL para obtener un multiplexor de cuatro canales
y una salida con demora de 25 ns entre la entrada D y la salida.
Entity MUX4 IS
PORT (A, B, C, D : in bit ;
S : in bit_vector (1 DOWNTO 0) ;
Y : out bit ) ;
End MUX4 ;
Architecture mux4_arch of mux4 is

Begin
Y <= A WHEN S= "00" ELSE

B WHEN S= "01" ELSE
C WHEN S= "10" ELSE
D After 25 ns ;
end mux4_arch ;
53
Atributos en VHDL.
Los atributos (attribute) en VHDL tienen diversos usos, uno de ellos es el de especificar los
terminales externos donde se desea que aparezcan determinadas señales. En el ejemplo
siguiente se ilustra este caso:
Ejemplo 2-38. Escriba un programa en VHDL para obtener las ocho compuertas lógicas.
Utilice los atributos para asignar las señales en terminales específicos, suponga que el
dispositivo programable es un 22v10 y que el terminal 1 no debe utilizarse.
Solución:
--Fichero puertas.vhd
Entity puertas is
port ( A, B : in bit ;
y_not, y_or2, y_and2 : out bit ;
y_nor2, y_nand2, y_xor2, y_xnor2, y_buffer: out bit ) ;
Attribute pin_numbers of puertas: entity is

"A:2 "&"B:3 "&"y_not:23 "&"y_or2:22 "&"y_and2:21 "
&"y_nor2:20 "&"y_nand2:19 "&"y_xor2:18 "&"y_xnor2:17 "&"y_buffer:16 " ;
END puertas ;
Architecture puertas of puertas is

begin
y_not <= not a ;
y_or2 <= a or b ;
y_and2 <= a and b ;
y_nor2 <= a nor b ;
y_nand2 <= a nand b ;
y_xor2 <= a xor b ;
y_xnor2 <= a xnor b ;
y_buffer <= a ;
end puertas ;
Después de compilar exitosamente el fichero anterior, obtenemos, entre cosas lo siguiente:

Las ecuaciones de diseño, la distribución de terminales del circuito integrado 22V10 que es
el utilizado en este diseño.
También se incluye un fragmento del fichero puertas.jed que es el que sirve para simular el
diseño y programar el dispositivo.
Finalmente se presentan los resultados de la simulación.
Una parte del fichero puertas.rpt es el siguiente:
DESIGN EQUATIONS (15:55:51)
54
y_buffer = a
y_xnor2 = /a * /b + a * b
y_xor2 = a * /b + /a * b
/y_nand2 = a * b
y_nor2 = /a * /b
y_and2 = a * b
/y_or2 = /a * /b
y_not = /a
DESIGN SIGNAL PLACEMENT (15:55:52)
C22V10
__________________________________________
not used *| 1 | |24|* not used
a=|2| |23|= y_not
b=|3| |22|= y_or2
not used *| 4 | |21|= y_and2
not used *| 5 | |20|= y_nor2
not used *| 6 | |19|= y_nand2
not used *| 7 | |18|= y_xor2
not used *| 8 | |17|= y_xnor2
not used *| 9 | |16|= y_buffer
not used *|10| |15|* not used
__________________________________________
Fragmento del fichero puertas.jed :
L00044
11111111111111111111111111111111111111111111
11111011111111111111111111111111111111111111
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
55
00000000000000000000000000000000000000000000
* Node y_not[23] => OE : 1 ,LOGIC : 8 *
L00440
11111111111111111111111111111111111111111111
11111011101111111111111111111111111111111111
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
* Node y_or2[22] => OE : 1 ,LOGIC : 10 *
L00924
11111111111111111111111111111111111111111111
11110111011111111111111111111111111111111111
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
* Node y_and2[21] => OE : 1 ,LOGIC : 12 *
L01496
11111111111111111111111111111111111111111111
11111011101111111111111111111111111111111111
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
56
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
* Node y_nor2[20] => OE : 1 ,LOGIC : 14 *
L02156
11111111111111111111111111111111111111111111
11110111011111111111111111111111111111111111
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
* Node y_nand2[19] => OE : 1 ,LOGIC : 16 *
L02904
11111111111111111111111111111111111111111111
11110111101111111111111111111111111111111111
11111011011111111111111111111111111111111111
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
* Node y_xor2[18] => OE : 1 ,LOGIC : 16 *
L03652
11111111111111111111111111111111111111111111
11111011101111111111111111111111111111111111
57
11110111011111111111111111111111111111111111
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
* Node y_xnor2[17] => OE : 1 ,LOGIC : 14 *
L04312
11111111111111111111111111111111111111111111
11110111111111111111111111111111111111111111
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
* Node y_buffer[16] => OE : 1 ,LOGIC : 12 *
L04884
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
* Not Used #[15] => OE : 1 ,LOGIC : 10 *
Los resultados obtenidos con la simulación son los siguientes:
58
59
Ejercicios.
2-1. Diseñe con VHDL un CLC que funcione de acuerdo a la tabla siguiente:
Entradas Salidas
G_L B A Y3 Y2 Y1 Y0
1 - - 1 1 1 1
0 0 0 1 1 1 0
0 0 1 1 1 0 1
0 1 0 1 0 1 1
0 1 1 0 1 1 1
(Utilice asignaciones condicionales del tipo: when ... else).
2-2. Repita el diseño del ejercicio anterior utilizando sentencias condicionales del tipo: if …
then … else (recuerde que estas sentencias sólo pueden emplearse dentro de un proceso o
de un subprograma).
2-3. Escriba la tabla de funcionamiento que corresponde al diseño

siguiente:
entity ejer2_3 is
port ( a, b : in bit_vector (3 downto 0) ;
S, EN_L : in bit ;
y : out bit_vector (3 downto 0) ) ;
end ejer2_3 ;
architecture ejer2_3 of ejer2_3 is

signal yi : bit_vector (3 downto 0) ;
begin
yi <= a when s = '0' else b ;
WITH EN_L SELECT

y <= yi when '0' ,
"0000" when others ;
end ejer2_3 ;
2-4. Escriba el programa dado en el ejercicio anterior; pero utilice asignaciones

condicionales de la forma: With ..... select ... when ... others.
2-5. Escriba un programa en VHDL para obtener un circuito en cuyas entradas se aplican
dos números (a, b) enteros de tres bit cada uno y que brinde en sus salidas la suma de los
60
mismos, su producto, el módulo de su diferencia o el cuadrado de su suma de acuerdo al
valor que tomen dos entradas adicionales de selección S1 y S0, según la tabla siguiente:
Entradas de selección Salida

S1 S0 Y
0 0 Suma de a y b
0 1 Producto de a y b
1 0 Módulo de la diferencia de a y b
1 1 Cuadrado de la suma de a y b
2-6. Escriba un programa en VHDL para diseñar un latch tipo D, cuya ecuación
característica es: Q* = D.C + Q./C, utilizando un procedimiento (procedure) definido en
la zona de declaraciones de la arquitectura.
2-7. Utilice el diseño jerárquico en VHDL y diseñe un CLC con tres entradas a,b,c y una
salida f que realice la función t ó la función w, dadas en la tabla, de acuerdo al valor que
tome una entrada adicional de selección, s . Cuando s = 0 la salida debe ser f = t y para s =
1 será f = w.
Entradas Salidas
c b a t w
0 - - 1 0
1 0 0 1 1
1 0 1 0 0
1 1 0 0 1
1 1 1 1 0
2-8. Utilice los bloques que sean necesarios y escriba un programa en VHDL para realizar
el diseño de un circuito que realice la función lógica y = a.b + c.d + e.
2-9. Escriba un programa en VHDL para obtener un contador binario descendente de 3 bit.
Debe tener la posibilidad de realizar la carga paralelo en forma asincrónica.
61
2-10. Escriba un programa en VHDL para obtener un flip flor tipo D con reset asincrónico.
2-11. Repita el diseño del ejercicio 2-1 utilizando un for Loop.
2-12. Escriba un programa en VHDL para obtener un contador de anillo de 8 estados, sin
auto corrección, con un “cero” circulante, cuya tabla de funcionamiento es la siguiente:
Q7 Q6 Q5 Q4 Q3 Q2 Q1 Q0
0 1 1 1 1 1 1 1
1 0 1 1 1 1 1 1
1 1 0 1 1 1 1 1
1 1 1 0 1 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 1 0 1 1
1 1 1 1 1 1 0 1
1 1 1 1 1 1 1 0
62

VHDL c02

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

VHDL c02

Загружено:

Авторское право:

Доступные форматы

CIME

Centro de Investigaciones en Microelectrónica

Capítulo 2. Lenguajes de descripción de hardware

Lenguajes de descripción de hardware. Introducción al VHDL.

Existen distintos tipos de HDL, generalmente se clasifican en tres niveles:

Estructura de VHDL. Como se planteó anteriormente, VHDL está formado por la

File texto (nombre.vhd)

Figura 2-1. Estructura de un modelo en VHDL

Sintaxis para la declaración de la entidad.

La declaración de las constantes genéricas dentro de la entidad antecede a la declaración del

Sintaxis para la definición de la arquitectura.

ARCHITECTURE nombre_arquitectura OF nombre_entidad IS

ARCHITECTURE and_2ent OF ejemplo1 IS

ARCHITECTURE and_2ent OF ejemplo1 IS

Esta es una forma posible de escribir el programa:

ENTITY ejemp2_3 IS -- Se cambió el nombre de la entidad

ARCHITECTURE dos_ent OF ejemp2_3 IS

En VHDL lo que se escribe después de -- es un comentario

Los resultados de la simulación confirman que se trata de la operación XOR:

En VHDL hay cuatro tipos de objetos: Constantes, señales variables y ficheros.

Constantes: Se declaran en la arquitectura antes de begin. Tienen tipo y no poseen modo.

Ejemplo de declaración de una constante:

Señales: Se declaran en la arquitectura antes de begin. Tienen tipo y no poseen modo.

La sintaxis para la declaración de las señales es la siguiente:

Signal < identificador > : tipo ;

Ejemplo de declaración de una señal:

La asignación del valor a una señal se realiza mediante <=

Variable: Se declaran en un proceso o en subprograma (función o procedimiento) antes del

La sintaxis para la declaración de una variable es la siguiente:

Ejemplo de declaración de una variable:

La asignación del valor a una variable se realiza mediante :=

Fichero (File) se utiliza para intercabiar información con el exterior. En su declaración se le

La sintaxis para la declaración de un fichero es la siguiente:

File < identificador > : tipo abrir_modo is < archivo > ;

El tipo está determinado por el tipo de los datos que contiene.

Ejemplo de declaración de un fichero:

File informe : Text open write_mode is C:\Trabajo\Monografia.txt ;

El fichero informe se abre en el modo de escritura con el objetivo de escribir información.

Si se omite el modo en la declaración del fichero, este se abrirá en el modo de lectura.

Modo de las señales.

IN, OUT, BUFFER, INOUT

IN En este modo las señales sólo entran en la entidad.

Cuando se omite el modo de una señal en la declaración de la entidad se sobreentiende que

Tipo de las señales.

Bit, boolean, std_logic, bit_vector, integer, std_logic_vector

Tabla 2-1. Algunas características de los tipos predefinidos en VHDL.

Debajo se muestran algunos de ellos:

Operadores Definidos en el lenguaje VHDL para los

Tabla 2-2. Algunos operadores en VHDL.

Asignaciones condicionales en VHDL.

WITH ..... SELECT ... WHEN ... OTHERS

WHEN ... ELSE ...

-- Solución. fichero: boole2_4.vhd

Entity boole4 is port (a, b: in boolean ;

architecture boole4_a of boole4 is begin

-- Solución. fichero: boole2_5.vhd

Entity boole5 is port (a, b : in boolean ;

Architecture boole5_a of boole5 is begin

En el Ejemplo 2-6 se ilustra la utilizacion en el mismo programa de las dos sentencias

Entradas de selección Salidas

-- Solución: fichero: aritmet1.vhd

Architecture aritmet1 of aritmet1 is

with suma select