PRACTICA 12.

INTRODUCCION A VHD(VHDL)
Parte de este material está basado en fuentes de Internet.

Objetivos

! Utilizar el lenguaje VHD como herramienta de programación de

circuitos lógicos.
! Aprender a ejecutar y compilar programas propios, creados con el
lenguaje VHD con la ayuda del software ISE 81i de XILINX.

Generalidades de VHDL

El VHDL: VHDL = VHSIC + HDL.

VHSIC = Very High Speed Integrated Circuit

“Circuitos Integrados de Muy Alta Velocidad”

HDL = Hardware Description Language

“Lenguaje de Descripción de Hardware”

VHDL es un lenguaje textual de alto nivel que se utiliza para la descripción del
hardware de los sistemas digitales.

VHDL es un lenguaje estándar que se emplea para la documentación,

simulación, síntesis y verificación de sistemas digitales. Los lenguajes de
descripción de hardware, como el VHDL, facilitan la descripción de circuitos
integrados digitales complejos.

Por medio de éste, se puede describir el funcionamiento de un circuito lógico,

(combinacional o secuencial), por medio de sus ecuaciones lógicas, o por
diagramas de estados o tablas.

¿Por qué VHDL?

• Flexibilidad de implementación en circuitos integrados: código VHDL portable
entre herramientas, aunque normalmente es necesario hacer ajustes según el
dispositivo o la tecnología.
• Es un lenguaje popular cuyo número de usuarios sigue aumentando.

Ventajas:
– Proceso de desarrollo más confiable y automatizado
– Reducción de costo y tiempo de salida al mercado

VHDL: Orígenes y evolución

• Desarrollado en los comienzos de los 80’s como un método para la

descripción de sistemas electrónicos, para el Departamento de Defensa de
EE.UU. Su sintaxis es similar al lenguaje de programación Ada.
• Fue estandarizado en 1987, bajo la norma IEEE 1076. En 1993 salió una
revisión con algunas nuevas capacidades, manteniendo su compatibilidad con la
norma original.
• Es utilizado ampliamente en la industria y academia, sin embargo, otros
lenguajes como SystemC y SystemVerilog están ganando mayor atención y
popularidad.

¿Para qué sirve VHDL?

• Comienzos de los 90’s: diseño de ASICs complejos, empleando herramientas

de síntesis.
• Mediados de los 90’s: diseño con lógica programable.
• Se utiliza en la documentación, así como en la simulación del sistema, y
además se emplea para sintetizar la parte hardware del sistema digital.
• Actualmente se emplea en el modelamiento de todo el sistema digital
(hardware y software.)

Limitaciones de VHDL

• No permite describir sistemas analógicos. Sin embargo, ya se están

desarrollando versiones análogas y mixtas.
• No existe un estilo de descripción normalizado. Para síntesis se requiere
ajustar los estilos disponibles a la capacidad de las herramientas.
• Es posible sintetizar lógica solo de un subconjunto del lenguaje. Las
herramientas de síntesis no soportan los mismos subconjuntos, y existen a
veces diferencias al mudar de herramientas.
CONOCIENDO EL LENGUAJE:

Después de conocer las ecuaciones lógicas que rigen un circuito, o su diagrama

de estados (para los circuitos secuenciales), este puede llevarse a VHDL,
compilarse y obtenerse un archivo (.vhd), que permite por medio de un
programador universal y por medio del Software XILINX ISE 8.1i programar un
dispositivo, con la función que requiera el usuario; por medio del software
XILINX, también se pueden hacer pruebas al circuito para comprobar que el
diseño si este optimo o si es del caso hacer las correcciones necesarias.

VHDL tiene palabras y símbolos reservados, es decir, tienen un uso restringido

dentro del programa, por ejemplo no pueden hacer parte del nombre de
ninguna variable.

OPERACIONES LOGICAS EN VHDL

OPERACIÓN SIMBOLO
NOT Not
AND And
OR Or
XOR Xor

COMENTARIOS

Cuando se desea documentar un programa realizado, o se desea hacer un

comentario en un lugar especifico, se puede hacer uso de la siguiente sintaxis.

-- comentario
-------------------------------------------------------------------------------------------------
Ejemplo:

--esto es un cometario e vhdl

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

SINTAXIS DE VHDL
Entidad y Arquitectura – Tipos de datos
Señales y variables – Asignaciones – Procesos
Sentencia IF ELSE – Sentencia CASE
 Entidades y Arquitecturas

• Entidad => Indica QUE es el diseño.

– Define la interfaz de un bloque, sin definir su comportamiento.
Equivale a un símbolo en un diagrama esquemático.

• Arquitectura => Indica COMO trabaja el diseño.

– Modela el comportamiento o estructura del circuito.
– Una entidad puede contener varias arquitecturas.

• Entidad + Arquitecturas = opciones de diseño, diferentes soluciones para un

mismo problema.

Entidad

• Define la interfaz con el mundo exterior (i.e., pines de entrada y salida)

• Funciona como un símbolo esquemático, con la diferencia que se usa texto en
vez de símbolos gráficos

Arquitectura

• Define la implementación del diseño.

• La arquitectura puede definirse mediante asignaciones de expresiones lógicas,
interconexiones de componentes y sentencias de alto nivel.
• Funciona como un circuito esquemático.
Un ejemplo completo de vhdl:

Puertos, Señales y Variables

• Los puertos se especifican en la entidad:

IN Puerto de entrada
OUT Puerto de salida
INOUT Puerto bidireccional

• Las señales y variables se usan en la arquitectura

1. SIGNAL Se declara antes del BEGIN de la arquitectura y se puede

usar en cualquier lugar de ella. Si va en un proceso su valor se
actualiza al salir de él. La asignación usa el símbolo <=
2. VARIABLE Se declara y utiliza en un proceso y actualiza
inmediatamente su valor asignado. La asignación usa el símbolo
:=
 Tipos de Datos

• Cada señal debe tener un tipo de dato asociado, que se indica cuando la señal
es declarada. Tipos diferentes de datos no pueden asignarse unos a otros.
Todos los puertos, señales y variables deben ser de algún tipo de dato. Existen
tipos ya construidos pero también pueden crearse nuevos.

• TIME => 10 ns 2.5 ps

• BIT => ‘0’ ‘1’
• BIT_VECTOR => grupo de bits “00101101” “0101”
• STD_LOGIC = {‘0’, ‘1’, ‘X’, ‘Z’} más otros 5 tipos no usados para síntesis.
– ‘X’ (no ´x´) es valor de no importa.
– ‘Z’ (mayúscula) es valor de tres-estados.
• STD_LOGIC_VECTOR => p.e. “0Z1X011”
• Carácter => ‘A’ ‘x’ ‘7’
• Cadenas => “VHDL”
• Real => 1.23 -9.8

Tipo de Dato INTEGER

• Se comporta como un entero en álgebra

• El rango es especificado por el usuario o en su defecto por el compilador.
– El usuario puede especificar cualquier subrango:
ana :INTEGER range 0 TO 255;
felipe :INTEGER range 200 DOWNTO 54;
– Si el rango no es especificado será el rango por defecto determinado
por el compilador.
Pedro :INTEGER;

Buses

• VHDL ofrece tipos vectores para crear buses.

• Tipos de vectores comunes:
– BIT_VECTOR, STD_LOGIC_VECTOR
• Ejemplos
– SIGNAL andres :bit_vector(7 downto 0);
– SIGNAL estefi :std_logic_vector(3 downto 0);
– SIGNAL laura :std_logic_vector(1 to 3);
El MSB queda indicado por el índice de la izquierda: andres(7), estefi(3)
,laura(1)
El LSB queda indicado por el índice de la derecha: andres(0), estefi(0), laura(3)
 Asignación de Buses

• Bus completo
– pebbles <= “11111111”;
• Un bit de un bus
– dino (3) <= ‘1’;
• Una parte del bus
– SIGNAL picapiedras: bit_vector (7 downto 0);
– picapiedras (3 downto 2) <= “11”;
• Encadenación
– SIGNAL mas: bit_vector (8 downto 0);
– mas <= a(1) & b(3 downto 0) & ‘0’ & “010”;
• Agregado
– mas (3 downto 0) <= ( a (1), b(3), ‘0’, ‘1’);
– maz <= ( 3=> ‘1’, 1 downto 0 => ‘1’, 2 => L );
– max <= (3=> ‘1’, OTHERS => N );
La dirección del subrango debe ser igual como en la declaración del vector

Tipos Enumerados

• Los tipos enumerados son tipos creados por el usuario.

• Se emplean principalmente para las máquinas de estado.
• Los tipos se enumeran en una secuencia binaria, comenzando desde cero e
incrementándose de uno en uno.
• Ejemplos
– TYPE país IS (Alemania, Italia, Japón);
– TYPE luces IS (rojo, verde, ámbar, negro);

Asignaciones de Señales Concurrentes

• Simple
a <= r or t;
b <= ((r or t) and not (g xor h));

• Condicional
q <= ‘0’ WHEN clr = ‘0’ ELSE
‘1’ WHEN set = ‘1’ ELSE
‘X’;

• Selectiva
WITH sel SELECT
q <= a WHEN ‘0’,
b WHEN ‘1’;
Estas dos últimas asignaciones no se emplean dentro de los procesos.
Especifican los valores de las señales para cualquier combinación de las
entradas.
La síntesis crea puertas y conexiones lógicas. No se crean latches ni flipflops.

Asignación múltiple

• Cuando más una señal recibe dos asignaciones de señales separadas, se dice
que es manejada por múltiples fuentes.
• En esos casos, se necesita una Función de Resolución. Si no existe una
función de resolución la asignación múltiple resulta ilegal.
• El tipo std_ulogic no soporta asignación múltiple, pero si el tipo std_logic.

Asignación simple

• Es una asignación directa, como en una función booleana o matemática:

c <= a AND b; -- crea una puerta AND
d <= e; -- conecta dos nodos
x <= y + z; -- suma y con z, luego asigna el resultado a x

Compuertas lógicas:

entity compuertas is
Port (a : in STD_LOGIC;
b: in STD_LOGIC;
not_a : out STD_LOGIC;
a_and_b : out STD_LOGIC;
a_or_b : out STD_LOGIC;
a_xor_b : out STD_LOGIC;
a_nor_b : out STD_LOGIC;
a_nand_b : out STD_LOGIC);
end compuertas;
architecture Behavioral of compuertas is
begin
--esta es la parte de programación aquí esta la esencia del programa
a_and_b <= a and b;
not_a <= not a;
a_or_b <= a or b;
a_xor_b <= a xor b;
a_nor_b <=a nor b;
a_nand_b<= a nand b;
--hasta aquí
end Behavioral;
 Asignación Condicional

• Lista una serie de expresiones que son asignadas a una señal, luego de una
evaluación positiva de una o más expresiones booleanas. Cada expresión
booleana se valida en el orden escrito.

-- Multiplexor 2 a 1: f <= a si s = ‘0’, b si s = ‘1’

ARCHITECTURE mux OF Mux2a1 IS

BEGIN
f <= a WHEN s = '0' ELSE b;
END Mux2a1;

Asignación Selectiva

Lista alternativas disponibles para cada valor de una expresión.

Multiplexor 4 a 1:

ENTITY multiplexor IS
PORT (
d0, d1, d2, d3: IN BIT;
s: IN INTEGER RANGE 0 TO 3;
q: OUT BIT);
END multiplexor;
ARCHITECTURE flujo OF multiplexor IS
BEGIN
WITH s SELECT
output <= d0 WHEN 0,
d1 WHEN 1,
d2 WHEN 2,
d3 WHEN 3;
end flujo
 Procesos

• Un proceso define sentencias que se ejecutan en la secuencia descrita.

• Una sentencia Wait o una Lista de Sensibilidad describe las condiciones para
ejecutar la sentencia Process (Proceso).
• Dentro del proceso, las sentencias se ejecutan secuencialmente.
• Los procesos se comunican entre sí concurrentemente mediante señales.
• En un proceso pueden existir asignación de variables, de señales, llamadas a
procedimientos, sentencias IF, sentencias CASE, y sentencias iterativas.
• Una arquitectura puede contener más de un proceso.

La Sentencia Process

• Usando lista de sensibilidad (Sensitivity List):

PROCESS (a, b, c, d)
BEGIN
-- sentencia secuencial #1
-- ...
-- sentencia secuencial #N
END PROCESS;

• Este proceso se ejecuta luego de un cambio en cualquier señal de la lista de

sensibilidad.

• Usando la sentencia Wait:

PROCESS
BEGIN
WAIT condición
-- sentencia secuencial #1
-- ...
-- sentencia secuencial #N
END PROCESS;

• Este proceso se ejecuta cuando la condición WAIT es verdadera

• Utilice etiquetas para la organización de varios procesos:

 abcd: PROCESS (a, b, c, d)
BEGIN
-- sentencia secuencial #1
-- ...
-- sentencia secuencial #N
END PROCESS abcd;

• La etiqueta (label) identifica procesos específicos en una arquitectura de

múltiples procesos

Ejemplo de un Multiplexor 4 a 1 por medio de un proceso:

entity multiplexor is
Port (selector : in STD_LOGIC_VECTOR (1 downto 0);
entrada1 : in STD_LOGIC;
entrada2 : in STD_LOGIC;
entrada3 : in STD_LOGIC;
entrada4 : in STD_LOGIC;
salida: out STD_LOGIC);
end multiplexor;
architecture Behavioral of multiplexor is
begin
process (selector,entrada1,entrada2,entrada3,entrada4)
begin
case selector is
when "00" => salida <= entrada1;
when "01" => salida <= entrada2;
when "10" => salida <= entrada3;
when "11" => salida <= entrada4;
when others => salida <= '0';
end case;
end process;
end Behavioral;

NOMENCLATURA PARA DENOMINAR LOS FICHEROS QUE CONTIENEN

A LAS UNIDADES DE DISEÑO:

Contenido del Nombre del fichero

fichero
Una entidad y una Nombredelaentidad.vhd
arquitectura
Solo una entidad Nombredelaentidad_ent.vhd
Solo una arquitectura Nombredelaentidad_nombrearquitectura_arch.vhd
Más de una Nombredelaentidad_arch.vhd
arquitectura
Solo una configuración Nombredelaentidad_nombredelaconfiguracion_cfg.vhd
Más de una Nombredelaentidad_cfg.vhd
configuración
Test (test bench) Nombredelaentidad_tb.vhd
Paquete Nombredelaentidad_pkg.vhd

PALABRAS RESERVADAS

abs Else nand return

access Elsif new select
after End next severity
alias Entity nor signal
all Exit not subtype
and File null then
architecture For of to
array Function on transoprt
asser Generate open type
attribute Generic or units
begin Guarded others until
block If out use
body In package variable
buffer Inout port wait
bus Is procedure when
case Label process while
component Library range with
configuration Linkage record xor
constant Loop register
disconnect Map rem
downto Mod report
 SIMBOLOS RESERVADOS

OPERADORES NOT, AND, OR, Tipo de operador: boolean

LÓGICOS NAND, NOR, XOR Tipo de resultado: boolean

Tipo de operador: cualquier

OPERADORES
= / < <= > >= tipo
RELACIONALES
Tipo de resultado: boolean
Tipo de operador: integer,
OPERADORES + - * / ** real, signal
ARITMÉTICOS MOD, REM, ABS tipo de resultado: integer,
real,signal
OPERADOR Tipo de operador: array
&
CONCADENACIÓN tipo de resultado: array
( ) . , : ; ' < > = | # :=
--

Ejecución de ISE 8.1i de XILINX

INICIANDO ISE SOFTWARE:

Para iniciar el ISE, doble clic en el icono que se creo en el escritorio al instalar
el programa:

O se va por:

inicio programas -> Xilinx ISE 8.1i -> Project Navigator

Después de ejecutar el programa nos encontramos una ventana como la

FIGURA #1:
 FIGURA #1

Después de haber ejecutado el programa desde Windows, se accede a la

primera opción en la barra de tareas. Esta es la opción file, dentro de ella se
activa la opción new, Project; a continuación se desplegara una ventana como
la FIGURA #2:
 FIGURA # 2

Los datos a ingresar en la pantalla (figura # 2) anterior son:

1. Escriba el nombre del proyecto, es el campo de “project name”.
2. Busque la localización donde quiere guardar el proyecto. Lo puede hacer
con el botón de “ ...”.
3. Verifique que HDL este seleccionado en el campo de “top-Level source
Type”.
4. Clic en el botón de “next”.

La próxima ventana (FIGURA # 3) que sale, será la configuración del

dispositivo para el cual sé esta programando. Para nuestro ejemplo
utilizaremos:
 FIGURA # 3

Los datos a ingresar el la pantalla anterior (FIGURA #3) son:

1. Product Category: All
2. Family: Spartan3
3. Device: XC3S200
4. Package: FT256
5. Speed Grade: - 4
6. Top-Level Module Type: HDL
7. Synthesis Tool: XST (VHDL/Verilog)
8. Simulator: ISE Simulator (VHDL/Verilog)
9. Verifique que Enable Enhanced Design Summary este seleccionado.
10. Clic en “next” para crear un nuevo archivo VHDL.

Para la creación del primer archivo VHDL la ventana (FIGURA # 4) es:

 FIGURA #4

1. Clic en el botón “new source...” y aparecerá una ventana (FIGURA # 5)

así:

FIGURA #5

Los datos a ingresar en la pantalla anterior (FIGURA # 5) son:

1. Seleccione en el cuadro de la derecha “VHDL Module”.

2. Escriba el nombre de archivo “File name”.
 3. Revise que esta seleccionado el cuadro de “add to project”.
4. Clic en “next” y saldrá una ventana (FIGURA # 6) así:

FIGURA # 6

Los datos a ingresar el la pantalla anterior (FIGURA # 6) son:

1. Escriba el nombre de la entidad, por defecto aparecerá en nombre del

archivo.
2. Escriba el nombre de la arquitectura, por defecto aparecerá “Behavioral”
que es la estructura por defecto de ISE 8.1i.
3. Defina los nombres de los puertos, su tipo, es decir (in o out) si
manejaran bus, y si manejan definir su MSB y LSB.
4. Clic en “next” y saldrá una ventana como la FIGURA # 7:
 FIGURA # 7

Esta ventana (FIGURA # 7) es un resumen de todo lo definido en el archivo

VHDL que se va a crear.

1. Clic en “Finish” para terminar la creación del primer archivo VHDL de

nuestro proyecto. Esto nos devuelve a la ventana de creación de
archivos VHDL, pero esta vez aparecerá en nuestra pantalla (FIGURA #
8) El nombre del archivo que creamos:
 FIGURA # 8

1. Clic en “next” en la pantalla (FIGURA # 8) para pasar a la ventana de

agregar fuentes existentes (FIGURA # 9)
 FIGURA # 9

En la pantalla anterior (FIGURA # 9) podemos hacer:

1. Si no queremos adicionar nada damos clic en “next” para terminar la

creación de nuestro proyecto.
2. Si queremos adicionar a nuestro proyecto fuentes ya creadas
anteriormente damos clic en “add source”, la cual nos desplegara una
ventana como la FIGURA # 10:
 FIGURA # 10

1. Buscamos en la pantalla anterior (FIGURA #10) el archivo que

queremos agregar, y le damos en “abrir” y esto nos devuelve a la
pantalla anterior.

La FIGURA # 11 es la pantalla que aparecerá al darle clic en “next” en la

pantalla de adicionar fuentes existentes (FIGURA # 9).
 FIGURA # 11

La figura # 11 es una pantalla de resumen de lo que contiene el proyecto.

1. Clic en “finish” para concluir la creación del proyecto. Nos aparecerá una
ventana como la FIGURA # 12:
 FIGURA # 12

En la FIGURA # 12 nos muestra que automáticamente el programa nos carga

dos archivos:
1. El archivo VBHDL creado.
2. El Design Summary el cual contiene un resumen de todo lo relacionado
con el proyecto.

La plantilla que nos saldrá en nuestro archivo VHDL será:

 ----------------------------------------------------------------------------------
-- Company:
-- Engineer:
--
-- Create Date: 14:38:55 11/23/2006
-- Design Name:
-- Module Name: Multiplexor - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
Library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating

---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity Multiplexor is
Port (salida : out STD_LOGIC;
entrada1 : in STD_LOGIC;
entrada2 : in STD_LOGIC;
entrada3 : in STD_LOGIC;
entrada4 : in STD_LOGIC;
selector : in STD_LOGIC_VECTOR (1 downto 0));
end Multiplexor;
architecture Behavioral of Multiplexor is
begin
end Behavioral;

Como ya se estudio anteriormente la parte de la arquitectura de VHDL es en

esta parte donde se define que hará el programa:
 architecture Behavioral of Multiplexor is
begin
-- aquí es donde esta la funcionalidad del programa
end Behavioral;

Para nuestro primer ejemplo haremos un multiplexor, y escribiremos después

de bejín lo siguiente:

process (selector,entrada1,entrada2,entrada3,entrada4)
begin
case selector is
when "00" => salida <= entrada1;
when "01" => salida <= entrada2;
when "10" => salida <= entrada3;
when "11" => salida <= entrada4;
when others => salida <= '0';
end case;
end process;

Nos quedaría el archivo así:

----------------------------------------------------------------------------------
-- Company:
-- Engineer:
--
-- Create Date: 16:44:06 11/22/2006
-- Design Name:
-- Module Name: multiplexor - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating

---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity multiplexor is
Port ( selector : in STD_LOGIC_VECTOR (1 downto 0);
entrada1 : in STD_LOGIC;
entrada2 : in STD_LOGIC;
entrada3 : in STD_LOGIC;
entrada4 : in STD_LOGIC;
salida : out STD_LOGIC);
end multiplexor;
architecture Behavioral of multiplexor is
begin
process (selector,entrada1,entrada2,entrada3,entrada4)
begin
case selector is
when "00" => salida <= entrada1;
when "01" => salida <= entrada2;
when "10" => salida <= entrada3;
when "11" => salida <= entrada4;
when others => salida <= '0';
end case;
end process;
end Behavioral;
 DESCRIPCION DEL ENCABEZAMIENTO DE LOS ARCHIVOS

Estos trece campos que se tienen a continuación se usan para documentar el

programa, por lo tanto su uso no es obligatorio.

Company: “Quien es el propietario del programa”

Engineer: “Quien creo el programa”
Create Date: 16:44:06 11/22/2006 “Fecha de creación”
Design Name: “Nombre del diseño”
Module Name: Multiplexor - Behavioral “Nombre del modulo”
Project Name: “Nombre del proyecto al que pertenece el archivo”
Target Devices: “Tarjeta del dispositivo a utilizar”
Tool versions: “Versión de la herramienta”
Description: “Descripción del lo que hace el archivo”
Dependencies: “Dependencias del archivo”
Revision: “Número de revisiones hechas”
Revision number: 0.01 - File Created
Additional Comments: “Comentarios adiccionales”

Nota: todo esto tiene que estar declarado como comentario.

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

Compilación de lógica combinatoria

Para compilar en la ventana secundaria (FIGURA #13) que se abre

automáticamente el lado derecho de la ventana hay una opción de “synthesize
– XST” darle clic en el "+" que esta a su lado y desplegara las opciones
disponibles:
 FIGURA # 13

Esto es lo que se despliega al darle clic en el “+” (FIGURA # 14), para mirar
o chequear la sintaxis damos clic en la opción “Check Syntax”, esto nos dirá
donde están los errores para poder corregirlos.

FIGURA # 14
La FIGURA # 15 es la que nos muestra donde sale los comentarios de la
compilación:

FIGURA # 15

Simulación en ISE 8.1i y Download Design to the Spartan™-3

Demo Board

Para simular nuestro Circuito, se hace por medio de test de bench.

Para ver un ejemplo de simulación y de cómo quemar ir a “help” en la barra

de Herramientas y luego seleccionar “tutorials” y luego darle clic el “ISE quick
start”.
 Ejemplos de un programa.

1. COMPUERTAS LOGICAS:
----------------------------------------------------------------------------------
-- Company: eafit
-- Engineer: monitoria
--
-- Create Date: 13:33:58 11/21/2006
-- Design Name:
-- Module Name: compuertas - Behavioral
-- Project Name: tutorial
-- Target Devices:
-- Tool versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating

---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity compuertas is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;
not_a : out STD_LOGIC;
a_and_b : out STD_LOGIC;
a_or_b : out STD_LOGIC;
a_xor_b : out STD_LOGIC;
a_nor_b : out STD_LOGIC;
a_nand_b : out STD_LOGIC);
end compuertas;

architecture Behavioral of compuertas is

begin
--esta es la parte de programacion aqui esta la esencia del programa
a_and_b <= a and b;
not_a <= not a;
a_or_b <= a or b;
a_xor_b <= a xor b;
a_nor_b <= a nor b;
a_nand_b<= a nand b;
--asta aqui
end Behavioral;

2. DECODIFICADOR 7 SEGMENTOS REALIZADO CON COMPUERTAS

LOGICAS:
----------------------------------------------------------------------------------
-- Company: eafit
-- Engineer: monitora
--
-- Create Date: 14:55:49 11/21/2006
-- Design Name:
-- Module Name: decodificador - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating

---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity decodificador is
Port ( a1 : in STD_LOGIC;
b1 : in STD_LOGIC;
c1 : in STD_LOGIC;
d1 : in STD_LOGIC;
a : out STD_LOGIC;
b : out STD_LOGIC;
c : out STD_LOGIC;
d : out STD_LOGIC;
e : out STD_LOGIC;
f : out STD_LOGIC;
g : out STD_LOGIC);

end decodificador;

architecture Behavioral of decodificador is

begin

a <= ((a1 or (not b1)) and c1) or (b1 xnor d1);

b <= ((not b1 or c1 )and d1) or (not c1 and not d1);

c<= (not b1) and (c1 or not b1);
d <= (c1 and (not d1 or not b1)) or (not b1 and not d1) or (b1 and not d1 and d1);
e <= not d1 and ((c1 or not b1));
f <= (a1 or (b1 and not d1)) or (not c1 and (b1 or not d1));
g <= (a1 or (not b1 and c1)) or (b1 and (not d1 or not c1));

end Behavioral;
 3. DECODIFICADOR 7 SEGMENTOS REALIZADO POR PROCESOS:

----------------------------------------------------------------------------------
-- Company:
-- Engineer:
--
-- Create Date: 10:33:33 11/22/2006
-- Design Name:
-- Module Name: decodificador2 - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating

---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity decodificador2 is
Port ( clock : in STD_LOGIC;
entrada : in STD_LOGIC_VECTOR (3 downto 0);
salida : out STD_LOGIC_VECTOR (7 downto 0));
end decodificador2;

architecture Behavioral of decodificador2 is

begin
process(clock)
begin
if ( clock'event and clock ='1') then
case entrada is
when "0000" => salida <= "11111100";
when "0001" => salida <= "01100000";
when "0010" => salida <= "11011010";
when "0011" => salida <= "11110010";
when "0100" => salida <= "01100110";
when "0101" => salida <= "10110110";
when "0110" => salida <= "00111110";
when "0111" => salida <= "11100000";
when "1000" => salida <= "11111110";
when "1001" => salida <= "11100110";
when others => salida <= "00000000";
end case;
end if;
end process;
end Behavioral;
 4. MAQUINA DE DULCES REALIZADO CON COMPUERTAS LOGICAS:

----------------------------------------------------------------------------------
-- Company: eafit
-- Engineer: monitora
--
-- Create Date: 11:42:57 11/22/2006
-- Design Name:
-- Module Name: dulces - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating

---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity dulces is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;
c : in STD_LOGIC;
salida : out STD_LOGIC);
end dulces;

architecture Behavioral of dulces is

begin
-- * = and = &
-- + = or = #
-- | = not =!
-- !$ = xnor = !$
-- B& A+ C&A + C &B
salida <= (b and a)or (c and a) or (c and b);
end Behavioral;
 5. MAQUINA DE DULCES REALIZADO POR PROCESOS:

----------------------------------------------------------------------------------
-- Company:
-- Engineer:
--
-- Create Date: 16:13:13 11/22/2006
-- Design Name:
-- Module Name: dulces - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating

---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity dulces is
Port ( clock : in STD_LOGIC;
entrada : in STD_LOGIC_VECTOR (2 downto 0);
salida : out STD_LOGIC);
end dulces;

architecture Behavioral of dulces is

begin
process(clock)
begin
if ( clock'event and clock ='1') then
case entrada is
when "011" => salida <= '1';
when "101" => salida <= '1';
when "110" => salida <= '1';
when "111" => salida <= '1';
when others => salida <= '0';
end case;
end if;
end process;
end Behavioral;
Equipo

! Chip XC3S200

! Software ISE 8.1i DE XILINX

Procedimiento