һ

44个vhdl实例 注1： 含有不可综合语句

                   next_state <= PLAY ;
                   active_bin <= present_active_bin ;
                   load_hand_with_active_bin <= TRUE ;
               end if ;
           else 
               -- Regular state to go to next bin during play
               next_state <= PLAY ;
               decrement_hand <= TRUE ;

               -- go to the next bin
               next_active_bin := shift(present_active_bin) ;

               -- We dont have to drop a marble in the opponents bin :
               -- shift one bin further if this is about to happen
               if ((player=LEFT and next_active_bin(OUTER_RIGHT)) OR
                   (player=RIGHT and next_active_bin(OUTER_LEFT))) then
                   next_active_bin := shift (next_active_bin) ; 
               end if ;
                  
               -- If the bin we go to is empty, flag that now, since
               -- we need to do something different in the next cycle.
               if (NOT is_empty (next_active_bin AND empty_bins)) then
                   next_bin_is_empty <= TRUE ;
               end if ;

               active_bin <= next_active_bin ;
           end if ;

         when WAIT_FOR_MOVE =>
           waiting_for_move <= TRUE ;
           if (is_empty((NOT empty_bins) AND not_home_bins)) then 
               -- Here, there are no more marbles in any of the 
               -- play bins. This is the end of the game. 
               next_state <= END_OF_GAME ;
               active_bin <= (others=>FALSE) ;
           elsif (is_empty(buttons AND (NOT empty_bins) AND not_home_bins)) then 
               -- Here, No button was pushed that is valid (not 
               -- selecting a empty bin and not selecting a home bin. 
               next_state <= WAIT_FOR_MOVE ;
               active_bin <= (others=>FALSE) ;
           else 
              -- Somebody pushed a button. Load the hand with selected 
              -- bin and restart the play
               next_state <= PLAY ;
               load_hand_with_active_bin <= TRUE ;
               active_bin <= buttons ; -- Should have only ONE bit set
           end if ;

         when END_OF_GAME =>
           -- Let the datapath calculate who the winner is
           end_of_the_game <= TRUE ;

           active_bin <= (others=>false) ;
           if (start_game) then
               next_state <= WAIT_FOR_MOVE ;
           else 
               next_state <= END_OF_GAME ;
           end if ;
       end case ;
   end process ;

 -- 
 -- Process that controls which player is on.
 -- The state machine defines when players have to be switched
 --
   process (clk, reset)
       procedure switch_players (signal pl : inout player_t) is
       begin 
           if (pl=LEFT) then
               pl <= RIGHT ;
           elsif (pl=RIGHT) then
               pl <= LEFT ;
           end if ;
       end ;
   begin
       if (reset='1') then
           player <= NEITHER ;
       elsif (clk'event and clk='1') then
           if (start_game) then
               player <= LEFT ;
           else
               if (switch_player) then 
                   switch_players (player) ;
               end if ;
           end if ;
       end if ;
   end process ;

   the_player <= player ;

end exemplar ;




library ieee ;
use ieee.std_logic_1164.all ;
use work.mancala_pack.all ;

entity mancala is
   generic (max_marbles : natural := 32) ;

   port (start_game              : boolean ;
         active_bin_value        : buffer integer range 0 to max_marbles-1;
         active_bin              : buffer  boolean_array(nr_of_bins-1 downto 0);
         blink_right, blink_left : inout std_logic;
         clk, reset              : in   std_logic;
         buttons                 : in   boolean_array(nr_of_bins-1 downto 0);
         button_lights           : out  boolean_array(nr_of_bins-1 downto 0);
         l_player, r_player      : out  std_logic
   ) ;
end mancala ;
  
architecture exemplar of mancala is 

   subtype bin_integer is integer range 0 to max_marbles-1 ; 
   type bin_integer_array is array (nr_of_bins-1 downto 0) of bin_integer ;


   -- The bins
   signal bins : bin_integer_array ; 
   signal incremented_bin_value : bin_integer ;
   signal empty_bins : boolean_array (nr_of_bins-1 downto 0) ;
  
   -- The hand 
   signal hand : bin_integer ;
   signal load_hand_with_active_bin : boolean ; 
   signal decrement_hand : boolean ;
   signal hand_is_empty : boolean ;

   -- Which player is playing / winning
   signal player : player_t ;
   signal winner : player_t ;   

   signal waiting_for_move : boolean ;
   signal end_of_the_game : boolean ;

begin

   c : control generic map ( nr_of_bins=>nr_of_bins) 
               port map ( -- To controller :
                          start_game=>start_game,
                          clk=>clk, 
                          reset=>reset,
                          buttons=>buttons, 
                          empty_bins=>empty_bins,
                          hand_is_empty=>hand_is_empty,

                          -- From controller :
                          active_bin=>active_bin,
                          decrement_hand=>decrement_hand,
                          load_hand_with_active_bin=>load_hand_with_active_bin,
                          the_player=>player,
                          end_of_the_game=>end_of_the_game,
                          waiting_for_move=>waiting_for_move
                  ) ;

 --
 -- Process the amount of marbles in the hand
 --
   process (clk, reset) 
   begin
      if (reset='1') then 
          hand <= 0 ;
      elsif clk'event and clk='1' then
          if (start_game) then
              hand <= 0 ;
          elsif (load_hand_with_active_bin) then
              hand <= active_bin_value ;
          elsif (decrement_hand and (not hand_is_empty)) then
              hand <= hand - 1 ;
          end if ;
      end if ;
   end process ; 

   hand_is_empty <= (hand=0) ; 

 --
 -- Process the amount of marbles in each bin
 --
   bin_procs : for i in bins'range generate
       process (reset, clk)
       begin
           if (reset='1') then
               bins(i) <= 0 ;
           elsif clk'event and clk='1' then
               if (start_game) then
                   -- Initialize the home bins to zero and the
                   -- work bins to a number that guarantees that there
                   -- will be max_marbles in the game. 
                   if (i=OUTER_LEFT or i=OUTER_RIGHT) then
                       bins(i) <= 0 ;
                   else 
                       bins(i) <= max_marbles/(nr_of_bins-2) ;
                   end if ;
               elsif (active_bin(i)) then
                   if (load_hand_with_active_bin) then
                       bins(i) <= 0 ;
                   elsif (decrement_hand and (not hand_is_empty)) then
                       bins(i) <= incremented_bin_value ; 
                   end if ;
               end if ;
           end if ;
       end process ;
       empty_bins(i) <= bins(i) = 0 ;
   end generate ; 
 
 -- 
 -- Select the bin (from the bins register) that is presently active 
 -- 
   process (active_bin, bins) 
   begin
      active_bin_value <= 0 ;
      for i in bins'range loop
          if (active_bin(i)) then
              active_bin_value <= bins(i) ;
          end if ;
      end loop ;
   end process ;

 --
 -- Calculate the incremented value of the presently selected bin
 --
   incremented_bin_value <= active_bin_value + 1 ;



 -- Generate the light signals for the player that is active
   l_player <= '1' when player=LEFT else '0' ;
   r_player <= '1' when player=RIGHT else '0' ;

 --
 -- Define the winner 
 --
   winner <= NEITHER when NOT end_of_the_game ELSE
             BOTH when bins(OUTER_LEFT)=bins(OUTER_RIGHT) ELSE
             LEFT when bins(OUTER_LEFT)>bins(OUTER_RIGHT) ELSE
             RIGHT ;
 -- 
 -- Blink the display of the winner (on/off)
 -- 
   process (clk, reset)
   begin
      if (reset='1') then
          -- Displays ON
          blink_left <= '1' ;
          blink_right <= '1' ;
      elsif clk'event and clk='1' then
          case winner is
             when LEFT =>
                blink_left <= NOT blink_left ;
                blink_right <= '1' ;
             when RIGHT =>
                blink_left <= '1' ;
                blink_right <= NOT blink_right ;
             when BOTH => 
                blink_left <= NOT blink_left ;
                blink_right <= NOT blink_right ;
             when OTHERS =>
                blink_left <= '1' ;
                blink_right <= '1' ;
          end case ;
      end if ;
   end process ;
   
 --
 -- Button lights 
 -- Light on each button for possible move
 --

   lights : for i in button_lights'range generate
       button_lights(i) <= TRUE when (waiting_for_move AND NOT empty_bins(i)) 
                           else FALSE ;
   end generate ; 

end exemplar ;