һ

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

-- 
--   Copyright (c) 1993,1994 by Exemplar Logic, Inc.  All Rights Reserved.
--
-- This source file may be used and distributed without restriction    
-- provided that this copyright statement is not removed from the file  
-- and that any derivative work contains this copyright notice.         
--
-----------
--
--  This is a synthesizable description that implements an emulator 
--  of the Mancala game (African beans game).
--
--  Description of the Hardware
-------------------------------
--
--  The hardware for the game includes a number of displays, each with a button and
--  a light, that each represent a 'bin' that can store marbles (beans). 
--
--  The display indicates the number of marbles in each bin at any given time. 
--  The light indecates that the present bin is not empty and that pushing the 
--  button is a valid move in the game.
--
--  The button for each display indicates that a player takes the marbles from 
--  the selected bin, and takes them in his hand. The hand is represented by a 
--  diplay itself (no button).
--
--  Each player has a home bin, located on opposite sides of the game. The home 
--  bin is also represented by a display. There should not be a button on the 
--  home bins, since the game does not allow the removal of marbles from the home
--  bins.
--
--  Besides this, the game has a button to start the game, and a reset for power-up
--  purposes.
--
--  Here is a picture that represents the hardware setup of the game :
--
--
--  *  == Light for valid move or to indicate the player who is active
--  O  == Button to make move
--  _
-- | | 
--  -  == 7 - segment display
-- |_|
--
--                           work bins
--                  *   O     *   O     *   O     *   O
--                  _   _     _   _     _   _     _   _
--                 | | | |   | | | |   | | | |   | | | | 
--                  -   -     -   -     -   -     -   -
--       *         |_| |_|   |_| |_|   |_| |_|   |_| |_|         *
--     _   _                                                   _   _
--    | | | |                                                 | | | |
--     -   -                                                   -   -
--    |_| |_|                                                 |_| |_|
--
-- home bin LEFT                                           home bin right
--                  *   O     *   O     *   O     *   O            
--                  _   _     _   _     _   _     _   _
--                 | | | |   | | | |   | | | |   | | | | 
--                  -   -     -   -     -   -     -   -
--                 |_| |_|   |_| |_|   |_| |_|   |_| |_|
--
--                            work bins
--
--     _   _
--    | | | |
--     -   -                                              O  Start Game
--    |_| |_|
--
--    Hand bin
--
--
-- The Rules of the game 
------------------------
--
--    At the start of the game, the left player is active and can make a move.
--    The left player selects a bin (by pressing the corresponding button).
--    The machine will move the marbles from the bin (display) to the hand (diplay)
--    and drop one marble in each successive bin (clockwise) from the hand, 
--    starting with the bin clock-wise adjecent to the selected bin.
--    A marble is never dropped in a opponents home bin (will be skipped).
--
--    If the last marble from the hand is dropped in an empty bin, the players
--    switch turns, and it is the other players turn to make a move.
--
--    If the last marble from the hand is dropped in the players home bin,
--    the player can make another move.
--
--    If the last marble from the hand is dropped in a non-empty work bin,
--    all the marbles from that bin will be moved back to the hand and the
 --   game proceeds.
--
--    The game ends if there are no more marbles in any of the work bins.
--
--    The winner of the game is the player who has most marbles in his/her
--    home bin at the end of the game.
--
--
--
--  About the design
--------------------
--
--    The design contains a controller and a data path. The controller contains 
--    a state machine that defines the overall state of the game (waiting for a
--    move, end of the game, playing). 
--    The controller also has a register that defines which bin is active at any
--    point in time during active playing. 
--
--    The controller provides signals for the data path to decrement the hand 
--    marble count, or load the hand with the selected work bin count, or indecate
--    that the game is over and a winner should be defined etc.
--
--    The data path contains a register for each bin in the game. 
--    The number of bins is easily programmable by setting a integer constant.
--    The data path also contains counters to decrement the hand marble count
--    or increment the bin marble counts.
--
--    The data path provides signals for the controller to indicate that the 
--    hand bin is empty, or which of the work bins is empty.
--   
--    The work bin registers are loaded with a equal number of marbles at the start 
--    of the game. The total number of marbles in the game is programmable by setting
--    a generic in the top entity.
--
--    The data path also includes light drivers for the lights on each button that 
--    indicate a valid move, and the lights that indicate which player is active.
--    Two extra signals are generated by the data path that let the home bin 
--    display of the winner of the game blink on and off (at the end of the game).
--
--    The design does not include a merry-go-round display driver. This is done
--    outside this design, on the Aptix board. 
--
--    The design does also not include a 18 bit clock devider that provides a 
--    vary slow ticking clock to let humans follow the moves of the machine 
--    cycle by cycle.
--
--    


library ieee ;
use ieee.std_logic_1164.all ;

package mancala_pack is

   type boolean_array is array (natural range <>) of boolean ;
   type player_t is (LEFT, RIGHT, BOTH, NEITHER) ;

   -- Define the number of bins in the game here.
   -- This include the two home bins
   constant nr_of_bins : natural := 10 ; 

   -- Define the indexes of the two home bins 
   constant OUTER_LEFT : natural := 0 ;
   constant OUTER_RIGHT : natural := nr_of_bins/2 ; 

   -- Make a 'mask' constant that eliminates the home bins
   constant not_home_bins : boolean_array (nr_of_bins-1 downto 0) := 
       (OUTER_LEFT=>FALSE, OUTER_RIGHT=>FALSE, OTHERS=>TRUE) ;

   -- Component Declaration of the controller of the game
   component control 
       generic (nr_of_bins : natural := 32) ;

       port (start_game : in boolean ;
           reset, clk : in std_logic ;
           buttons : in boolean_array (nr_of_bins-1 downto 0) ;
           empty_bins : in boolean_array (nr_of_bins-1 downto 0) ;
           hand_is_empty : in boolean ; 
         
           active_bin : buffer boolean_array (nr_of_bins-1 downto 0) ;
           decrement_hand : out boolean ;
           load_hand_with_active_bin : out boolean ;
     
           the_player : out player_t ;
           end_of_the_game : out boolean ;
           waiting_for_move : out boolean
       ) ;
   end component ;

end mancala_pack ;

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

entity control is
   generic (nr_of_bins : natural := 10) ;

   port (start_game : in boolean ;
         reset, clk : in std_logic ;
         buttons : in boolean_array (nr_of_bins-1 downto 0) ;
         empty_bins : in boolean_array (nr_of_bins-1 downto 0) ;
         hand_is_empty : in boolean ; 
         
         active_bin : buffer boolean_array (nr_of_bins-1 downto 0) ;
         decrement_hand : out boolean ;
         load_hand_with_active_bin : out boolean ;
         the_player : out player_t ;

         end_of_the_game : out boolean ;
         waiting_for_move : out boolean 
   ) ;
end control ;

architecture exemplar of control is 

   type state_t is (PLAY, WAIT_FOR_MOVE, END_OF_GAME);

   -- The state variables for the controller state machine
   signal present_state, next_state : state_t ;

   -- A separate register (one-hot) defines which bin is active
   signal present_active_bin : boolean_array(nr_of_bins-1 downto 0) ;

   signal player : player_t ;
   signal switch_player : boolean ;

   signal last_bin_was_empty, next_bin_is_empty : boolean ;

   -- Shift routine to shift to the next bin.
   function shift(sel : boolean_array) return boolean_array is
   begin
      -- shift this register to the right, roll over right bit to left
      return sel(sel'right) & sel(sel'left downto sel'right+1); 
   end ;

   -- General routine to check if a boolean array contains all 'false' elements.
   function is_empty (bins : boolean_array) return boolean is
      constant empty : boolean_array (bins'range) := (others=>false) ;
   begin 
      return (bins = empty) ;
   end ;

begin

   process (clk, reset)
   begin
       if (reset='1') then
           present_state <= END_OF_GAME ;
           last_bin_was_empty <= FALSE ;
           present_active_bin <= (others=>false) ;
       elsif (clk'event and clk='1') then
           present_state <= next_state ;
           last_bin_was_empty <= next_bin_is_empty ;
           present_active_bin <= active_bin ;
       end if ;
   end process ;

   process (start_game,present_state,hand_is_empty,empty_bins,buttons,
            present_active_bin, last_bin_was_empty, player)
       variable next_active_bin : boolean_array (present_active_bin'range) ;
   begin
       load_hand_with_active_bin <= FALSE ;
       decrement_hand <= FALSE ;
       switch_player <= FALSE ;
       waiting_for_move <= FALSE ;
       next_bin_is_empty <= FALSE ;
       end_of_the_game <= FALSE ;

       case present_state is
         when PLAY =>
           if (hand_is_empty) then
               -- No more marbles in the hand.

               if (is_empty (present_active_bin AND not_home_bins)) then
                  -- Stop if we drop the last marble in our own bin
                   next_state <= WAIT_FOR_MOVE ;
                   active_bin <= (others=>false) ;

               elsif (last_bin_was_empty) then
                  -- Stop and switch players if we drop the last marble
                  -- in an empty bin
                   switch_player <= TRUE ;
                   next_state <= WAIT_FOR_MOVE ;
                   active_bin <= (others=>false) ;
               else 
                  -- Continue if last marble dropped in a non-empty bin.
                  -- Re-load hand with the full bin contents.