Управление семисегментным дисплеем с помощью ПЛИС

entity delay is
    -- При объявлении entity, поле generic не является обязательным
    generic (delay_cnt: integer);
    -- Описываем входные и выходные сигналы устройства
    port(clk: in std_logic; out_s: out std_logic := '0');	
end entity delay;

-- В секции architecture описывается то, как устройство будет работать
-- С одной entity может быть связано 0 или более архитектур
architecture delay_arch of delay is
begin
    delay_proc: process(clk)
        variable clk_cnt: integer range 0 to delay_cnt := 0;
        variable out_v: std_logic := '0';
    begin
        -- Если имеем дело с передним фронтом сигнала
        if(rising_edge(clk)) then
            clk_cnt := clk_cnt + 1;					
				
  	    if(clk_cnt >= delay_cnt) then
                -- switch/case в языке VHDL
	        case out_v is
	    	    when '0' => 
                        out_v := '1';
	   	    when others =>
			out_v := '0';
		end case;
				
		clk_cnt := 0;
                -- Устанавливаем в сигнал out_s значение переменной out_v
		out_s <= out_v;
            end if;
	end if;
    end process delay_proc;
end delay_arch;

entity bcd_to_7seg is
    port(bcd: in std_logic_vector(3 downto 0) := X"0";
           disp_out: out std_logic_vector(7 downto 0) := X"00");
end entity bcd_to_7seg;

architecture bcd_to_7seg_arch of bcd_to_7seg is
    signal not_bcd_s: std_logic_vector(3 downto 0) := X"0";
begin
    not_bcd_s <= not bcd;

    disp_out(7) <= (bcd(2) and not_bcd_s(1) and not_bcd_s(0)) or 
			   (not_bcd_s(3) and not_bcd_s(2) and not_bcd_s(1) 
                            and bcd(0));
					
    disp_out(6) <= (bcd(2) and not_bcd_s(1) and bcd(0)) or
			   (bcd(2) and bcd(1) and not_bcd_s(0));
					
    disp_out(5) <= not_bcd_s(2) and bcd(1) and not_bcd_s(0);
	
    disp_out(4) <= (not_bcd_s(3) and not_bcd_s(2) and not_bcd_s(1) 
                             and bcd(0)) or
			   (bcd(2) and not_bcd_s(1) and not_bcd_s(0)) or
			   (bcd(2) and bcd(1) and bcd(0));
					
    disp_out(3) <= (bcd(2) and not_bcd_s(1)) or bcd(0);
	
    disp_out(2) <= (not_bcd_s(3) and not_bcd_s(2) and bcd(0)) or
		    	   (not_bcd_s(3) and not_bcd_s(2) and bcd(1)) or
			   (bcd(1) and bcd(0));
					
    disp_out(1) <= (not_bcd_s(3) and not_bcd_s(2) and not_bcd_s(1)) or
		           (bcd(2) and bcd(1) and bcd(0));
	
    disp_out(0) <= '1';
end bcd_to_7seg_arch;

entity transmitter is
    port(enable: in boolean; 
           clk: in std_logic; 
           digit_pos: in std_logic_vector(7 downto 0) := X"00"; 
           digit: in std_logic_vector(7 downto 0) := X"00"; 
           sclk, dio: out std_logic := '0'; 
           ready: buffer boolean := true);
end entity transmitter;

architecture transmitter_arch of transmitter is
    constant max_int: integer := 16;
begin
    sclk <= clk when not ready else '0';		

    send_proc: process(clk, enable, ready)
	variable dio_cnt_v: integer range 0 to max_int := 0;
	variable data_v: std_logic_vector((max_int - 1) downto 0);
    begin
	-- Установка сигнала dio происходит по заднему фронту сигнала clk
	if(falling_edge(clk) and (enable or not ready)) then
	    if(dio_cnt_v = 0) then
		-- Прежде всего передаем данные, потом позицию на дисплее
		-- Нулевой бит данных идет в нулевой бит объединенного вектора
		data_v := digit_pos & digit;
		ready <= false;
	    end if;			
			
	    if(dio_cnt_v = max_int) then				
		dio_cnt_v := 0;
		ready <= true;
		dio <= '0';
	    else	
		dio <= data_v(dio_cnt_v);
		dio_cnt_v := dio_cnt_v + 1;
	    end if;
	end if;
    end process send_proc;
end transmitter_arch;

entity display is
    port(clk: in std_logic; sclk, rclk, dio: out std_logic := '0');
end entity display;

architecture display_arch of display is
    component delay is
	generic (delay_cnt: integer); 
	port(clk: in std_logic; out_s: out std_logic := '0');
    end component;
	
    component bcd_counter is
	port(clk: in std_logic; bcd: out std_logic_vector(3 downto 0));
    end component;
	
    component bcd_to_7seg is
	port(bcd: in std_logic_vector(3 downto 0); 
               disp_out: out std_logic_vector(7 downto 0));
    end component;
	
    component transmitter is
	port(enable: in boolean; 
               clk: in std_logic; 
               digit_pos: in std_logic_vector(7 downto 0); 
               digit: in std_logic_vector(7 downto 0); 
               sclk, dio: out std_logic; 
               ready: buffer boolean);
    end component;
	
    signal sec_s: std_logic := '0';
    signal bcd_counter_s: std_logic_vector(3 downto 0) := X"0";
    signal disp_out_s: std_logic_vector(7 downto 0) := X"00";
	
    signal tr_enable_s: boolean;
    signal tr_ready_s: boolean;
    signal tr_data_s: std_logic_vector(7 downto 0) := X"00";
	
    -- Этот флаг, совместно с tr_ready_s контролирует 
    -- установку и сброс rclk сигнала 
    signal disp_refresh_s: boolean;
	
    signal transfer_clk: std_logic := '0';
begin
    sec_delay: delay generic map(25_000_000)	
				port map(clk, sec_s);
				
    transfer_delay: delay generic map(10)
				port map(clk, transfer_clk);
				
    bcd_counter1: bcd_counter port map(sec_s, bcd_counter_s);
	
    bcd_to_7seg1: bcd_to_7seg port map(bcd_counter_s, disp_out_s);
	
    transmitter1: transmitter port map(tr_enable_s, 
                                                    transfer_clk, 
                                                    X"10", 
                                                    tr_data_s, 
                                                    sclk, 
                                                    dio,
                                                    tr_ready_s);
	
    tr_proc: process(transfer_clk)
	variable prev_disp: std_logic_vector(7 downto 0);
	variable rclk_v: std_logic := '0';
    begin
	if(rising_edge(transfer_clk)) then
            -- Если передатчик готов к передаче следующей порции данных
	    if(tr_ready_s) then	
                -- Если передаваемые данные не были только что переданы
	        if(not (prev_disp = disp_out_s)) then		 
		    prev_disp := disp_out_s;
                    -- Помещаем передаваемые данные в шину данных передатчика
	            tr_data_s <= disp_out_s;	
                    -- Запускаем передачу данных			
		    tr_enable_s <= true;
		end if;
	    else
		disp_refresh_s <= true;
				
		-- Флаг запуска передачи данных нужно снять 
                -- до завершения передачи,
                -- поэтому снимаю его по приходу следующего частотного сигнала
		tr_enable_s <= false;
	    end if;
			
	    if(rclk_v = '1') then
		disp_refresh_s <= false;
	    end if;
			
	    if(tr_ready_s and disp_refresh_s) then			 
		rclk_v := '1';
            else
		rclk_v := '0';
	    end if;
			
	    rclk <= rclk_v;
	end if;		
    end process tr_proc;
end display_arch;