VHDL

De binario a siete segmentos: la conversión

Figura 3: Número binario 0b000011111 visualizado en siete segmentos.

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.

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
Tabla 1: Conversión de decimal a código BCD natural.

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.

BCD Binario
Centenas
(4 bits)
Decenas
(4 bits)
Unidades
(4 bits)
Número binario
(9 dígitos)
Tabla 2: Estructura básica para la conversión.

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:

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
Tabla 3: Conversión de 9 bits a 4 dígitos de BCD.

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.

Figura 1: Simulación de módulo de binario a BCD.

Figura 1: Simulación de módulo de binario a BCD.

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…).

Figura 2: Diagrama esquemático del convertidor de binario a visualizadores de siete segmentos.

Figura 2: Diagrama esquemático del convertidor de binario a visualizadores de siete segmentos.

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.

Figura 3: Número binario 0b000011111 visualizado en siete segmentos.

Figura 3: Número binario 0b000011111 visualizado en siete segmentos.

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.

You Might Also Like

38 Comentarios

  • Responder
    Maria Jose
    mayo 25, 2014 at 11:22 am

    Como hago un convertidor de 5 bits a 7 segmentos

    • Responder
      Carlos Ramos
      mayo 27, 2014 at 10:34 am

      Buenos días, Maria Jose,
      Quizá lo más apropiado sea crear una ROM con los datos de las 32 combinaciones posibles (lo que sería más o menos equivalente a 32 when si se utilizara un case como en el listado 1 de siete segmentos y VHDL).
      Para cada una de las combinaciones deberás sacar manualmente el dato en BCD, 00000 es 0x00, 10000 es 0x16, 11111 es 0x31, etcétera. Como podrás notar en los ejemplos, el valor binario corresponde a su valor decimal… en hexadecimal. Solamente es cuestión de llenar la ROM o crear los case necesarios.
      Saludos.

  • Responder
    JAIME
    noviembre 21, 2014 at 11:35 am

    Buenos dias una pregunta, como puede hacer este programa pero en bloques en el programa de quartus dos, es que no se muy bien como hacer que se recorran los de la izquierda para crear el numero de binario a BCD

    • Responder
      Carlos Ramos
      noviembre 21, 2014 at 4:49 pm

      Buenas tardes, Jaime. El programa de Quartus II no lo he utilizado para realizar componentes por bloques, así que en ese departamento no soy de mucha utilidad. Saludos.

  • Responder
    Juan
    noviembre 23, 2014 at 6:14 am

    Estoy intentando hacer uno de 14 bits a bcd pero no se donde está mi error, ¿podrías ayudarme?
    Este es mi código VHDL

    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) &gt; 4 then
             z(19 downto 16) := z(19 downto 16) +3;
          end if;
    
          if z(23 downto 20) &gt;4 then
             z(23 downto 20) := z(23 downto 20)+3;
          end if;
    
          if z(27 downto 24) &gt;4 then
             z(27 downto 24) := z(27 downto 24)+3;
          end if;
    
        
    
          z(29 downto 1) := z(28 downto 0);
       end loop;
    
       P&lt;=z(29 downto 16);
    end process bcdl;
    
  • Responder
    Uriel
    mayo 6, 2015 at 1:48 pm

    Buenas tardes Ingeniero Carlos
    Como podria implementar un convertidor de binario 8 bits a bcd pero usando una maquina de estadosfinito una (FSM) en donde introdusca los datos en un registro entrada paralelo salida paralelo y donde el corrimiento para la conversion en otro estado la suma de 3 en otro estado y la salida en un decodificador multipexor en otro estado

  • Responder
    uriel
    mayo 9, 2015 at 11:50 pm

    Buenas noches ingeniero Carlos como podria implementar un convertidor de binario de 8 bits a bcd con una maquina de estados finitos que los datos a intoducir sean un estado, que la conversion sea otro estado y que el decodificador o multiplexor sea otro estado

  • Responder
    Oscar Mendez
    octubre 6, 2015 at 9:37 am

    Gracias hermano eres un dios me salvaste

  • Responder
    Daniel Perez
    noviembre 30, 2015 at 12:39 am

    hola, quisiera saber si se puede hacer esto mismo para 8 bits pero sin usar el STD_LOGIC_VECTOR, es decir, asignando las 8 variables para cada bit

  • Responder
    franco
    mayo 31, 2016 at 7:54 am

    Buenos dia deseo saber cual es la función de la línea 18 en el listado 4?
    entity work…………………..
    otra: es posible en vhdl llamar módulos de programas bases para poder armar un proyecto mayor?
    gracias por la respuesta…………

  • Responder
    alfredo
    septiembre 6, 2016 at 8:39 pm

    que tal buenas noches, oye me podrias asesorar para encender cada segmento de uno de los display que lleva la placa Nexys 2? solamente quiero realizar eso por lo pronto. encender cada segmento con un interruptor. muchas gracias¡¡

    • Responder
      Carlos Ramos
      septiembre 7, 2016 at 9:37 pm

      Alfredo, simplemente crea ocho señales de entrada y asígnalas a ocho señales de salida. Lo más complicado en este caso, sería los pines (el archivo de implementación), ya sea que lo quieras mandar a los LED de la tarjeta o de una vez al visualizador (recomendaría primero mandarlo a los ocho LEDs).
      Recuerda que los visualizadores de siete segmentos no son mas que siete u ocho foquitos acomodados de manera “bonita”.
      Hazme saber cómo te va con el pequeño programa que quieres hacer :).

  • Responder
    alfredo
    octubre 28, 2016 at 1:43 pm

    buenas tardes, disculpa nos dejaron un proyecto acerca de convertidor analogico digital con un adc0804 e implementarlo a un fpga y que el resultado se visualice en una pantalla lcd, me podrias ayudar o asesorar como hacerlo, porque realmente apenas me estoy familiarizando con este tipo de logica programable
    muchas gracias’¡¡¡

    • Responder
      Carlos Ramos
      octubre 31, 2016 at 10:26 am

      Alfredo, así es como yo lo haría:
      1. Consultar la hoja de datos y ver cómo entrega los datos. Si son 8 pines, simplemente los puedes conectar a este módulo y ver la entrada en los visualizadores de siete segmentos.
      2. Una vez que puedas ver los datos en los visualizadores, plantear su migración a LCD.
      3. Aquí no tengo módulo para lidiar con LCD, así que tendrías que buscar uno.
      4. Probar los módulos que encuentres hasta encontrar uno que sirva y que le entiendas, que puedas modificar para enviar los datos que ahora se muestran en los visualizadores.
      5. Validar que los datos mostrados en el LCD son correctos.
      6. Celebrar el éxito obtenido.

  • Responder
    Alvaro
    octubre 31, 2016 at 10:10 am

    Hola, gracias por el aporte. Un consulta… Como puedo hacer para que la entrada no sean 9 pulsadores, sino un encoder rotacional de 512 pulsos por revolución. poder mostrar estos pulsos en los display. Saludos. Lo que quiero decir que sea una sola entrada de 9 bits y no 9 switches. Saludos

    • Responder
      Carlos Ramos
      octubre 31, 2016 at 10:16 am

      Álvaro, creo que para ello tendrás que conseguir un módulo que pueda leer el encoder. Probablemente manda los datos de manera serial, por I2C, o alguno de los tantos protocolos existentes. Lo más simple sería buscar un módulo para ese protocolo que usa tu encoder y conectarlo al decodificador.

  • Responder
    Uriel
    noviembre 13, 2016 at 11:49 am

    hey bro nececito como hacer de BCD a BINARIOOOO .. tienes algunos consejos ahi ??

    • Responder
      Carlos Ramos
      noviembre 14, 2016 at 9:01 am

      Uriel, lo que ves es lo que hay. Así que, de momento, no tengo nada al respecto.

  • Responder
    jorge
    diciembre 8, 2016 at 3:55 pm

    Hola amigo una consulta
    me dejaron hacer un contador de 0 a 99 que se vaya incrementando de 1 en 1 al percibir un cambio en un. swich me podrías ayudar o dar unos consejos te quedaría muy agradecido
    Saludos

  • Responder
    Gonzalo
    diciembre 19, 2016 at 6:08 am

    Hola Carlos,
    ¿Para un convertidor de 16 bits habrá algún cambio en el algoritmo por favor?

    • Responder
      Carlos Ramos
      diciembre 19, 2016 at 10:28 am

      Gonzalo, no hay ningún cambio en el algoritmo. Solamente hay que cambiar las veces que hace el ciclo y la cantidad de bits en entradas y salidas.

  • Responder
    Gabriel Gagliardi
    enero 23, 2017 at 10:40 am

    Hola Carlos! primero que nada gracias por la publicación, es muy buena. Me encuentro con el problema que cuando realizo el Test bech la salida Mux no me aparece(U). Alguna sugerencia?

    • Responder
      Carlos Ramos
      enero 23, 2017 at 11:12 am

      ¡Gabriel, gracias por tu comentario!
      ¿Estás utilizando el Xilinx ISE o qué programa utilizas para correr la simulación? Si es así, algunas veces no reconoce el test bench o marca errores (sí, el ISE es una lata).
      Lo que puedes intentar es cerrar y abrir el ISE (soluciones de los de sistemas :P), o incluso crear un nuevo archivo fuente de test bench y copiar el código allí.
      Espero eso te sirva.

  • Responder
    Ana Graciela
    mayo 17, 2017 at 6:12 pm

    Hola Carlos, tengo un problema que no logro comprender, es el siguiente:
    “Diseñe un circuito que multiplique dos numeros binarios, N1 y N2 de 2 digitos cada uno y muestre el resultado en decimal en un indicador de 7 segmentos. Considere que N1 esta dado por AB y N2 por CD. El resultado de N1xN2 se debe mostrar en el indicador, encendiendo los segmentos correspondientes.” Y sale una figura como esta:
    _
    | _ |
    | _ | marcado desde el superior como 1,2,3,4,5,6 y 7

    Espero que puedas ayudarme a comprender paso a paso :'(

  • Responder
    Nick Taylor
    septiembre 14, 2017 at 11:41 pm

    muy buenas noches estimado Carlos Ramos, primeramente quiero agradecerte por el aporte y ayuda que has estado ofreciendo que de hecho ya me han salvado el semestre, en este momento estoy queriendo hacer un convertidor de binario a BCD y es de 4bits pero no logro entender ciertas partes, estare muy agradecido.

    este es mi codigo de 4 bits apoyado del generico que diste, gracias por cierto

    variable z: STD_LOGIC_VECTOR(9 downto 0);
    begin

    — Inicialización de datos en cero.
    z := (others => ‘0’);
    — Se realizan los primeros tres corrimientos. (aqui)
    z(6 downto 3) := num_bin;
    — Ciclo para las iteraciones restantes.
    for i in 0 to 2 loop (aqui) en este segun el generico es 0
    — Unidades (4 bits).
    if z(7 downto 4) > 4 then (aqui)
    z(7 downto 4) := z(7 downto 4) + 3; (aqui)
    end if;
    — Decenas (4 bits).
    if z(11 downto 8) > 4 then (aqui)
    z(11 downto 8) := z(11 downto 8) + 3; (aqui)
    — Corrimiento a la izquierda.
    z(8 downto 1) := z(7 downto 0); (aqui)
    end loop;
    — Pasando datos de variable Z, correspondiente a BCD.
    num_bcd <= z(8 downto 4); (aqui)
    end process;
    end Behavioral;

  • Responder
    William Montenegro
    noviembre 21, 2017 at 9:41 am

    Hola, buenos días Ing. Carlos, tengo una consulta… necesito que me despejes varías dudas, te lo agradecería. ¿como haría para ingresar dos números binarios?, es decir, cada numero de 4 bits, todo con el objetivo de hacer operaciones básicas entre ambos números y visualizarlos por los display, tendría que agregar un modulo nuevo para la “operación”? ¿Donde integraría dicho modulo? Gracias.

    • Responder
      Carlos Ramos
      noviembre 21, 2017 at 11:45 pm

      William, tendrías que crear el módulo de la adición como hermanito a ser instanciado dentro del módulo principal descrito en el listado 4. Al menos, esto es lo que yo haría:
      – mandar el primer número a un visualizador (D3).
      – mandar el segundo número al segundo visualizador de la izquierda (D2).
      – utilizar el convertidor de binario a siete segmentos para la suma de los dos números, aquí mismo en el módulo principal.

      Las dos entradas las puedes mandar directo, pues del 0 a F se envían tal cual a los visualizadores, haciendo innecesaria la conversión de dichos dígitos a siete segmentos.

      Nada mas la suma (o multiplicación, acumulación, u operación que necesites) es la que necesitaría una señal interna para ser calculada, y dicha señal ser enviada al convertidor, el cual puedes ajustar a los bits necesarios.

      Espero la información te sirva como guía, saludos :).

  • Responder
    juan carlos
    diciembre 3, 2017 at 12:30 pm

    hola buenas tardes una pregunta no me puedes decir porque marca error en la libreria —-use IEEE.STD_LOGIC_UNSIGNED.ALL;
    gracias.

    • Responder
      Carlos Ramos
      diciembre 4, 2017 at 12:12 pm

      Juan, ¿cuál es el error que te sale? Saludos.

      • Responder
        juan carlos
        diciembre 5, 2017 at 12:29 am

        binario_a_bcd_ojalayquede.vhd:4:10: primary unit “std_logic_unsigned” not found in library “ieee”—-ese es el error

  • Responder
    Silvia
    junio 3, 2018 at 10:25 am

    Gracias por la ayuda!

    • Responder
      Carlos Ramos
      junio 7, 2018 at 1:24 pm

      De nada, Silvia :D. Un gusto que el contenido te sea de utilidad.

  • Responder
    Jonathan Fabricio Carrion Cabrera
    enero 6, 2019 at 4:41 pm

    saludos
    Quisiera saber como haces el barrido de display para que muestre en los leds de 7 segmentos, seria de gran ayuda
    gracias!

  • Responder
    Blanca
    mayo 18, 2019 at 8:36 am

    Buenas Ingeniero Carlos,
    Disculpe para la transformación 16 bits no se puede cambiar a bcd con el algoritmo propuesto , queria saber si hay algun cambio q haya q hacer para q pueda cambiarse a bcd.

  • Deja tu comentario