Curso VHDL – Sumador/Restador con operadores aritméticos

Se nota que me gustan los sumadores ¿verdad? En las anteriores entregas hemos armado sumadores a base de compuertas que se unieron para crear medios sumadores y a partir de estos sumadores completos. Posteriormente armamos un sumador de un bit a partir de su ecuación booleana, que utilizamos para armar un sumador de cuatro bits. En esta entrega veremos un circuito de suma más (que también resta), pero en esta ocasión haremos uso de los operadores aritméticos que VHDL pone a nuestra disposición. Sin más introducción, empecemos con nuestro proyecto.

Creamos un nuevo proyecto en ISE Project Navigator, lo nombramos SumaRestaVHDL, el módulo principal será de tipo HDL.

Ahora, agregamos un nuevo fuente, ya sea con el botón a la izquierda de la ventana Design o mediante el menú que aparece tras hacer clic derecho sobre el nombre de nuestro proyecto, el módulo será de tipo VHDL y por nombre le pondremos SumaResta:

Nuestro sumador/restador será de 4 bits, por lo que tiene dos entradas de 4 bits y una salida también de 4 bits, en VHDL podemos declarar puertos de varios bits a los que se denominan buses, el asistente para agregar un nuevo archivo fuente nos permite indicar los puertos que son buses de esta forma:

Marcamos la casilla en la columna Bus para indicar que el puerto es un bus, además, el número de bits del bus lo indicamos mediante un par de números en las columnas MSB (Most Significant Bit – bit más significativo) y LSB (Least Significant Bit – bit menos significativo), esto es, el número de bit que corresponde a los bits más y menos significativos. Recordemos, en electrónica digital los buses, registros o demás elementos compuestos por más de un bit generalmente se numeran del bit más a la derecha (el menos significativo) hacia la izquierda iniciando en cero, por ejemplo, un elemento de cuatro bits podría ser:

# bit	3	2	1	0
Valor	X	X	X	X

El bit menos significativo es el 0, mientras que el más signicativo es el bit 3, que son los que indicamos en el asistente para nuestro nuevo módulo. En cuanto terminemos de agregar el módulo usando el asistente veremos cómo se declara un bus en código VHDL.

Quizá alguien se haya preguntado para qué se utilizará la entrada denominada Sel. Recordemos que nuestro módulo debe sumar y restar, pero solo puede realizar una operación a la vez (solo tiene una salida), así que ¿cómo le indicamos si debe sumar o restar las entradas? La entrada Sel nos permitirá seleccionar la operación a realizar, si su valor es 1, la salida corresponderá a la resta (A – B), mientras que, cuando Sel tenga un valor de 0, la salida corresponderá a la suma (A + B), una vez aclarada la función de la entrada Sel finalicemos con el asistente y pongamos atención a la sintaxis para declarar un bus en VHDL:

A : in std_logic_vector( 3 downto 0 );

La diferencia contra las declaraciones que hasta el momento habíamos utilizado (puertos de 1 bit), es la utilización del tipo STD_LOGIC_VECTOR en lugar de STD_LOGIC, seguido de la indicación de los bits más y menos significativos indicados entre paréntesis (separados por la instrucción downto. VHDL nos permite numerar los bits de un bus del modo que nosotros deseemos, ya sea empezando por el menos significativo y aumentando hacia el más significativo o al revés, que el más significativo sea el bit 0 por ejemplo y el menos significativo el bit número 3 (para el caso de un bus de cuatro bits), para lo que se usaría la instrucción to en lugar de downto, o incluso empezar a numerar de un valor mayor a 0, a continuación pondremos algunos ejemplos de declaraciones de un puerto de cuatro bits:

puerto1 : in std_logic_vector( 3 downto 0 );
puerto2 : in std_logic_vector( 0 to 3 );
puerto3 : in std_logic_vector( 1 to 4 );
puerto4 : in std_logic_vector( 10 downto 7 );

Todas las instrucciones anteriores declaran puertos de entrada de cuatro bits, la diferencia estriba en la manera en la que podremos acceder a los bits individuales de cada uno de ellos, por ejemplo, para acceder al bit más significativo de puerto1 usaríamos:

puerto1(3);

mientras que para acceder al bit más significativo de puerto3 tendríamos que usar:

puerto3(1);

Pero como mencionamos, en electrónica digital generalmente se numera a partir de cero y empezando por el bit menos significativo, así que esa será la forma como trabajaremos las declaraciones de buses en este curso.

Continuemos ahora con el código de nuestro módulo SumaResta, tenemos que cuando la entrada Sel tenga un valor de 0 a la salida enviaremos el resultado de la suma de las entradas A y B, y cuando valga 1 enviaremos el resultado de la resta A – B. En los lenguajes de programación de PC podemos ejecutar una u otra porción de código dependiendo del resultado de la evaluación de una expresión empleando la sentencia if, en VHDL también existe dicha instrucción, pero solo puede utilizarse dentro de un bloque de proceso, los cuales veremos hasta la próxima entrega, así que por ahora no los usaremos ;). VHDL nos proporciona otra instrucción que consigue un efecto similar y que puede emplearse fuera de un proceso, se trata de la sentencia when-else, cuya sintaxis es la siguiente:

SALIDA <= (RESULTADO) when selector=VALOR else (OTRORESULTADO);

RESULTADO se encuentra entre paréntesis porque peude ser un valor constante o el resultado de una operación. Utilizando la sentencia when-else para asignar a la salida de nuestro módulo la suma o resta de las entradas A y B según el valor de la entrada Sel tendríamos lo siguiente en nuestro código:

Salida <= ( A - B ) when Sel = '1' else ( A + B );

Esto es, asigna a Salida el resultado de la operación (A - B) cuando Sel valga '1' (nótese que un valor de un bit va entre comillas simples), para otros valores de Sel asigna a la salida el resultado de la operación (A + B).

El código completo quedaría similar a este:

----------------------------------------------------------------------------------
-- Módulo sumador y restador de 4 bits
-- Mexchip - Tutorial VHDL
-- Diciembre 2011
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity SumaResta is
	port (
		A : in  STD_LOGIC_VECTOR (3 downto 0);
      B : in  STD_LOGIC_VECTOR (3 downto 0);
      Sel : in  STD_LOGIC;
      Salida : out  STD_LOGIC_VECTOR (3 downto 0)
	);
end SumaResta;

architecture Behavioral of SumaResta is

begin

	Salida <= ( A - B ) when Sel = '1' else ( A + B );

end Behavioral;

Ahora si, guardemos el módulo, revisamos sintaxis y... ¡Error!

¿Qué ocurrió? Veamos los mensajes de error que nos arrojó Project Navigator:

ERROR:HDLParsers:808 - "E:/.../SumaResta.vhd" Line 22. - can not have such operands in this context.
ERROR:HDLParsers:808 - "E:/.../SumaResta.vhd" Line 22. + can not have such operands in this context.

Nos indica que ambos problemas se encuentran en la línea 22, indicando que no podemos tener operadores - o + en tal contexto, la línea 22 de nuestro código:

	Salida <= ( A - B ) when Sel = '1' else ( A + B );

Peri si seguimos la sintaxis indicada para la sentencia when-else, ¿cuál es el problema? El problema es que los operadores de suma y resta no se encuentran definidos por defecto en VHDL, sino que son parte de una biblioteca adicional, la biblioteca STD_LOGIC_UNSIGNED (para valores sin signo, también existe la biblioteca STD_LOGIC_SIGNED que utiliza valores con signo), la cual debemos incluir para poder utilizar estos operadores, entonces, incluyámosla:

----------------------------------------------------------------------------------
-- Módulo sumador y restador de 4 bits
-- Mexchip - Tutorial VHDL
-- Diciembre 2011
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity SumaResta is
	port (
		A : in  STD_LOGIC_VECTOR (3 downto 0);
      B : in  STD_LOGIC_VECTOR (3 downto 0);
      Sel : in  STD_LOGIC;
      Salida : out  STD_LOGIC_VECTOR (3 downto 0)
	);
end SumaResta;

architecture Behavioral of SumaResta is

begin

	Salida <= ( A - B ) when Sel = '1' else ( A + B );

end Behavioral;

Revisamos sintaxis y en esta ocasión todo está correcto.

Muy bien, entonces procedamos a simular nuestro diseño, vamos a la vista Simulation en la ventana Design y hacemos doble clic sobre el proceso Simulate Behavioral Model:

Ahora tendremos abierto ISim:

Si observamos, los puertos que son buses en nuestro diseño tienen entre corchetes los números de los bits MSB y LSB, además, a la izquierda tienen una flecha, si hacemos clic sobre ella podremos ver desplegados en la ventana de formas de onda cada uno de los bits que componen el bus:

Ejecutemos ahora una primera simulación, sumaremos los valores 5 (entrada A) y 3 (entrada B), habrá también que indicar un valor de 0 para la entrada Sel. Utilizaremos la función Force Constant..., primero haremos clic derecho sobre el nombre de la señal a[3:0] y seleccionaremos Force Constant... del menú desplegable:

En la ventana que aparece indicaremos el valor en el campo Force to Value:, debemos indicar un valor que corresponda al formato indicada en el campo Value Radix, que en este caso es Binary, que nos indica valores binarios:

Pero también podemos indicar valores en formato decimal si cambiamos el campo Value Radix a Unsigned Decimal (también existe la opción Signed Decimal):

Repitamos la operación para las entradas B (0011 - 3) y Sel (0):


Ahora si, hacemos clic en el botón Run for the time specified on the toolbar y tendremos:

Como podemos observar, la salida tiene el valor binario 1000 que corresponde con la suma que esperábamos (5+3), también podemos cambiar el formato con el que se visualizan los valores en la ventana de formas de onda haciendo clic derecho sobre el nombre del puerto que deseamos modificar, luego vamos al menú Radix y seleccionamos el deseado, por ejemplo Unsigned Decimal:

Así, si modificamos el formato para los tres buses (A, B y Salida) a Unsigned Decimal nuestra ventana de simulación se vería así:

Ahora puede ser más fácil observar los resultados (sobre todo cuando los buses sean de más bits).
Muy bien, hagamos otra simulación, ahora modifiquemos el valor de la entrada Sel a 1:

Con lo que esperaríamos que ahora el resultado fuera la resta de A - B:

Al parecer, nuestro módulo funciona correctamente, como ejercicio pueden realizar algunas otras operaciones para asegurarse de que así sea, aquí nosotros continuaremos con la implementación en una tarjeta Nexys 2, la asignación de pines la hemos hecho de esta forma:

# Pines de la tarjeta Nexys 2
# para sumador/restador de 4 bits
NET "Sel" LOC = H13;
NET "A<3>" LOC = R17;
NET "A<2>" LOC = N17;
NET "A<1>" LOC = L13;
NET "A<0>" LOC = L14;
NET "B<3>" LOC = K17;
NET "B<2>" LOC = K18;
NET "B<1>" LOC = H18;
NET "B<0>" LOC = G18;
NET "Salida<3>" LOC = K14;
NET "Salida<2>" LOC = K15;
NET "Salida<1>" LOC = J15;
NET "Salida<0>" LOC = J14;

Y este es un breve video con unas pruebas (5 +/- 3) y ( 8 +/- 1) para observar el funcionamiento:

Muy bien, hasta aquí llegamos con esta entrega, ¡hasta la próxima!