Módulos

Reloj digital con VHDL

Figura 1: Bloques que componen nuestro reloj digital.

¡Oh, el horror! Aún recuerdo aquellos días donde fue necesario realizar un reloj digital utilizando decenas de pequeños integrados de la serie 74XX interconectados entre sí. Por fortuna, en este artículo se realiza la misma tarea de una manera más fácil: utilizando VHDL y una tarjeta Basys2.

En esta entrada retomamos el progreso anterior: divisor de frecuencia a 200 Hz, controlador para visualizadores de siete segmentos y multiplexor para mostrar cuatro visualizadores.

La figura 1 muestra los bloques necesarios para construir el reloj, los cuales son:

  • Siete segmentos completo: Esta unidad contiene lo necesario para mostrar digitos en los cuatro visualizadores, con la ayuda de los componentes anteriormente mencionados: divisor de frecuencia, control para visualizadores y multiplexor.
  • Contador de reloj: Este componente se encargará de contar de 0 a 23 para las horas y de 0 a 59 para los minutos.
  • Reloj de 1Hz: Se utilizara como señal de entrada en el contador (contaremos cada segundo).
Figura 1: Bloques que componen nuestro reloj digital.

Figura 1: Bloques que componen nuestro reloj digital.

Sólo porque sé que adoran escribir tanto como yo, aquí incluyo los archivos fuente necesarios para implementar el reloj digital:

[wpdm_file id=9]

El contador

La entidad del contador se describe en la figura 2, donde se observa que solamente tiene dos entradas: el reloj de 1 Hz (o 1 segundo) y la señal de reset. Las salidas corresponden a los cuatro digitos: dos para mostrar la hora y dos para mostrar los minutos.

Figura 2: Entradas y salidas del contador.

Figura 2: Entradas y salidas del contador.

Existen diversas formas para realizar el contador del reloj, todas con ventajas y desventajas. En esta entrada se optó por usar cuatro contadores independientes (uno por dígito) para evitar posteriores conversiones de números binarios a BCD. El listado 1 muestra el código utilizado para crear el contador para nuestro reloj.

library IEEE;
use IEEE.NUMERIC_STD.ALL;
use IEEE.STD_LOGIC_1164.ALL;

entity contador_reloj is
    PORT (
        clk  : IN  STD_LOGIC; --Reloj de 1Hz.
        reset: IN  STD_LOGIC; --Señal de reset.
        H1   : OUT STD_LOGIC_VECTOR(2 DOWNTO 0); --Segundo digito de la hora.
        H0   : OUT STD_LOGIC_VECTOR(3 DOWNTO 0); --Primer digito de la hora.
        M1   : OUT STD_LOGIC_VECTOR(2 DOWNTO 0); --Segundo digito de los minutos.
        M0   : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)  --Primer digito de los minutos.
    );
end contador_reloj;

architecture Behavioral of contador_reloj is
    signal mm1: UNSIGNED(2 downto 0) := "000" ;
    signal mm0: UNSIGNED(3 downto 0) := "0000";
    signal hh1: UNSIGNED(2 downto 0) := "000" ;
    signal hh0: UNSIGNED(3 downto 0) := "0000";
begin
    reloj: process (clk, reset) begin
        if reset = '1' then
            hh1 <= "000" ;
            hh0 <= "0000";
            mm1 <= "000" ;
            mm0 <= "0000";
        elsif rising_edge(clk) then
            mm0 <= mm0 + 1;
            if mm0 = 9 then
                mm1 <= mm1 + 1;
                mm0 <= "0000";
            end if;
            -- Al pasar 59 minutos, contar una hora.
            if mm1 = 5 AND mm0 = 9 then
                hh0 <= hh0 + 1;
                mm1 <= "000";
            end if;
            if hh0 = 9 then
                hh1 <= hh1 + 1;
                hh0 <= "0000";
            end if;
            -- Al pasar 23:59, regresar a 00:00.
            if hh1 = 2 AND hh0 = 3 AND mm1 = 5 AND mm0 = 9 then
                hh1 <= "000";
                hh0 <= "0000";
            end if;
        end if;
    end process;

    --Asignación de señales.
    H1 <= STD_LOGIC_VECTOR(hh1);
    H0 <= STD_LOGIC_VECTOR(hh0);
    M1 <= STD_LOGIC_VECTOR(mm1);
    M0 <= STD_LOGIC_VECTOR(mm0);
end Behavioral;

Las líneas 5 a 14 contienen la definición de la entidad del contador del reloj, listando sus entradas y salidas. Los contadores internos a utilizar se declaran en las líneas 17 a 20. El proceso reloj es bastante simple:

  • El reset se encarga de regresar el contador a cero (líneas 23 a 27).
  • El contador mm0 cuenta de 0 a 9, incrementa en uno cada vez que recibe la señal de reloj.
  • El contador mm1 cuenta de 0 a 5, incrementa en uno cada vez que mm0 es nueve.
  • El contador hh0 cuenta de 0 a 9, incrementa en uno cada vez que mm1 es 5 y mm0 es 9 (cada hora).
  • El contador hh0 cuenta de 0 a 2, incrementa en uno cada vez que hh0 es nueve.
  • Los contadores de hora, hh0 y hh1, regresan a cero cuando la hora es 23:59.

El divisor de frecuencia a 1 Hz

El divisor a 1Hz es similar al divisor a 200Hz, sólo es necesario cambiar la constante que sirve para conmutar la señal de salida. Los cálculos para dividir la frecuencia de entrada de 50 MHz a 1 Hz son:

\(contador_{1Hz} = \frac{50MHz}{1Hz}= 50 000 000\)

Como sabemos, el reloj tiene el mismo tiempo en alto que en bajo:

\(t_{alto} = t_{bajo} = \frac{50 000 000}{2} = 25 000 000\)

Y dado que empezamos el conteo desde cero, nuestra nueva constante para el reloj es 24 999 999.

(Aunque es sólo copiar el módulo del divisor de 200Hz y cambiar unas cuantas cosas, aquí dejo el código correspondiente al divisor de 1 Hz).

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity clk1Hz is
    Port (
        entrada: in  STD_LOGIC;
        reset  : in  STD_LOGIC;
        salida : out STD_LOGIC
    );
end clk1Hz;

architecture Behavioral of clk1Hz is
    signal temporal: STD_LOGIC;
    signal contador: integer range 0 to 24999999 := 0;
begin
    divisor_frecuencia: process (reset, entrada) begin
        if (reset = '1') then
            temporal <= '0';
            contador <= 0;
        elsif rising_edge(entrada) then
            if (contador = 24999999) then
                temporal <= NOT(temporal);
                contador <= 0;
            else
                contador <= contador+1;
            end if;
        end if;
    end process;

    salida <= temporal;
end Behavioral;

Uniéndolo todo

Ahora que ya tenemos todos los bloques necesarios, sólamente falta enlazarlos. Esto se realiza mediante un nuevo archivo, denominado reloj.vhd, que contiene los PORT MAP correspondientes, como se muestra en el listado 3.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity reloj is
    PORT(
        clk   : IN  STD_LOGIC;
        reset : IN  STD_LOGIC;
        salida: OUT STD_LOGIC_VECTOR(7 downto 0);
        MUX   : OUT STD_LOGIC_VECTOR(3 downto 0)
    );
end reloj;

architecture Behavioral of reloj is
    COMPONENT clk1Hz IS
        PORT (
            entrada: IN  STD_LOGIC;
            reset  : IN  STD_LOGIC;
            salida : OUT STD_LOGIC
        );
    END COMPONENT;

    COMPONENT contador_reloj IS
        PORT (
            clk  : IN  STD_LOGIC;
            reset: IN  STD_LOGIC;
            H1   : OUT STD_LOGIC_VECTOR(2 DOWNTO 0);
            H0   : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
            M1   : OUT STD_LOGIC_VECTOR(2 DOWNTO 0);
            M0   : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
        );
    END COMPONENT;

    COMPONENT siete_segmentos_completo IS
        PORT (
            clk   : IN  STD_LOGIC;
            reset : IN  STD_LOGIC;
            D0    : IN  STD_LOGIC_VECTOR(5 downto 0);
            D1    : IN  STD_LOGIC_VECTOR(5 downto 0);
            D2    : IN  STD_LOGIC_VECTOR(5 downto 0);
            D3    : IN  STD_LOGIC_VECTOR(5 downto 0);
            salida: OUT STD_LOGIC_VECTOR(7 downto 0);
            MUX   : OUT STD_LOGIC_VECTOR(3 downto 0)
        );
    END COMPONENT;

    signal clk_out : STD_LOGIC := '0';
    signal HH1, MM1: STD_LOGIC_VECTOR(2 downto 0);
    signal HH0, MM0: STD_LOGIC_VECTOR(3 downto 0);
    signal pHH1, pHH0, pMM1, pMM0: STD_LOGIC_VECTOR(5 downto 0);
begin
    --PORT MAPs necesarios para habilitar el reloj.
    clk_i: clk1Hz PORT MAP(clk, reset, clk_out);
    cnt_i: contador_reloj PORT MAP(clk_out, reset, HH1, HH0, MM1, MM0);
    seg_i: siete_segmentos_completo PORT MAP(clk, reset, pMM0, pMM1, pHH0, pHH1, salida, MUX);

    --Padding de las señales del contador para siete segmentos.
    pHH1 <= "000" & HH1;
    pHH0 <= "00"  & HH0;
    pMM1 <= "000" & MM1;
    pMM0 <= "00"  & MM0;
end Behavioral;

Implementación en Basys2

Para probar nuestro gran diseño digital en la tarjeta Basys2 es necesario crear un archivo de constraints que enlacen las señales de salida a puertos en el FPGA. El contenido del archivo se muestra en el listado 4 mientras que en la figura 3 se muestra el resultado de dicha implementación.

NET  "clk"         LOC = "B8";
NET  "reset"       LOC = "G12";
# Segmentos del visualizador. #########
NET  "salida<7>"   LOC = "N13"; # dp
NET  "salida<6>"   LOC = "M12"; # g
NET  "salida<5>"   LOC = "L13"; # f
NET  "salida<4>"   LOC = "P12"; # e
NET  "salida<3>"   LOC = "N11"; # d
NET  "salida<2>"   LOC = "N14"; # c
NET  "salida<1>"   LOC = "H12"; # b
NET  "salida<0>"   LOC = "L14"; # a
# Multiplexor #########################
NET  "MUX<3>"      LOC = "F12";
NET  "MUX<2>"      LOC = "J12";
NET  "MUX<1>"      LOC = "M13";
NET  "MUX<0>"      LOC = "K14";
Figura 3: Reloj en tarjeta Basys2.

Figura 3: Reloj en tarjeta Basys2.

El error

Sí has seguido el proyecto hasta este punto puede que ya te hayas dado cuenta de un pequeño error: el reloj cuenta los minutos y las horas, pero el contador de minutos se basa en un reloj que marca los segundos (¡Oh, no!). La pregunta es, ¿cómo solucionarías este problema? ¿qué alternativas existen para que el contador de minutos cuente, efectivamente, minutos?

Está bien, pero…

… ¿cómo establezco la hora inicial? Hasta ahora, la única forma de poner la hora correcta es reiniciar el contador a media noche… lo cual no es exactamente óptimo. Dejaremos la función de establecer la hora y la correción del contador para la próxima entrada. Me gustaría escuchar sugerencias para resolver los problemas mencionados.

You Might Also Like

109 Comentarios

  • Responder
    Fernando Lage
    noviembre 15, 2012 at 1:37 am

    Ya pude resolver lo del tiempo, simplemente agregue un contador y al llegar a 60 me manda un 1 en temporal.

    Acerca de como establecer la hora, tengo dos opciones, una es agregar un boton al codigo de contador_reloj y hacer un switch para los cuatro digitos e ir aumentando las variables.

    La otra opcion es haciendolo por portmap con otro vhdl source file..

    que me recomiendas ?

    Gracias por tu respuesta

    • Responder
      Carlos Ramos
      noviembre 16, 2012 at 5:04 pm

      Gracias por tu comentario, Fernando. Así es, el problema del tiempo se soluciona creando otro contador. Respecto a establecer la hora: ¿cómo manejarías el incremento si utilizas un componente externo? Personalmente, optaría por agregar entradas para el incremento al componente contador_reloj. Me gustaría saber más acerca de cómo solucionas el problema.

    • Responder
      javier vile
      noviembre 1, 2013 at 8:41 pm

      hola fernado, como estas.. te escribo para ver si puedes explicarme sobre como arreglaste el contador, de antemano te agradesco

    • Responder
      carlos rodriguez
      octubre 30, 2017 at 7:05 pm

      disculpa como solucionaste lo del otro contador , yo agregue uno mas pero sigue sin contarme ya cuando lo implemento en la basys

      • Responder
        Carlos Ramos
        noviembre 1, 2017 at 6:11 pm

        Carlos, ¿ya tomaste el mini curso gratuito? Te lo recomiendo mucho, pues creo que soluciona la pregunta que acabas de hacer :). Si no es así, puedes comentar después de que revises ese material.

  • Responder
    julio
    mayo 9, 2013 at 9:28 pm

    disculpa necesito que se pare en 15 minutos y luego mande la señal para que suene una alarma

    • Responder
      Carlos Ramos
      mayo 9, 2013 at 11:16 pm

      Buenas, Julio. Debido a que esta versión del reloj cuenta en minutos y segundo (sí, sí, ya sé que las señales se llaman HH y MM), podrías simplemente sustituir las líneas 43 a 47 del listado 1 por algo similar a lo siguiente:

      -- Al pasar 14:59, regresar a 00:00 y lanzar alarma.
      if hh1 = 1 AND hh0 = 4 AND mm1 = 5 AND mm0 = 9 then
          hh1 <= "000";
          hh0 <= "0000";
          alarma <= '1';
      end if;
      

      Siendo alarma un puerto de salida definido en la entidad. Esta misma señal puede ser asignada a un LED del FPGA, por mencionar un ejemplo, por medio del archivo de constraints. Si necesitas que se detenga en ese tiempo, puedes crear otra señal auxiliar como bandera o mover las instrucciones correspondientes al incremento hacia el else (aunque probablemente serán necesarios otros ligeros ajustes):

      -- Al pasar 14:59, regresar a 00:00 y lanzar alarma.
      if hh1 = 1 AND hh0 = 4 AND mm1 = 5 AND mm0 = 9 then
          hh1 <= "000";
          hh0 <= "0000";
          alarma <= '1';
      else
          mm0 <= mm0 + 1;
      end if;
      
  • Responder
    julio
    mayo 10, 2013 at 12:44 am

    Muchas gracias

  • Responder
    Cristian
    mayo 12, 2013 at 11:14 am

    Cordial saludo.
    Yo necesito un cronometro pero en FPGA Cyclone II, creo que funciona de forma diferente a esta tarjeta que ustedes utilizan.

    • Responder
      Carlos Ramos
      mayo 14, 2013 at 8:44 pm

      Buenas noches, Cristian. Ha decir verdad, no he tenido la oportunidad de trabajar con las herramientas o FPGAs de Altera. En teoría, la descripción de hardware que utilizo en Xilinx debería ser sintetizada sin problema por las herramientas de Altera, aunque no puedo asegurarlo. Me encantaría saber si el diseño funciona en otro entorno y apreciaría tu retroalimentación al respecto.

  • Responder
    Sergio
    mayo 26, 2013 at 11:11 pm

    Hola que tal, oye que buen proyecto tienes aqui en verdad esta muy bueno, pero sabes tengo un problema en el codigo de reloj, en donde ya esta todo junto, me marca algunos errores —— http://img9.imageshack.us/img9/8413/capc.png —– espero me puedas ayudar ya que revise todos los codigos que tengo y nose como solucionar el problema. Gracias por la ayuda.

    Nos vemos.

    • Responder
      Carlos Ramos
      mayo 27, 2013 at 2:34 pm

      Buenas tardes, Sergio. ¿El error surge tras querer sintetizar los archivos agregados en un nuevo proyecto? Me gustaría saber más acerca del entorno en el que estás trabajando, como los archivos incluidos y las propiedades del proyecto. Espero tu respuesta.

  • Responder
    Edwin Beltrán
    mayo 30, 2013 at 2:46 pm

    hola buen día… podría colaborarme como asignar en el UFC el clk en una nexys 3… todos los demás pines los he podido asociar pero en la hoja de datos de la nexys no me apacere el reloj como en la basys 2 (B8) se lo agradezco…

    • Responder
      Carlos Ramos
      junio 3, 2013 at 8:23 am

      Buen día, Edwin. De acuerdo con el manual de referencia provisto por Digilent, la tarjeta Nexys 3 incluye un oscilador de 100 MHz conectado en el puerto V10 (página 11). Saludos.

  • Responder
    alexander
    octubre 6, 2013 at 9:17 pm

    Hola, Quiero diseñar un temporizador, pero tengo problemas al momento de simular. No se si puedas ayudarme en algo.
    De antemano gracias, saludos.

    • Responder
      Carlos Ramos
      octubre 8, 2013 at 10:23 am

      Buenos días, Alexander. Gracias por tu comentario. Claro que sí puedo ayudarte, solamente dime qué es lo que necesitas, ¿cuál es tu problema específico con el temporizador que me comentas? ¿ya tienes el código del módulo pero la simulación no corresponde? Espero más información.

      • Responder
        Alexander
        octubre 19, 2013 at 9:19 pm

        Gracias, mira ya tengo el VHDL y me simula bien pero al momento de sintetizar me sale que no puede hacerlo porque el estilo de programación no lo soporta el programa… Mira te dejo el código.

        las señales:
        clkdiv…… señal que viene de un divisor de frec… 1 hert
        rst…… señal de reset
        ptot…. programar tiempo, si está en cero…. o temporizar cuando está en uno… la idea es que en el flanco de subida de esa señal, se cargue el número que el usuario desee, son las de entrada que vienen de un contador: H0C, todas las que tienen una C, de contador… la idea es que cuando llegue a 0 las horas, 0 min y cero seg, mande una señal activa en 1 a alarma….
        Si puedes simularlo, para que veas que si lo simula, pero creo me marca problema al cargar los datos que vienen del contador, el cual es el valor del cual comenzará a temporizar…

        De antemano gracias.

        library IEEE;
        use IEEE.STD_LOGIC_1164.ALL;
        use IEEE.STD_LOGIC_ARITH.ALL;
        use IEEE.STD_LOGIC_UNSIGNED.ALL;
        
        entity temp is
            Port ( clkdiv,rst,ptot: in  STD_LOGIC;
        		H0C: in  STD_LOGIC_VECTOR (3 downto 0);
        		M1C: in  STD_LOGIC_VECTOR (2 downto 0);
        		M0C: in  STD_LOGIC_VECTOR (3 downto 0);
        		S1C: in  STD_LOGIC_VECTOR (2 downto 0);
        		S0C: in  STD_LOGIC_VECTOR (3 downto 0);
        		H0: inout  STD_LOGIC_VECTOR (3 downto 0);
        		M1: inout  STD_LOGIC_VECTOR (2 downto 0);
        		M0: inout  STD_LOGIC_VECTOR (3 downto 0);
        		S1: inout  STD_LOGIC_VECTOR (2 downto 0);
        		S0: inout  STD_LOGIC_VECTOR (3 downto 0);
        		alarma: out STD_LOGIC);
        end temp;
        
        architecture arqtemp of temp is
        
        begin
        
        process (clkdiv,rst,H0,M1,M0,S1,S0,H0C,M1C,M0C,S1C,S0C,ptot)
        	begin
        		if ptot'event and ptot='1' then
        			H0 <= H0C;
        			M1 <= M1C;
        			M0 <= M0C;
        			S1 <= S1C;
        			S0 <= S0C;
        			
        		end if;
        		
        		if rst='1' then 
        			H0 <= "0000";
        			M1 <= "000";
        			M0 <= "0000";
        			S1 <= "000";
        			S0 <= "0000";
        			alarma <= '0';
        					
        		elsif (clkdiv'event and clkdiv='1') and  ptot='1' then
        		
        					S0<= S0-1;
        					if S0="0000" then
        						S1<=S1-1;
        						S0<="1001";
        					end if;
        					
        					if s1="000" and S0="0000"  then
        						M0<=M0-1;
        						S1<="101";
        					end if;
        					
        					if M0="0000" and s1="000" and S0="0000" then 
        						M1<=M1-1;
        						M0<="1001";	
        					end if;
        					
        					if M1="000" and M0="0000" and s1="000" and S0="0000" then 
        						H0 <= H0-1;
        						M1<="101";	
        					end if;
        					
        					if H0="0000" and M1="000" and M0="0000" and s1="000" and S0="0000" and rst='0' then
        					  H0<="0000";
        					  M1 <= "000";
        					  M0 <= "0000";
        					  S1 <= "000";
        					  S0 <= "0000";
        					  Alarma  '0');
           signal M1C : std_logic_vector(2 downto 0) := (others => '0');
           signal M0C : std_logic_vector(3 downto 0) := (others => '0');
           signal S1C : std_logic_vector(2 downto 0) := (others => '0');
           signal S0C : std_logic_vector(3 downto 0) := (others => '0');
        
        	--BiDirs
           signal H0 : std_logic_vector(3 downto 0);
           signal M1 : std_logic_vector(2 downto 0);
           signal M0 : std_logic_vector(3 downto 0);
           signal S1 : std_logic_vector(2 downto 0);
           signal S0 : std_logic_vector(3 downto 0);
        	signal alrma: std_logic;
        
           -- Clock period definitions
           constant clkdiv_period : time := 10 ns;
         
        BEGIN
         
        	-- Instantiate the Unit Under Test (UUT)
           uut: temp PORT MAP (
                  clkdiv => clkdiv,
                  rst => rst,
                  ptot => ptot,
                  H0C => H0C,
                  M1C => M1C,
                  M0C => M0C,
                  S1C => S1C,
                  S0C => S0C,
                  H0 => H0,
                  M1 => M1,
                  M0 => M0,
                  S1 => S1,
                  S0 => S0,
        			 alarma => alrma
                );
        
           -- Clock process definitions
           clkdiv_process :process
           begin
        		clkdiv <= '0';
        		wait for clkdiv_period/2;
        		clkdiv <= '1';
        		wait for clkdiv_period/2;
           end process;
         
        
           -- Stimulus process
           stim_proc: process
           begin		
              -- hold reset state for 100 ns.
              wait for 100 ns;	
        
              wait for clkdiv_period*10;
        
              -- insert stimulus here 
        
              wait;
           end process;
        	
          rst <= '1', '0' after 25 ns, '1' after 15 us, '0' after 15.1 us;
          ptot<=  '0', '1' after 100 ns, '0' after 500 ns, '1' after 540 ns,'0' after 15.2 us, '1' after 15.3 us;
          H0C <= "0101","0011" after 400 ns, "0001" after 15.2 us;
          M1C <= "100","010" after 250 ns,"011" after 15.2 us;
          M0C <= "1000","0100" after 300 ns,"0111" after 15.2 us;
          S1C <= "010","010" after 350 ns,"101" after 15.2 us;
          S0C <= "0110", "0110" after 400 ns,"1000" after 15.2 us;
        
        END;
        
        • Responder
          carlos
          noviembre 3, 2014 at 2:31 pm

          Buenas tardes, estoy diseñando un temporizador digital que temporice de 1, 5, 10, hasta 99 minutos. La inquietud es como introducir en el process otra variable que va hacer la del usuario pueda escoger el tiempo a temporizar,

          • Carlos Ramos
            noviembre 11, 2014 at 9:42 pm

            Hola, Carlos. Es una muy buena pregunta. ¿Ya has experimentado dividir en procesos pero te marca error de colisión de señales? Por lo que se lee en el comentario, parece que has tenido problemas con la implementación, ¿qué error marca el compilador en tus experimentos? Saludos.

          • Carlos
            noviembre 11, 2014 at 10:49 pm

            “En el código primero había hecho dos procces uno para programar el tiempo y otro para que ejecutara el tiempo programado. Hay salia errores en todas las señales muchos driver conectados y error en SS0.

            luego hice este código me compila pero solo esta ejecutando el tiempo a programar y no hace nada mas

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

            entity CONTA_2 is
            Port ( CLK_RELOJ_1 : IN STD_LOGIC; –Reloj de 1Hz
            START_2 : IN STD_LOGIC; –Habilita temporizador
            START_1 : IN STD_LOGIC; –pulsador 1 que habilita
            CLK_USUARIO : IN STD_LOGIC; –Digita el tiempo el usuario
            RESET : IN STD_LOGIC; –Señal de Reset
            SELECTOR : IN STD_LOGIC_VECTOR (2 DOWNTO 0);
            M0 : OUT STD_LOGIC_VECTOR (5 DOWNTO 0); –1° digito de los minutos
            M1 : OUT STD_LOGIC_VECTOR (5 DOWNTO 0); –2° digito de los minutos
            S0 : OUT STD_LOGIC_VECTOR (5 DOWNTO 0); –1° digito de los segundos
            S1 : OUT STD_LOGIC_VECTOR (5 DOWNTO 0); –2° digito de los segundos
            BUZZER : OUT STD_LOGIC; — Buzzer
            OFF : OUT STD_LOGIC — Apaga el sistema
            );
            end CONTA_2;

            architecture Behavioral of CONTA_2 is
            signal MM1: SIGNED(5 downto 0) := “000000”;
            signal MM0: SIGNED(5 downto 0) := “000000”;
            signal SS1: SIGNED(5 downto 0) := “000000”;
            signal SS0: SIGNED(5 downto 0) := “000000”;

            type estados is (v0, v1);
            signal estado : estados;

            begin
            Temporizador_1:PROCESS (RESET, CLK_USUARIO, CLK_RELOJ_1)
            begin

            if RESET = ‘1’ then
            MM1 <= "000000";
            MM0 <= "000000";
            SS1 <= "000000";
            SS0
            SS0 <= SS0 + 9;
            if SS0 = 9 then
            SS1 <= SS1 + 1;
            SS0 <= "000000";
            end if;
            –Al pasar 59 segundos, contar 1 minuto
            if SS1 = 5 and SS0 = 9 then
            MM0 <= MM0 + 1;
            SS1 <= "000000";
            end if;
            if MM0 = 9 then
            MM1 <= MM1 + 1;
            MM0 <= "000000";
            end if;

            –estado

            if ((MM1 = 0 and MM0 = 1)or(MM1 = 0 and MM0 = 2)or(MM1 = 0 and MM0 = 3)) then
            if (START_1 = ‘0’)then
            elsif(CLK_RELOJ_1’EVENT and CLK_RELOJ_1 =’1′) then
            SS0 <= SS0 – 1;
            if SS0 = 0 then
            SS1 <= SS1 – 1;
            SS0 <= "001001";
            end if;
            –Al pasar 60 segundos contar 1 minuto—
            if SS1 = 0 and SS0 = 0 then
            MM0 <= MM0 – 1;
            SS1 <= "000101";
            end if;
            if MM0 = 0 then
            MM1 <= MM1 – 1;
            MM0 <= "001001";
            end if;
            if (MM1 = 0 and MM0 = 0 and SS1 = 0 and SS0 = 0 )then
            OFF
            BUZZER
            BUZZER
            BUZZER
            BUZZER
            BUZZER
            BUZZER
            BUZZER
            BUZZER <= '0';
            end case;
            end if;
            end if;
            end if;
            estado <= v0;
            end case;
            end if;
            end process Temporizador_1;

            M1 <= STD_LOGIC_VECTOR(MM1);
            M0 <= STD_LOGIC_VECTOR(MM0);
            S1 <= STD_LOGIC_VECTOR(SS1);
            S0 <= STD_LOGIC_VECTOR(SS0);

            end Behavioral;

  • Responder
    samanta
    noviembre 5, 2013 at 6:08 pm

    Hola, también estoy haciendo un reloj digital, es mas una variante de este, solo que tengo una duda, como se haría el multiplexor para hacer que cada digito aparezca en un display diferente, aun no puedo visualizarlo bien. Vi que en el código declaras un mux pero no puedo ver donde se empleo o como. De antemano muchas gracias por su atención.

  • Responder
    Luis
    noviembre 8, 2013 at 8:16 pm

    Que tal Carlos, estoy intentando corregir el error de los minutos, no he logrado realizarlo, podrias darme una sugerencia mas a fondo por favor, saludos y de antemano gracias

  • Responder
    galadriel
    mayo 28, 2014 at 1:16 pm

    hola podrias ayudarme aser un cronometro en esquematico para vhdl pero en basy 2

    • Responder
      Carlos Ramos
      mayo 28, 2014 at 4:46 pm

      Buenas tardes, Galadriel. De momento me encuentro ocupado con otros proyectos así que no puedo asistirte en estos momentos con ese proyecto en específico. Sin embargo, es una muy buena idea para entradas posteriores. Saludos.

  • Responder
    Abraham Fuentes
    mayo 31, 2014 at 2:31 pm

    Hola, ¿qué tal Carlos? Solamente quería agradecerte por tan excelente aportación. Me será de mucha ayuda. En mi caso voy a implementarlo en una Spartan-3E Starter Board.
    El reloj es parte de un proyecto. Sinceramente estaba muy perdido, mi profesor simplemente me explicó como implementar y simular compuertas lógicas básicas como AND, OR, XOR, etc. Además de cómo implementar un multiplexor 1-4. Eso en 3 días. Es decir, nunca me enseñó realmente el lenguaje. Y para evaluar quiere que se implemente este reloj (que por cierto, también se hizo con las circuitos integrados y como tú dices, fue todo un lío).
    Por eso estaba muy perdido. ¡Gracias por el aporte!
    Nada más una pequeña duda, para la simulación en el Banco de Pruebas, alguna sugerencia de cómo podría hacer éste. De antemano muchas gracias.

    • Responder
      Carlos Ramos
      junio 1, 2014 at 10:48 am

      Buenos días, Abraham,
      ¡Me agrada saber que la información te ha sido de utilidad!
      Respecto a la simulación, es un tanto complicado. Si deseas simular el reloj digital y observar el periodo de un segundo, tardará bastante (y cuando digo bastante, hablo posiblemente de horas). Lo que puedes hacer es simular el comportamiento del contador con la entrada de 50MHz (o la correspondiente al Spartan-3E Starter Board), para observar cómo incrementan los cuatro contadores. En otra prueba puedes observar el divisor de frecuencia de un segundo (que es la que tardará bastante en completarse).
      Espero que la información te sea de utilidad.
      Saludos.

  • Responder
    abel
    junio 11, 2014 at 1:28 pm

    oyes amigo ya descargue todos los archivos y los pude compilar bien y los cargue a mi tarjeta y en el display nadamas me aparece 3210 y de hay no pasa no cuenta ni hace nada en donde pudiera estar el error??

    • Responder
      Carlos Ramos
      junio 11, 2014 at 2:44 pm

      Buenas tardes, abel,
      Quisiera saber si compilaste los archivos del reloj o los de multiplexor de frecuencia solamente. Lo que me comentas me suena a lo implementado en Multiplexores y visualizadores de siete segmentos. ¿Podrías verificar los archivos fuente y ver si fue implementado todo el módulo del reloj o el proyecto antes mencionado? Saludos.

      • Responder
        Esau Olivas
        octubre 29, 2017 at 1:35 pm

        Holaaa, yo tengo el mismo problema. ¿Encontraron alguna otra solución?

        Gracias.

        • Responder
          Carlos Ramos
          noviembre 1, 2017 at 6:13 pm

          Esau, busca en los archivo fuente, por la cadena “0000”, “0001”. Esos son los valores fijos que muestran el cero y el uno fijos, respectivamente. Encuentra esos valores y podrás colocar las señales correctas allí. Saludos cordiales.

  • Responder
    fernando
    junio 18, 2014 at 1:21 am

    Mi duda es sobre la lógica del lenguaje VHDL

    He leído en varias partes, y es sabido que las señales no pueden modificarse más de dos veces dentro de un process, y en el process del contador, se modifican al menos dos veces mm0:

    mm0 &lt;= mm0 + 1; -- primer cambio 
    if mm0 = 9 then
        mm1 &lt;= mm1 + 1;
        mm0 &lt;= &quot;0000&quot;; -- segundo cambio
    end if;
    

    Lineas del 29 al 32.
    Espero que no sea una pregunta tan simple y tan falta de lógica, de antemano gracias

    • Responder
      Carlos Ramos
      junio 18, 2014 at 3:25 am

      Buenas noches, fernando.
      Tu pregunta no carece de sentido, en lo absoluto. Es cierto lo que dices, las señales entran en conflicto si las modificas en más de un proceso, o incluso si cambian su valor dentro del mismo proceso.
      Pero depende de qué tipo de instrucciones estés utilizando: concurrentes o secuenciales. Al crear estructuras como if o for, el código contenido se interpreta de manera secuencial (asigna un valor y posteriormente otro). Si bien no es un error de síntesis dado que el compilador XST no falla, se puede considerar una mala práctica vestigio de programación en C pues pueden existir errores de tiempo, ¿cómo saber si se guardó el primer valor o el segundo? ¿cuál es el cambio que permanece para el siguiente ciclo?
      Aún así, las herramientas de síntesis siguen avanzando, lo que nos permite realizar código de más alto nivel dejándole el trabajo pesado al software de síntesis. Un if convierte el código dentro de la estructura en secuencial (por lo que no hay problema), pero el cómo se almacena el valor y cuál permanece después del ciclo es una decisión de XST.
      Para evitar los conflictos entre las señales (las dos asignaciones) sería necesario “bajarnos” más, a un nivel registro-transferencia posiblemente. Debido a que ésto incrementaría el tiempo de diseño, simplemente confiamos en las herramientas de síntesis (que ya consideran posibles colisiones en circuitos secuenciales y establecen prioridad).
      Espero mi respuesta te haya servido a aclarar tus dudas.
      Saludos cordiales.

      • Responder
        fernando
        junio 18, 2014 at 3:37 pm

        Me parece bien la respuesta, de alguna manera eso quiere decir que respetara la ultima asignación como la correcta no es así ?

        mm0 &lt;= mm0 + 1; -- primer cambio
        if mm0 = 9 then
            mm1 &lt;= mm1 + 1;
            mm0 &lt;= &quot;0000&quot;; -- segundo cambio TOMARA esta asignación como la &quot;verdadera&quot; (siempre se se cumpla la condición obviamente)
        end if;
        

        Pero pasando a lo concurrente, debo entender que la asignaciones de la misma señal en diferentes procesos dentro de una misma arquitectura representaría un grave problema?

        S &lt;= a or b;
        S &lt;= b and a
        
        • Responder
          Carlos Ramos
          junio 26, 2014 at 1:47 pm

          Fernando,
          Sí y no. Aunque sea un sistema secuencial, hay que recordar que no es como un programa de computadora debido a los tiempos de propagación que hay que tomar en cuenta. Por ejemplo:

          mm0 &lt;= mm0 + 1; -- primer cambio
          if mm0 = 9 then
              banderaMinutosDecenas &lt;= '1';
          end if;
          if banderaMinutosDecenas = '1' then
              mm1 &lt;= mm1 + 1;
              mm0 &lt;= &quot;0000&quot;;
          end if;
          

          En este caso, la señal banderaMinutosDecenas toma “un tiempo” en actualizarse, por lo cual no lo detectará inmediatamente en la misma “pasada”, sino hasta la siguiente vez que entre en el proceso. Así es como, a pesar de ser secuencial, existen diversos problemas asociados al tiempo de propagación de las señales entre las compuertas.

          Pero sí, a nivel concurrente existe un problema existencial debido a que, según el ejemplo, la señal S no sabe cuál de los dos valores tomar. Debido a dos asignaciones a la misma señal el sistema no es determinista, no está definido, no sabe qué hacer, así que marca error. Si tuvieras que estar en dos lugares a la vez, e.g. escuela y trabajo, ¿cómo le haces? A menos que seas como el Hombre Múltiple, ese un problema sin solución (simplemente escoges una e ignoras la otra… o colapsas por estrés).

          Saludos.

  • Responder
    Juan
    octubre 23, 2014 at 10:55 pm

    Hola como estas necesitaria que me dijeses donde estan resueltas las dos preguntas del final ya que este es el proyecto de fin de curso y lo tengo que entregar urgente y no se me ocurre como corregir ambos errores y ademas necesito implementar un cronómetro que se reinicie cuando llegue a cierta cuenta. Desde ya muchas gracias saludos desde uruguay

    • Responder
      Carlos Ramos
      octubre 28, 2014 at 3:56 pm

      Buenas tardes, Juan. Fernando sugiere una forma de resolver el problema de conteo de segundos como minutos, utilizando el divisor de 1Hz como entrada a otro contador que cuente sesenta veces. Respecto a cómo establecer la hora inicial, es un problema un poco más complicado para el cual no tengo una respuesta en este momento. Sin embargo, es una buena idea para tratar en una próxima entrada. Saludos.

  • Responder
    Gerardo
    noviembre 3, 2014 at 6:46 pm

    Muy buen proyecta y funciona al 100!! Lo probé en una Nexys 3.
    Amigo, fíjate que estoy tratando de hacer un contador de 0 a 99, y que este comience a contar cuando reciba una señal, y que también cuente hacia abajo cuando reciba otra señal distinta. Que me recomiendas que haga… gracias.

    • Responder
      Carlos Ramos
      noviembre 11, 2014 at 9:45 pm

      Gerardo, un gusto ser de utilidad. Físicamente, ¿cómo consideras las señales para iniciar el conteo y para cambiar el sentido? ¿Como un pulso de un botón (push button) o como un interruptor que mantiene la posición (switch)? Eso es lo primero antes de comenzar la descripción. Saludos.

      • Responder
        Alexander G
        marzo 15, 2015 at 8:24 am

        Buenas, estoy muy interesando en la pregunta que haces, antes de hablar del código del contador, la verdad apenas soy un amateur en el tema, y me gustaría saber como activar una función ( en este caso los siete segmentos) con un switch, es decir que al subir o bajar el switch se activen los 7 segmentos… Espero hacerme entender. Buena tarde.

        • Responder
          Carlos Ramos
          marzo 15, 2015 at 3:02 pm

          Hola, Alexander. La verdad no estoy muy seguro de a qué te refieres. ¿Hablas de activar y desactivar un solo visualizador? ¿o de que ninguno de los cuatro se encienda? En cualquier caso, determinamos que para la Basys2 se enciende con un “0”. Por lo tanto, siempre que tenga un 1 estará apagado, por lo que se puede resolver a lo siguiente:
          estado OR 1 = 1 (apagado)
          estado OR 0 = estado (depende de nuestro estado)

          Por lo tanto, si tienes estado OR switch, tendrás el resultado deseado (para un solo visualizador).

          Espero haber interpretado bien la pregunta y haber dado una respuesta apropiada. Saludos.

          • Alexander G
            marzo 15, 2015 at 6:27 pm

            Si tiene razón, o eso creo, pero me gustaría ver dónde puedo modificar eso para la placa, si en el código VHDL o en la implantación de pines, no sé como hacer eso. (Me hago entender?)

          • Carlos Ramos
            marzo 16, 2015 at 11:12 am

            Alexander, sigo sin saber si el objetivo es deshabilitar un solo visualizador o los cuatro. Pero por pasos:

            1. Agregar una nueva entrada para switch (u otro nombre) para activar o desactivar los visualizadores.
            2. Dentro de la lógica, añadir código que cree la máscara según la entrada del switch. Esto quiere decir que si switch = 1, la máscara es "0000" (con 1, los visualizadores están activos). Con switch = 0, la máscara es "1111".
            3. Cada vez que mandemos datos a los visualizadores hacemos un OR con la máscara: MUX <= "1110" OR mascara;
            4. Finalmente, añadimos a la lista de entradas y salidas una referencia a un interruptor de la tarjeta.

            Espero esa información te sirva de guía en tu proyecto. Saludos.

  • Responder
    Sergio
    noviembre 25, 2014 at 4:39 pm

    Hola buen día. Descargué los archivos fuente que dejaste, uso ISE para programar la FPGA Nexys 3. Genero el archivo de programa y todo, pero a la hora de cargarla en la FPGA sólo se queda 0123 y ya no avanza, no sé en dónde esté el error porque si compilo todo el módulo del reloj. No sé si haya problemas con mi UCF en el MUX

    NET “MUX” LOC= “N16”;
    NET “MUX” LOC= “N15”;
    NET “MUX” LOC= “P18”;
    NET “MUX” LOC= “P17”;

    Espero respuestas gracias.

    • Responder
      Carlos Ramos
      noviembre 25, 2014 at 10:07 pm

      Buenas noches, Sergio. ¿Compilaste el proyecto con “reloj.vhd” como módulo principal? Saludos.

      • Responder
        Sergio
        noviembre 26, 2014 at 9:40 am

        Si, si lo ando compilando como módulo principal. En la imagen se puede observar eso.

      • Responder
        Sergio
        noviembre 26, 2014 at 9:40 am

        http://i.imgur.com/NKGa1p8.jpg

        • Responder
          Carlos Ramos
          noviembre 26, 2014 at 9:07 pm

          Sergio,
          Ya veo que la estructura es la correcta. Ese problema me pasaba cuando estaba probando el componente de los cuatro segmentos separados. El contador no se utilizaba, y solamente mandaba los datos fijos, siempre mostrando un dígito diferente pero nada más. ¿Podrías decirme si en los PORT MAP del módulo principal se utilizan las señales con el contador o unos valores fijos?
          Saludos.

          • Sergio
            noviembre 26, 2014 at 11:03 pm

            Tenía valores por defecto que era 0 1 2 3, sólo era cambiar D0, D1, D2, D3 para que sirviera. Al igual le implemente la parte de horas, minutos y horas y los despliego mediante el switch y cree otro mux para que vaya más rapido para ver si hacía el conteo correcto. Me sirvió de mucho y gracias.!

          • Carlos Ramos
            noviembre 28, 2014 at 9:41 pm

            Sergio, me agrada saber que has solucionado el problema. Saludos.

          • Gabriel
            abril 19, 2016 at 6:59 pm

            que le cambiaste a las Ds?

  • Responder
    ivan rebollar
    noviembre 29, 2014 at 11:57 pm

    tengo problemas con el reloj digital

    • Responder
      Carlos Ramos
      diciembre 2, 2014 at 10:08 pm

      Iván,¿qué clase de problemas tienes con el componente? Saludos.

      • Responder
        ivan rebollar
        diciembre 8, 2014 at 10:52 am

        hola!, se que se tienen que crear los símbolos, para posteriormente enlazarlos en el esquemático, la gran duda es ¿el reloj y el siete segmentos son también elementos?, ¿o para que me funcione solo debo introducir el código tal cual e implementarlo?.
        Saludos.

        • Responder
          Carlos Ramos
          diciembre 8, 2014 at 9:11 pm

          Saludos, Iván. Personalmente, prefiero evitar el esquemático; y el reloj funciona con el código provisto. Si decides tomar la ruta del esquemático, el componente de siete segmentos es un símbolo, y el reloj pasaría a ser el módulo principal (el esquemático que construyes). Sin embargo, en el módulo en VHDL (el listado 3, reloj.vhd) se realiza un poco de procesamiento para el padding (líneas 57 a 60), mismas que pudieran representar un problema al usar un esquemático. Aún así, hazme saber si construyes el reloj en esquemático. Espero haber ayudado.

  • Responder
    Sujey
    diciembre 4, 2014 at 10:16 pm

    Disculpa Nesistaba Un Contador De 0 – 15
    Tengo Ya Programado El Del 0 – 9 Solo q No Se Que Hacer,
    No Se Que Hacer Cuando Hace El Cambio De 9 – 10, 11, 12, 13, 14, 15 y q Se Reinicie..
    Neta Si Pudieras Hacerme Esa Programacion Te Lo Agradeceria Demasiado! Es Con Quartus ll

    • Responder
      Carlos Ramos
      diciembre 8, 2014 at 9:30 pm

      Sujey, lo más que puedo hacer es guiarte en el proceso. En el reloj se realiza un conteo de 0 a 59, y luego se reinicia. Podrías eliminar dos dígitos del reloj, y trabajar con los dos que necesitas (para representar de 0 a 15). En el caso del reloj, se trabaja con dos contadores independientes, uno de unidades y uno de decenas. Si debes utilizar un número único en binario, deberás utilizar un convertidor de binario a siete segmentos. Dependiendo de la forma que implementes el contador, en lugar de comparar con el límite de 5 y 9, utilizar el 1 y 5 para reiniciar la cuenta. En caso de que utilices un número de cuatro bits, no es necesario reiniciar. Espero la información te auxilie en tu tarea. Saludos.

  • Responder
    ivan rebollar
    diciembre 9, 2014 at 11:53 am

    lo he intentado por esquemático, pero no me resulta. ¿entonces tu dices que con el código solo hay que sintetizar,implementarlo,y por ultimo generar la extensión que va a la tarjeta ?, (soy nuevo en los sistemas digitales),

    • Responder
      Carlos Ramos
      diciembre 15, 2014 at 6:23 pm

      Así es, Iván. Las instrucciones PORT MAP equivalen a lo que serían las conexiones en un diagrama esquemático (como explico en esta entrada). El programa, ya sea Xilinx ISE o Altera Quartus, se encarga de generar el archivo a ser implementado en el FPGA. ¿Qué software estás utilizando para compilar el código? Saludos.

  • Responder
    Aaron
    marzo 16, 2015 at 6:46 pm

    Oye disculpa como arreglaste el problema; donde te muestra el valor fijo en los displays (0,1,2,3), como hago para que cuente; como le asigno ese valor a D0, D1, D2,D3, me puedes ayudar porfavor.

    • Responder
      Carlos Ramos
      marzo 16, 2015 at 9:35 pm

      Aaron, ¿podrías intentar usar el código disponible en GitHub? Me parece que el módulo reloj.vhd es el del problema. Saludos.

  • Responder
    carlos betancourt
    julio 30, 2015 at 3:50 pm

    Hola tengo un codigo en vhdl, en el cual solo quiero contar de 0 a 9 con un div de freq de 1 segundo, el codigo es muy sencillo lo que sucede es que cuando cargo el programa al fpga una nexys 3, solo me muestra el numero 8 no me muestra el conteo te agradeceria me pudieras asesorar con este inconveniente

  • Responder
    Alexander Gonzalez
    octubre 26, 2015 at 5:57 pm

    Hola, que tal, Soy nuevo en este mundo de VHDL, la verdad me gusta bastante. Pero obviamente, como todo principiante tengo siempre preguntas y siempre hago cosas en el código que generan Warning, pero bueno mi pregunta, para este código, es si tienes algún pequeño código donde me pudieras explicar cómo uniste el código que hiciste en el 1er modulo de VHDL con el 2do Modulo, en un 3er modulo, o eso es lo que entiendo, haces un recorrido de lo que hay y lo unes al final.

    • Responder
      Carlos Ramos
      octubre 27, 2015 at 8:10 pm

      Alexander, el tema se explica un poco en PORT MAP. Espero y te sea de utilidad la información en esa entrada. Saludos.

  • Responder
    Eduardo
    noviembre 2, 2015 at 10:47 pm

    A que se refiere :

    COMPONENT siete_segmentos_completo IS
    PORT (
    clk : IN STD_LOGIC;
    reset : IN STD_LOGIC;
    D0 : IN STD_LOGIC_VECTOR(5 downto 0);
    D1 : IN STD_LOGIC_VECTOR(5 downto 0);
    D2 : IN STD_LOGIC_VECTOR(5 downto 0);
    D3 : IN STD_LOGIC_VECTOR(5 downto 0);
    salida: OUT STD_LOGIC_VECTOR(7 downto 0);
    MUX : OUT STD_LOGIC_VECTOR(3 downto 0)
    );
    END COMPONENT;

    afuerza debo agregar otro archivo .vhd al reloj.vhd? o solo con escribirlo funciona el reloj? es que soy principiante de vhdl y me encargaron ese proyecto y sino mal recuerdo al tener component tengo que agregar un codigo que ya hubiese tenido, en este caso no lo tengo, y vuelvo a repetir, a que funcion se refiere, tendras el codigo completo para agregarlo al reloj que estoy haciendo? de antemano gracias.

    • Responder
      Carlos Ramos
      noviembre 3, 2015 at 3:09 pm

      Eduardo, todo el código fuente está disponible en el archivo descargable. Efectivamente, utilizamos otros componentes, definidos en otros archivos VHDL. En la entrada se proveen los enlaces a los componentes, y otra entrada que te puede servir es la de PORT MAP.
      Espero te haya servido.

  • Responder
    juan jose
    noviembre 9, 2015 at 12:35 am

    amigo 🙁 me sale el error del 3210 y ya cheque que compile en orden el reloj .vhd no sé qu pueda estar mal no he cambiado absolutamente nada del codigo qéu puedo hacer?

    • Responder
      juan jose
      noviembre 9, 2015 at 1:25 am

      YA LO SOLUCIONE

      • Responder
        Carlos Ramos
        noviembre 10, 2015 at 9:56 pm

        Juan José, me alegra saber que solucionaste el problema. Me gustaría saber cuál fue el problema que se te presentó, y cómo lo solucionaste, para tenerlo como futura referencia. Saludos.

        • Responder
          Jorge
          noviembre 19, 2015 at 8:15 am

          Hola, a mí también me sucede lo mismo ¿sabes cuál es el error?

          • Gabriel
            abril 18, 2016 at 3:43 pm

            pueden pasar el cogido?

      • Responder
        Francisco V
        marzo 8, 2017 at 2:49 pm

        Hola Juan José, cómo solucionaste el problema del “3210” que se muestra en el BCD a 7 segmentos en la Basys2?

  • Responder
    Rafa Preciado
    noviembre 23, 2015 at 1:58 pm

    Hola, que tal, cuando quiero sintetizarlo me marca estas advertencias

    WARNING:Xst:647 – Input D0 is never used. This port will be preserved and left unconnected if it belongs to a top-level block or it belongs to a sub-block and the hierarchy of this sub-block is preserved.

    WARNING:Xst:1290 – Hierarchical block clk_i is unconnected in block .
    It will be removed from the design.
    WARNING:Xst:1290 – Hierarchical block cnt_i is unconnected in block .
    It will be removed from the design.

    WARNING:Xst:2973 – All outputs of instance cnt_i of block contador_reloj are unconnected in block reloj . Underlying logic will be removed.
    WARNING:Xst:2677 – Node clk_i/temporal of sequential type is unconnected in block reloj .

    Espero que me puedas ayudar a resolverlo, gracias

  • Responder
    Miguel Castillo
    noviembre 24, 2015 at 3:38 pm

    Excelente aportación, profesor. Me fue de gran ayuda. Me hubiera gustado que usted nos hubiese impartido la materia de Electrónica Digital para habernos especializado más.
    Saludos y muchas gracias.

  • Responder
    Mario
    diciembre 8, 2015 at 11:14 pm

    Buenas noches tengo un problema con el codigo se me queda trabado del 3 al 0 en cada display, que podria hacer para que funcione el reloj, graxias

  • Responder
    Gabriel
    abril 18, 2016 at 2:08 pm

    me sale muchas advertencias y al probarlo en la basys no funciona necesito ayuda urgente porfavor!!!

    • Responder
      Carlos Ramos
      noviembre 14, 2016 at 11:40 am

      ¿Cuáles advertencias? Tu comentario no ayuda mucho sin información concreta.

  • Responder
    osmar aram
    mayo 23, 2016 at 4:34 pm

    saludos!!!, buena visualización del contador no se si ya se agrego el ajuste de las horas y los minutos estoy teniendo problemas con eso y si me podrían ayudar

    • Responder
      Carlos Ramos
      noviembre 14, 2016 at 11:43 am

      Osmar, aún no se realiza tal cosa. No obstante, estoy trabajando en un minicurso que plantea una posible solución a ese problema. Debería estar listo para principios de diciembre 2016.

  • Responder
    Elienai
    julio 18, 2016 at 2:38 pm

    Disculpa como le haría para implementarlo en una Spartan 3E, o alguien sabe, soy nueva en esto y se me dificulta quisiera saber si lo puedo hacer y como????

    • Responder
      Carlos Ramos
      julio 19, 2016 at 7:52 am

      Elienai, para implementarlo en una Spartan3E sólo debes cambiar el archivo de implementación (reloj_basys2.ucf) para que funcione con los pines que marca la hoja de datos de tu tarjeta para el reloj, y los visualizadores de siete segmentos. Saludos.

  • Responder
    Osvaldo
    agosto 3, 2016 at 8:23 am

    Hola que tal. Tengo una pregunta, una vez que tengo mi reloj, ¿cómo podría añadirle una alarma pero que sea ajustable desde la tarjeta, ya sea con los botones o los switches?

    • Responder
      Carlos Ramos
      noviembre 14, 2016 at 11:45 am

      Pues, con unos cuantos módulos más de código XD. Primero hay que hacer que la hora del reloj sea ajustable antes de pensar en una alarma. Estoy trabajando en un minicurso para el ajuste manual de la hora a través de botones. Espero esté listo pronto y les sea de utilidad.

  • Responder
    Luis David Carabali
    septiembre 26, 2016 at 12:43 pm

    Hola Buen Dia estoy tratando de implemetar el codigo en QUARTUS, la verdad soy nuevo en VHDL, y ya compile todo estoy usadon una UP2 pero no quiero usar los displays de la fpga lo quiero usar externos y mi pregunta es las salidas de los MUX van conectadas a donde a los displays o a donde van? y lo otro la señal CKL va conectada al reloj interno de la fpga o donde? me refiero aesta parte de tu codigo:

    NET  &quot;clk&quot;         LOC = &quot;B8&quot;;
    NET  &quot;reset&quot;       LOC = &quot;G12&quot;;
    # Segmentos del visualizador. #########
    NET  &quot;salida&lt;7&gt;&quot;   LOC = &quot;N13&quot;; # dp
    NET  &quot;salida&lt;6&gt;&quot;   LOC = &quot;M12&quot;; # g
    NET  &quot;salida&lt;5&gt;&quot;   LOC = &quot;L13&quot;; # f
    NET  &quot;salida&lt;4&gt;&quot;   LOC = &quot;P12&quot;; # e
    NET  &quot;salida&lt;3&gt;&quot;   LOC = &quot;N11&quot;; # d
    NET  &quot;salida&lt;2&gt;&quot;   LOC = &quot;N14&quot;; # c
    NET  &quot;salida&lt;1&gt;&quot;   LOC = &quot;H12&quot;; # b
    NET  &quot;salida&lt;0&gt;&quot;   LOC = &quot;L14&quot;; # a
    # Multiplexor #########################
    NET  &quot;MUX&lt;3&gt;&quot;      LOC = &quot;F12&quot;;
    NET  &quot;MUX&lt;2&gt;&quot;      LOC = &quot;J12&quot;;
    NET  &quot;MUX&lt;1&gt;&quot;      LOC = &quot;M13&quot;;
    NET  &quot;MUX&lt;0&gt;&quot;      LOC = &quot;K14&quot;;
    

    De antemano gracias por tu aporte

    • Responder
      Carlos Ramos
      septiembre 26, 2016 at 1:30 pm

      La salida de los MUX debe ir a la alimentación de los visualizadores, de forma que mandes el 1 al que quieras prendido y el 0 al que estén apagados. Y, sí, la señal de reloj va a tu reloj interno de la tarjeta. Espero te haya sido útil :).

      • Responder
        Luis David Carabali
        septiembre 26, 2016 at 4:56 pm

        Gracias Voy a probarlo y segun los resultados de comento

  • Responder
    Andrea Restrepo
    octubre 22, 2016 at 6:40 pm

    Buenas!
    Tengo una duda, debo hacer un temporizador en VDHL que vaya hasta 15, es decir, cuente de 0 a 5, de ahí se reinicie y vuelva a contar de 0 a 10, luego lo mismo de 0 a 15… Cómo podría hacerlo? Es que no sé

    • Responder
      Carlos Ramos
      octubre 24, 2016 at 10:55 am

      Andrea, ¿podrías definir un poco más los requisitos de este temporizador? La verdad, no entendí muy bien lo que necesitas :s.

      • Responder
        Andrea Restrepo
        octubre 24, 2016 at 5:38 pm

        Umm, pues el temporizador solo debe contar hasta 15 segundos, amm pues primero que cuente de 0 a 5 segundos se reinicie en el instante que llegue a 5 y empiece a contar esta vez de 0 a 10 segundos y pues cuando llegue a 10 segundos se reinicie para así ahora solo contar de 0 a 15 segundos y ya.
        No sé como explícartelo más…

        • Responder
          Carlos Ramos
          octubre 25, 2016 at 4:08 pm

          Andrea, según lo describes, yo haría tres contadores independientes, con una máquina de tres estados (al menos). Primero, el contador de 0 a 5, que cambie al siguiente estado al llegar a cinco. Para el segundo estado, empiezas el contador de 0 a 10, y al llegar al tope cambias al tercer estado. Ya en el tercer estado activas el contador de 0 a 15, y regresas al primer estado, de 0 a 5. Habrá que hacer alguna que otra magia para regresar a cero los contadores entre estados, pero esa primera aproximación debe darte una idea de cómo estructurar el código. ¿Qué llevas de avance hasta ahora?

          • Andrea Restrepo
            octubre 25, 2016 at 4:23 pm

            Pues en realidad hasta ahora llevo prácticamente nada, no tengo idea de como hacerlo. Y pues maquinas de estado no he aprendido hasta el momento =(

  • Responder
    Juana Martinez Gonzalez
    noviembre 14, 2016 at 11:13 am

    hola chicos, estoy trabajando con un reloj en VHDL para la nexys 3, lo único que me falta es encender los dos puntos que tiene el display de la tarjeta, sabe como se pueden encender?

    • Responder
      Carlos Ramos
      noviembre 14, 2016 at 11:20 am

      Juana, me parece que la Nexys 3 no tiene ese pin conectado, por lo que no es posible utilizarlo. Puedes revisar la hoja de datos, para ver si descubres que sí tiene un puerto asignado, pero casi creo que no es así. Saludos.

  • Responder
    JOSE EUSEBIO LOPEZ
    noviembre 17, 2016 at 3:51 pm

    Buenas tardes ingeniero:

    Buena pagina.
    soy estudiante de Ingeniería Electrónica y debo realizar un proyecto donde debo contar el tiempo de 3 corredores y guardarlos en una memoria para luego mostrarlos la frecuencia del reloj es 1 hz.
    Sera que me puede asesorar.

    • Responder
      Carlos Ramos
      noviembre 18, 2016 at 4:03 pm

      José, visita mi página de contacto sobre los requerimientos para este tipo de preguntas.

  • Responder
    Yahir González
    diciembre 19, 2016 at 11:15 pm

    ¿Se puede modificar este programa para hacer un reloj descendente?

    Y como se hace???

  • Responder
    Isaac
    abril 19, 2017 at 12:31 am

    Oye una pregunta me dejaron un reloj digital que marque la hora actual y minutos me tocó hacerlo jerarquico estoy trabajando con virtualbox soy nuevo en esto cres que me podrías orientar

  • Responder
    Jhony
    mayo 29, 2017 at 10:34 pm

    Hola Carlos me preguntaba si trabajas con verilog es que soy nuevo en esto y necesito hacer un contador de 0 a 9.

    • Responder
      Carlos Ramos
      junio 26, 2017 at 9:46 am

      De momento no tengo material en Verilog, aún está en planes a futuro :(.

  • Responder
    juan
    septiembre 20, 2017 at 10:36 pm

    hola Carlos disculpa el reloj lo quiero aplicar en la tarjeta spartan 3E en el display LCD si se lo puede hacer ?? y el codigo seria el mismo de esta pagina web

    • Responder
      Carlos Ramos
      octubre 16, 2017 at 1:07 am

      Juan, tendrías que encontrar un módulo que tenga la interfaz con el LCD, y allí ya enviar los datos del reloj hacia allá. Es decir, primero consigue un núcleo IP que trabaje con el LCD que quieres, y después te preocupas de un codificador de BCD a la pantalla LCD.

  • Responder
    Julio Ruiz
    noviembre 1, 2017 at 5:52 pm

    Excelente post, me gustaria saber como solucionar el error que sale en la BCD “3210” y de ahi no se mueve, ¿Me podrian eplicar que es lo que sucede o el porque dentro de las lineas de codigo?

    • Responder
      Carlos Ramos
      noviembre 1, 2017 at 6:05 pm

      Julio, hay un problema en el PORT MAP. Busca la línea donde se envían los datos directamente, como “0000”, “0001”, etcétera. En su lugar, debes colocar las señales que recibe el módulo Saludos, espero te sirva.

      • Responder
        Julio Ruiz
        noviembre 1, 2017 at 7:15 pm

        Gracias ! si era el error en PORT MAP , solo que es de MM/SS, no de HH/MM , busque en tu mini curso pero no viene el codigo como tal. De antemano muchas gracias.

  • Responder
    Oscar Loera
    febrero 1, 2018 at 1:35 pm

    Hola que tal…. una pregunta: tengo una practica de un multiplexor de 4:1, 2 selectores(S1 y S0), entradas(A0, A2, A3, y A3) y una sola salida Y. Tengo 4 procesos diferentes para cada valor de S. osea: cuando el selector S marca 00, con las entradas A, en la tarjeta Basys2 puedo mostrar en los 4 displays los numeros de 0 a 9…. cunado S es 01, es el codigo binario…. cuando S es 10 es una circuito logico y cuando S es 11 es la letra H….. mi pregunta es: el tarjeta Basys2 todo esto se muestra al mismo tiempo en los 4 displays… como le hago o que tengo que modificar en mi programa VHDL para que me los muestre en un solo display…. que me muestre todo tal cual esta programado pero solo en un display de los 4… los otros 3 que se queden apagados…. el profesor nos dio una pista y nos dijo que es modificando algo en el programa, en la estructura que programe… es para una practica de examen de la escuela, soy principiante y quisiera por favor me ayudaran… de antemano gracias

  • Responder
    Juan Lalito Juaréz
    mayo 25, 2020 at 1:57 am

    Buenas noches, disculpe estoy tratando hacer un botón para ajustar de forma manual los minutos y segundos. No se si pudiera ayudarme ya que estoy teniendo problemas con eso.

  • Deja tu comentario