Arduino Pong Game

My main project is Arduino Pong Game. The game is made of 6 LED matrices that display the game pong. The paddles are controlled by two potentiometers. The potentiometers are read by the Arduino which is the language the game is programmed in.

Engineer

Ryan Z

Area of Interest

Engineering / Computer Science

School

Packer Collegiate Institute

Grade

Incoming Sophomore

ryan_headshot

Arduino Pong Game

Final Milestone

My final Milestone was to make the game in Processing. Processing is a programming language that is focused on visuals. It is also relatively easy to link Arduino to Processing, which is why I decided to use Processing. The hardware is the exact same and I used the same setup from the LED pong game for the processing pong game. The game is single player pong and you control the paddle with the potentiometer.

First Milestone

My first milestone was to finish the game with the LED matrices. After we spent a long time trying to figure out if we could get the 4 x 1 matrices to work, we decided to cut the matrices and rearrange them. In this step I learned about potentiometers because they are the things that control the paddles. Potentiometers are variable resistors, so depending on the speed of the current, the Arduino can figure out how much it is turned. Each LED needs four pins, power, ground, and two digital pins. Each potentiometer is wired to ground, power and an analog pin.

The Code

Arduino Code for Processing game and LED version

Processing version Code

void setup() {
pinMode(A1, INPUT);
Serial.begin(9600);
}

void loop() {
Serial.println(analogRead(A1));
delay(35);
}

LED version code:

//We always have to include the library
#include “LedControl.h”
byte rightscore;
byte leftscore;
int toneloop=1000;
byte pongdisplay[]={ // Used upon start up to display “Pong”

B11111111, B00000000,
B00001001, B00000000,
B00001001, B00000000,
B00000110, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B01110000, B00000000,
B10001000, B00000000,
B10001000, B00000000,
B01110000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B11110000, B00000000,
B00001000, B00000000,
B00001000, B00000000,
B11110000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B11001111, B00000000,
B10001001, B00000000,
B10001001, B00000000,
B11111111, B00000000,
B00000000, B00000000,
B00000000, B00000000,
};

byte zero[]={ // Used to display a ‘0’ for when displaying the score
B00000000,
B00000000,
B00111100,
B01000010,
B01000010,
B01000010,
B00111100,
B00000000
};
byte one[]={ // Used to display a ‘1’ for when displaying the score
B00000000,
B00000000,
B10001000,
B10000100,
B11111110,
B10000000,
B10000000,
B00000000
};

byte two[]={ // Used to display a ‘2’ for when displaying the score
B00000000,
B01100010,
B01010001,
B01010001,
B01001001,
B01000110,
B00000000,
B00000000
};
byte three[]={ // Used to display a ‘3’ for when displaying the score
B00000000,
B00100110,
B01000001,
B01001001,
B00110110,
B00000000,
B00000000,
B00000000
};

byte four[]={ // Used to diplay a ‘4’ for when displaying the score
B00000000,
B00000000,
B00001111,
B00001000,
B00001000,
B11111111,
B00000000,
B00000000
};
byte five[]={ // Used to display a ‘5’ for when displaying the score
B00000000,
B00000000,
B10011110,
B10010010,
B10010010,
B11110010,
B00000000,
B00000000
};

byte displayevens=0;
byte displayrow=0;
byte displayindex=0;
byte displayodds=1;
unsigned long time;
unsigned long currenttime;
/*
Now we need a LedControl to work with.
pin 12 is connected to the DataIn
pin 11 is connected to the CLK
pin 10 is connected to LOAD
We have 6 MAX72XX.
*/
byte mode;
byte deflect;
byte carry;
int line;
LedControl lc=LedControl(12,11,10,6);
long randnumber;
byte dir;
int startpos;
byte row;
byte column;
long randNumber;
byte start;
byte diry;
int pass;
byte limit;
#define leftpaddle 0 //left pong knob is connected to analog input 0
#define rightpaddle 1 // right pong knob is connected to analog intput 1
int directionpong;
int rightpongval;
int leftpongval;
byte blinkx;

byte pong[]={ // Stores the position of the ball and paddles
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,

B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,

B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000,
B00000000, B00000000};

void setup(){
pinMode(leftpaddle, INPUT); //the paddle is an input.
pinMode(rightpaddle, INPUT); // the paddle is an input.

Serial.begin(9600); // serial communication for debugging. Set to 9600 baud

// These statemetns below go through and sets up the matrices to the given settings
lc.shutdown(0,false);
lc.setIntensity(0,1);
lc.clearDisplay(0);

lc.shutdown(1,false);
lc.setIntensity(1,1);
lc.clearDisplay(1);

lc.shutdown(2,false);
lc.setIntensity(2,1);
lc.clearDisplay(2);

lc.shutdown(3,false);
lc.setIntensity(3,1);
lc.clearDisplay(3);

lc.shutdown(4,false);
lc.setIntensity(4,1);
lc.clearDisplay(4);

lc.shutdown(5,false);
lc.setIntensity(5,1);
lc.clearDisplay(5);

while(displayevens<5){
while(displayrow<=7){
lc.setRow(displayevens,displayrow,pongdisplay[displayindex]);
displayrow++;
displayindex+=2;
}
displayrow=0;
displayevens+=2;
}

displayrow=0;
displayindex=1;
randomSeed(analogRead(4));
start=1;
time=millis();
currenttime=millis();

while(currenttime-time<3000){
leftpongval=analogRead(leftpaddle);
leftpongval=map(leftpongval,1023,20,2,0);
if(leftpongval==0){
lc.setLed(3,2,7,true);
lc.setLed(3,3,7,false);
lc.setLed(3,4,7,false);
mode=1;
limit=2;
}
if(leftpongval==1){
lc.setLed(3,2,7,true);
lc.setLed(3,3,7,true);
lc.setLed(3,4,7,false);
mode=2;
limit=1;
}
if(leftpongval==2){
lc.setLed(3,2,7,true);
lc.setLed(3,3,7,true);
lc.setLed(3,4,7,true);
mode=3;
limit=2;
}
delay(50);
lc.clearDisplay(3);
currenttime=millis();
}

}

void loop(){
paddles();
pongsim();
displayscreen();

}

void paddles(){ //reads data from the paddles and displays that in the array
int searchbit;
int carry=0;
// Serial.print(“LeftPaddle:”);
// Serial.println(analogRead(leftpaddle));
leftpongval=analogRead(leftpaddle);
leftpongval=map(leftpongval,0,1010,0,13);
rightpongval=analogRead(rightpaddle);
rightpongval=map(rightpongval,1023,20,0,13);

// Serial.print(“RightPaddle:”);
// Serial.println(rightpongval);

//clears the previous paddle inorder to display the next one
pong[0]=B00000000;
pong[1]=B00000000;
pong[46]=B00000000;
pong[47]=B00000000;
//——————————-right paddle
if(mode!=3){
if(rightpongval<=7){
rightpongval=map(rightpongval,0,7,7,0);
bitSet(pong[46], rightpongval);
if(rightpongval-1>=0){
bitSet(pong[46],rightpongval-1);
}
else{
bitSet(pong[47], 7);
if(mode!=2){
bitSet(pong[47],6);
carry=1;
}
}
if(mode!=2){
if(carry==0){
if(rightpongval-2>=0){
bitSet(pong[46], rightpongval-2);
}
else{
bitSet(pong[47], 7);
carry=1;
}
}
}
}

if(rightpongval>7){
rightpongval=map(rightpongval,8,13,7,limit);
bitSet(pong[47],rightpongval);
bitSet(pong[47],rightpongval-1);
if(mode!=2){
bitSet(pong[47],rightpongval-2);
}
}
}
else{
pong[46]=B11111111;
pong[47]=B11111111;
lc.setRow(4,7,pong[46]);
lc.setRow(5,7,pong[47]);
}

//———————————-left paddle
carry=0;

if(leftpongval<=7){
leftpongval=map(leftpongval,0,7,7,0);
bitSet(pong[0], leftpongval);
if(leftpongval-1>=0){
bitSet(pong[0],leftpongval-1);
}
else{
bitSet(pong[1], 7);
if(mode!=2){
bitSet(pong[1],6);
carry=1;
}
}
if(mode!=2){
if(carry==0){
if(leftpongval-2>=0){
bitSet(pong[0], leftpongval-2);
}
else{
bitSet(pong[1], 7);
}
}
}
}

if(leftpongval>7){
leftpongval=map(leftpongval,8,13,7,limit);
bitSet(pong[1],leftpongval);
bitSet(pong[1],leftpongval-1);
if(mode!=2){
bitSet(pong[1],leftpongval-2);
}
}

}

void pongsim(){

if( ((line==2 || line==3) && diry == 0) || ((line==44 || line==45) && diry==1)){
ball_meets_paddle();
}

if(start==1){ // Starting a new game
randnumber=random(1,7); // Come up with a random starting bit
dir=random(2); // Come up with a random starting left to right or right to left motion
diry=random(2); // Come up with a random starting y movement direction
if(diry==0){ // If the y direction is 0. Movement from bottom to top
line=random(30,34); // Come up with a random starting line between 30-34
bitSet(pong[line],randnumber); // Set the bit on the random line and random bit equal to 1 in the pong array
}
if(diry==1){ // If the y direction is 1. Movement from top to bottom
line=random(12,16); // Come up with a random starting line between 12-16
bitSet(pong[line],randnumber); // Set the bit on the random line and random bit equal to 1 in the pong array
}
start=0; // Set the start varaible back equal to 0
}

if(diry==0){ // If the ball is moving from bottom to top
if(dir==0){ // If the ball is moving from right to left
if(deflect==0 && carry==0){ // If the ball is not deflecting or carrying over to another matrix
line-=2; // Progress the ball towards the other side by subtracting 2 from the line
pong[line]= pong[line+2] << 1;// Shift the ball left and set it equal to the new line
pong[line+2]=B00000000; // Clear the old line of the ball
}
if(carry==1){ // If the ball has to carry over to a new matrix
line-=3; // Progress the ball towards the other side by subtracting 3 from the line
pong[line]=B00000001; // Set the new line
pong[line+3]=B00000000; // Clear the old line of the ball
carry=0; // Set the carry variable back to 0
return; // We are done here
}
if(deflect==1){ // If the ball has to deflect off the wall
line-=2; // Progress the ball towards the other side by subtracting 2 from the line
pong[line]=B01000000; // Set the new line
pong[line+2]=B00000000; // Clear the old line of the ball
deflect=0; // Set the deflect variable back to 0
dir=1; // Switch the direction to left to right
return; // We are done here
}
if(bitRead(pong[line],7)==1){ // If the ball is on the 7th bit of the line
if(line==3|| line==5 || line==7 || line==9 || line==11 || line==13 || line==15 || // If the line is an odd line
line==17 || line==19 || line==21 || line==23 || line==25 || line==27 ||
line==29 || line==31 || line==33 || line==35 || line==37 || line==39 || line==41 ||line==43 || line==45){
carry=1; // The ball needs to carry over to another matrix
return; // We are done here
}
else{ // Else the ball is on an even line
if(line!=2){ // The line can not be 2 because the ball meets the paddle at 2
deflect=1; // The ball needs to deflect off the wall
return; // We are done here
}
}
}
}

// The comments above should explain all of the stuff below. Some stuff, different parameters.

if(dir==1){
if(deflect==0 && carry==0){
line-=2;
pong[line]= pong[line+2] >> 1;
pong[line+2]=B00000000;
}
if(carry==1){
line–;
pong[line]=B10000000;
pong[line+1]=B00000000;
carry=0;
return;
}
if(deflect==1){
line-=2;
pong[line]=B00000010;
pong[line+2]=B0000000;
deflect=0;
dir=0;
return;
}
if(bitRead(pong[line],0)==1){
if( line==2 || line==4 || line==6 || line==8 || line==10 || line==12 || line==14 ||
line==16 || line==18 || line==20 || line==22 || line==24 || line==26 ||
line==28 || line==30 || line==32 || line==34 || line==36|| line==38 || line==40 ||line==42 || line==44 ){
carry=1;
return;
}
else{
if(line!=3){
deflect=1;
return;
}
}
}
}
}

//——————————————–diry = 1 below
if(diry==1){
if(dir==0){
if(deflect==0 && carry==0){
line+=2;
pong[line]= pong[line-2] << 1;
pong[line-2]=B00000000;
}
if(carry==1){
line+=1;
pong[line]=B00000001;
pong[line-1]=B00000000;
carry=0;
return;
}
if(deflect==1){
line+=2;
pong[line]=B01000000;
pong[line-2]=B00000000;
deflect=0;
dir=1;
return;
}
if(bitRead(pong[line],7)==1){
if( line==5 || line==7 || line==9 || line==11 || line==13 || line==15 ||
line==17 || line==19 || line==21 || line==23 || line==25 || line==27 ||
line==29 || line==31 || line==33 || line==35 || line==37 || line==39|| line==41 ||line==43 || line==45){
carry=1;
return;
}
else{
if(line!=44){
deflect=1;
return;
}
}
}
}

if(dir==1){
if(deflect==0 && carry==0){
line+=2;
pong[line]= pong[line-2] >> 1;
pong[line-2]=B00000000;
}
if(carry==1){
line+=3;
pong[line]=B10000000;
pong[line-3]=B00000000;
carry=0;
return;
}
if(deflect==1){
line+=2;
pong[line]=B00000010;
pong[line-2]=B0000000;
deflect=0;
dir=0;
return;
}
if(bitRead(pong[line],0)==1){
if(line==2|| line==4 || line==6 || line==8 || line==10 || line==12 || line==14 ||
line==16 || line==18 || line==20 || line==22 || line==24 || line==26 ||
line==28 || line==30 || line==32 || line==34 || line==36|| line==38 || line==40 ||line==42 || line==44 ){
carry=1;
return;
}
else{
if(line!=45){
deflect=1;
return;
}
}
}
}
}
}

void displayscreen(){
displayevens=0;
displayrow=0;
displayindex=0;
displayodds=1;

while(displayevens<5){
while(displayrow<=7){
lc.setRow(displayevens,displayrow,pong[displayindex]);
displayrow++;
displayindex+=2;
}
displayrow=0;
displayevens+=2;
}

displayrow=0;
displayindex=1;

while(displayodds<6){
while(displayrow<8){
lc.setRow(displayodds,displayrow,pong[displayindex]);
displayrow++;
displayindex+=2;
}
displayrow=0;
displayodds+=2;
}
}

void clearscreen(){
int clearing=0;

while(clearing<49){
pong[clearing]=B00000000;
clearing++;
}
}

void ball_meets_paddle(){
byte search1=0;

if(diry==0){ // ball moving up
if(dir==0){ //ball moving from right to left
while(search1<8){ //find the bit the ball is on
if(bitRead(pong[line],search1)==1){ //found the bit the ball is on
if(line==2){
if( search1!=6 && search1!=7){ //if its on line 2, make sure it isnt on those special bits
if( bitRead(pong[0], search1)==1){ // check to see that there is a paddle there
diry=1; //switch y direction so it heads towards other paddle
tone(9,500,100);
}
else if( bitRead(pong[0], search1+1)==1){
diry=1;
dir=1;
tone(9,500,100);
if(search1==0){
carry=1;
}
}
else { // no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}

if(search1==6){ //special bit, needs to deflect same path it comes in
if(bitRead(pong[0],7)==1){ //there is a paddle there
pong[2]=B01000000;
dir=1;
diry=1;
tone(9,500,100);
}
else{//missed it, no paddle.
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}

if(search1==7){//special bit, needs to bounce off wall first
if(bitRead(pong[0],6)==1){// found the paddle
pong[2]=B00100000;
diry=1;
dir=1;
line=2;
tone(9,500,100);
displayscreen();
}
else{//missed it, no paddle.
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}
}

if(line==3){
if( search1!=7){ //if its on line 3, make sure it isnt on those special bits
if( bitRead(pong[1], search1)==1){ // check to see that there is a paddle there
diry=1; //switch y direction so it heads towards other paddle
tone(9,500,100);
}
else if( bitRead(pong[1], search1+1)==1){
diry=1;
dir=1;
tone(9,500,100);
}
else { // no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}

if(search1==7){//special bit, needs to carry over to next matrix
if(bitRead(pong[1],7)==1){ //found a paddle there
//pong[2]=B10000000; //clear the row it was on
dir=0; //direction is the same
diry=1; // y direction changes
tone(9,500,100);
}
else if(bitRead(pong[0],0)==1){
dir=1;
diry=1;
tone(9,500,100);
carry=0;
}
else{// no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}
}
}
search1++;
}
}

if(dir==1){//ball is moving from left to right
while(search1<8){ //find the bit the ball is on
if(bitRead(pong[line],search1)==1){ //found the bit the ball is on
if(line==3){
if( search1!=1 && search1!=0){ //if it is on line 3, make sure it isnt on a special bit
if(bitRead(pong[1], search1)==1){ //check if there is a paddle
diry=1; // switch the y direction so the ball heads towards the other paddle
tone(9,500,100);
}
else if(bitRead(pong[1], search1-1)==1){
diry=1;
dir=0;
tone(9,500,100);
if(search1==7){
carry=1;
}
}
else{ // no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}

if(search1==1){
if(bitRead(pong[1],0)==1){
pong[3]=B00000010;
dir=0;
diry=1;
tone(9,500,100);
}
else{
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}

if(search1==0){
if(bitRead(pong[1],0)==1){
pong[3]=B00000100;
diry=1;
dir=0;
line=3;
tone(9,500,100);
displayscreen();
}
else{
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}
}

if(line==2){
if( search1!=0){
if(bitRead(pong[0], search1)==1){ //check if there is a paddle
diry=1; // switch the y direction so the ball heads towards the other paddle
tone(9,500,100);
}
else if(bitRead(pong[0], search1-1)==1){
diry=1;
dir=0;
tone(9,500,100);
}
else{ // no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}

if(search1==0){
if(bitRead(pong[0],0)==1){
// pong[2]=B00000001;
line=2;
dir=1;
diry=1;
tone(9,500,100);
return;
}
else if(bitRead(pong[1],7)==1){
diry=1;
dir=0;
tone(9,500,100);
carry=0;
}
else{
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreleft();
}
}
}
}
search1++;
}
}
}
//———————————————————————-

if(diry==1){ // ball moving up
if(dir==0){ //ball moving from right to left
while(search1<8){ //find the bit the ball is on
if(bitRead(pong[line],search1)==1){ //found the bit the ball is on
if(line==44){
if( search1!=6 && search1!=7){ //if its on line 2, make sure it isnt on those special bits
if( bitRead(pong[46], search1)==1){ // check to see that there is a paddle there
diry=0; //switch y direction so it heads towards other paddle
tone(9,500,100);
}
else if( bitRead(pong[46], search1+1)==1){
diry=0;
dir=1;
tone(9,500,100);
if(search1==0){
carry=1;
}
}
else { // no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreright();
}
}

if(search1==6){ //special bit, needs to deflect same path it comes in
if(bitRead(pong[46],7)==1){ //there is a paddle there
dir=1;
diry=0;
tone(9,500,100);
}
else{//missed it, no paddle.
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreright();
}
}

if(search1==7){//special bit, needs to bounce off wall first
if(bitRead(pong[46],6)==1){// found the paddle
pong[44]=B00100000;
diry=0;
dir=1;
tone(9,500,100);
displayscreen();
line=44;
return;
}
}
}

if(line==45){
if( search1!=7){ //if its on line 3, make sure it isnt on those special bits
if( bitRead(pong[47], search1)==1){ // check to see that there is a paddle there
diry=0; //switch y direction so it heads towards other paddle
tone(9,500,100);
}
else if( bitRead(pong[47], search1+1)==1){
diry=0;
dir=1;
tone(9,500,100);
}
else { // no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreright();
}
}

if(search1==7){//special bit, needs to carry over to next matrix
if(bitRead(pong[47],7)==1){ //found a paddle there
// pong[45]=B10000000; //clear the row it was on
line=45;
dir=0; //direction is the same
diry=0; // y direction changes
tone(9,500,100);
}
else if(bitRead(pong[46],0)==1){
dir=1;
diry=0;
tone(9,500,100);
carry=0;
}
else{// no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreright();
}
}
}
}
search1++;
}
}

if(dir==1){//ball is moving from left to right
while(search1<8){ //find the bit the ball is on
if(bitRead(pong[line],search1)==1){ //found the bit the ball is on
if(line==45){
if( search1!=1 && search1!=0){ //if it is on line 3, make sure it isnt on a special bit
if(bitRead(pong[47], search1)==1){ //check if there is a paddle
diry=0; // switch the y direction so the ball heads towards the other paddle
tone(9,500,100);
}
else if(bitRead(pong[47], search1-1)==1){
diry=0;
dir=0;
tone(9,500,100);
if(search1==7){
carry=1;
}
}
else{ // no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreright();
}
}

if(search1==1){
if(bitRead(pong[47],0)==1){
pong[43]=B00000010;
dir=0;
diry=0;
tone(9,500,100);
}
else{
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreright();
}
}

if(search1==0){
if(bitRead(pong[47],1)==1){
pong[45]=B00000100;
diry=0;
dir=0;
line=45;
tone(9,500,100);
displayscreen();
}
else{
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreright();
}
}
}

if(line==44){
if( search1!=0){
if(bitRead(pong[46], search1)==1){ //check if there is a paddle
diry=0; // switch the y direction so the ball heads towards the other paddle
tone(9,500,100);
}
else if(bitRead(pong[46], search1-1)==1){
diry=0;
dir=0;
tone(9,500,100);
}
else{ // no paddle, missed the ball
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreright();
}
}

if(search1==0){
if(bitRead(pong[46],0)==1){
pong[44]=B00000001;
line=44;
dir=1;
diry=0;
tone(9,500,100);
}
else if(bitRead(pong[47],7)==1){
dir=0;
diry=0;
tone(9,500,100);
carry=0;
}
else{
tone(9,500,300);
clearscreen();
start=1;
delay(1000);
scoreright();
}
}
}
}
search1++;
}
}
}
pass=1;
search1=0;
}

void scoreleft(){
clearscreen();
rightscore++;
setscore();
displayscreen();

if(rightscore==5){
while(blinkx++<4){
clearscreen();
displayscreen();
delay(500);
setscore();
displayscreen();
delay(500);
}
blinkx=0;
rightscore=0;
leftscore=0;
}
else{
delay(2000);
}

clearscreen();

}

void scoreright(){
clearscreen();
leftscore++;
setscore();
displayscreen();

if(leftscore==5){
while(blinkx++<4){
clearscreen();
displayscreen();
delay(500);
setscore();
displayscreen();
delay(500);
}
blinkx=0;
rightscore=0;
leftscore=0;
}
else{
delay(2000);
}

clearscreen();

}

void setscore(){

byte setScoreLoop=0;

while(setScoreLoop<=7){
if(leftscore==0){
pong[setScoreLoop*2]=zero[setScoreLoop];
}
if(leftscore==1){
pong[setScoreLoop*2]=one[setScoreLoop];
}
if(leftscore==2){
pong[setScoreLoop*2]=two[setScoreLoop];
}
if(leftscore==3){
pong[setScoreLoop*2]=three[setScoreLoop];
}
if(leftscore==4){
pong[setScoreLoop*2]=four[setScoreLoop];
}
if(leftscore==5){
pong[setScoreLoop*2]=five[setScoreLoop];
}

if(rightscore==0){
pong[32+(setScoreLoop*2)]=zero[setScoreLoop];
}
if(rightscore==1){
pong[32+(setScoreLoop*2)]=one[setScoreLoop];
}
if(rightscore==2){
pong[32+(setScoreLoop*2)]=two[setScoreLoop];
}
if(rightscore==3){
pong[32+(setScoreLoop*2)]=three[setScoreLoop];
}
if(rightscore==4){
pong[32+(setScoreLoop*2)]=four[setScoreLoop];
}
if(rightscore==5){
pong[32+(setScoreLoop*2)]=five[setScoreLoop];
}
setScoreLoop++;
}

pong[20]=B00011000;
pong[22]=B00011000;
pong[24]=B00011000;

}

Processing Code

//Ryan Single Player Pong Program, 7/03/19
import processing.serial.*;
Serial myPort;
String val;
String val2;
float paddleY = 0;
float ballX = 300;
float ballY = 300;
float ballVX = random(2.8, 3.2);
float ballVY = random(2.7, 3.1);
float time = 0;
float speed = 1;
void setup() {
size(600, 600);
String portName = Serial.list()[1];
myPort = new Serial(this, portName, 9600); //lets me communicate with the Arduino
}
void draw() {
background(255);
fill(200);
rect(595,0, 5, 600);
time++;
fill(0, 0, 0);
if (round(time/60) == 1) { //second vs seconds
text(“Time ellapsed: ” + round(time/60) + ” second”, 20.0, 20.0);
}
else {
text(“Time ellapsed: ” + round(time/60) + ” seconds”, 20.0, 20.0);
}
if (myPort.available() > 0) { // If data is available,
val = myPort.readStringUntil(‘\n’); // sets val to the value of the potentiometer
if (val == null) {
val = val2; //val2 is the backup incase val is null
}
}
fill(0, 0, 0);
text(“Potentiometer: ” + val, 190.0, 20.0);
text(“Speed: ” + String.format(“%.2f”, speed), 330, 20);
println(val);
fill(0,0,255);
if (val != null) {
rect(15.0, float(val)/1.82, 10.0, 40.0); //Left Paddle
}
fill(0,0,0);
ballX += ballVX;
ballY += ballVY;
ellipse(ballX, ballY, 10.0, 10.0); //Ball, radius 5
if (ballX > 590 || ballX < 30 && abs(ballY – float(val)/1.82 – 20) <= 25) { //if the ball is touching the paddle or the right wall
if (ballX > 590) { //right wall
ballVX *= -1;
}
if (ballX < 50) { //paddle
ballVX *= random(-1.02, -1.08);
ballVY *= random(1.02, 1.08);
speed *= random(1.02, 1.08);
}
}
if (val != null) {
if (ballX < 12 && abs(ballY – float(val)/1.82 – 20) > 25) {
text(“You lose! Your time is: ” + round(time/60) + ” seconds”, 210, 300); //you lose
println(“lose”);
stop(); //ends program
}
}
if (ballY > 595 || ballY < 5) { //top and bottom of screen
ballVY *=-1;
}
val2 = val;
}

Starter Project

My starter project is the Electronic Dice kit. The die is activated when it is hit against something. The piezo then outputs electricity to the PIC micro controller. The micro controller is preprogrammed to randomly choose a value from 1 to 6 and sends current to the corresponding LEDs.

How it works

Construction:

Steps 1 & 2: Solder Resistors and a Diode. Without the resistors the LEDs receives to much current and would go out

Step 3: Solder all 7 LEDs.

Step 4: Install the PIC micro controller. The micro controller is preprogrammed to randomly choose a number and then redirect electricity to the right LEDs.

Step 5: Install the battery holder on the back of the PCB.

Step 6: Wire the piezo to the PCB. A piezoelectric material generates an electric current when it is pressed. When the piezo is pressed it outputs electricity to the micro controller, which causes the micro controller to turn on the LEDs.

Step 7: Assemble acrylic base and attach it to the PCB.

EDK schematic

screen-shot-2019-07-05-at-1.40.30-pm
Image Source: https://www.spikenzielabs.com/learn/dicekit.html

Start typing and press Enter to search