原创 【转】VHDL设计举例：一个游戏程序

--   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.

                   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 ;