Вы находитесь на странице: 1из 21

Sistemas digitales (VHDL)

LENGUAJE VHDL

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

INDICE

Descripción General ...................................................................................................................... 3


Tipos de datos predefinidos .......................................................................................................... 3
Operadores predefinidos .............................................................................................................. 6
La Declaración de Entidad y el Cuerpo de Arquitectura ............................................................... 6
Cuerpos de Arquitectura. Nociones Básicas ................................................................................. 8
Simulación del modelo VHDL ........................................................................................................ 9
Estilos de arquitecturas: .............................................................................................................. 10
Descripción de flujo de datos .................................................................................................. 10
Descripción de comportamiento............................................................................................. 12
Variables y Señales .................................................................................................................. 12
Sentencias secuenciales .......................................................................................................... 14
Ejemplos ...................................................................................................................................... 16
Compuerta tres estados ...................................................................................................... 16
Multiplexor .......................................................................................................................... 16
Sumador .............................................................................................................................. 17
Contador.............................................................................................................................. 17
SIMULACION................................................................................................................................ 20
REFERENCIAS BIBLIOGRAFICAS ................................................................................................... 21

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

Descripción General

• VHDL ignora los saltos de línea y espacios, por lo tanto el contexto formal de la
escritura del programa depende de la mejor inteligibilidad del mismo.
• Comentarios: Comienzan con dos guiones – y finaliza automáticamente con el final de
línea.
• Palabras clave, especiales o reservadas: Son cadenas de caracteres especiales
reservados por VHDL para su sintaxis. En el ejemplo pueden leerse varias ENTITY,
PORT, IN, OUT, ACHITECTURE, ETC.
• Identificadores: Son aquellas cadenas de caracteres que el diseñador utiliza para
nominar o identificar algo del diseño. En nuestro ejemplo: X, Y, Z, BIT, Compuerta, etc.
Hay algunos identificadores especiales que se usan para ciertos tipos de definiciones.
Es el caso de “BIT” en este ejemplo.
• Las palabras clave y los identificadores no reconocen diferencia entre mayúsculas y
minúsculas.

• Identificadores: Son cualquier cadena de caracteres que sirven para identificar


variables, señales, procesos, etc. Puede ser cualquier nombre compuesto por letras
y/o números, incluyendo el símbolo de subrayado "_". Las mayúsculas y minúsculas
son consideradas iguales, por lo tanto los identificadores SALIDA y salida representan
el mismo elemento. No debe contener los símbolos especiales mostrados
anteriormente, no debe empezar con número o subrayado, no debe acabar en
subrayado, ni puede contener dos subrayados seguidos. Ningún identificador debe
coincidir con alguna palabra reservada del lenguaje.
• Números: Por defecto los números se representan en base 10, se admite la notación
científica convencional. Para expresar números en una base diferente se usa el
símbolo “#”, ejemplo: 2#1100# (binario), 16#CF5A# (hexadecimal)
• Caracteres: Se representan entre comillas simples, ejemplo : ‘1’ , ‘3’, ‘a’
• Cadenas: Se representan entre comillas, ejemplo: “esto es una cadena”
• Cadena de bits: Para definir una cadena de bits, no necesariamente debe convertirse
a binario, pues puede usar la siguiente notación: B”100101” , O”1407” , X”FE4”

Tipos de datos predefinidos


Los tipos predefinidos –todos ellos declarados en los paquetes STD y
TEXTIO– son los siguientes:

✓ Enumerados:
CHARACTER: Formado por los 128 caracteres ASCII.
BOOLEAN: Definido sobre los valores (FALSE, TRUE).
BIT: Formado por los caracteres '0' y '1'
SEVERITY LEVEL: Formado por los valores (NOTE, WARNING, ERROR,
FAILURE).
✓ Escalares:
INTEGER y REAL: Con un rango que depende de cada herramienta.
✓ Arrays:
STRING: Definido como un array de caracteres.
BIT_VECTOR: Definido como un array de BIT.
✓ Físicos:
TIME: Definido para especificar unidades de tiempo.
✓ Tipos para operaciones de entrada/salida sobre ficheros:
LINE: Puntero a STRING.
TEXT: Fichero de STRINGS
SIDE: Enumerado sobre los valores (RIGHT, LEFT)

También existen subtipos predefinidos por restricción de rango:

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

NATURAL: desde 0 al máximo valor INTEGER.


POSITIVE: desde 1 al máximo valor INTEGER.
WIDTH: desde 0 al máximo valor INTEGER.

Algunos de los tipos de datos anteriores son similares a los de los lenguajes de
programación. Las operaciones disponibles para ellos, también. Los tipos BIT y BIT_VECTOR,
SEVERITY_LEVEL y TIME se proveen específicamente para el modelado hardware.

Los tipos BIT y BIT_VECTOR están orientados al modelado de niveles lógicos. Una de
sus principales características, la inexistencia de operaciones aritméticas predefinidas, ya ha
sido expuesta; las consecuencias que acarrea: su inadecuación para el modelado de
procesamiento aritmético, también. Igualmente limita su uso el hecho de no tener definidos
valores metalógicos que representen estados como el indeterminado o el de alta impedancia.

Hay que señalar que en la versión normalizada de las librerías de IEEE – en la de


Synopsys no– existe un paquete, denominado numeric_bit, donde se definen operaciones
aritméticas para estos tipos. Pero es una utilidad que apenas se utiliza, en primer lugar, por la
escasa –por tardía– difusión de la versión normalizada de la librería IEEE y, en segundo lugar,
porque no resuelve el problema de la indefinición de valores metalógicos y, como pronto se
verá, hay otros tipos disponibles que sí disponen de ellos.
Ejemplos:
SIGNAL nodo1, nodo2, nodo3: BIT;
SIGNAL bus_datos:BIT_VECTOR(0 TO 15);
CONSTANT dir : BIT_VECTOR(31 DOWNTO 0) := X”C3A9_0000”;
VARIABLE val_ini: BIT_VECTOR(63 DOWNTO 0) := (OTHERS => ‘0’);
En estos ejemplos pueden observarse algunos detalles sintácticos de interés:

➢ En una sentencia de declaración pueden declararse varios objetos si son de la misma


clase y comparten el tipo de datos.

➢ La fórmula de especificación del rango de un array es:


(limite_izquierdo TO/DOWNTO limite_derecho)

Si se utiliza la palabra DOWNTO, para definir un rango descendente, el límite


izquierdo debe ser mayor o igual que el derecho; si se utiliza TO, para definir un rango
ascendente, al revés. De acuerdo con esto, los siguientes rangos:

(0 TO 7)
(1 DOWNTO 0)

Son válidos, mientras que estos otros, no:

(7 TO 0)
(0 DOWNTO 1)

➢ La señal bus_datos es de tipo BIT_VECTOR, es decir, es un array de valores de tipo


BIT; por tanto es un STRING –un array de caracteres–, puesto que el tipo BIT se
define por enumeración de los caracteres cero
(‘0’) y uno (‘1’). Observe como se especifica el valor de un STRING, entre comillas, mientras
que en los caracteres se utilizan apóstrofes.

➢ En la inicialización de la constante dir se utiliza la base hexadecimal para evitar una


larga sucesión de ceros y unos. La letra que antecede a la ristra de números especifica
la base de numeración (O para octal, X para hexadecimal, B para binario; sin prefijo se
entiende que es binario); además pueden intercalarse “subrayados” para facilitar la
legibilidad.

➢ La fórmula (OTHERS => ‘0’) inicializa todos los valores del array a ‘0’. Su uso es
frecuente cuando se trabaja con vectores largos.

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

El modo de nombrar los arrays declarados –o a una parte de ellos– puede aprenderse en
los siguientes ejemplos:

val_ini(31 DOWNTO 0) := dir; -- Se asigna dir a una parte de val_ini


bus_datos(3) <= nodo1; -- Se asigna al elemento 3 nodo1
bus_datos (0 TO 2) <= nodo3 & nodo2 & nodo1;

En el último ejemplo, se utiliza el operador de encadenamiento, &, de modo que al


elemento 0 del array se le asigna el valor de nodo3, al 1 el de
nodo2 y al 2 el de nodo1 (obsérvese que bus_datos está declarado con rango ascendente; si
tuviera rango descendente, nodo1 se asignaría al elemento 0 y
nodo3 al 2).

El tipo TIME forma parte de una clase denominada tipos físicos. Estos tipos se definen
mediante una unidad básica, un conjunto de unidades secundarias y una restricción de rango.
Por ejemplo, la declaración del tipo TIME en el paquete STANDARD es:
-- predefined type TIME:
TYPE TIME IS RANGE
UNITS
FS;
PS = 1000 FS;
NS = 1000 PS;
US = 1000 NS;
MS = 1000 US;
SEC = 1000 MS;
MIN = 60 SEC;
HR = 60 MIN;
END UNITS;

Valores válidos de este tipo son, por ejemplo:

25 NS, 2.7 SEC, 5E3 PS, 2 HR


Que corresponden a 25 nanosegundos, 2’7 segundos, 5000 picosegundos y 2 horas.

Una variable o una constante –ya que no tiene sentido definir una señal con este tipo– de tipo
TIME se declaran así:

VARIABLE retardo: TIME;


CONSTANT dia: TIME:= 24 HR;

Los retardos que se especifican en las asignaciones de valor a señal deben ser valores u
objetos de tipo TIME:

Bus_datos(0 TO 2) <= “010” AFTER retardo;


Bus_datos(3) <= ‘0’ AFTER 3 MS;

Con los valores y objetos de tipo TIME pueden utilizarse operaciones aritméticas y de
comparación. Se reporta un error si la evaluación del resultado de una operación es un tiempo
(retardo) negativo.

El tipo SEVERITY_LEVEL se utiliza en sentencias de comprobación de condiciones,


para avisar sobre la gravedad de determinadas situaciones. Por ejemplo, para avisar del
incumplimiento de un tiempo de set-up de un flip-flop o abortar una simulación cuando se ha
producido una situación que da lugar a una alerta de nivel ERROR o FAILURE. Este tipo de
datos no dispone de operaciones.

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

Operadores predefinidos

La Declaración de Entidad y el Cuerpo de Arquitectura

La realización del modelo hardware de un dispositivo en VHDL consiste en la


elaboración de dos unidades de código VHDL: una Declaración de Entidad y un Cuerpo de
Arquitectura.

La Declaración de Entidad es la unidad de diseño VHDL que sirve para especificar el


interfaz de los dispositivos. Cumple, por tanto, funciones equivalentes a las de los símbolos en
las representaciones gráficas.
El Cuerpo de Arquitectura es la unidad de diseño VHDL que sirve para especificar el
funcionamiento de un dispositivo identificado por una determinada. Declaración de Entidad, por
lo que se puede considerar el equivalente a las tablas de verdad o a los cronogramas.

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

En la figura se muestra el código correspondiente al modelo de una puerta and de dos


entradas.
En la Declaración de Entidad se define el nombre del dispositivo y sus puertos; en el
Cuerpo de Arquitectura su funcionamiento, en este caso mediante una sentencia que utiliza un
operador lógico.

La construcción del modelo de un dispositivo en un entorno VHDL finaliza, en principio,


en el momento en que las unidades VHDL que lo describen quedan almacenadas en una
librería VHDL. Para ello hay que editar las unidades y compilarlas. En el proceso de
compilación se comprueba que no se incumplen una serie de reglas sintácticas y semánticas.

▪ Sintaxis Básica de la Declaración de Entidad


La sintaxis básica de la Declaración de Entidad es la siguiente:

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

Obviamente, el identificador que sigue a la palabra clave ENTITY es el nombre del


dispositivo. Los puertos del dispositivo se especifican, entre paréntesis, en la lista de interfaz de
la declaración de entidad, que es el campo señalado por la palabra clave PORT. Para cada
puerto hay que declarar:

✓ 1Su nombre: Los nombres de los puertos son etiquetas definibles por el usuario. No
pueden utilizarse palabras reservadas del lenguaje.

✓ Su dirección: La dirección del puerto se determina a partir de las características del


terminal del dispositivo que se desea modelar: los pines de entrada se definen como de
tipo IN, los de salida como OUT y los bidireccionales como INOUT.

✓ El tipo de datos que maneja el puerto: En los modelos VHDL hay que definir el tipo de
datos de los objetos. La elección del tipo de datos es muy importante, pues determina
el conjunto de valores que puede tomar el objeto declarado, así como las operaciones
(lógicas, aritméticas y de conversión de tipos) que se le pueden aplicar, cuestión
fundamental a la hora de describir el funcionamiento de los dispositivos.

En el ejemplo de la puerta and se utiliza el tipo BIT. En VHDL este tipo consta de dos valores,
los caracteres ‘0’ y ‘1’, sobre los que se definen las operaciones lógicas básicas y las de
comparación.

Cuerpos de Arquitectura. Nociones Básicas

La sintaxis básica de un Cuerpo de Arquitectura es la siguiente:

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

Las dos etiquetas que forman parte de la cabecera nombran a la propia


Arquitectura y a la Declaración de Entidad a la que esta asociada. La primera
vuelve a aparecer en la línea que cierra el Cuerpo de Arquitectura.
Por lo demás, se distinguen dos áreas para la inclusión de código con dos propósitos distintos:

✓ La comprendida entre la cabecera y la palabra BEGIN está destinada a la declaración


de objetos que se precisen para realizar la descripción del funcionamiento del
dispositivo.

✓ Entre la palabra BEGIN y END {arquitectura} se describe el funcionamiento.

En el ejemplo de la puerta and no se declara ningún objeto y la descripción del


funcionamiento se realiza utilizando una sentencia concurrente de asignación de valor a señal.

Simulación del modelo VHDL

La compilación exitosa de la Declaración de Entidad y la Arquitectura


VHDL garantiza que se cumplen una serie de reglas sintácticas y semánticas, pero no que el
hardware se haya modelado correctamente. Para probar el modelo es preciso simularlo.

Una simulación VHDL se realiza conectando el modelo en pruebas a un conjunto de estímulos


que permiten observar la respuesta del mismo. Para ello hay que construir un test-bench
(banco de test). A continuación se muestra un
test-bench VHDL que permitiría simular el modelo de la puerta and.

Como puede verse, consta, al igual que el modelo de un dispositivo, de una Declaración
de Entidad y un Cuerpo de Arquitectura, pero con las siguientes peculiaridades:

1. La Declaración de Entidad no tiene puertos.

2. En el Cuerpo de Arquitectura no se describe el funcionamiento de un dispositivo, sino que se


conecta el dispositivo a probar a un conjunto de señales (estímulos y salidas).

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

El conjunto de valores que toman los estímulos a lo largo del tiempo constituyen los vectores
de test que se aplican al modelo en pruebas.

Un simulador VHDL es capaz de ejecutar test-benches disponiendo, normalmente, de un


conjunto de utilidades que facilitan la depuración de los modelos y la revisión de resultados.

Estilos de arquitecturas:
La descripción puede ser de tres tipos:

a. 1.Descripción de flujo de datos


b. Descripción de comportamiento
c. Descripción estructural

Descripción de flujo de datos

A la hora de plantearse crear un programa en VHDL no hay que pensar como si fuera un
programa típico para ordenador. No hay que olvidar que en VHDL hay que describir un
hardware, algo que no se hace en un programa para ordenador. Un circuito electrónico puede
tener muchos elementos que estén ejecutando acciones a la vez, por ejemplo en un circuito
puede tener una entrada que se aplique a dos compuertas lógicas y de cada una obtener una
salida, en este caso tendría dos caminos en los que se ejecutarían acciones (las compuertas
lógicas) de forma paralela. Esto es lo que se llama concurrencia. VHDL es un lenguaje
concurrente, como consecuencia no se seguirá el orden en que están escritas las instrucciones
a la hora de ejecutar el código. De hecho, si hay dos instrucciones, no tiene porqué ejecutarse
una antes que otra, pueden ejecutarse a la vez.

Sentencias Concurrentes
La instrucción básica de la ejecución concurrente es la asignación entre señales a
través del símbolo <=. Para facilitar la asignación de las señales VHDL incluye elementos de
alto nivel como son instrucciones condicionales, de selección, etc., que se verán a
continuación.

WHEN... ELSE

Sentencia de selección múltiple. En hardware es necesario incluir todas las


opciones posibles. En este caso es obligatorio siempre acabar la expresión con un ELSE.

<señal> <= <asignación1> WHEN <condición1> ELSE


<asignación2> WHEN <condición2> ELSE
...
<asignaciónN> WHEN <condiciónN> ELSE
<asignaciónM>;

Un posible ejemplo de este tipo de sentencias podría ser la siguiente.

--------------------------------------------------------------------------------

s <= "00" WHEN a = b ELSE


"01" WHEN a > b ELSE
"11";

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

Siempre es obligatorio asignar algo, aunque es posible no realizar ninguna acción, para
ello se utiliza la palabra reservada UNAFFECTED. De esta forma se asignará el mismo valor
que tenía la señal.

s1 <= d1 WHEN control = '1' ELSE UNAFFECTED;


s2 <= d2 WHEN control = '1' ELSE s2;

Las dos sentencias anteriores parecen iguales, pero en la segunda se produce una
transacción, aspecto que en la primera no sucede.

WITH... SELECT... THEN

Es similar a las sentencias CASE o SWITCH de C. La asignación se hace según el


contenido de un objeto o resultado de cierta expresión.

WITH <señal1> SELECT


<señal2> <= <asignación1> WHEN <estado_señal1>,
<asignación2> WHEN <estado_señal2>,
...
<asignaciónN> WHEN OTHERS;
Un ejemplo de esta sentencia es la siguiente.

--------------------------------------------------------------------------------

WITH estado SELECT


Semaforo <= "rojo" WHEN "01",
"verde" WHEN "10",
"amarillo" WHEN "11",
"roto" WHEN OTHERS;

La cláusula WHEN OTHERS especifica todos los demás valores que no han sido
contemplados. También es posible utilizar la opción que se contempló en el caso anterior
(UNAFFECTED).

BLOCK

En ocasiones interesa agrupar un conjunto de sentencias en bloques. Estos bloques


permiten dividir el sistema en módulos, estos módulos pueden estar compuestos de otros
módulos. La estructura general es la siguiente.

block_id;
BLOCK(expresión de guardia)
cabecera
declaraciones
BEGIN
Sentencias concurrentes
END BLOCK block_id;

El nombre del bloque es opcional (block_id), al igual que la expresión de guardia. Un ejemplo
de esto podría ser el siguiente.

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

--------------------------------------------------------------------------------
latch: BLOCK(clk='1')
BEGIN
q <= GUARDED d;
END BLOCK latch;
--------------------------------------------------------------------------------

Descripción de comportamiento
Como la programación concurrente no siempre es la mejor forma de describir ideas,
VHDL incorpora la programación serie, la cual se define en bloques indicados con la sentencia
PROCESS. En un mismo diseño puede haber varios bloques de este tipo, cada uno de estos
bloques corresponderá a una instrucción concurrente. Es decir, internamente la ejecución de
las instrucciones de los PROCESS es serie, pero entre los bloques es concurrente.
A continuación se verán las estructuras más comunes de la ejecución serie y sus
características.

PROCESS

Un PROCESS, como se ha dicho antes, es una sentencia concurrente en el sentido de


que todos los PROCESS y todas las demás sentencias concurrentes se ejecutarán sin un
orden establecido. No obstante las sentencias que hay dentro del PROCESS se ejecutan de
forma secuencial.

Por lo tanto se puede decir que una estructura secuencial va en el interior de un


PROCESS.
La estructura genérica de esta sentencia es:

PROCESS [lista de sensibilidad]


[declaración de variables]
BEGIN
[sentencias secuenciales]
END PROCESS;

La lista de sensibilidad es una serie de señales que, al cambiar de valor, hacen que se ejecute
el PROCESS.

Un ejemplo sería:

PROCESS(señal1, señal2)

...
El PROCESS anterior sólo se ejecutará cuando señal1 o señal2 cambien de valor.

Variables y Señales

Hay que distinguir las señales y las variables, las señales se declaran entre
ARCHITECTURE y su correspondiente BEGIN mientras que las variables se declaran entre
PROCESS y su BEGIN.

Dentro de un PROCESS pueden usarse ambas, pero hay una diferencia importante
entre ellas: las señales sólo se actualizan al terminar el proceso en el que se usan, mientras

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

que las variables se actualizan instantáneamente, es decir, su valor cambia en el momento de


la asignación.

Unos ejemplos son:

--------------------------------------------------------------------------------

ENTITY ejemplo
PORT (c: IN std_logic;
d: OUT std_logic);
END ENTITY;

ARCHITECTURE ejemplo_arch OF ejemplo IS


SIGNAL a,b: std_logic;
BEGIN
PROCESS(c) 11

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

VARIABLE z: std_logic;
BEGIN
a<= c and b; --asignación de señales: después de ejecutarse esta línea a seguirá valiendo lo
mismo, sólo se actualiza al acabar el PROCESS

z:= a or c; --asignación de variables: en el momento de ejecutarse esta línea z valdrá a or c


(el valor que tenía a cuando empezó el PROCESS)

END PROCESS;

END ARCHITECTURE;

Sentencias secuenciales

❖ IF ... THEN ... ELSE

Permite la ejecución de un bloque de código dependiendo de una o varias condiciones.


IF <condición1> THEN
[sentencias 1]
ELSIF <condición2> THEN
[sentencias 2]
ELSE
[sentencias N]
END IF;

Un ejemplo es:

--------------------------------------------------------------------------------
IF (reloj='1' AND enable='1') THEN
salida<=entrada;
ELSIF (enable='1') THEN
salida<=tmp;
ELSE
salida<='0';
END IF;

--------------------------------------------------------------------------------

CASE

Es parecido al anterior porque también ejecuta un bloque de código condicionalmente,


pero en esta ocasión se evalúa una expresión en vez de una condición. Se debe recordar que
se deben tener en cuenta todos los casos, es decir, incluir como última opción la sentencia
WHEN OTHERS.

CASE <expresión> IS
WHEN <valor1> => [sentencias1]
WHEN <valor2> => [sentencias2]
WHEN <rango de valores> => [sentenciasN]
WHEN OTHERS => [sentenciasM]
END CASE;

Un ejemplo es: 12

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

--------------------------------------------------------------------------------

CASE a IS
WHEN 0 => B:=0;
WHEN 1 to 50 => B:=1;
WHEN 99 to 51 => B:=2;
WHEN OTHERS => B:=3;
END CASE;
--------------------------------------------------------------------------------

LOOP

LOOP es la forma de hacer bucles en VHDL. Sería el equivalente a un FOR o WHILE de un


lenguaje convencional.

Su estructura es:

[etiqueta:] [WHILE <condición> | FOR <condición>] LOOP


[sentencias]
[exit;]
[next;]
END LOOP [etiqueta];

Un ejemplo de bucles anidados es:

--------------------------------------------------------------------------------
bucle1: LOOP
a:=A+1
b:=20;
bucle2: LOOP
IF b < (a*b) THEN
EXIT bucle2;
END IF;
b:=b+a;
END LOOP bucle2;
EXIT bucle1 WHEN a>10;
END LOOP bucle1;

--------------------------------------------------------------------------------

Otro ejemplo, este con FOR es:

--------------------------------------------------------------------------------
bucle1: FOR a IN 1 TO 10 LOOP
b:=20;
bucle2: LOOP
IF b<(a*a) THEN
EXIT bucle2;
END IF;
b:=b-a;
END LOOP bucle2;
END LOOP bucle1;
--------------------------------------------------------------------------------

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

Ejemplos

Compuerta tres estados

El objetivo es crear una compuerta que tenga una señal de operación la cual, a estado
alto, habilite la salida, por lo tanto el valor de la entrada pasará a la salida. Cuando la señal de
operación esté a nivel bajo la compuerta no sacará una señal, es decir, estará en alta
impedancia.

Entradas:
entrada: entrada de datos.
op: señal que indica el modo de funcionar de la compuerta.
Salidas:
salida: salida de datos.

--------------------------------------------------------------------------------
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;

ENTITY triestado IS
PORT(op, entrada: IN std_logic;
salida: OUT std_logic);
END triestado;

ARCHITECTURE synth OF triestado IS


BEGIN
PROCESS(entrada,op)
BEGIN
IF op='1' THEN
salida <= entrada;
ELSE
salida <= 'Z';
END IF;
END PROCESS;
END ARCHITECTURE synth;

Multiplexor

El objetivo es crear un sistema que devuelva un valor dependiente de otra señal de


entrada, la cual será la encargada de seleccionar la salida. Además se definirán varias
entradas de datos que actuarán como salidas. Cuando la señal de selección este a cero no se
producirá ninguna salida, es decir el valor será cero.

Entradas:
EntradaX: entradas de datos.
sel: señal que indica la señal que va a ser devuelta.
Salidas:
salida: salida de datos.

library IEEE;
use IEEE.STD_LOGIC_1164.all;

ENTITY mux IS
PORT(c : IN std_logic_vector(3 DOWNTO 0);

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

sel : IN std_logic_vector(1 DOWNTO 0);


salida : OUT std_logic_vector(3 DOWNTO 0));
END mux;
ARCHITECTURE synth OF mux IS
BEGIN

PROCESS (sel, a, b, c) IS
BEGIN
CASE sel IS
WHEN "00" => salida <= (others => '0');
WHEN "01" => salida <= a;
WHEN "10" => salida <= b;
WHEN "11" => salida <= c;
WHEN OTHERS => salida <= (others => '0');
END CASE;
END PROCESS;
END synth;

Sumador

El objetivo es crear un sumador que dadas dos entradas de datos devuelva la suma de
estos.
Entradas:

a: operando 1.
b: operando 2.
Salidas:
salida: suma de las entradas.
--------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.all;

ENTITY sum IS
PORT (a : IN std_logic_vector(3 DOWNTO 0);
b : IN std_logic_vector(3 DOWNTO 0);
salida : OUT std_logic_vector(4 DOWNTO 0));
END sum;

ARCHITECTURE synth OF sum IS


BEGIN
PROCESS (a, b) IS
BEGIN
salida <= a + b;
END PROCESS;
END synth

Contador

El objetivo es crear un contador con dos salidas, las cuales corresponderán a un


contador rápido y a otro lento. Ademas, se dispondrá de cuatro señale de entrada, donde habrá
dos reseteadores (uno para cada contador) y dos enables, que permitirán la parada e inicio de
los contadores. También se incluirá el reset y el reloj del sistema.

Entradas:
rst: Reset del sistema. clk: Reloj del sistema. reset1: Reset del contador rápido.
reset2: Reset del contador lento.

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

enable1: Activación-Desactivación del contador rápido. enable2: Activación-Desactivación del


contador lento.
Salidas:
count1: Salida del contador rápido. count2: Salida del contador lento.
Los enables (enable1 y enable2) no actúan como enables puros, realmente cuando se produce
un evento en dicha entrada pasará a activarse o desactivarse el contador correspondiente.
--------------------------------------------------------------------------------
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.all;

ENTITY count IS
PORT (clk : IN std_logic;
rst : IN std_logic;
enable1 : IN std_logic;
enable2 : IN std_logic;
reset1: IN std_logic;
reset2 : IN std_logic;
count1 : OUT std_logic_vector (7 DOWNTO 0);
count2 : OUT std_logic_vector (31 DOWNTO 0));
END count;

ARCHITECTURE synth OF sum IS


SIGNAL cnt1 : std_logic_vector(7 DOWNTO 0) := (others => '0');
SIGNAL cnt2 : std_logic_vector(31 DOWNTO 0) := (others => '0');
SIGNAL en1 : boolean := false;

SIGNAL en2 : boolean := false;


BEGIN
pSeq : PROCESS (clk, rst) IS
BEGIN
IF rst = '1' THEN
cnt1 <= (others => '0');
cnt2 <= (others => '0');
ELSIF clk='1' AND clk'event THEN
IF en1 THEN
cnt1 <= cnt1 + 1;
END IF;
IF en2 THEN
cnt2 <= cnt2 + 1;
END IF;
END IF; 28

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

END PROCESS;
pCom : PROCESS (enable1, enable2) IS
BEGIN
IF enable1 = '1' THEN
en1 <= NOT en1;
END IF;
IF enable2 = '1' THEN
en2 <= NOT en2;
END IF;
END PROCESS;
count1 <= cnt1;
count2 <= cnt2;
END synth;

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

SIMULACION

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA


Sistemas digitales (VHDL)

REFERENCIAS BIBLIOGRAFICAS

[1] http://www1.frm.utn.edu.ar/tecnicad1/_private/Apuntes/VHDL.pdf

[2] https://www.researchgate.net/publication/273258300_Diseno_de_sistemas_digitales_con_VHDL

[3]
http://ciecfie.epn.edu.ec/wss/VirtualDirectories/80/pag_personales/PChico/Materiales_DLP/seminario
_folleto.pdf

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA

Вам также может понравиться