In this two-week lab, you will use your ball and line modules to make a Pong game.

• Exercise 1: You will use your modules from Part 1 to draw a ball and two paddles on the screen.
• Exercise 2: Make the ball bounce around the screen. (This exercise is the largest part of the lab)
• Exercise 3: Make the paddles move when the appropriate buttons are pressed.
• Exercise 4: Make the ball bounce off of the paddles, and change the ball color when a player misses the ball.

• Learn how to implement more complex digital systems that combine several modules using state machines, sequential and combination circuitry.

This video shows an implementation of the Pong game for this lab. Your implementation does not need to look exactly like this. Feel free to change colors, object sizes, paddle positions, etc. Note that the video shows a wide-screen monitor, so there are “black bars” on the left and right that aren't part of the drawable space.

As you can see in the video above, the Pong game consists of drawing and moving around three objects: the ball, the left paddle and the right paddle. The animation is done by continuously drawing the objects, waiting some time, erasing them, moving them, and then repeating. Erasing is done by drawing the objects black.

The diagram below provides the state machine that will control most of the Pong game. Rather than have separate states for drawing and erasing, the state machine is designed to use the same three states to draw the objects. Thus, the state machine will continuously repeat the state ordering (BALL→PADDLE_L→PADDLE_R→WAIT_TIMER→) to draw the objects and wait for some time, then (BALL→PADDLE_L→PADDLE_R→MOVE→) to erase the objects, and move them before repeating the same sequence again.

Some explanation of the state machine:

• ballStart and lineStart will trigger the drawing of the ball and line objects, and are connected to the start inputs of the modules you created last lab. ballDone and lineDone are connected to the done ports of these modules.
• initBall and initPaddles will instruct the ball and paddles locations to be set to where they should be located at the start of a game.
• Although not shown in the state diagram, a 1-bit flip-fop named erasing will control whether the BALL, PADDLE_L and PADDLE_R states draw the objects in color or black. It is also used to determine whether the state machine should wait for move the objects after drawing them. The switchErase signal output by the state machine will cause this flip-flop to invert its value.
• You are free to choose how long to wait in the WAIT_TIMER state. Somewhere between 0.1s and 0.001s is a good choice, depending on how fast you want the gameplay.

Given your system clock, how many cycles do you need to wait for, in order to implement a 0.01 second delay?

Within the Pong module, the state machine is connected to a number of other components that implement the game loop timer, manage the ball location and direction, paddle locations, and score. This is shown below. These blocks are not submodules, but rather represent different sequential and combinational blocks that will make up your Pong module.

Review the state machine and system diagrams above, and make sure you understand how the Pong game will work. In this exercise you will implement a limited set of features: simply drawing the ball and two paddles.

What to do in this exercise:

1. Create a new Vivado project, add your BallDrawer, VLineDrawer, the BitmapToVga and clk_generator modules, and the top-level module provided here: top_pong.sv

Inspect the top-level module above, and note how the modules are connected. The module instantiates the BitmapToVga module and the glk_generator module needed to draw graphics on the VGA monitor. It also instantiates a Pong module, which controls the inputs to the BitmapToVga module. The four buttons are provided as inputs to the Pong module to control the paddle movements.

Note: You shouldn't change the top-level file. However, be sure to add a constraints file to your project that is configured appropriately.

The Pong module is where you will design an FSM that implements the game loop. All of the code for this lab will be within the Pong module. The Pong module instantiates a copy of your BallDrawer and VLineDrawer, and will control which of these modules is active at a time, the (x, y) coordinate of the object being drawn, and its color.

Your Pong module contains the ports described here:

A file has been provided to you to get started:

Pong.sv

// Add your header here
 
`default_nettype none
 
module Pong (
    input wire logic        clk,
    input wire logic        reset,
 
    input wire logic        paddle1_up,
    input wire logic        paddle1_down,
    input wire logic        paddle2_up,
    input wire logic        paddle2_down,
 
    output logic    [8:0]   vga_x,
    output logic    [7:0]   vga_y,
    output logic    [2:0]   vga_color,
    output logic            vga_wr_en
);
 
 
/////// Create a state machine here //////
//
// Your state machine should provide start, x_in and y_in to the BallDrawer
// Use the done signal from the BallDrawer to determine when a ball is done drawing
//
// Your state machine should also control the vga_color and vga_wr_en signals 
 
 
////////////////// Ball Drawing /////////////////////
BallDrawer BallDrawer_inst(
    .clk(clk),
    .reset(reset),
    .start(/* Todo */),
    .draw(/* Todo */),
    .done(/* Todo */),
    .x_in(/* Todo */),
    .y_in(/* Todo */),
    .x_out(/* Todo */),
    .y_out(/* Todo */)
);
 
////////////////// Line Drawing /////////////////////
VLineDrawer VLineDrawer_inst(
    .clk(clk),
    .reset(reset),
    .start(/* Todo */),
    .draw(/* Todo */),
    .done(/* Todo */),
    .x_in(/* Todo */),
    .y_in(/* Todo */),
    .x_out(/* Todo */),
    .y_out(/* Todo */),
    .height(/* Todo */)
);
 
endmodule

For this exercise, your Pong module should draw the two paddles and a ball on the screen. The paddles should be halfway down the screen on the left and right locations. Don't place the paddles right at the edge of the screen (x=0), as sometimes the first few columns/rows of pixels may be cut off. Instead draw your paddles at x=10, or something similar you choose. The ball should be drawn in the center of the screen.

You may notice that the Pong module includes one instantiation of the BallDrawer and one instantiation of the VLineDrawer. You SHOULD NOT add any more instantiations of these module. Even through you are drawing multiple paddles, drawing and erasing balls multiples times, the only one instance of the modules will be used.

The provided Pong module provides a good starting point. You will need to add a state machine that:

• Draws the three objects (paddle1, paddle2 and ball) one at a time.
• Your state machine will need to control the start, x and y signals that are input to the modules. These can be combinational outputs of your state machine.
• Your state machine will also need to control the vga_color output; this can also be an output of the state machine.
• The vga_wr_en output should also be combinational logic, and be derived from the draw signals coming out of the ball and line drawing modules.
• You will also need logic to control the vga_x and vga_y outputs.
• Remember to use the done signal from the drawing modules to determine when the object is done drawing, allowing your state machine to transition to drawing the next ball.

Tip: You only need one state of your state machine to draw each object. So for this exercise, your state machine may only have three states (or perhaps a fourth for an initial/reset state). As you complete more phases of the game loop in later exercises you can add new states to this state machine.

Tip: So far, when you have designed your state machine modules, you have placed all of your input/output logic in a single always_comb block. However, as you begin to design larger and more complex modules (including this lab), you may find your code is more readable if you split the logic into multiple blocks. There are many different ways you can structure your circuits in SystemVerilog, and it takes experience to learn which ways are best. In this part of the lab, you might want to try organizing your code using a few always blocks. For example, you might use one always_comb for the next state logic, another block to control the x/y/color VGA outputs, and perhaps another to control the x/y inputs to your ball and line drawer modules.

Exercise #1 Pass-off: Show the TA your display that draws the paddles and ball.

In this exercise you will modify your Pong module to make the ball bounce around the screen.

Suggested approach:

Add two registers that you will use to maintain the current ball x and y location. Modify your Pong state machine to draw the ball at the location stored in these registers. Upon reset, these registers should position the ball in the center of the screen. You may want to use a new always_ff block to describe the behavior of these registers (which at this point, will only contain code to set these register values upon reset).

Build and run this on the board. Make sure that when you press the reset button, the ball appears at the center of the screen.

Add new states in your Pong state machine that will introduce a waiting period. This will involve creating a counter register that is reset upon entering the waiting state, and modifying the state machine to remain in a waiting state until the counter reaches a certain value (you can decide how long you want to wait).

For simplicity, we will assume the ball is always moving with speed -1 or 1 in both the x and y direction. Add two new single-bit registers that track the direction of ball movement in the x and y direction. For example, ball_moving_right can be logic-1 when the ball has an x-velocity of 1, and logic-0 when the ball has an x-velocity of -1. Again, you may want to create a new always_ff block to describe the behavior of these registers.

Add a state to your Pong state machine that will be used to update the x,y location of the ball. Update the logic for the ball location registers so that they are incremented or decremented appropriately when the state machine is in this state.

Build and run this on the board. Make sure that when you press the reset button, the ball appears at the center of the screen, and then moves in a diagonal direction (the direction depends on how you reset these registers). You don't need to erase the old ball location yet, so you should expect to see many balls being drawn on the screen.

Modify the logic that controls the ball movement directions. When the ball location reaches the edges of the screen, the direction should be changed. For example, if the ball x-location is 0, you would set ball_moving_right to 1, and if the ball x-location is 319-BALL_WIDTH you would set ball_moving_right to 0.

Build and run this on the board. Make sure the ball bounces on the edges of the screen.

Modify your Pong state machine to add new state(s) that will cause the Ball to be erased (this involves just drawing a black ball at the current ball location). Make sure you arrange your states to implement the game loop described above (Draw, Wait, Erase, Move, repeat)

Exercise #2 Pass-Off: Show the TA your display with the ball bouncing around the screen. You don't need to worry about paddle collisions yet.

In this exercise you will implement the logic to move the paddles when the user presses the buttons.

Add two new registers that maintain the current paddle y-locations, and modify your Pong state machine to draw the paddles at the location stored in these registers.

In the same state that you move the ball location, add additional logic to also move the paddles, if the appropriate buttons are being pressed. Because we have a wait state in our game loop, you don't need to worry about any button debouncing, it is sufficient to just check the button values, and modify the paddle y-locations as necessary. You may want to move the paddles by 2 or 3 pixels, so that the paddles can move faster than the ball.

Build and run your design on the board. Make sure it works before moving on.

Modify your Pong state machine to add new states that will cause the paddles to be erased before they are moved.

Exercise #3 Pass-Off: Demonstrate to the TAs that the buttons move the paddles up and down. You don't need to worry about collisions yet.

In this exercise you will complete the game by adding ball collisions with the paddles.

• Update the logic that determines the ball x-direction to take into account the locations of the paddles. If the ball hits a paddle, the register that stores the x-direction should be updated accordingly.

Exercise #4 Pass-Off: Demonstrate your completed game to the TA.

Modify your game so that it keeps track of when a player “scores”. You can do this however you like. In the video demo above, the ball changes color when it hits the side walls. If you want to go with this approach:

• Add a register that maintains the ball color.
• When a player misses the ball (and the ball bounces off of the side walls), alternate the ball color.

You are welcome to choose a different method instead. You could:

• Keep score and use the 7-segment controller to display the score on the 7-segment displays.
• Keep score and display the score in binary on the LEDs.
• Shrink the player paddle when they score a point.
• Use the CharDrawer to display a score on the screen.

Submit your SystemVerilog modules using the code submission on Learning Suite. (Make sure your SystemVerilog conforms to the lab SystemVerilog coding standards).