Dispositivos lógicos

Programables
y Lenguaje VHDL

Preparado por: Jairo M. Vergara

Ávila
(Diapositivas tomadas de varias fuentes de Internet)
 VHDL
VHSIC Hardware Design
Language

(VHSIC es acrónimo de ‘Very High Speed Integrated Circuits’)

 Historia
• El VHDL nace por iniciativa del Departamento de
Defensa de EE.UU. (comienzo de los 80)
• En julio de 1983 tres compañías (Texas Instruments,
IBM e Internetics) reciben el encargo de desarrollarlo
• La primera versión se publica en agosto de 1985
• En 1986 se convierte en un estándar del IEEE (IEEE
1076-1987)
• Posteriormente, con el estándar IEEE 1164 se le
añaden nuevas características
• El estándar 1076 debe ser revisado cada cinco años.
Actualmente rige el 1076-1993
 Principales ventajas
• Estándar público
• Independiente de la tecnología
• Soporta diferentes metodologías de
diseño
• Independiente del sistema de diseño
• Compatible
 DEFINICIÓN:
VHDL es un lenguaje de descripción de circuitos electrónicos
digitales que utiliza distintos niveles de abstracción.

El significado de las siglas VHDL es VHSIC (Very High Speed

Integrated Circuits) Hardware Description Language.

Esto significa que VHDL permite acelerar el proceso de diseño.

Los circuitos descritos en VHDL pueden ser simulados utilizando

herramientas de simulación para reproducir el funcionamiento del
circuito. Además utilizando herramientas de síntesis se puede
implementar dicho circuito en un dispositivo lógico programable o en
un circuito integrado.
MODELAJE DE HARDWARE
Al describir cualquier dispositivo en VHDL, el diseñador
debe definir tres elementos principales:

Librerías (LIBRARY). La librería estándar es siempre

visible. Si se requieren
utilizar otras librerías se deben importar.
La entidad (ENTITY). Especifica la interfaz del
circuito. Describe la forma de interconectar un bloque con
los demás (entradas, salidas)
La arquitectura (ARCHITECTURE). Es la descripción
interna del circuito. Describe el comportamiento lógico del
bloque
 Entidad
Las entidades definen el Nombre
de los puertos, el modo (entradas o
salidas) y el tipo (integer, bit,…) de
un circuito.

La declaración de las entidades es

análoga al símbolo esquemático de
lo que queremos implementar, el
cual describe las conexiones del
proyecto, es decir, si hay una
entrada o puerto de 8 bits o dos
salidas o puertos de 4 bits, etc.
 Arquitectura
Indica el tipo de procesamiento que se realiza con
las señales de entradas, (declarados en la entidad).
En ella reside todo el funcionamiento del circuito.

Si la entidad es vista como una “caja negra”, para lo

cual lo único importante son las entradas y salidas,
entonces, la arquitectura es el conjunto de detalles
interiores de la caja negra

La arquitectura presenta diferentes modelos, los

cuales son:
• - Algorítmico (funcional o comportamental ).
• - Flujo de datos.
• - Estructural.
COMPOSICIÓN DE UN
MODELO
Ejemplo:
Describir en VHDL, un circuito que multiplexe dos
líneas(a y b)
de un bit, a una sola línea de salida de un bit.
Modelo comportamental:
Mux 2x1:

SOLUCION:
ENTITY mux2 IS
PORT ( a, b: IN BIT;
selec: IN BIT;
salida: OUT BIT);
END mux2;
ARCHITECTURE comportamental OF mux2 IS
BEGIN
PROCESS (a, b, selec)
BEGIN
Un bloque PROCESS, se considera como una subrutina
IF (selec = ‘0’) THEN cuyas instrucciones se ejecutan secuencialmente cada
vez que algunas de las señales de la lista sensible
salida <= ‘a’; cambia. Esta lista sensible es una lista de señales que se
ELSE suele poner junto a la palabra PROCESS, como en el
ejemplo es (a, b, selec).
salida <= ‘b’;
END IF;
END PROCESS;
END comportamental;
Flujo de datos:
Mux 2x1:
tabla característica:

SELEC SALIDA
0 a
1 b
Expresión de la salida:
Luego el programa en VHDL es:Salida = a(selec) + b(selec)
ENTITY mux2x1 IS
PORT (a,b: in bit;
selec: in bit;
salida: out bit);
END mux2x1;
ARCHITECTURE mux OF mux2x1 IS
BEGIN
Salida <= ((a and (not selec)) or (b and selec));
END mux;
 Estructur
al:
Mux 2x1.
ENTITY Mux2x1 IS
PORT (a,b: IN bit;
selec: IN bit;
salida: OUT bit);
END Mux2x1;
--****************************
ARCHITECTURE estructural OF Mux2x1
IS
SIGNAL nosel, ax, bx : bit;

COMPONENT and2
PORT (e1,e2: IN bit; y: OUT bit);
END COMPONENT; BEGIN
u0: inv PORT MAP (e=>selec,
COMPONENT or2 y=>nosel);
PORT(e1,e2: IN bit; y: OUT bit); u1: and2 PORT MAP (e1=>a,
END COMPONENT; e2=>nosel, y=>ax);
u2: and2 PORT MAP (e1=>b,
COMPONENT inv e2=>sel, y=>bx);
PORT(e: IN bit; y: OUT bit); u3: or2 PORT (e1=>ax,
END COMPONENT; e2=>bx,y=>salida);
END estructural;
 LOGICA SECUENCIAL
Describir de forma comportamental, el funcionamiento de
un Flip-flop tipo D, el cual posee una entrada de reset y es
activo en alto.
entity ff is
port(d,clk,clr: in bit;
Q: out bit);
end ff;
architecture funcional of ff is
begin
process(clk,clr)
begin
if clr = '1' then
Q <='0';
elsif (clk'event and clk
='1') then
Q <= d;
end if;
end process;
end architecture funcional;
Operadores predefinidos
 PROCESO
• La manera más general de describir el comportamiento de
una arquitectura es mediante sentencias tipo proceso
• Un proceso puede contener órdenes secuenciales, pero todos
los procesos se ejecutan concurrentemente
• Las acciones descritas en el cuerpo del proceso se ejecutan
en orden, de la primera a la última
• Cuando se ejecuta la última acción se dice que el proceso
queda suspendido
• Cuando ocurre un cambio en una señal de la lista de
sensibilidades el proceso se inicia de nuevo, volviendo a
ejecutar las acciones de la primera a la última
 PROCESO
• Cada proceso se ejecuta una vez al comienzo de la
simulación para determinar el valor inicial de sus salidas
• Algunas sentencias sólo pueden aparecer en un proceso
porque implican ejecución secuencial: estructural de
ejecución secuencial

• Otras estructuras de ejecución secuencial:

• – Sentencia de espera: wait
• – Sentencia condicional: if...then...else
• – Sentencia de selección: case
• – Sentencia de bucles: for y while
Ejemplo de proceso
• – Nombre del proceso
• – Lista de sensibilidades
• – Declaración de variable
• – Inicialización de la variable
• – La variable cnt se incrementa cada vez que se ejecuta el
proceso
• – Esto ocurre al comienzo de la simulación y cada vez que
cambia la señal x

count: process (x)

variable cnt : integer :=
-1;
begin
cnt:=cnt+1;
end process;
 Declaración de constantes, variables y
señales
• Constantes: Es un elemento que se inicializa con un determinado valor y no
puede ser cambiado una vez inicializado.
Ejemplo: Constant e: real:= 2.71828;
Constant retraso: time:=10 ms;
********************************************************************************************
• Variables: Es lo mismo que una constante con la diferencia de que se valor
puede ser alterado en cualquier momento, a las variables también se les puede
asignar un valor inicial.
Ejemplo: Variable contador : natural := 00;
Variable aux: bit_vector (31 downto 00);
**********************************************************************************************
• Señales: Las señales se declaran igual a las constantes y variables con la
diferencia de que las señales pueden además ser de varios tipos: normal,
register y bus, por defecto son de tipo normal, a las señales también se les
puede asignar un valor inicial.
Ejemplo: Signal select: bit:= ‘0’;
Signal datos: bit_vector (7 downto 0) bus :=(“00000000”);
 Diferencias entre señales y variables
• Un bloque PROCESS es equivalente a una única instrucción concurrente
formada por numerosas instrucciones en series
• En un bloque PROCESS las SEÑALES conservan su valor y no cambian
hasta que el bloque termine de ejecutarse, momento en el cual, ya
tiene el valor que se les halla asignado durante la ejecución del
proceso debido a que se encontrará en el siguiente paso de simulación.
(es como si la señal tuviera un valor actual y otro valor en el estado
siguiente
• Las variables son algo diferentes. Puesto que las variables toman su
valor en el momento de la asignación, como ocurre en otros lenguajes
de programación.

• Estas diferencias se ven el siguiente ejemplo:

 Diferencias entre señales y
variables
-- Uso incorrecto de las señales
-- Uso correcto de las variables
ARCHITECTURE ejemp1 OF cosa IS
SIGNAL a,b,c,x,y: integer; ARCHITECTURE ejemp1 OF cosa IS
BEGIN SIGNAL a,b,x,y: integer;
p1: PROCESS(a,b,c) BEGIN
BEGIN
c<=a; -- Se ignora
p1: PROCESS(a,b)
x<=c+2; VARIABLE c: integer;
c<=b; -- Se mantiene BEGIN
y<=c+2;
c:=a; -- Inmediato
END PROCESS p1;
END ejemp1;
x<=c+2;
c:=b; -- Inmediato
y<=c+2;
END PROCESS p1;
END ejemp1
 Ejemplo sobre las diferencias entre señales y variables

Uso incorrecto de las señales Uso correcto de las

ARCHITECTURE ejemp1 OF cosa IS
variables
SIGNAL a,b,c,x,y: integer;
BEGIN
p1: PROCESS(a,b,c)
ARCHITECTURE ejemp1 OF
BEGIN cosa IS
c<=a; -- Se ignora SIGNAL a,b,x,y: integer;
x<=c+2;
c<=b; -- Se mantiene BEGIN
y<=c+2 p1: PROCESS(a,b)
VARIABLE c: integer;
BEGIN
c:=a; --
Inmediato
x<=c+2;
c:=b; --
Inmediato
y<=c+2;
END PROCESS p1;
EJEMPLOS
 DECODIFICADOR 3X8 CON
HABILITACION
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Deco3x8 is
Port ( Entradas : in STD_LOGIC_VECTOR (2 downto
0);
Habilitacion : in STD_LOGIC;
Salidas : out STD_LOGIC_VECTOR (7 downto
0);
end Deco3x8;
architecture Decodificador of Deco3x8 is
Begin
Habilitar_deco: process(Entradas,Habilitacion)
begin
If (Habilitacion = '1') then
case Entradas is
when "000" => Salidas <= "00000001";
when "001" => Salidas <= "00000010";
when "010" => Salidas <= "00000100";
when "011" => Salidas <= "00001000";
when "100" => Salidas <= "00010000";
when "101" => Salidas <= "00100000";
when "110" => Salidas <= "01000000";
when others => Salidas <= "10000000";
end case;
else Salidas <= "00000000";
end if;
DECODIFICADOR DE 2X4
ENTITY decod24 IS
PORT (f0,f1:IN BIT; s0,s1,s2,s3:OUT BIT);
END decod24;

ARCHITECTURE comportamiento OF decod24 IS

BEGIN
PROCESS (f0,f1)
BEGIN
IF f0='0' and f1='0' THEN
s0<='1' ;
s1<='0' ;
s2<='0' ;
s3<='0' ;
ELSIF f0='1' and f1='0' THEN
s0<='0' ;
s1<='1' ;
s2<='0' ;
s3<='0' ;
ELSIF f0='0' and f1='1' THEN
s0<='0' ;
s1<='0' ;
s2<='1' ;
s3<='0' ;
ELSIF f0='1' and f1='1' THEN
s0<='0' ;
s1<='0' ;
s2<='0' ;
s3<='1' ;
END IF;
END PROCESS;
END comportamiento;
 CODIFICADOR DE 4X2

ENTITY decod42 IS
PORT (f0,f1,f2,f3:IN BIT; salida:OUT BIT_VECTOR(1 DOWNTO 0));
END decod42;

ARCHITECTURE comportamental OF decod42 IS

BEGIN
PROCESS (f0,f1,f2,f3)
BEGIN
IF f0='1' and f1='0' and f2='0' and f3='0' THEN
salida(0)<='0' ;
salida(1)<='0' ;
ELSIF f0='0' and f1='1' and f2='0' and f3='0' THEN
salida(0)<='1' ;
salida(1)<='0' ;
ELSIF f0='0' and f1='0' and f2='1' and f3='0' THEN
salida(0)<='0' ;
salida(1)<='1' ;
ELSIF f0='0' and f1='0' and f2='0' and f3='1' THEN
salida(0)<='1' ;
salida(1)<='0' ;
ELSIF f0='0' and f1='0' and f2='0' and f3='1' THEN
salida(0)<='1' ;
salida(1)<='1' ;
END IF;
END PROCESS;
END comportamental;
 FLIP FLOP TIPO D

ENTITY biestable_D IS
PORT(D,clk:IN BIT;
Q,Q_menos: OUT BIT); ENTITY BIESTABLE_D IS
END biestable_D; PORT(D,CLK:IN BIT;Q:OUT BIT);
END BIESTABLE_D;
ARCHITECTURE comportamiento OF ARCHITECTURE COMPORTAMIENTO OF
biestable_D IS BIESTABLE_D IS
BEGIN BEGIN
PROCESS(CLK) PROCESS(CLK)
BEGIN BEGIN
IF CLK'EVENT AND clk='1' IF CLK'EVENT AND CLK='1' THEN
THEN CASE D IS
CASE D IS WHEN '1'=>
WHEN '1' => Q<='1';
Q<='1'; WHEN '0' =>
Q_menos<='0'; Q<='0';
WHEN '0' => END CASE;
Q<='0'; END IF;
Q_menos<='1'; END PROCESS;
END CASE; END COMPORTAMIENTO;
END IF;
END PROCESS;
END comportamiento;
Contador ascendente de 4 bits
library ieee;
use ieee.std_logic_1164.all;
use work.std_arith.all;

entity contador is
port(clk: in std_logic;
conta: buffer std_logic_vector(3 downto 0));
end contador;

architecture archicontador of contador is

begin
process (clk)
begin
if (clk'event and clk= '1') then
conta <= conta + 1;
end if;
end process;
end archicontador;
Contador ascendente con carga y reset

entity contador is
port(clk, load, reset:in std_logic;
data: in std_logic_vector(3 downto0);
conta:buffer std_logic_vector(3 downto 0));
end contador;

architecture archicontador of contador is

Begin
process (clk,reset)
begin
if reset = '1' then
conta <= "0000";
elsif (clk'event and clk= '1') then
if load = '1' then
conta <= data;
else
conta <= conta + 1;
end if;
end if;
end process;
end archicontador;
 Diseño de una Máquina de Estados

Se trata de diseñar una maquina de estados que active una salida S

cuando se detecta la secuencia …001... en una línea de datos E
sincronizada con un reloj. Este detector de secuencia se puede realizar con
una máquina de Moore de cuatro estados.

— S1: Esperar el l.er Cero de la secuencia.

— S2: Esperar el 2.° Cero de la secuencia.
— S3: Esperar el uno de la secuencia y activar la salida S cuando llega.
library IEEE;
use IEEE.std_logic_1164.all;

entity FSM is
port(reset, E, clk: in bit; O: out bit);
end FSM;

architecture ARCH of FSM is

type ESTADOS is (S1, S2, S3,S4);
signal ESTADO, SIG_ESTADO: ESTADOS;
Begin

SINCRONO: process(clk,reset)
begin
if reset ='1' then
ESTADO <= S1;
elsif clk'event and clk='1' then
ESTADO < = SIG_ESTADO;
end if;
end process SINCRONO;

CONTROL: process(ESTADO,E)
begin
case ESTADO is
when S1 =>
O <= '0';
if (E='0') then
 SIG_ESTADO <= S2;
else
SIG_ESTADO <= S1;
end if;
when S2 =>
O <= '0';
if (E='0') then
SIG_ESTADO <= S3;
else
SIG_ESTADO <= S1;
end if;
when S3 =>
O <= '0';
if (E='0') then
SIG_ESTADO <= S3;
else
SIG_ESTADO <= S4;
end if;
when S4 =>
O <= '1';
if (E='0') then
SIG_ESTADO <= S2;
else
SIG_ESTADO <= S1;
end if;
end case;
end process control;
end ARCH;
Tutorial Xilinx-ISE
Manejo básico
 XILINX ISE
La herramienta XILINX ISE (Integrated
Software Environment) es una
herramienta de diseño profesional, que
mediante la realización de circuitos
esquemáticos, o la utilización de lenguaje
de programación como el VHDL, nos
permite la simulación y la generación de
códigos ejecutables para programar
dispositivos lógicos.
 Creación de un nuevo proyecto

• Un proyecto es un conjunto de
ficheros, tales como esquemáticos,
líneas de códigos de programa
(utilizando un lenguaje de
programación), lista de
conexionados, librerías de
componentes, vectores de test para
simulación, etc., seleccionados para
un proyecto específico.
 Para crear un nuevo
proyecto
1. File  New Project.
2. Project Name  Colocar el nombre del proyecto
3. Project Location  Elegir la carpeta para guardar el proyecto
4. Top-Level Source Type  Seleccionar el método de trabajo,
Schematic o HDL (Si utiliza lenguaje de
programación VHDL)
5. Next
1. Family: Seleccionar según dispositivo a programar, CDLP(XC9500XL CPLDs ) o
FPGA (Spartan3E)
2. Device: CPLD ( XC9572XL) o FPGA(XC3500E)
3. Package: CPLD (PC44) o FPGA (FG320)
4. Preferred Language: VHDL
5. Next
1. New Source: Seleccionar la fuente del proyecto
2. En la nueva ventana que se despliega seleccionar: Shematic
(Esquemáticos) o VHDL Module según el método seleccionado
anteriormente.
3. File Name: Escriba el nombre del archivo
4. Next
1. Entity Name: Digite el nombre de la Entidad.
2. Architecture Name: Digite un nombre para la arquitectura (ojalá nombres
coherentes con el proyecto)
3. Port Name: Asigne el nombre de los puertos de entradas y salidas
4. Selecione la opción una de las opciones, in, out, inout según el diseño del
proyecto.
5. Si utilza vectores de entrada o salida habilite la opción de Bus y digite cual es
el bit mas significativo y el menos significativo (Por ejemplo si el vector es de 8
bits, entonces MSB = 7 y LSB = 0)
6.Next
1. Resumen del proyecto para su revisión, si existe
algún error oprima Back para regresar y corregir
2. Presione el botón Finish
Opción para crear un nuevo proyecto y un nuevo
archivo fuente, en nuestro caso oprima Next, Next.
Ventana donde se muestra las especificaciones del
proyecto.
Oprima Finish.
Empiece a desarrollar el programa (arquitectura) utilizando el
lenguaje VHDL y después proceda a generar el archivo de
programación (Generate Programming File)
(Ejemplo demostrativo)
Programa totalmente terminado y
compilado