Cómo trabajar con vhdl usando software libre

Las clases de ingeniería electrónica suelen dictarse usando herramientas popietarias, así que siempre paso algunas horas buscando hacer mis trabajos con software libre. Por esta razón, he decidido compartir la siguiente guía.

Instalando lo necesario

Para compilar y simular nuestros programas usaremos GHDL un compilador libre basado en GCC. Para ver los resultados de la simulación, usaremos GTKWAVE. Como editor recomiendo Geany ya que reconoce casi todos los lenguajes de programación.

sudo apt-get install ghdl gtkwave geany

Un proyecto de ejemplo

Utilicemos como ejemplo este comparador:

Antes de crear un proyecto, comencemos creando una carpeta donde se alojarán todos los archivos. En este caso, /home/usuario/vhdl. Allí guardaremos el código fuente de nuestros programas con extensión .vhd.

Luego, escribimos nuestro programa usando Geany, como se ve en la captura de pantalla.

Lo guardamos como compara.vhd.

Ahora necesitaremos crear las señales para la simulación. Para ello, crearemos un componente que use el bloque anterior y le especificaremos las señales.

Las lineas A < = «0011» after 0 ns,»0111″ after 5 ns, «0111» after 10 ns; son las que configuran las señales de entrada en el tiempo

Guardamos los archivos en /home/usuario/vhdl. Luego, abrimos un terminal y a compilar:

ghdl -a compara.vhd

Si no hay mensajes de error, la compilación es exitosa.

Ahora compilamos el “componente”

ghdl -a compara_tb.vhd

Si no hay errores, creamos el ejecutable:

ghdl -e compara_tb

Finalmente, resta realizar la simulación y guardar los resultados en el con nombre “compara.vcd”

ghdl -r compara_tb --vcd=compara.vcd

Para poder ver los resultados usaremos gtkwave:

gtkwave compara.vcd

Una vez abierto, señalar con la tecla Ctrl y el mouse las señales que nos interesan y presionar insertar. Luego, doble clic en los vectores para ver las señales separadas. Después, clic derecho en los señales para elegir el formato (binario, hex, octal, decimal, etc.)

En caso de que sea necesario, el botón con forma de lupa con un cuadrado en el centro ajusta la gráfica a la pantalla.

ALU: arithmetic and logic unit

Bien, ahora hagamos algo más interesante: un ALU (aritmethic and logic unit). Será una unidad lógica, una unidad aritmética y un multiplexor.

Unidad lógica (LoU.vhdl)

     LIBRARY ieee;
     USE IEEE.STD_LOGIC_1164.all;
     USE IEEE.NUMERIC_STD.all;

ENTITY lou IS
PORT(op1 : IN std_logic_vector(7 DOWNTO 0);
op2 : IN std_logic_vector(7 DOWNTO 0);
proceso : IN std_logic_vector(3 DOWNTO 0);
res : OUT std_logic_vector(7 DOWNTO 0));
END lou;

ARCHITECTURE synth2 OF lou IS
SIGNAL a,b:UNSIGNED(op1’range);
SIGNAL c:UNSIGNED(res’range);
BEGIN
PROCESS (a, b, proceso)
BEGIN
CASE proceso IS
WHEN «0000» => c < = RESIZE((not a),c’length);
WHEN «0001» => c < = RESIZE((a and b),c’length);
WHEN «0010» => c < = RESIZE((a or b),c’length);

WHEN «0011» => c < = RESIZE((a xor b),c’length);
WHEN «0100» => c < = RESIZE((a nand b),c’length);
WHEN «0101» => c < = RESIZE((a nor b),c’length);
WHEN OTHERS => null;
END CASE;
END PROCESS;

a < = UNSIGNED(op1);
b < = UNSIGNED(op2);
res < = std_logic_vector(c);

END synth2;

Unidad aritmetica (ArU.vhd)

     LIBRARY ieee;
     USE IEEE.STD_LOGIC_1164.all;
     USE IEEE.NUMERIC_STD.all;

ENTITY aru IS
PORT(op1 : IN std_logic_vector(7 DOWNTO 0);
op2 : IN std_logic_vector(7 DOWNTO 0);
proceso : IN std_logic_vector(3 DOWNTO 0);
res : OUT std_logic_vector(7 DOWNTO 0));
END aru;

ARCHITECTURE synth OF aru IS
SIGNAL a,b:UNSIGNED(op1’range);
SIGNAL c:UNSIGNED(res’range);
BEGIN
PROCESS (a, b, proceso)
BEGIN
CASE proceso IS
WHEN «0000» => c < = RESIZE((a + b),c’length);
WHEN «0001» => c < = RESIZE((a – b),c’length);
WHEN «0010» => c < = RESIZE((a * b),c’length);

WHEN «0011» => c < = RESIZE((a / b),c’length);
WHEN «0100» => c < = RESIZE((a + «1»),c’length);
WHEN «0101» => c < = RESIZE((b + «1»),c’length);
WHEN OTHERS => null;
END CASE;
END PROCESS;

a < = UNSIGNED(op1);
b < = UNSIGNED(op2);
res < = std_logic_vector(c);

END synth;

Multiplexor (muxVector.vhd)

     LIBRARY ieee;     USE IEEE.STD_LOGIC_1164.all;
     USE IEEE.NUMERIC_STD.all;

ENTITY muxVector IS
PORT(desdeARU : IN std_logic_vector(7 DOWNTO 0);
desdeLOU : IN std_logic_vector(7 DOWNTO 0);
switch : IN std_logic;
salida : out std_logic_vector(7 DOWNTO 0));
END muxVector;

ARCHITECTURE cambio OF muxVector IS
BEGIN
with switch select
salida < = desdeARU when ‘0’ , desdeLOU when others;
END cambio;

Componente ALU (aluComponente.vhd)

     LIBRARY ieee;     USE IEEE.STD_LOGIC_1164.all;
     USE IEEE.NUMERIC_STD.all;

ENTITY aluComponente IS
END aluComponente;

ARCHITECTURE entradas_aluComponente OF aluComponente IS

COMPONENT aru
PORT(op1 : IN std_logic_vector(7 DOWNTO 0);
op2 : IN std_logic_vector(7 DOWNTO 0);
proceso : IN std_logic_vector(3 DOWNTO 0);
res : OUT std_logic_vector(7 DOWNTO 0));
END COMPONENT;

COMPONENT lou
PORT(op1 : IN std_logic_vector(7 DOWNTO 0);
op2 : IN std_logic_vector(7 DOWNTO 0);
proceso : IN std_logic_vector(3 DOWNTO 0);
res : OUT std_logic_vector(7 DOWNTO 0));
END COMPONENT;

COMPONENT muxVector
PORT(desdeARU : IN std_logic_vector(7 DOWNTO 0);
desdeLOU : IN std_logic_vector(7 DOWNTO 0);
switch : IN std_logic;
salida : out std_logic_vector(7 DOWNTO 0));
END COMPONENT;

SIGNAL salidaARU : std_logic_vector(7 DOWNTO 0);
SIGNAL salidaLOU : std_logic_vector(7 DOWNTO 0);
signal Switch : std_logic;
signal proceso : std_logic_vector(3 DOWNTO 0);
signal salida : std_logic_vector(7 DOWNTO 0);
SIGNAL A : std_logic_vector(7 DOWNTO 0);
SIGNAL B : std_logic_vector(7 DOWNTO 0);

BEGIN
u0: aru PORT MAP (A,B,proceso,salidaARU);
u1: lou PORT MAP (A,B,proceso,salidaLOU);
u2: muxVector PORT MAP (salidaARU,salidaLOU,switch,salida);

A < = «00000011» after 0 ns,»00000111″ after 5 ns, «00000111» after 10 ns, «00001001» after 15 ns, «00000000» after 20 ns, «00000101» after 25 ns, «00001111» after 30 ns, «00000101» after 35 ns;
B < = «00000010» after 0 ns,»00000100″ after 5 ns, «00000010» after 10 ns, «00000011» after 15 ns, «00000100» after 20 ns, «00000110» after 25 ns, «00001111» after 30 ns, «00000011» after 35 ns;
switch < = ‘1’ after 0 ns,’0′ after 5 ns,’1′ after 10 ns, ‘0’ after 15 ns,’1′ after 20 ns,’0′ after 25 ns,’1′ after 30 ns,’0′ after 35 ns,’1′ after 40 ns;
proceso < = «0000» after 0 ns,»0001″ after 5 ns, «0010» after 10 ns, «0011» after 15 ns, «0100» after 20 ns, «0101» after 25 ns, «0110» after 30 ns;
END entradas_aluComponente;

Para no perder tiempo compilando comando por comando mientras trabajamos en el programa, guardamos en la misma carpeta un archivo llamado compilar.sh con el siguiente contenido:

ghdl -a lou.vhd && ghdl -a aru.vhd && ghdl -a muxVector.vhd &&  ghdl -a aluComponente.vhd  && ghdl -e aluComponente && ghdl -r aluComponente --vcd=aluComponente.vcd && gtkwave aluComponente.vcd

Abrir un terminal, entrar a la carpeta y ejecutar el script:

cd /home/usuario/vhdl
sh compilar.sh

Si no hay errores se abrirá gtkwave y podremos ver las señales:

Estas herramientas me han sido muy útiles y mas fáciles de usar que las herramientas propietarias que usamos en clase, las que sospechosamente tardan demasiado para copilar. Con ghdl tardo más en cambiar de ventana que en compilar.

Más info sobre VHDL

Para los nuevos en vhdl, aquí tienen un ejemplo básico de un negador.

Un vídeo de ejemplo:
http://www.youtube.com/watch?v=feVMXsyLSOU

Recuerden que las últimas versiones de Ubuntu no tienen GHDL en sus repositorios. Éste puede descargarse para Linux/Windows desde la página del proyecto:
http://ghdl.free.fr/site/pmwiki.php?n=Main.Download