Block diagrams of the design, design explanation, design

criteria and functionality for the different design blocks.

entity SpaceInv is
Port( Clk : in STD_LOGIC;
Reset : in STD_LOGIC;
Test : in std_logic;
Start : in std_logic;
Left : in std_logic;
Right : in std_logic;
Fire : in std_logic;
HSync : out std_logic;
VSync : out std_logic;
R,G,B : out std_logic );
end SpaceInv;



This is the top entity of our Space Invaders game. As inputs, it has the clock (Clk)
and reset for synchronous operations. It has another the five inputs (Fire, Left,
Right, Start and Test) that are linked to some buttons on the Spartan board to
control the game. The outputs of the entity (R, G, B, HSync and VSync) are those
that control the display through a VGA cable.

This entity has no logic inside it, it is only a container to link all the components
that the game has and control each one an specific aspect of the game (invaders,
screen, etc.).




entity ScreenFormat is
Port ( RGB : out STD_LOGIC_VECTOR(2 downto 0);
X : in unsigned (4 downto 0);
Y : in unsigned (4 downto 0);
subX : in unsigned (3 downto 0);
subY : in unsigned (3 downto 0);
Test : in std_logic;
iArray : in unsigned (0 to 19);
iRow : in unsigned (3 downto 0);
starshipArray : in unsigned (0 to 19);
shotX : in unsigned (4 downto 0);
shotY : in unsigned (4 downto 0);
fin : in std_logic );
end ScreenFormat;



This entity controls the RGB (red, green and blue) signal. It receives all the
information needed to deduce what color it has to output. X and Y are the current
coordinates of the screen. SubX and SubY are the subcoordinates used to print
the sprites of the invaders and the starship (extra explained later on).

ScreenFormat receives the current state of the invaders, starship and shot to know
where the have to be printed on the screen. When fin is 1, there are no invaders
left so the game is over.

If Test input in 1 the program prints out a chessboard and pauses the game.




entity VGA is
Port ( Clk : in STD_LOGIC;
Reset : in STD_LOGIC;
RGB : in STD_LOGIC_VECTOR(2 downto 0);
HSync : out STD_LOGIC;
VSync : out STD_LOGIC;
R,G,B : out STD_LOGIC;
X : out unsigned (4 downto 0);
Y : out unsigned (4 downto 0);
subX : out unsigned (3 downto 0);
subY : out unsigned (3 downto 0) );
end VGA;



This entity is designed to count the pixels of the screen. With two counters, it
counts some specific times, (detailed in a table in the practice workbook).

CounterX counts the coordinates of the X axis, and CounterY counts only when
CounterX is full, so, when the line ends Y coordinate is increased by one.

This entity also controls HSync and VSync outputs, sent to the screen to control
the synchronization of the screen (horizontal and vertical).

X and Y are the output coordinates supposing that we divide the screen in 20
columns and 15 rows. SubX and subY are used to divide each of the squares
obtained with X and Y in 32x32 pixels.




entity Invaders is
Port( Clk : in STD_LOGIC;
Reset : in STD_LOGIC;
Test : in std_logic;
Start : in std_logic;
shotX : in unsigned (4 downto 0);
shotY : in unsigned (4 downto 0);
iArray : out unsigned (0 to 19);
iRow : out unsigned (3 downto 0);
fin : out std_logic );
end Invaders;



This entity controls the logic of the invaders in our game. The invaders are stored
in an unsigned array of 20 elements (iArray). In this array, a 1 represent a living
invader, while a 0 represents an empty space.

Invaders entity has a timer component, so each 0.6 seconds (approximately) the
invaders move one space to the right. When the invader on the right side arrives to
the end of the screen, invaders go down one row (information stored in iRow) and
start to move on the left direction.

Inputs shotX and shotY determine where the bullet is at each moment. If the bullet
an a invader are at the same place in the screen at the same moment, that invader
is deleted from the invaders array (1 0).

When the invaders reach the last row, where the starship is, or all invaders are
eliminated, output fin is set to 1 so others component may know that the game is
over.








entity Starship is
Port( Clk : in STD_LOGIC;
Reset : in STD_LOGIC;
Test : in std_logic;
Start : in std_logic;
Left : in std_logic;
Right : in std_logic;
starshipArray : out unsigned (0 to 19);
pos : out unsigned (4 downto 0) );
end Starship;



This entity controls the starship logic. The starship position is stored in an array
like the invaders, but there is only a one at each time in the entire array, as there
can only be one starship in the game.

The array is shifted to the right or to the left as Right or Left input buttons are
pressed. If the starship reaches one of the edges of the screen it will not move more
to that side.

Starship entity also outputs the position of the starship in the Array (number of
column) with pos, to make more easy to handle that position in Bullet entity, in
order to know in which square the bullet has to appear.

As a summary, this entity has almost the same logic that the invaders one, but the
invaders are moved in an specific time using a timer and here the starship is
moved using the input buttons on the Spartan board.








entity Shot is
Port( Clk : in STD_LOGIC;
Reset : in STD_LOGIC;
Test : in std_logic;
Start : in std_logic;
Fire : in std_logic;
posStarhip : in unsigned (4 downto 0);
fin : in std_logic;
shotX : out unsigned (4 downto 0);
shotY : out unsigned (4 downto 0) );
end Shot;



This is the entity that deals with the bullet in our game. When the user presses Fire
button, a new bullet must appear.

This bullet appears at the position the starship is when the button is pressed. Then
it moves to the top but always in the same column. A timer controls this movement
as in the invaders entity, but of a lower size, so the bullet moves faster than the
invaders.

There can only be one bullet at the same time in the screen, and when the bullet
reaches the position of an invader, that invader and the bullet disappear from the
screen.

The input fin is received from Invaders entity and tells us that the game is over,
because there are no invaders left or they have reached the last row, where the
starship is. When fin is 1 the game is over, so no more bullets will appear on the
screen.







entity EdgeDetector is
Port ( Clk : in STD_LOGIC;
Reset : in std_logic;
E : in STD_LOGIC;
S : out STD_LOGIC );
end EdgeDetector;



On the practice workbook we were asked to implement an edge detector for some
of the input buttons as Left or Right, and it is implemented in this entity. This is a
falling edge detector, so when the player presses the button Left for example, the
starship does not move until the user releases the button, and moves only one
position. This is the schematic of an edge detector:





It works as follows: while the button is pressed E is equal to 1, so first flip-flop
output will be 1, but the second will be zero, so the output is equal to 0. When
the button is released, the first flip-flop output is equal to 0, but the second is
equal to 1, so the output will be 1 for just one clock cycle, as in the next cycle the
second Q will be zero.



entity Debouncer is
Generic( counter_size : integer );

Port( Clk : in STD_LOGIC;
button : in STD_LOGIC;
result : out STD_LOGIC );
end Debouncer;



This entity is made as an optional assignment of the project. It is used to
debounce some of the input buttons of the game.

The bouncing is an effect that the hardware buttons always have. When it is
pressed and then released, it produces a train of pulses before setting in 0. So we
had to make an entity that discards this train of pulses, as they are not real
pressings of the buttons.

This is done by a timer. When the entity receives a 1 from the button, it starts the
timer and waits until the timer is full. If in that moment the input is also 1 it is
taken as a real pressing and the output result is 1. If not, the output is 0.



















entity timer is
Generic( width : integer );

Port ( Clk : in std_logic;
Reset : in std_logic;
Enable : in std_logic;
Count : out std_logic_vector (width-1 downto 0);
Full : out std_logic );
end timer;























FSMs Diagrams.
Functionality of the testbenches performed.


Todo

Hsync


Vsync




invaders horizontal



invaders vertical


Nave



timer



edge detector

Explanation of the improvements made.
Synthesis Results (area, delay, maximum clock frequency, etc.)
with detailed explanations.
If warnings occur during synthesis, a detailed explanation of
them.
Comments related to some difficult points encountered during
the design implementation.
Other appropriate or relevant comments.