Difference between revisions of "ECE434 Project - Cornhole Board"

From eLinux.org
Jump to: navigation, search
(Created page with "PT PT {{YoderHead}} Team members: Mark A. Yoder == Grading Template == I'm using the following template to g...")
 
(Grading Template)
 
(21 intermediate revisions by the same user not shown)
Line 3: Line 3:
 
{{YoderHead}}
 
{{YoderHead}}
  
Team members: [[user:Yoder|Mark A. Yoder]]
+
Team members: [[user:hedricsd|Sam Hedrick]], Tristen Foisy
  
 
== Grading Template ==
 
== Grading Template ==
Line 10: Line 10:
  
 
<pre style="color:red">
 
<pre style="color:red">
09 Executive Summary
+
00 Executive Summary
09 Packaging
+
00 Packaging
09 Installation Instructions  
+
00 Installation Instructions  
09 User Instructions
+
00 User Instructions
09 Highlights
+
00 Highlights
09 Theory of Operation
+
00 Theory of Operation
09 Work Breakdown
+
00 Work Breakdown
09 Future Work/Conclusions
+
00 Future Work/Conclusions
09 Hackster.io
+
00 Hackster.io
09 Demo/Poster
+
00 Demo/Poster
 
00 Not Late
 
00 Not Late
  
Score:  90/100
+
Score:  00/100 (not yet graded)
 
</pre>
 
</pre>
  
 
== Executive Summary ==
 
== Executive Summary ==
  
Picture that summarizes the project.
+
Our project features a game modeled after cornhole (also known as bags). The player is able to throw objects into the hole on the game board to score, which is indicated and kept track of using various electrical elements we included.  
  
Give two sentence intro to the project.
+
We implemented the project by using a servo, infrared reflection sensor, buzzer, and 7-segment digital display, we can give feedback to the user regarding the current score. The IR reflection sensor detects when an object is in front of it and the returned wavelength is less than the amount set by changing a potentiometer on the sensor. Then, it reacts by changing a servo’s position and after a round is complete the display updates with the current score.  
  
Give two sentences telling what works.
+
The implementation currently has nothing that was not implemented; everything that was implemented was what in accordance with what we planned for this iteration of the project (we elaborate on previous ideas later). One component that didn’t work exactly as planned was the 7-segment display; we had to use GPIO to drive it because we did not have a way to drive the display with i2c.
  
Give two sentences telling what isn't working.
+
Though we were not able to realize our initial goals, we did arrive at a product that we are satisfied with. It was very fun to explore some hardware that we did not use in class, and we are grateful that Dr. Yoder’s instruction was able to help us complete the project! 
  
End with a two sentence conclusion.
 
  
The sentence count is approximate and only to give an idea of the expected length.
+
[[File:CornholeBoard.jpg|Flow Chart|500px]]
  
 
== Packaging ==
 
== Packaging ==
If you have hardware, consider [http://cpprojects.blogspot.com/2013/07/small-build-big-execuition.html Small Build, Big Execuition] for ideas on the final packaging.
+
 
 +
Our project features a scaled-down version of cornhole, and thus requires a board to be made to match. This board is simple: it is a slanted cardboard platform with a hole near the top. Inside this hole is our infrared reflection sensor, which detects when an object (bag, ball, or otherwise) enters the hole. The servo features a pinwheel that shows the current score outcome for that round. Based on how many times each player has scored, one of 9 positions will be pointed to. There is also a pushbutton that is used to change which player is currently shooting.
 +
 
 +
[[File:Cornholediagram.png|Flow Chart|500px]]
  
 
== Installation Instructions ==
 
== Installation Instructions ==
  
Give step by step instructions on how to install your project.
+
github Path:  [https://github.com/hedricsd/ECE434/tree/master/hw10 https://github.com/hedricsd/ECE434/tree/master/hw10].'''
 +
 
 +
To install and use, a few things are needed.
 +
First, the FinalProject.py program needs to be downloaded. This can be found in our hw10 repos on Github. Running this program requires the imports below. If the user does not have them, they need to be installed first.
  
* Include your [https://github.com/ github] path as a link like this to the read-only git site:  [https://github.com/MarkAYoder/gitLearn https://github.com/MarkAYoder/gitLearn].  
+
- Import Adafruit_BPIO.GPIO
* Be sure your README.md is includes an up-to-date and clear description of your project so that someone who comes across you git repository can quickly learn what you did and how they can reproduce it.
+
 
* Include a Makefile for your code if using C.
+
- Import Adafruit_BPIO.PWM
* Include any additional packages installed via '''apt'''. Include '''install.sh''' and '''setup.sh''' files.
+
 
* Include kernel mods.
+
- From time import sleep
* If there is extra hardware needed, include links to where it can be obtained.
+
 
 +
- Import math
 +
 
 +
As this is a python program, the user must also have python installed to run it. The pins needed for this project are GPIO and PWM pins, so we also need to setup all of the pins to be able to be ran this way. To do this just run the setup.sh file that we have provided.
  
 
== User Instructions ==
 
== User Instructions ==
  
Once everything is installed, how do you use the program?  Give details here, so if you have a long user manual, link to it here.
+
Using our game is incredibly simple! Our goal was to make something engaging to the player, yet familiar.  
  
Consider making it autostart for full credit.
+
To begin gameplay, the user must run “FinalProject.py” with the computer connected to the BeagleBone. After doing so, the program will have started running and the players may proceed to play.
 +
 
 +
Once gameplay has started, players take turns trying to throw objects into the hole. After each player has taken a shot, they must press the pushbutton that is on the board to switch to the next player’s turn. Players continue taking turns until each one takes 4 shots for a total of 8 attempts across both players.
 +
 
 +
Each time a player makes a shot, the servo’s position will change to reflect the new round score. It will point to one of 9 positions (between 1-4 for each player, plus 0 points) based on who has made how many shots. Making a shot will cause the position to move towards each player’s respective ‘half’ of the 180-degree semicircle; the first player causes the servo to move to the left and the second player causes the servo to move to the right.
 +
 
 +
After all 8 shots have been taken in a round, the servo resets its position to position 0 and the 7-segment display is updated with how many points were earned.
 +
 
 +
The game ends when either player has scored a total of 21 points. At this point, the console thanks the users for playing and program execution ends.  
  
 
== Highlights ==
 
== Highlights ==
  
Here is where you brag about what your project can do.
+
What we are proudest of with this project is how many different components we were able to use. It let us use a lot of hardware that we did not get exposure to in class, which was an engaging and informative experience. We are particularly proud of how we got the 5V power rail working, which was necessary to use the servo. All other components used the 3.3 volt coming from the external power supply as well.
  
Include a [http://www.youtube.com/ YouTube] demo the audio description.
+
We also take pride in the fact that our game is fun to play! Cornhole is a staple of outdoor hangout sessions across the country and having a miniaturized electronic version of it adds some extra features (and hopefully, player enjoyment). Keeping track of the score is incredibly helpful for forgetful people like us. Being able to track per-round score and overall game score is truly a useful addition.
  
 
== Theory of Operation ==
 
== Theory of Operation ==
  
Give a high level overview of the structure of your software. Are you using GStreamer?  Show a diagram of the pipeline. Are you running multiple tasks?  Show what they do and how they interact.
+
Our software requires one Python script to run. It does not use GStreamer. It does utilize a while loop structure to wait for an object to pass in front of the IR proximity sensor. After detection is made, the buzzer and servo are updated accordingly. The program also keeps track of shots made; if the number equals 8, the round is ended and the display is updated.
 +
 
 +
After the target score of 21 is reached by either player, the while loop is exited. After this occurs, PWM and GPIO need to be stopped.
 +
 
 +
Almost all inputs and outputs are handled using GPIO, however, the servo is used by changing the duty cycle of the pulse width modulation.  
 +
 
 +
Necessary packages required to run the program include Adafruit_BPIO, time, and math.  
  
 
== Work Breakdown ==
 
== Work Breakdown ==
  
List the major tasks in your project and who did what.
+
Both Sam and Tristen did a great deal of research for the previous ideas that were planned for the project. This includes research into stepper motors, electromagnets, 3D printing, and parts to buy.
 +
 
 +
After we moved onto the current version, work was broken down as follows:
 +
 
 +
- Sam programmed the scripts and wired the board up for the project. He was able to figure out how the majority of things worked and write the programs that allowed everything to execute.  
  
Also list here what doesn't work yet and when you think it will be finished and who is finishing it.
+
- Tristen did the writing for the project and built the housing. He did most of this webpage and used hot glue and cardboard to build the casing, which was designed to fit the components of the board.
  
 
== Future Work ==
 
== Future Work ==
  
Suggest addition things that could be done with this project.
+
As far as additional work is concerned, we will focus primarily on two different facets. Namely, we will focus on how this design can be improved and a few of the previous ideas we had planned but were unable to execute on due to technical and temporal difficulties. There are a small handful of things we think would improve our project in its current state.
 +
 
 +
They are:
 +
 
 +
- Improving the 7-segment display to work over i2c. Doing so would lessen the flicker that is currently visible and also help to give the project a more polished look.
 +
 
 +
- Making the board larger. By making it larger and out of better materials, we can improve the general quality of our project. It also gives us more room for the next improvement, which is:
 +
 
 +
- Creating two gameplay boards. Doing this would require us doubling the number of IR detectors we use, but the rest of the project can use the given hardware. Points and the rotation of the servo work the same. With a larger play area, we might need to add a second button to indicate the next player’s turn. The location of some of the common hardware (like the servo, display, and buzzer) might need to be changed as well to facilitate ease of use. Having two boards closer approximates the real-world analog of our game too.
 +
 
 +
- Changing how we switch between players. A simple solution for this would be an IR remote and receiver to replace the buttons. A more complex version could be to add a camera and use computer vision to teach the BeagleBone to recognize when different colored bags make an appearance in the game area.
 +
 
 +
 
 +
We also feel that now is a good time to mention some of the previous ideas and how they would be implemented. The primary reason for doing so is because we may complete some of these in the future and we believe that future students could feel inspired by our ideas.
 +
 
 +
- Initially, we planned to make a 2-dimensional chess board. This would work using stepper motors to create an XY table, which allows movement in two dimensions.  Attached to each of the chess pieces is a magnet that interacts with an electromagnet on the steppers that is powered on and off when moving pieces. To picture this, think of a 3D printer, but instead of the plastic nozzle there is an electromagnet. Commands are issued via the pc terminal. The primary issues we ran into with implementing this design were figuring out the stepper motors and power supply.
 +
 
 +
- Once we had figured out that using the XY table for chess was too complex, we changed our design slightly, this time trying to make tic tac toe due to its simplicity. However, we ran into the same issues that prevented us from realizing this: the stepper motors and power supply were difficult to work with.
  
 
== Conclusions ==
 
== Conclusions ==
  
Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.
+
We are very grateful that we were able to complete a project that we are happy with. We were very inspired by all the different hardware we looked at and working with so many different components presented us with a great deal of learning opportunities. Above all, we are glad we got to learn something new through our cornhole board and are grateful for all the intellectual growth we got from this class!
  
 
{{YoderFoot}}
 
{{YoderFoot}}

Latest revision as of 21:12, 16 November 2021

thumb‎ Embedded Linux Class by Mark A. Yoder


Team members: Sam Hedrick, Tristen Foisy

Grading Template

I'm using the following template to grade. Each slot is 10 points. 0 = Missing, 5=OK, 10=Wow!

00 Executive Summary
00 Packaging
00 Installation Instructions 
00 User Instructions
00 Highlights
00 Theory of Operation
00 Work Breakdown
00 Future Work/Conclusions
00 Hackster.io
00 Demo/Poster
00 Not Late

Score:  00/100 (not yet graded)

Executive Summary

Our project features a game modeled after cornhole (also known as bags). The player is able to throw objects into the hole on the game board to score, which is indicated and kept track of using various electrical elements we included.

We implemented the project by using a servo, infrared reflection sensor, buzzer, and 7-segment digital display, we can give feedback to the user regarding the current score. The IR reflection sensor detects when an object is in front of it and the returned wavelength is less than the amount set by changing a potentiometer on the sensor. Then, it reacts by changing a servo’s position and after a round is complete the display updates with the current score.

The implementation currently has nothing that was not implemented; everything that was implemented was what in accordance with what we planned for this iteration of the project (we elaborate on previous ideas later). One component that didn’t work exactly as planned was the 7-segment display; we had to use GPIO to drive it because we did not have a way to drive the display with i2c.

Though we were not able to realize our initial goals, we did arrive at a product that we are satisfied with. It was very fun to explore some hardware that we did not use in class, and we are grateful that Dr. Yoder’s instruction was able to help us complete the project!


Flow Chart

Packaging

Our project features a scaled-down version of cornhole, and thus requires a board to be made to match. This board is simple: it is a slanted cardboard platform with a hole near the top. Inside this hole is our infrared reflection sensor, which detects when an object (bag, ball, or otherwise) enters the hole. The servo features a pinwheel that shows the current score outcome for that round. Based on how many times each player has scored, one of 9 positions will be pointed to. There is also a pushbutton that is used to change which player is currently shooting.

Flow Chart

Installation Instructions

github Path: https://github.com/hedricsd/ECE434/tree/master/hw10.

To install and use, a few things are needed. First, the FinalProject.py program needs to be downloaded. This can be found in our hw10 repos on Github. Running this program requires the imports below. If the user does not have them, they need to be installed first.

- Import Adafruit_BPIO.GPIO

- Import Adafruit_BPIO.PWM

- From time import sleep

- Import math

As this is a python program, the user must also have python installed to run it. The pins needed for this project are GPIO and PWM pins, so we also need to setup all of the pins to be able to be ran this way. To do this just run the setup.sh file that we have provided.

User Instructions

Using our game is incredibly simple! Our goal was to make something engaging to the player, yet familiar.

To begin gameplay, the user must run “FinalProject.py” with the computer connected to the BeagleBone. After doing so, the program will have started running and the players may proceed to play.

Once gameplay has started, players take turns trying to throw objects into the hole. After each player has taken a shot, they must press the pushbutton that is on the board to switch to the next player’s turn. Players continue taking turns until each one takes 4 shots for a total of 8 attempts across both players.

Each time a player makes a shot, the servo’s position will change to reflect the new round score. It will point to one of 9 positions (between 1-4 for each player, plus 0 points) based on who has made how many shots. Making a shot will cause the position to move towards each player’s respective ‘half’ of the 180-degree semicircle; the first player causes the servo to move to the left and the second player causes the servo to move to the right.

After all 8 shots have been taken in a round, the servo resets its position to position 0 and the 7-segment display is updated with how many points were earned.

The game ends when either player has scored a total of 21 points. At this point, the console thanks the users for playing and program execution ends.

Highlights

What we are proudest of with this project is how many different components we were able to use. It let us use a lot of hardware that we did not get exposure to in class, which was an engaging and informative experience. We are particularly proud of how we got the 5V power rail working, which was necessary to use the servo. All other components used the 3.3 volt coming from the external power supply as well.

We also take pride in the fact that our game is fun to play! Cornhole is a staple of outdoor hangout sessions across the country and having a miniaturized electronic version of it adds some extra features (and hopefully, player enjoyment). Keeping track of the score is incredibly helpful for forgetful people like us. Being able to track per-round score and overall game score is truly a useful addition.

Theory of Operation

Our software requires one Python script to run. It does not use GStreamer. It does utilize a while loop structure to wait for an object to pass in front of the IR proximity sensor. After detection is made, the buzzer and servo are updated accordingly. The program also keeps track of shots made; if the number equals 8, the round is ended and the display is updated.

After the target score of 21 is reached by either player, the while loop is exited. After this occurs, PWM and GPIO need to be stopped.

Almost all inputs and outputs are handled using GPIO, however, the servo is used by changing the duty cycle of the pulse width modulation.

Necessary packages required to run the program include Adafruit_BPIO, time, and math.

Work Breakdown

Both Sam and Tristen did a great deal of research for the previous ideas that were planned for the project. This includes research into stepper motors, electromagnets, 3D printing, and parts to buy.

After we moved onto the current version, work was broken down as follows:

- Sam programmed the scripts and wired the board up for the project. He was able to figure out how the majority of things worked and write the programs that allowed everything to execute.

- Tristen did the writing for the project and built the housing. He did most of this webpage and used hot glue and cardboard to build the casing, which was designed to fit the components of the board.

Future Work

As far as additional work is concerned, we will focus primarily on two different facets. Namely, we will focus on how this design can be improved and a few of the previous ideas we had planned but were unable to execute on due to technical and temporal difficulties. There are a small handful of things we think would improve our project in its current state.

They are:

- Improving the 7-segment display to work over i2c. Doing so would lessen the flicker that is currently visible and also help to give the project a more polished look.

- Making the board larger. By making it larger and out of better materials, we can improve the general quality of our project. It also gives us more room for the next improvement, which is:

- Creating two gameplay boards. Doing this would require us doubling the number of IR detectors we use, but the rest of the project can use the given hardware. Points and the rotation of the servo work the same. With a larger play area, we might need to add a second button to indicate the next player’s turn. The location of some of the common hardware (like the servo, display, and buzzer) might need to be changed as well to facilitate ease of use. Having two boards closer approximates the real-world analog of our game too.

- Changing how we switch between players. A simple solution for this would be an IR remote and receiver to replace the buttons. A more complex version could be to add a camera and use computer vision to teach the BeagleBone to recognize when different colored bags make an appearance in the game area.


We also feel that now is a good time to mention some of the previous ideas and how they would be implemented. The primary reason for doing so is because we may complete some of these in the future and we believe that future students could feel inspired by our ideas.

- Initially, we planned to make a 2-dimensional chess board. This would work using stepper motors to create an XY table, which allows movement in two dimensions. Attached to each of the chess pieces is a magnet that interacts with an electromagnet on the steppers that is powered on and off when moving pieces. To picture this, think of a 3D printer, but instead of the plastic nozzle there is an electromagnet. Commands are issued via the pc terminal. The primary issues we ran into with implementing this design were figuring out the stepper motors and power supply.

- Once we had figured out that using the XY table for chess was too complex, we changed our design slightly, this time trying to make tic tac toe due to its simplicity. However, we ran into the same issues that prevented us from realizing this: the stepper motors and power supply were difficult to work with.

Conclusions

We are very grateful that we were able to complete a project that we are happy with. We were very inspired by all the different hardware we looked at and working with so many different components presented us with a great deal of learning opportunities. Above all, we are glad we got to learn something new through our cornhole board and are grateful for all the intellectual growth we got from this class!




thumb‎ Embedded Linux Class by Mark A. Yoder