Преместващи регистри

Необходимите файлове се намират в проекта johnson.

Брояч на Джонсън

  • Разгледайте брояча на Джонсън и сответният тест
  • Симулирайте го и се уверете, че работи правилно.
  • 
    library ieee;
    use ieee.std_logic_1164.all;
    use ieee.numeric_std.all;
    
    entity johnson is
        generic(N: positive);
        port( clock, reset: in std_logic;
            reg: out std_logic_vector (N-1 downto 0));
    end johnson;
    
    architecture v1 of johnson is
        signal reg_i: std_logic_vector(reg'range);
    begin
        reg <= reg_i;
        process (clock, reset)
        begin
            if( reset = '1') then
                reg_i <= (others=>'0');
            elsif rising_edge(clock) then
                -- using concatenation
                reg_i <= reg_i(reg'left-1 downto reg'right) &amp; not reg_i(reg'left);
            end if;
        end process;
    end v1;
    
    architecture v2 of johnson is
        signal reg_i: unsigned(reg'range);
    begin
        reg <= std_logic_vector(reg_i);
        process (clock, reset)
            variable tmp: std_logic;
        begin
            if( reset = '1') then
                reg_i <= (others=>'0');
            elsif rising_edge(clock) then
                -- using shift functions
                tmp := reg_i(reg'left); 
                reg_i <= shift_left(reg_i, 1);
                reg_i(reg'right) <= not tmp;
            end if;
        end process;
    end v2;
    
    

    Синтезирана схема на 4-битов брояч на Джонсън.

    johnson_4bit-sch

    Тест

    library ieee;
    use ieee.std_logic_1164.all;
     
    entity johnson_tb is
    end johnson_tb;
     
    architecture behavior of johnson_tb is  
        constant CLOCK_PERIOD : time := 10 ns; 
        constant WIDTH : positive := 8;
        signal clock_run : boolean := true;
       
        signal clock : std_logic;
        signal reset : std_logic;
        signal led : std_logic_vector(WIDTH-1 downto 0);
    begin
       UUT: entity work.johnson(v1)
          generic map( N => WIDTH )
          port map (
             clock => clock,
             reset => reset,
             reg => led
          );
    
        clock_process :process
        begin
        if clock_run then
            clock <= '0';
            wait for CLOCK_PERIOD/2;
            clock <= '1';
            wait for CLOCK_PERIOD/2;
        else
            wait;
        end if;
        end process;
     
       stim_proc: process
       begin      
          reset <= '1';
          wait until falling_edge(clock);
          assert led = "00000000" report "led != 00000000";
          
          reset <= '0';
          wait until falling_edge(clock);
          assert led = "00000001" report "led != 00000001";
          
          wait until falling_edge(clock);
          assert led = "00000011" report "led != 00000011";
          
          wait until falling_edge(clock);
          assert led = "00000111" report "led != 00000111";
          
          wait until falling_edge(clock);
          assert led = "00001111" report "led != 00001111";
          
          wait until falling_edge(clock);
          assert led = "00011111" report "led != 00011111";
          
          wait until falling_edge(clock);
          assert led = "00111111" report "led != 00111111";
          
          wait until falling_edge(clock);
          assert led = "01111111" report "led != 01111111";
          
          wait until falling_edge(clock);
          assert led = "11111111" report "led != 11111111";
          
          wait until falling_edge(clock);
          assert led = "11111110" report "led != 11111110";
          
          wait until falling_edge(clock);
          assert led = "11111100" report "led != 11111100";
          
          for i in 1 to 6 loop
             wait until falling_edge(clock);
          end loop;
          assert led = "00000000" report "led != 00000000";
          
          for i in 1 to 8 loop
             wait until falling_edge(clock);
          end loop;
          assert led = "11111111" report "led != 11111111";
          
          clock_run <= false;
          wait;
       end process;
    end;
    

    johnson

    Стрктурен модела за тестване на проектната единица top експерименталната платка.

    library ieee;
    use ieee.std_logic_1164.all;
    
    entity experiment is
        port ( clock50: in std_logic;
               reset: in std_logic;
               led: out std_logic_vector (7 downto 0));
    end experiment;
    
    architecture structural of experiment is
       signal clock: std_logic; 
    begin
     
       U1: entity work.johnson(v1)
          generic map (N =&amp;gt; 8)
          port map(
              clock =&amp;gt; clock,
              reset =&amp;gt; reset,
              reg =&amp;gt; led);
     
       U2: entity work.clock_divider
          generic map (N =&amp;gt; 23)
          port map( 
              clock_in =&amp;gt; clock50,
              clock_out =&amp;gt; clock,
              reset =&amp;gt; reset);
    end structural;
    

Бягаща светлина

  • Променете броячът на Джонсън от предишната задача, така че да се получи ефект на "бягаща светлина".
  • Модифицирайте теста, така че да съответства на новата спецификация.
  • Синтезирайте проекта и се убедете, че работи на макета.

running_light_sim

Указания

При reset, инициализирайте преместващия регистър с единица в единият от битовете и нули в останалите:

    reg_int <= (0=>'1', others=>'0');

Бягаща светлина със смяна на посоката

  • Променете моделът от предишната задача, така че да се получи ефект на "бягаща светлина със смяна на посоката" (виж фигурата по-долу).
  • Модифицирайте теста, така че да съответства на новата спецификация.
  • Синтезирайте проекта и се убедете, че работи на макета.

bouncing_light

Указания

Въведете сигнал dir, който да указва посоката на преместване:

    type direction is (right_to_left, left_to_right);
    signal dir: direction;

В зависимост от стойността на dir, регистърът премества наляво или надясно.
Стойността на dir да се променя когато единицата достигне края на преместващия регистър.