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

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;