En la última entrada, unimos la ROM con el divisor de frecuencia y obtuvimos el metrónomo… o algo así. La verdad es que un proyecto no sirve si no podemos ver el estado en el que se encuentra, ¿está trabajando? ¿ya acabó? ¿siquiera empezó? ¿o si lo detengo pero estaba trabajando?

Imagina que llegas a tu horno de microondas, abres la compuerta e introduces tu café (que no te terminaste en la mañana), mismo que deseas calentar durante cuarenta segundos. Presionas el 4, pero no hay un visualizador que te muestre el tiempo. Y tampoco hubo sonido tras presionar la tecla. ¡Bien podría estar desconectado!

¿Qué tan frustrado te sentirías si tu microondas no mostrara el tiempo restante y tuvieras que regresar cuando creyeras que hubiese terminado?

Yo estaría bastante frustrado, asumo que tú también. Por eso, en esta entrada crearemos un componente simple pero poderoso: un convertidor de binario a siete segmentos, para mostrar un número binario en lenguaje común.

Descargar codigo ejemplo

De decimal a BCD

Sé que eres fanático de la base 2, que prefieres leer los números en binario, y puedes convertir el número 0b11011 a decimal en menos de dos fracciones de segundo. Pero los diseños deben ser lo más amigables posibles, y eso incluye la lectura de tales cantidades binarias.

Particularmente, no creo que una violinista prefiera saber que su ritmo es de 0b1010000 BPM en lugar de 80 BPM aunque hay cada caso… Como una línea de LEDs no es la solución, pasamos a otro conjunto de LEDs ordenados: los visualizadores de siete segmentos.

El problema es ¿cómo separas un número binario en tres o cuatro dígitos de siete segmentos? Una forma de realizar tal separación es utilizando un código, denominado BCD (que significa Decimal Codificado en Binario).

La conversión de decimal a BCD es bastante simple: tomamos cada uno de los dígitos decimales por separado y le asignamos su valor binario conforme a la tabla 1.

Tabla 1: Conversión de decimal a código BCD natural.

Decimal	Binario
0	0001
1	0001
2	0010
3	0011
4	0100
5	0101
6	0110
7	0111
8	1000
9	1001
10-15	No importa

Así que de decimal a BCD es una simple conversión del dígito a cuatro bits en binario, excepto que las últimas seis posiciones, de 0b1010 a 0b1111, no se utilizan. El problema, por supuesto, es la conversión de binario a BCD.

De binario a BCD

Lamentablemente, de binario a BCD no podemos simplemente separar conjuntos de cuatro bits y esperar a que todo funcione. Para la conversión, se requiere el uso de un algoritmo denominado desplazar a la izquierda y sumar tres. Y lo que hace es, bueno, ¡desplazar y sumar tres!

En resumen, el proceso es:

1. Desplazar el número binario hacia la izquierda un bit.
2. Si alguno de los dígitos tiene una valor igual o mayor a cinco, sumar tres.
3. Repetir los pasos 1 y 2 la cantidad de bits del número binario que se quiere convertir.

En esta entrada se realiza el ejemplo del convertidor pensado para el metrónomo, la cantidad de BPM a visualizar va de 1 a 512. Lo que implica 3 dígitos en BCD. Y las direcciones de la ROM van de 0 a 511, cantidades que se representan en 9 bits. Por lo tanto, el componente a ser desarrollado es un convertidor de 9 bits en binario a tres digitos en BCD. En la tabla 2 se muestra la escructura básica de cómo se alinearáfn los datos para la conversión: centenas, decenas, unidades, y el número binario inicial.

Tabla 2: Estructura básica para la conversión.

BCD			Binario
Centenas (4 bits)	Decenas (4 bits)	Unidades (4 bits)	Número binario (9 dígitos)

Ahora, siguiendo la alinación en la tabla 2, realizaremos la conversión de un número decimal entre el 1 y 512. Creo que estás pensando en el 417, ¿es así? ¿es así? Bueno, de cualquier forma, haremos el ejemplo del número 417:

Tabla 3: Conversión de 9 bits a 4 dígitos de BCD.

Operación	BCD			Binario
	Centenas (4 bits)	Decenas (4 bits)	Unidades (4 bits)	Número binario (9 bits)
Disposición inicial				1 1 0 1 0 0 0 0 1
Desplazar a la izquierda (1)			1	1 0 1 0 0 0 0 1
Desplazar a la izquierda (2)			1 1	0 1 0 0 0 0 1
Desplazar a la izquierda (3)			1 1 0	1 0 0 0 0 1
Sumar tres a unidades			1 0 0 1	1 0 0 0 0 1
Desplazar a la izquierda (4)		1	0 0 1 1	0 0 0 0 1
Desplazar a la izquierda (5)		1 0	0 1 1 0	0 0 0 1
Sumar tres a unidades		1 0	1 0 0 1	0 0 0 1
Desplazar a la izquierda (6)		1 0 1	0 0 1 0	0 0 1
Sumar tres a decenas		1 0 0 0	0 0 1 0	0 0 1
Desplazar a la izquierda (7)	1	0 0 0 0	0 1 0 0	0 1
Desplazar a la izquierda (8)	1 0	0 0 0 0	1 0 0 0	1
Sumar tres a unidades	1 0	0 0 0 0	1 0 1 1	1
Desplazar a la izquierda (9)	1 0 0	0 0 0 1	0 1 1 1

Y, al final, observamos que los tres dígitos corresponden a 417, correctamente separado. En la tabla tres se ejemplifica el procedimiento simple, que será la base del módulo en VHDL:

1. Inicializamos todos los digitos BCD en 0.
2. Realizamos el siguiente procedimiento 9 veces (la cantidad de bits):
   1. Desplazar el número binario una posición hacia la izquierda.
   2. Verificar si alguno de los dígitos BCD es mayor o igual a cinco.
   3. En caso de que algún número en BCD cumpla (sea 5, 6, o 7), sumar tres.

Módulo en VHDL para la conversión de binario a BCD

En la red hay varios ejemplos, como un convertidor de 8 bits a BCD, un convertidor de binario a BCD serial o una sugerencia sobre su implementación eficiente en ROM o LUT. Además, en el libro Learning by Example Using VHDL – Basic Digital Design with a Basys FPGA Board también se incluye el código de un convertidor de 8 bits a BCD, código que se utiliza como base del presente módulo.

Ya con la base del algoritmo, podemos crear el código en VHDL. Antes de eso, hay que tomar en cuenta dos consideraciones:

1. En los primeros dos desplazamientos no se puede llegar al cinco o pasar más allá de él. Por lo tanto, es hasta el tercer desplazamiento que es necesario comprobar si se debe sumar tres a algún dígito.
2. El código BCD de las centenas representará como máximo un 5 (ya que el máximo es 512), razón por la que la representación BCD será de tres bits.

Por lo tanto, diseñaremos un convertidor de 9 bits a tres dígitos BCD en 11 bits (con el digito de centenas truncado). ¿Recuerdan el ejemplo de la tabla 3? Porque exactamente eso haremos en código.

En el listado 1 se muestra el código completo para el módulo, siguiendo el algoritmo. Sus correspondencias, por línea, son:

1. Declaramos nuestra entrada num_bin de 9 bits, correspondiente al número binario, y nuestra salida num_bcd de 11 bits, correspondiente al código en BCD (líneas 7 y 8).
2. Justo como en la tabla 3, creamos una sola línea con todos los datos. Ésto es, un vector de 9 + 4 + 4 + 3 = 20 localidades. Sobre ese vector se realizarán las operaciones de corrimiento (línea 15).
3. Dado que en z se contienen todos los datos, debemos asegurarnos que se inicializa en ceros (línea 18).
4. En los primeros dos corrimientos no habrá sumas, así que se realizan los primeros tres corrimientos sin problema (línea 20).
5. De las líneas 21 a 36 se ejecuta un ciclo para los seis desplazamientos restantes, equivalentes a 9 bits – 3 desplazamientos ya realizados.
6. Dentro del ciclo, se separa el vector en conjuntos de cuatro bits, correspondientes a cada dígito en BCD. Si las unidades (líneas 22 a 25), las decenas (líneas 26 a 29), o las centenas (líneas 30 a 33), exceden cuatro, se les aplica una suma de tres.
7. Tras la adición, se realiza el corrimiento de datos hacia la izquierda (línea 35).
8. Finalmente, se toman los valores de los dígitos en BCD y se envían a la salida del módulo (línea 38).

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity bin2bcd9 is
	PORT(
		num_bin: in  STD_LOGIC_VECTOR(8 downto 0);
		num_bcd: out STD_LOGIC_VECTOR(10 downto 0)
	);
end bin2bcd9;

architecture Behavioral of bin2bcd9 is
begin
	proceso_bcd: process(num_bin)
		variable z: STD_LOGIC_VECTOR(19 downto 0);
	begin
		-- Inicialización de datos en cero.
		z := (others => '0');
		-- Se realizan los primeros tres corrimientos.
		z(11 downto 3) := num_bin;
		for i in 0 to 5 loop
			-- Unidades (4 bits).
			if z(12 downto 9) > 4 then
				z(12 downto 9) := z(12 downto 9) + 3;
			end if;
			-- Decenas (4 bits).
			if z(16 downto 13) > 4 then
				z(16 downto 13) := z(16 downto 13) + 3;
			end if;
			-- Centenas (3 bits).
			if z(19 downto 17) > 4 then
				z(19 downto 17) := z(19 downto 17) + 3;
			end if;
			-- Corrimiento a la izquierda.
			z(19 downto 1) := z(18 downto 0);
		end loop;
		-- Pasando datos de variable Z, correspondiente a BCD.
		num_bcd <= z(19 downto 9);
	end process;
end Behavioral;

Descargar codigo ejemplo

Si necesitas modificar la cantidad de bits, quizá el código del listado 2 resulte mejor para su modificación (aunque puede parecer un tanto confuso al haber sustituido la cantidad de bits por GENERIC).

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity bin2bcd9 is
	GENERIC(
		NBITS  : integer :=  9; -- Cantidad de bits del número binario.
		NSALIDA: integer := 11  -- Cantidad de bits de salida en formato BCD.
	);
	PORT(
		num_bin: in  STD_LOGIC_VECTOR(NBITS-1   downto 0);
		num_bcd: out STD_LOGIC_VECTOR(NSALIDA-1 downto 0)
	);
end bin2bcd9;

architecture Behavioral of bin2bcd9 is
begin
	proceso_bcd: process(num_bin)
		variable z: STD_LOGIC_VECTOR(NBITS+NSALIDA-1 downto 0);
	begin
		-- Inicialización de datos en cero.
		z := (others => '0');
		-- Se realizan los primeros tres corrimientos.
		z(NBITS+2 downto 3) := num_bin;
		-- Ciclo para las iteraciones restantes.
		for i in 0 to NBITS-4 loop
			-- Unidades (4 bits).
			if z(NBITS+3 downto NBITS) > 4 then
				z(NBITS+3 downto NBITS) := z(NBITS+3 downto NBITS) + 3;
			end if;
			-- Decenas (4 bits).
			if z(NBITS+7 downto NBITS+4) > 4 then
				z(NBITS+7 downto NBITS+4) := z(NBITS+7 downto NBITS+4) + 3;
			end if;
			-- Centenas (3 bits).
			if z(NBITS+10 downto NBITS+8) > 4 then
				z(NBITS+10 downto NBITS+8) := z(NBITS+10 downto NBITS+8) + 3;
			end if;
			-- Corrimiento a la izquierda.
			z(NBITS+NSALIDA-1 downto 1) := z(NBITS+NSALIDA-2 downto 0);
		end loop;
		-- Pasando datos de variable Z, correspondiente a BCD.
		num_bcd <= z(NBITS+NSALIDA-1 downto NBITS);
	end process;
end Behavioral;

La simulación

En el listado 3 se muestra lo relevante de la simulación (incluida en la descarga), con los valores esperados. En la figura 1 se muestran los resultados, que concuerdan con lo mostrado en los comentarios del listado 3.

num_bin <= "000000001"; --   1, 000 0000 0001
wait for 10 ms;
num_bin <= "000000010"; --   2, 000 0000 0010
wait for 10 ms;
num_bin <= "000000100"; --   4, 000 0000 0100
wait for 10 ms;
num_bin <= "000001000"; --   8, 000 0000 1000
wait for 10 ms;
num_bin <= "000010000"; --  16, 000 0001 0110
wait for 10 ms;
num_bin <= "000100000"; --  32, 000 0011 0010
wait for 10 ms;
num_bin <= "001000000"; --  64, 000 0110 0100
wait for 10 ms;
num_bin <= "010000000"; -- 128, 001 0010 1000
wait for 10 ms;
num_bin <= "100000000"; -- 256, 010 0101 0110
wait;

Y ahora de BCD a siete segmentos

Antes habíamos realizado un decodificador de seis bits a siete segmentos, aunque ahora solamente será necesario tomar en cuenta los dígitos del cero al nueve (o lo necesario para leer solamente cuatro bits). En esta entrada solamente tomaremos prestado el código del proyecto de decodificador de cuatro bits a siete segmentos y añadiremos el convertidor de binario a BCD.

En la figura 2 se muestra el diagrama esquemático, que corresponde a la unión del controlador de siete segmentos completo con decodificador de cuatro bits con el convertidor de binario de 9 bits a BCD en 11 digitos (y ese es el nombre ahora…).

El módulo solamente recibe la señal de reloj de 50MHz, el reset, y el número binario de nueve bits a ser mostrado. Entonces la magia sucede y el valor se muestra en los cuatro visualizadores. El código para dicha magia se muestra en el listado 4.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity bin7seg is
	PORT (
        clk     : in  STD_LOGIC; -- Reloj de entrada de 50MHz.
        reset   : in  STD_LOGIC; -- Señal de reset.
		num_bin : in  STD_LOGIC_VECTOR(8 downto 0);
		d7s     : out STD_LOGIC_VECTOR(7 downto 0);
		MUX     : out STD_LOGIC_VECTOR(3 downto 0)
    );
end bin7seg;

architecture Behavioral of bin7seg is
	signal num_bcd: STD_LOGIC_VECTOR(10 downto 0);
	signal D0, D1, D2, D3: STD_LOGIC_VECTOR(3 downto 0);
begin
	d7s_i: entity work.siete_segmentos_completo(Behavioral)
		PORT MAP(clk, reset, D0, D1, D2, D3, d7s, MUX);
	bin2bcd9_i: entity bin2bcd9(Behavioral)
		PORT MAP(num_bin, num_bcd);

	D3 <= "0000";                     -- Siempre en cero.
	D2 <= "0" & num_bcd(10 downto 8); -- Rellenando para ser cuatro dígitos.
	D1 <= num_bcd(7 downto 4);
	D0 <= num_bcd(3 downto 0);
end Behavioral;

El archivo de implementación se encuentra en la descarga. Por si aún no lo tienes, aquí va de nuevo:

[wpdm_file id=19]

Ahora podemos ver

Finalmente, en la figura 3 se muestra el resultado en el FPGA. Los ocho interruptores se utilizaron como entrada de datos (falta el bit nueve, pero ese simplemente lo mandamos a otro botón). Al mover los interruptores (el valor binario), los visualizadores cambian en consecuencia, mostrando su valor decimal.

Según se aprecia, los interruptores activos son cinco, correspondientes a los de menor significancia:

\( 0b000011111 = 2^4 + 2^3 + 2^2 + 2^1 + 2^0 = 16 + 8 + 4 + 2 + 1 = 31 \)

Por lo que nuestro módulo funciona y por fin podemos ver algo relevante en nuestra tarjeta Basys2 :D. Pero eso es todo por ahora.

Pregunta rápida: ¿cómo realizarías un convertidor de un número binario para utilizar los cuatro visualizadores de la tarjeta? ¿de cuántos bits debería ser el número binario?

No te olvides de compartir esta entrada si te gustó el contenido. Así todos sabrán que, como yo, eres un entusiasta de los sistemas digitales.

bcdl: process(B)
variable z : STD_LOGIC_VECTOR(29 downto 0);
begin
   for i in 0 to 29 loop
      z(i) :='0';
   end loop;

   z(18 downto 5) :=B;

   for i in 0 to 8 loop 
      if z(19 downto 16) > 4 then
         z(19 downto 16) := z(19 downto 16) +3;
      end if;

      if z(23 downto 20) >4 then
         z(23 downto 20) := z(23 downto 20)+3;
      end if;

      if z(27 downto 24) >4 then
         z(27 downto 24) := z(27 downto 24)+3;
      end if;

    

      z(29 downto 1) := z(28 downto 0);
   end loop;

   P<=z(29 downto 16);
end process bcdl;