Team Big DC Energia:

•

•

•

Published April 23, 2019 © GPL3+

Super Smash Blows

Playing with toy cars and buttons has never been so fun!

IntermediateFull instructions provided3 hours873

Things used in this project

Hardware components

Texas Instruments EK-TM4C123GXL TM4C Tiva LaunchPad

Seeed Studio Sidekick Basic Kit for TI Launchpad

Using: -RGB LED -Button (2) -Breadboard (3) -Assorted Wires

Seeed Studio Grove Starter Kit for LaunchPad

Using: -Expansion Board -Piezzo Buzzer -Ultrasonic Sensor (2) -4 digit display

Hot Wheels Car

Software apps and online services

Texas Instruments Energia

Story

As college students who work tirelessly day and night, BD(c)E wanted to create a product which would be as fun to make as it was to use. The team sat down, wrote out the equipment that we had access to and began brainstorming for ideas. Our planning session immediately targeted games as a fun category of product to both create and use. Our initial idea was in fact Red Light Green Light but after playing around with the ultrasonic sensor (which would be critical in the design) we realized that it could only detect humans in a range that was too short for our liking. We then had an ingenious idea: what if we used the sensor’s short range to our advantage?

Through further deliberation we settled on creating a game which involved coming close to the sensor for a point and competing with a second player to reach 15 points first. Hot Wheels, the childhood obsession of one of our team members, became the key element of our game by allowing us to easily get an object closer to the sensor to register a point. After noticing that the cars may be too low for the sensor to detect, we created a board that was mounted to each car to make detection easier. These boards would soon serve as more than a compensation for the sensor, but also for a method of getting a car to the sensor in the first place. The boards resembled the sails one would see on boats and we immediately capitalized on this observation, allowing us to finally mesh all our ideas together. The “sails” of these cars became the backbone of our game, allowing us to add an element of greater challenge to the game while simultaneously making it unique.

In addition to the challenge of blowing cars, we also decided we wanted to keep an element of randomness from our original idea of Red Light Green Light, in order to make our new game more interesting and less monotonous. This was achieved by the incorporation of a bonus point LED - whenever the light randomly switches to red, the first player to press their buttons receives an additional two points.

After formulating the concept, creating the game itself presented its own challenges. We spent several hours in the Oshman Engineering Design Kitchen designing circuitry, debugging code, and creating a hub for the LEDs, sensors and breadboard circuit. After a few hundred lines of code and a prototype for the game, our product - Super Smash Blows - was born. The product of a diverse set of ideas, hard work, and sheer college student ingenuity, Super Smash Blows moved from merely an idea to a physical reality. Just as we had planned from even before its conception, the project truly was as fun to design as it was to use. To us, that was the greatest success of all.

To Play:

1. Both players press their buttons to initialize the game. The game will not start unless both buttons are pressed and the cars are the correct distance (at least 2 feet) away from their respective sensors.

2. Players blow their cars towards their sensor. When the car gets close enough, the player gets 1 point! The buzzer will sound and their score counter will increase. After earning the point, the player must reset the car to its starting position before they will be able to score again.

3. At random intervals, the LED will change colors, corresponding to a different buzzer tone. When this occurs, whichever player presses their button first will earn 2 points!

4. When one player passes 15 points, they win! The LED and digit display will start flashing, and the buzzer plays a fun little victory tune.

Game Walkthrough

Code

SSBCode

#include <TM1637.h>
#include <Ultrasonic.h>

#define ULTRASONIC_PIN1   24
#define ULTRASONIC_PIN2   25
#define BUZZER_PORT  36
#define CLK 38
#define DIO 37

#define NOTE_G3  196
#define NOTE_A3  220
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_G4  392

#define MAX_SCORE 7


const int buttonPin1 = 9;
const int buttonPin2 = 10;

Ultrasonic ultrasonic1(ULTRASONIC_PIN1);
Ultrasonic ultrasonic2(ULTRASONIC_PIN2);
TM1637 tm1637(CLK, DIO);

int buttonState1 = 0;         // variable for reading the pushbutton status
int buttonState2 = 0;
int distance1 = 0;
int distance2 = 0; 
int score1 = 0;
int score2 = 0;
bool scoring1 = true;
bool scoring2 = true;
char state = 'w';    // w = wait; d = delay; g = game; e = endgame AVENGERS YAAAA
String LEDstate = "green";
int LEDcount = 0;
int randNumber = 0;
int pauseBetweenNotes = 1000/2 * 3;
//Initialize any constants or variables we will use in the later code

void setup() {
  //Determine the input/output statues of the different ports we write to
  pinMode(buttonPin1, INPUT_PULLUP);   
  pinMode(buttonPin2, INPUT_PULLUP);
  pinMode(RED_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(BLUE_LED, OUTPUT);
  randomSeed(analogRead(A0));
  tm1637.init();
  tm1637.set(BRIGHT_TYPICAL);//BRIGHT_TYPICAL = 2,BRIGHT_DARKEST = 0,BRIGHTEST = 7;
  digitalWrite(RED_LED, LOW);
  digitalWrite(GREEN_LED, HIGH);
  digitalWrite(BLUE_LED, LOW);
  //Initialize Serial Monitor
  Serial.begin(9600);
}

void loop() {
  //Constantly check the status of the distance sensors and buttons
  buttonState1 = digitalRead(buttonPin1);
  buttonState2 = digitalRead(buttonPin2);
  distance1 = ultrasonic1.MeasureInCentimeters();
  distance2 = ultrasonic2.MeasureInCentimeters();

  //Waiting State, the state when the device is turned on or when game is reset in End State
  if(state == 'w'){
    //Waits until the two buttons are pressed and distance sensors sense that the cars are far away enough at thei starting distances
    if(distance1 > 10 and distance2 > 10 and buttonState1 == LOW and buttonState2 == LOW){
      //Once satisfied, start the countdown and display 3... 2... 1... and play notes and vary LED
      digitalWrite(BLUE_LED, HIGH);
      Serial.println("Wating ended...");
      state = 'g';
      delay(1000);
      //delay -> WdRdWdRdG
      tm1637.display(1, 3);
      tm1637.display(3, 3);
      digitalWrite(RED_LED, LOW);
      tone(36, NOTE_C4,1000/2);
      delay(pauseBetweenNotes);

      tm1637.display(1, 2);
      tm1637.display(3, 2);
      tone(36, NOTE_C4,1000/2);
      delay(pauseBetweenNotes);

      tm1637.display(1, 1);
      tm1637.display(3, 1);
      tone(36, NOTE_G4,1000/2);
      digitalWrite(RED_LED, HIGH);
      digitalWrite(GREEN_LED, LOW);
      delay(pauseBetweenNotes);
      
      tm1637.display(1, 0);
      tm1637.display(3, 0);
      tm1637.point(POINT_ON);
    }
  }

  //Game state
  else if(state == 'g'){
    //Serial.println(scoring1);
    //Serial.println(scoring2);
    //Serial.println(score1);
    //Serial.println(score2);
    //Serial.println(distance1);
    //Serial.println(score2);

    //Scoring logic, avoids when a player is within the distance of the sensor, that the sensor doesn't keep counting up the score
    if(scoring1){
      if(distance1 <= 2){
        //Pitch is played, score is incremeneted
        score1 += 1;
        tone(36, NOTE_C4,1000/4);
        scoring1 = false;
      }
    }
    else{
      //Scoring logic reset
      if(distance1 > 10){
        scoring1 = true;
      }
    }

   //Scoring logic for player two
    if(scoring2){
      if(distance2 <= 2){
        //Pitch is played, score is incremeneted
        score2 += 1;
        tone(36, NOTE_G4,1000/4);
        scoring2 = false;
      }
    }
    else{
      //Scoring logic reset
      if(distance2 > 10){
        scoring2 = true;
      }
    }

    //Bonus LED button random state change logic
    if(LEDstate == "green"){
      //Turns LED red at random time
      randNumber = random(1,400);
      Serial.println(randNumber);
      if(randNumber == 2){
        digitalWrite(RED_LED, LOW);
        digitalWrite(GREEN_LED, HIGH);
        LEDstate = "red";
      }
    }

    //LED scoring logic
    if(LEDstate == "red"){
      LEDcount += 1;
      if(buttonState1 == LOW){
        //play tune and adjust score
        LEDcount = 0;
        LEDstate = "green";
        digitalWrite(RED_LED, HIGH);
        digitalWrite(GREEN_LED, LOW);
        tone(36, NOTE_C4,1000/4);
        score1 += 2;
      }
      else if(buttonState2 == LOW){
        LEDcount = 0;
        LEDstate = "green";
        digitalWrite(RED_LED, HIGH);
        digitalWrite(GREEN_LED, LOW);
        tone(36, NOTE_G4,1000/4);
        score2 += 2;
      }
      //Turn LED back to green from red if no one presses it in time
      if(LEDcount >= 100){
        LEDcount = 0;
        LEDstate = "green";
        digitalWrite(RED_LED, HIGH);
        digitalWrite(GREEN_LED, LOW);
      }
    }

    //Display score
    int digit2p1 = score1 % 10;
    int digit1p1 = score1 / 10;
    int digit2p2 = score2 % 10;
    int digit1p2 = score2 / 10;
    if (digit1p1 != 0){
       tm1637.display(0, digit1p1);
    }
    
    tm1637.display(1, digit2p1);
    if (digit1p2 != 0){
       tm1637.display(2, digit1p2);
    }
    tm1637.display(3, digit2p2);

    //Check to see if anyone has won the game yet
    if(score2 >= MAX_SCORE or score1 >= MAX_SCORE){
      state = 'e';
    }
  }

  //End state
  else if(state == 'e'){
    //Display final scores 
    int digit2p1 = score1 % 10;
    int digit1p1 = score1 / 10;
    int digit2p2 = score2 % 10;
    int digit1p2 = score2 / 10;
    //Play melody
    int melody[] = {
    NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3, NOTE_G3,0, NOTE_B3, NOTE_C4};

    // note durations: 4 = quarter note, 8 = eighth note, etc.:
    int noteDurations[] = {
      4, 8, 8, 4,4,4,4,4 };
    digitalWrite(RED_LED, LOW);
    digitalWrite(GREEN_LED, LOW);
    digitalWrite(BLUE_LED, LOW);
    pauseBetweenNotes = 1000/2;
    for (int thisNote = 0; thisNote < 8; thisNote++) {
      // to calculate the note duration, take one second 
      // divided by the note type.
      //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 500/noteDurations[thisNote];
      tone(BUZZER_PORT, melody[thisNote],noteDuration);
      // to distinguish the notes, set a minimum time between them.
      // the note's duration + 30% seems to work well:
      int pauseBetweenNotes = noteDuration * 1.30;
      delay(pauseBetweenNotes);
      delay(100);
      // stop the tone playing:
      noTone(BUZZER_PORT);
    }
    
    digitalWrite(BLUE_LED, HIGH);

    //Flash score, LED, and wait till the reset conditions (same as start game conditions) are satisfied and then send state back to Waiting State
    bool cond = false;
    while(not cond){
      buttonState1 = digitalRead(buttonPin1);
      buttonState2 = digitalRead(buttonPin2);
      distance1 = ultrasonic1.MeasureInCentimeters();
      distance2 = ultrasonic2.MeasureInCentimeters();
      tm1637.set(BRIGHT_TYPICAL);
      digitalWrite(RED_LED, HIGH);
      digitalWrite(GREEN_LED, LOW);
      if (digit1p1 != 0){
       tm1637.display(0, digit1p1);
      }
      
      tm1637.display(1, digit2p1);
      if (digit1p2 != 0){
         tm1637.display(2, digit1p2);
      }
      tm1637.display(3, digit2p2);
      delay(1000);
      
      tm1637.set(0);
      digitalWrite(RED_LED, LOW);
      digitalWrite(GREEN_LED, HIGH);
      if (digit1p1 != 0){
       tm1637.display(0, digit1p1);
      }
      
      tm1637.display(1, digit2p1);
      if (digit1p2 != 0){
         tm1637.display(2, digit1p2);
      }
      tm1637.display(3, digit2p2);
      delay(1000);
    }
    if(distance1 > 10 and distance2 > 10 and buttonState1 == LOW and buttonState2 == LOW){
      cond = true;
      state = 'w';
    }
  }
  delay(30);
}

Credits

Comments

Please log in or sign up to comment.

Super Smash Blows