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.

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?

VHSIC = Very High Speed Integrated Circuit �Circuitos Integrados de Muy Alta Velocidad�

HDL = Hardware Description Language �Lenguaje de Descripción de Hardware�

� 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.

Asignación Selectiva

Lista alternativas disponibles para cada valor de una expresión. Multiplexor 4 a 1:

-- 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;

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):

� Este proceso se ejecuta luego de un cambio en cualquier señal de la lista de sensibilidad. � Usando la sentencia Wait:

� Este proceso se ejecuta cuando la condición WAIT es verdadera � Utilice etiquetas para la organización de varios procesos:

PROCESS BEGIN WAIT condición

-- sentencia secuencial #1 -- ... -- sentencia secuencial #N

END PROCESS;

PROCESS (a, b, c, d) BEGIN

-- sentencia secuencial #1 -- ... -- sentencia secuencial #N

END PROCESS;

� 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:

NOMENCLATURA PARA DENOMINAR LOS FICHEROS QUE CONTIENEN

A LAS UNIDADES DE DISEÑO:

Contenido del fichero

Nombre del fichero

Una entidad y una arquitectura

Nombredelaentidad.vhd

Solo una entidad Nombredelaentidad_ent.vhd

abcd: PROCESS (a, b, c, d) BEGIN

-- sentencia secuencial #1 -- ... -- sentencia secuencial #N

END PROCESS abcd;

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;

Solo una arquitectura Nombredelaentidad_nombrearquitectura_arch.vhd Más de una arquitectura

Nombredelaentidad_arch.vhd

Solo una configuración Nombredelaentidad_nombredelaconfiguracion_cfg.vhd Más de una configuración

Nombredelaentidad_cfg.vhd

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 LÓGICOS

NOT, AND, OR, NAND, NOR, XOR

Tipo de operador: boolean Tipo de resultado: boolean

OPERADORES RELACIONALES = / < <= > >=

Tipo de operador: cualquier tipo Tipo de resultado: boolean

OPERADORES ARITMÉTICOS

+ - * / ** MOD, REM, ABS

Tipo de operador: integer, real, signal tipo de resultado: integer, real,signal

OPERADOR CONCADENACIÓN & Tipo de operador: array

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á:

Como ya se estudio anteriormente la parte de la arquitectura de VHDL es en esta parte donde se define que hará el programa:

---------------------------------------------------------------------------------- -- 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;

Para nuestro primer ejemplo haremos un multiplexor, y escribiremos después de bejín lo siguiente:

Nos quedaría el archivo así:

architecture Behavioral of Multiplexor is begin -- aquí es donde esta la funcionalidad del programa end Behavioral;

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;

------------------------------------------------------------------------------------ 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:

2. DECODIFICADOR 7 SEGMENTOS REALIZADO CON 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;

---------------------------------------------------------------------------------- -- 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