Differences

This shows you the differences between two versions of the page.

--- labs:pong_part_2 [2019/11/10 23:25]
jgoeders [Exercise #1 - Drawing the objects]
+++ labs:pong_part_2 [2019/12/03 16:26] (current)
jgoeders [Exercise #1 - Drawing the objects]
@@ Line 3: / Line 3: @@
   * 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 3: Make the paddles move, and make the ball bounce off of the paddles.
-  * Exercise 4: Make the ball bounce off of the paddles, and change the ball color when a player misses the ball.
+  * Exercise 4: Keep score.
@@ Line 15: / Line 15: @@
 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.
-{{youtube>JRMBcn9saP8?rel=0&noborder&560x315}}
+{{youtube>cUQDCrGownw?rel=0&noborder&560x315}}
-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.
+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 immediately redrawing them and repeating the process.  Erasing is done by drawing the objects black.  The buttons are used to move the paddles, and the score is displayed using the seven segment controller.
 ==== State Machine ====
-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.
+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 (PADDLE_L->BALL->PADDLE_R->WAIT_TIMER->) to draw the objects and wait for some time, then (PADDLE_L->BALL->PADDLE_R->MOVE->) to erase the objects, and move them before repeating the same sequence again.
 {{ :labs:lab_pong:pong_sm.png?600 |}}
@@ Line 26: / Line 27: @@
 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.
+  * ''initGame'' will reset the appropriate registers (ball location, ball direction, paddle locations, score, etc.)
-  * 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.
+  * 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, or move the objects after drawing them.  The ''invertErasing'' 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.
-<color #ed1c24>Given your system clock, how many cycles do you need to wait for, in order to implement a 0.01 second delay?</color>
+<color #ed1c24>Given your system clock, how many cycles do you need to wait for, in order to implement a 0.01 second delay? How many bits wide does your counter need to be to implement this wait?</color>
+<color #ed1c24>Why is ''invertErasing'' a mealy output when leaving state ''PADDLE_R'' instead of just having it be a moore output in that state?</color>
 ==== Module Design ====
 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.
+The ''Pong'' module will also instance the ''BallDrawer'' and ''VLineDrawer'' modules, although for simplicity, this is not shown in the diagram.
 {{ :labs:lab_pong:pong_system_diagram.png |}}
@@ Line 48: / Line 55: @@
 What to do in this exercise:
-. Create a new Vivado project, add your ''BallDrawer'', ''VLineDrawer'', the ''BitmapToVga'' and ''clk_generator'' modules, and the top-level module provided here: {{ :labs:lab_pong:top_pong.sv |}}
+. Create a new Vivado project, add your ''BallDrawer'' and ''VLineDrawer'' modules, as well as the ''BitmapToVga'',  ''clk_generator'' and ''SevenSegmentControl'' modules.  Also add the top-level module provided here: {{ :labs:lab_pong:top_pong.sv |}}
-. Inspect the top-level module, 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**.
+. Inspect the top-level module, 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 you will create in a later step), 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**.
 . Add a constraints file to your project that is configured appropriately.
-. Create a ''Pong'' module and add it to your project.  The ''Pong'' module is where you will add all of your code for this lab.  It instantiates a copy of your ''BallDrawer'' and ''VLineDrawer'', and will include the state machine and other module components shown in the diagram above.
+. Create a ''Pong'' module and add it to your project (a starting file is provided below).  The ''Pong'' module is where you will add all of your code for this lab.  It instantiates a copy of your ''BallDrawer'' and ''VLineDrawer'', and will include the state machine and other module components shown in the diagram above.
 Your ''Pong'' module contains the ports described here:
@@ Line 78: / Line 85: @@
 <file verilog Pong.sv>
 // Add your header here
 `default_nettype none
@@ Line 89: / Line 95: @@
     input wire logic        RPaddleUp,
     input wire logic        RPaddleDown,
     output logic    [8:0]   vga_x,
     output logic    [7:0]   vga_y,
     output logic    [2:0]   vga_color,
     output logic            vga_wr_en,
-    output logic    [7:0]   P1score;
+    output logic    [7:0]   P1score,
-    output logic    [7:0]   P2score;
+    output logic    [7:0]   P2score
 );
+localparam              VGA_X_MAX = 319;
+localparam              VGA_Y_MAX = 239;
+// ball drawer signals
+logic           [8:0]   ballDrawX;
+logic           [7:0]   ballDrawY;
+logic                   ballStart;
+logic                   ballDone;
+logic                   ballDrawEn;
+// line drawer for paddles
+logic           [8:0]   lineX, lineDrawX;
+logic           [7:0]   lineY, lineDrawY;
+logic                   lineStart;
+logic                   lineDone;
+logic                   lineDrawEn;
+// location of ball, paddles
+logic           [8:0]   ballX;
+logic           [7:0]   ballY;
+logic           [7:0]   LPaddleY;
+logic           [7:0]   RPaddleY;
+// velocity of ball
+logic                   ballMovingRight;
+logic                   ballMovingDown;
+// delay counter
+logic           [31:0]  timerCount;
+logic                   timerDone;
+logic                   timerRst;
+logic                   initGame;
+logic                   moveAndScore;
+logic                   erasing;
+logic                   invertErasing;
+////////////////// Game Loop Timer /////////////
+// Added in exercise 2
+////////////////// Erasing /////////////////////
+// Added in exercise 2
+////////////////// Ball Location ///////////////
+// Added in exercise 1, updated in exercise 2
+////////////////// Paddle Locations ////////////
+// Added in exercise 1, updated in exercise 3
+////////////////// Player Score ////////////////
+// Added in exercise 1, updated in exercise 4
-/////// Create a state machine here //////
+////////////////// Ball Direction ///////////////
+// Added in exercise 2, updated in exercise 3
+////////////////// State Machine ////////////////
+// Added in exercise 1, updated in exercise 2
-////////////////// Ball Drawing /////////////////////
+////////////////// Drawing Submodules ///////////
 BallDrawer BallDrawer_inst(
     .clk(clk),
     .reset(reset),
+    .draw(ballDrawEn),
     .start(ballStart),
     .done(ballDone),
@@ Line 112: / Line 173: @@
     .y_in(ballY),
     .x_out(ballDrawX),
-    .y_out(ballDrawY),
+    .y_out(ballDrawY)
-    .draw(ballDrawEn)
 );
-////////////////// Line Drawing /////////////////////
 VLineDrawer VLineDrawer_inst(
     .clk(clk),
     .reset(reset),
     .start(lineStart),
+    .draw(lineDrawEn),
     .done(lineDone),
     .x_in(lineX),
@@ Line 126: / Line 186: @@
     .x_out(lineDrawX),
     .y_out(lineDrawY),
-    .draw(lineDrawEn),
+    .height(PADDLE_HEIGHT)
-    .height(/* Todo */)
 );
 endmodule
 </file>
-.  Create the above state machine with just the states needed to start the game and draw the objects: INIT, BALL, PADDLE_L and PADDLE_R.  For this exercise you might want to create a DONE state that the state machine stays in once it is down drawing the right paddle.
+.  Create the above state machine with just the states needed to start the game and draw the objects: INIT, BALL, PADDLE_L and PADDLE_R.  For this exercise you might want to create a DONE state that the state machine stays in once it is done drawing the right paddle.
 . Implement the other components as follows:
+  * **Ball Location:** You should create a new ''always_ff'' block to manage the ball location.  Create two registers, ''ballX'' and ''ballY'' that are reset to the center of the screen when ''initGame'' is true.  This is sufficient for this exercise.
+  * **Paddle Locations:**  You should create a new ''always_ff'' block to manage the paddle locations.  Create two registers, ''LPaddleY'' and ''RPaddleY'' that position the paddles halfway down the screen when ''initGame'' is true.  This is sufficient for this exercise.
+  * **Player Scores:**  You should create a new ''always_ff'' block to manage the player scores.  For this exercise, just assign the ''P1score'' and ''P2score'' registers to 0 when ''initGame'' is true.
+  * **Ball Direction:** Not needed in this exercise.
   * **Game Loop Timer:** Not needed in this exercise.
-  * **Ball Location:** You should create a new ''always_ff'' block to manage the ball location.  Create two registers, ''BallX'' and ''BallY'' that are reset to the center of the screen when ''initBall'' is true.  This is sufficient for this exercise.
-  * **Ball Location:**  You should create a new ''always_ff'' block to manage the paddle locations.  Create two registers, ''LPaddleY'' and ''RPaddleY'' that position the paddles halfway down the screen when ''initPaddles'' is true.  This is sufficient for this exercise.
-  * **Ball Location:**  You should create a new ''always_ff'' block to manage the player scores.  For this exercise, just assign the ''P1score'' and ''P2score'' registers to 0.
   * **Erase Switch:** Not needed in this exercise.
-. Update your state machine to also output the other outputs shown in the diagram:
+. Update your state machine to also output the other outputs shown in the system diagram:
   * ''vga_x'', ''vga_y'', and ''vga_wr_en''  should be connected to either ''ballDrawX'', ''ballDrawY'', and ''ballDrawEn'' or the corresponding signals from the ''VLineDrawer'', depending on the state.
   * Assign ''vga_color'' to values of your choice in each state.
   * Assign ''lineX'' to appropriate values of your choice in the two states that draw the paddles.  Don't place the paddles right at the edge of the screen (x=0 or x=319), as sometimes the first/last few columns/rows of pixels may be cut off.
+  * Assign ''lineY'' to the appropriate paddle signal, ''LPaddleY'' or ''RPaddleY'', depending on the state.
 //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, only one instance of each module will be used.//
@@ Line 159: / Line 221: @@
 ==== Exercise #2 - Bouncing Ball ====
-In this exercise you will modify your ''Pong'' module to make the ball bounce around the screen.
+In this exercise you will modify your ''Pong'' module to make the ball bounce around the screen.  You don't need to interact with the paddles or keep score yet.
 Suggested approach:
-=== Ball Location ===
+. Add the remaining two states of the state machine.
-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.
+. Update the following components:
+  * **Game Loop Timer:** Implement this as a counter using the ''timerRst'' and ''timerDone'' signals.
+  * **Ball Location:** Add more logic to your ball location component.  When in the move state (''moveAndScore'' is high), update the ball location according to its direction.  Consider the values of ''ballMovingRight'' and ''ballMovingDown'' and either add 1 or subtract 1 from ''ballX'' and ''ballY'' accordingly.
+  * **Ball Direction: ** You should create a new ''always_ff'' block to manage the ball directions (''ballMovingRight'' and ''ballMovingDown'' registers).  On ''initGame'', you should reset these registers to values of your choice.  When the ball hits a wall (check the ball location), you should update these registers appropriately.
+  * **Erase Switch:** Create a flip-flop, ''erasing'' that is reset to 0 on ''initGame'' and flips its value if  ''invertErase'' is high.
-=== Waiting ===
-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).
-=== Moving the ball ===
-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.
+** A note on debugging:** You will likely need to debug your design to get it working properly.  The best way to do this is to set up a simulation tcl file.  Consider how you can change your design to make it easier to simulate and debug.  For example, you could make the timer delay small to make it faster to simulate, or change the values assigned to registers on ''initGame''.  For example, you could initialize the ball close to a wall so that you don't need much simulation time in order to see if it bounced off of the wall correctly.
-__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.
-=== Bouncing the ball ===
-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.
-=== Ball Erasing ===
-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.
@@ Line 190: / Line 242: @@
 ----
-==== Exercise #3 - Moving the Paddles ====
+==== Exercise #3 - Moving the Paddles and Collisions ====
 In this exercise you will implement the logic to move the paddles when the user presses the buttons.
-=== Paddle Locations ===
+Update the following components:
-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.
+  * **Ball Direction:** Detect if the ball is located on a player paddle, and update the ball direction appropriately.  To keep things simple, you can assume the ball only bounces off of the front of the paddle.
+  * **Paddle Locations:** In the move state (''moveAndScore'' is high), move the paddles appropriately based on the button inputs (''LPaddleUp'', ''RPaddleUp'', etc.)  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 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.  The logic to do this is a bit tricky, so think about it carefully.  You don't want the paddles to be able to move off of the screen.
-=== Moving the Paddles ===
+** Exercise #3 Pass-Off:** Demonstrate to the TAs that the buttons move the paddles up and down, and that the ball collides and bounces off the paddles consistently.
-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.
+----
-=== Paddle Erasing ===
+==== Exercises #4 - Keeping Score ====
-Modify your ''Pong'' state machine to add new states that will cause the paddles to be erased before they are moved.
+In this exercise you will complete the game by adding score keeping.  The player scores are already shown on the seven segment displays, you just need to update the registers you created earlier when a player scores a point.
-** 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.
+Add logic that looks at looks at the ball location in the move state (''moveAndScore'' is high), and update the player scores appropriately.
+** Exercise #4 Pass-Off:** Demonstrate your completed game to the TA.
 ----
-==== Exercises #4 - Collisions ====
-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.
 ===== Personal Exploration =====
-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:
+<color #ed1c24>No personal exploration is required for this lab</color>, but feel free to have fun making whatever changes you would like to the game.  For example, you might shrink the player paddles when they score a point to make it more challenging, or speed up the gameplay.
-  * 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.
 ===== Final Submission =====

User Tools

Differences

Page Tools

BYU ECEn 220

Site Tools