Curso VHDL – Simulación

En la tercera entrega de este tutorial, creamos nuestro primer módulo VHDL, una compuerta AND de dos entradas. Es un módulo muy simple y sencillo, pero crearlo nos permite familiarizarnos de manera más fácil con el entorno de trabajo.
Una vez que hemos verificado la sintaxis del código de nuestro módulo, una forma de verificar que funcione y se comporte como deseamos es realizar una simulación. Dependiendo del entorno de trabajo serán las herramientas de simulación que tendremos a nuestra disposición, nosotros usaremos ISim, un simulador que viene integrado en ISE Design Suite y que sirve perfectamente para nuestros propósitos.

Veamos cómo realizar una simulación de nuestro componente compuerta_and.
Primero, en Project Navigator, en la sección Design, en la opción View, debemos seleccionar Simulation:

A continuación, dentro de la ventana Hierarchy, seleccionamos el componente que deseamos simular, al hacerlo cambiarán las opciones disponibles en la ventana Processes, en este caso se muestra ISim Simulator, hacemos clic en el signo “+” a la izquierda de ISim Simulator y nos mostrará dos procesos: Behavioral Check Syntax y Simulate Behavioral Model
Este último proceso es el que nos permitirá realizar la simulación, hacemos doble clic y esperamos a que se abra ISim:

ISim muestra por defecto cuatro ventanas o secciones, una en la parte inferior y tres en el medio: Instances and Processes, que nos muestra las entidades, bibliotecas y procesos existentes en nuestro módulo; Objects, que despliega una lista de los puertos que forman parte de nuestro módulo, indicando con pequeño icono con la letra I aquellos que son entradas y con la letra O los que son salidas; y la ventana de simulación, donde tenemos desplegados nuevamente los puertos del módulo con líneas de tiempo que nos permitirán visualizar el comportamiento de cada uno de dichos puertos para cada instante de la simulación.
Vamos a recordar ahora la tabla de verdad de una compuerta AND de dos entradas:

B A S
0 0 0
0 1 0
1 0 0
1 1 1


Tenemos cuatro combinaciones posibles de valores para las entradas A y B, para comprobar el funcionamiento de nuestro módulo es conveniente simular estos cuatro casos, para ello, asignaremos valores a las entradas de manera que tengamos las cuatro combinaciones posibles y podamos evaluar el valor que toma la salida para cada una de ellas.
Empezaremos por la primera combinación, cuando ambas entradas valen 0, para indicar que una entrada tendrá el valor 0 en el simulador, hacemos clic con el botón derecho del ratón sobre dicha entrada en la ventana de simulación, del menú que se despliega seleccionamos la opción Force Constant…
Aparecerá la ventana Force Selected Signal, en la opción Force to Value: escribiremos un 0:

Hacemos clic en el botón OK. Repetiremos estos pasos para la señal de entrada b: hacemos clic con el botón derecho sobre el nombre de la entrada en la ventana de simulación, seleccionamos la opción Force Constant…, y establecemos a 0 la opción Force to Value:, hacemos clic en el botón OK.
No se nota ningún cambio en la ventana de simulación una vez que hemos indicado los valores de 0 para las dos señales, estos se notarán hasta que ejecutemos la simulación. Para ello haremos uso de la barra de herramientas ISim:
.
Haremo clic en el botón que tiene como icono una punta de flecha y un reloj de arena, se ejecuta la simulación por un tiempo determinado, el que se indica a la derecha del botón, en este caso, 1 us, la ventana de simulación ahora mostrará:

Observemos que en los valores en la columna Value han cambiado de U a 0, la U indica valor desconocido, que era el caso antes de iniciar la simulación, ahora que hemos simulado por un tiempo de 1us, las entradas se encuentran en valores 0, que fue como nosotros lo “forzamos”, además la señal de salida s también tiene el valor 0, esta no la hemos forzado, sino que toma el valor de acuerdo a lo que hemos especifidado en nuestro módulo: la operación AND entre las entradas a y b, que en este caso es 0.
Ahora, vamos a cambiar el valor de la entrada a a 1, para evaluar el segundo caso de la tabla de verdad de la operación AND de dos entradas, hacemos clic con el botón derecho sobre el nombre de la señal y seleccionamos el comando Force Constant…, y ahora pondremos un 1 en la opción Force to value:
, hacemos clic en el botón para ejecutar la simulación por cierto tiempo y ahora tendremos en la ventana de simulación:

La columna Value ha cambiado a 1 para el caso de la señal a, además, en la ventana de tiempo la línea verde a la derecha de la misma señal se encuentra más arriba y ahora con una zona sombreada debajo, esto indica que durante ese tiempo la señal se encuentra en un estado alto (1). La señal de salida s se mantiene en 0, que es correcto pues solamente cambiará de estado cuando ambas entradas sean 1. Ahora simulemos el tercer caso de la tabla de verdad, cuando a vale 0 y b vale 1:

Ahora la señal se mantiene en alto durante el tiempo de la simulación, pero la salida s se mantiene en 0. Finalmente simulemos el caso cuando ambas entradas valen 1:

Finalmente, la salida s ha cambiado a 1, lo cual corresponde con la tabla de verdad de la operación AND, así hemos comprobado que nuestro componente funciona correctamente.
Si lo han notado, en cada paso, en la ventana de simulación apareció a la derecha un valor con letras amarillas que cambió de 1,000,000 ps a 2,000,000 ps en el primer tiempo de simulación, y así hasta llegar a 5,000,000 ps. Esto nos indica que entre cada paso avanzamos 1 us, que es el tiempo que configuramos en la barra de herramientas, podemos visualizar la simulación completa si hacemos clic en el botón Zoom to Full View:

Podemos ver los cuatro pasos de simulación que ejecutamos, y apreciamos por completo que corresponden con la tabla de verdad de nuestro componente.
Ahora, agregaremos un par de componentes más: una compuerta OR y otra XOR. Podemos cerrar ISim y volvemos a Project Navigator, desde el menú Project seleccionamos New Source…, o también podemos hacer clic con el botón derecho sobre el nombre del proyecto o del dispositivo para el cual está destinado y también tendremos la opción New Source…. Indicamos que agregaremos un módulo VHDL y como nombre de archivo pondremos compuerta_or, hacemos clic en el botón Next, en esta ocasión solamente no cambiaremos nada en la ventana Define Module

hacemos clic en el botón Next y después en Finish.
Tendremos el nuevo módulo compuerta_or en la ventana Hierarchy, en el editor estará el código generado por Project Navigator:

----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    22:46:05 11/19/2010 
-- Design Name: 
-- Module Name:    compuerta_or - 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;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity compuerta_or is
end compuerta_or;

architecture Behavioral of compuerta_or is

begin


end Behavioral;

Ahora, vamos a editarlo, en cuanto a los comentarios, haremos algo similar a lo que realizamos al crear el módulo compuerta_and:

----------------------------------------------------------------------------------
-- Compuerta OR de dos entradas
-- Mexchip - Tutorial VHDL
-- Noviembre 2010
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

Después, tenemos el código que declara la entidad compuerta_or, pero no tenemos ninguna señal declarada, hagámoslo ahora, de manera similar al componente compuerta_and, las entradas se llamarán a y b, mientras que la salida s

entity compuerta_or is
	port (
		a : in std_logic;
		b : in std_logic;
		s : out std_logic;
	);
end compuerta_or;

Y el código de la arquitectura:

architecture Behavioral of compuerta_or is

begin

	s <= a or b;
	
end Behavioral;

El siguiente paso es revisar la sintaxis del módulo, debemos seleccionar la opción Implementation en la ventana Design, después seleccionamos el módulo compuerta_or y en la ventana de procesos hacemos doble clic en Check Syntax, si hubo algún problema se indicará en la consola en la parte inferior.

En este caso, tenemos un error, en la consola inferior se nos indica que el error está en la línea 14, un error de parseo, indicando que se esperaba un identificador y no una instrucción de cierre. SE indica que en esa esa línea se generó el error pues no se encontró la instrucción esperada, pero no que precisamente en esa línea esté el código incorrecto. En este caso, yendo hacia atrás a partir de la línea 14, encontramos el error en la línea 13, y es que, recordemos, las declaraciones de señales dentro de port llevan todas punto y coma al final excepto la última, así que debemos quitar el punto y coma para la señal de salida s.
Así, el código completo de compuerta_or sería:

----------------------------------------------------------------------------------
-- Compuerta OR de dos entradas
-- Mexchip - Tutorial VHDL
-- Noviembre 2010
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity compuerta_or is
	port (
		a : in std_logic;
		b : in std_logic;
		s : out std_logic
	);
end compuerta_or;

architecture Behavioral of compuerta_or is

begin

	s <= a or b;
	
end Behavioral;

Verificamos sintaxis:

Queda a continuación realizar la simulación de este módulo, pero por el momento lo dejaremos como ejercicio, eso y además agregar un módulo XOR de dos entradas :). Hasta la próxima.

13 comentarios en “Curso VHDL – Simulación”

  1. hola saludo el ise xilinx me genera este error:

    “You will need to have adminstrative privilege to run VC++ 2008 Redistributable.”

    muchas gracias no se que sera

  2. Hola, felicitaciones y muchas gracias por este tutorial.

    Quisiera saber si hay alguna manera de exportar los datos resultado de la simulaci’on, utilizando el ise o modelsim. Gracias

    1. Hola, gracias por tus comentarios :).

      Lamentablemente no he visto una opción para exportar los datos de la simulación, cuando he requerido he tomado solo capturas de pantalla, voy a revisar y te comento :).

  3. hola
    antes que nada una felicitacion, y dos presguntas la primera, como es que se podria insertar una señal(reloj) a un vector para su posterior simulacion?, y dos, si tengo varias señales de entrada estas se pueden agrupar en una sola variable para despues insertar un reloj a la misma?…saludos y gracias

    1. Qué tal, primero muchas gracias por la felicitación :), ahora, con las preguntas:
      1.Teniendo el vector, haces clic derecho sobre su nombre y utilizas la opción “Force Clock”, ahí indicas el valor del flanco de inicio y del final (“Leading Edge Value” y “Trailing Edge Value”), p. ej. en el primero pondrías 0 y en el segundo 1 para que tu pulso inicie con transición de 0 a 1. En las últimas dos opciones indicas el porcentaje de ciclo de trabajo (“Duty Cicle”) y el periodo que tendrá la señal, aquí te recomiendo uses un submúltiplo del tiempo que especificas para cada paso de simulación, p. ej., si tienes seleccionado un tiempo de simulación de 1 us y deseas ver 10 transiciones, el periodo sería de 100 ns.
      2. Desconozco una opción que te permita realizar lo que indicas, lo que se podría hacer es conectar las señales que deseas agrupar a un bus adicional/auxiliar, y manipular este último.

  4. ola amigo muy buen aprote estoy llevando circuitos ligicos secuenciales y de verdad q m callo de lujo este curso.. en lo personal m gustaria si podrias subir uno parecido pero para diseñar un flip flop ya sea ff j-k o ff D. se agradece

    1. Gracias por los comentarios :). Últimamente he estado bastante ocupado, hasta el día de hoy que me dí tiempo para responder algunos comentarios, puedes ver ejemplos de flip flops y de otros elementos en los templetes de ISE Project Navigator, ve al menú Edit -> Language Templates -> VHDL (o Verilog) -> Synthesis Constructs -> Coding Examples, espero te sirva.

  5. Hola disculpa, puedo utilizar la protoboard spartan 3E y VHDL para realizar un carrito seguidor de linea? y si es asi me podrias decir que materiales nesecitaria porfavor? 😀 gracias

    1. Qué tal, claro que puedes utilizarla para hacer lo que mencionas, los materiales para hacerlo puedes investigarlos, pero básicamente necesitarás con qué mover tu carrito y con qué detectar la línea. Para la detección de la línea se utilizan muy comúnmente detectores infrarrojos que vienen en par emisor-receptor, como el CNY70 o alguno similar. Una vez teniendo estos elementos la lógica para que funcionen no es muy complicada y un FPGA como el que tienes está más que sobrado para esta aplicación :).

  6. Hola , que tal, ¿como podria simular en un vector de entradas? es decir al forzar el reloj en todos las variable de entrada, solo cambia, a la hora de correrlo, la ultima variable a la que le asigne valores…

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *