Eddy Ji - Interaction Lab Blog

Midterm Project – Lizard Sitter 9000

CONTEXT AND SIGNIFICANCE

From previous analysis of readings, I wrote that interaction could be understood as the reciprocal actions and/or influence between two or more actors, actors being entities that are able to receive information from an actor and be able to output an action with given information. In all the interactive projects that I had looked at, there would be a consistent exchange of information between the project and the audience, where both the project and the audience receive and create new information that affects each other. 

Tamagotchi Keychain

The most basic idea of the project came from Tamagotchis, which are keychain-sized pet simulators where you can take care of a pet by fulfilling its needs. It is a fun game that requires you to periodically take care of your Tamagotchi so that it doesn’t die.

My partner and I took this idea and expanded upon it by making a more physically interactive and larger model. The project is intended for anybody who is willing to play as one of the main goals for this project is to make something entertaining. However, we also feel that this project would be good in improving your motor skills when pressing the button and scrubbing rapidly. A perceived message from this project, especially for younger audiences can also be that taking care of a pet is an important task that takes dedication and effort. 

 

CONCEPTION AND DESIGN

One of the more important decisions in our design process was deciding where we would put the input components for the user to interact with. We initially thought about putting it either on top of the enclosure or within the enclosure, but we ultimately decided against this because it would be susceptible to collapsing or hard to access respectively. Instead, we decided to go for an arcade machine layout with the controls being put in front of the enclosure. We also originally planned to have four different needs, food & water, exercise, hygiene and entertainment. When working on entertainment, a Simon Says game, I felt that it was taking up too many resources, both physically and time-wise, there were just too many components and too little time and energy, it could have been a whole project by itself. As for the food and water needs, we just didn’t have enough time or pins left on the Arduino. 

 

FABRICATION AND PRODUCTION

Before we got to the production process, we made some preliminary sketches and brainstorms just to make a roadmap of how our project would look like. 

Creating LED indicator lights separately

At the beginning of the production process, I started to experiment with the different functions of the project, both circuitry and code-wise. After my partner and I figured out all the different functions, it became a matter of putting the code and circuitry all together, which was the more complicated part. Aside from smaller logical and circuitry mistakes that we needed to fix, the biggest issue I think we had was trying to figure out how to use the millis() function properly as we needed many parts of the code to run at the same time. Despite this challenge, we managed to get it to work properly in the end. It was during this time as well that we worked on putting together the housing and visual aspects of the project, which seemed to go relatively smoothly. 

Immediately after user testing

Final Version

 

During user testing, we found that many people had a hard time understanding how their inputs would affect the output of our project. We also found that people expected there to be a winning condition for the game, which we had not implemented yet. With the first concern, we implemented more visual symbols so that players could understand the function of each input component better. For the second concern, we added more code so that there were winning conditions that could be met, this included a level counting system, 3 levels, and a winning signal. A level indication LED was also added to complement this change in code.  It was also during this time that we decided that the inclusion of a 5-watt LED would also help indicate when the game has started to the user, with it also providing better lighting within the enclosure

Code:

#include <Servo.h>
Servo myservo;
int startButton = 2; // Start game button
int playButton = 3; // Button to increase Play Need Value
int washGLED = 4;
int washYLED = 5;
int washRLED = 6;
int playGLED = 7;
int playYLED = 8;
int playRLED = 9;
int servoPin = 11; // Servo motor pin
int visLED = 12;
int buzzer = 13;
// Game Functioning Values
bool gameStat = false; // Game state
int servoPos = 0; //Servo position
// Need Values
int washNeedVal = 80; // Wash Need Value initialization
int playNeedVal = 79; // Play Need Value initialization
// Play functional Values
bool freshButton = true;
// Wash functional values
bool reachedMax = false; // Flag to check if max slider value is reached
long lastUpdateTime = 0; // To track time for decrementing need values
// For ending
int endFlashCount = 0;
//Level Counter
int levelCount = 1;
int levelLED = 10;
//Difficulty setting variables
int washDecreaseAmnt = 1;
int playDecreaseAmnt = 1;
//Event counters
bool countdownDisplayed = false;
bool levelDisplayed = false;
int melody[] = {
262, // C4
294, // D4
330, // E4
349, // F4
392, // G4
440, // A4
494, // B4
523 // C5
};
// Note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
4, 4, 4, 4, 4, 4, 4, 2
};
////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
Serial.begin(9600);
myservo.attach(servoPin);
pinMode(startButton, INPUT); // Set start button as input
pinMode(playButton, INPUT); // Set play button as input to increase Play Need Value
pinMode(washGLED, OUTPUT);
pinMode(washYLED, OUTPUT);
pinMode(washRLED, OUTPUT);
pinMode(playGLED, OUTPUT);
pinMode(playYLED, OUTPUT);
pinMode(playRLED, OUTPUT);
pinMode(levelLED, OUTPUT);
pinMode (visLED, OUTPUT);
}
////////////////////////////////////////////////////////////////////////////////////////////////
void loop() {
digitalWrite(playGLED, LOW);
digitalWrite(playYLED, LOW);
digitalWrite(playRLED, LOW);
digitalWrite(washGLED, LOW);
digitalWrite(washYLED, LOW);
digitalWrite(washRLED, LOW);
// Check if the start game button is pressed
if (digitalRead(startButton) == HIGH && gameStat == false) {
gameStat = true;
countdownDisplayed = false;
levelDisplayed = false;
Serial.println(“Game started”);
}
if (gameStat == true) {
digitalWrite(visLED, HIGH);
//////////////////////////////////////////////////////////////////////////////////////////////// RECOGNIZE LEVEL
if (levelCount == 1 && levelDisplayed == false) {
washDecreaseAmnt = 5;
playDecreaseAmnt = 1;
digitalWrite(levelLED, HIGH);
tone(buzzer, 600);
delay(500);
digitalWrite(levelLED, LOW);
noTone(buzzer);
delay(2000);
levelDisplayed = true;
}
if (levelCount == 2 && levelDisplayed == false) {
washDecreaseAmnt = 6;
playDecreaseAmnt = 3;
digitalWrite(levelLED, HIGH);
tone(buzzer, 600);
delay(500);
digitalWrite(levelLED, LOW);
noTone(buzzer);
delay(500);
digitalWrite(levelLED, HIGH);
tone(buzzer, 600);
delay(500);
digitalWrite(levelLED, LOW);
noTone(buzzer);
delay(2000);
levelDisplayed = true;
}
if (levelCount == 3 && levelDisplayed == false) {
washDecreaseAmnt = 8;
playDecreaseAmnt = 5;
digitalWrite(levelLED, HIGH);
tone(buzzer, 600);
delay(500);
digitalWrite(levelLED, LOW);
noTone(buzzer);
delay(500);
digitalWrite(levelLED, HIGH);
tone(buzzer, 600);
delay(500);
digitalWrite(levelLED, LOW);
noTone(buzzer);
delay(500);
digitalWrite(levelLED, HIGH);
tone(buzzer, 600);
delay(500);
digitalWrite(levelLED, LOW);
noTone(buzzer);
delay(2000);
levelDisplayed = true;
}
if (levelCount > 3) {
gameWinSignal();
}
//////////////////////////////////////////////////////////////////////////////////////////////// COUNTDOWN
if (countdownDisplayed == false) {
tone(buzzer, 500);
delay(200); // Debouncing and preventing continuous input
noTone(buzzer);
delay(400);
tone(buzzer, 500);
delay(200);
noTone(buzzer);
delay(400);
tone(buzzer, 500);
delay(200); // Debouncing and preventing continuous input
noTone(buzzer);
delay(400);
tone(buzzer, 3000);
delay(200); // Debouncing and preventing continuous input
noTone(buzzer);
countdownDisplayed = true;
}
//////////////////////////////////////////////////////////////////////////////////////////////// NEED VALUE LIMITER
if (playNeedVal >= 100) {
playNeedVal = 100;
}
if (washNeedVal >= 100) {
washNeedVal = 100;
}
//////////////////////////////////////////////////////////////////////////////////////////////// PET DIRECTOR
if (washNeedVal < playNeedVal) {
servoPos = 30;
}
if (playNeedVal < washNeedVal) {
servoPos = 150;
}
if (playNeedVal == washNeedVal) {
servoPos = 90;
}
myservo.write(servoPos);
//////////////////////////////////////////////////////////////////////////////////////////////// LED INDICATORS
//WASH LED INDICATORS
if (washNeedVal > 66) {
digitalWrite(washYLED, LOW); //Making sure that the other LEDs are off
digitalWrite(washRLED, LOW);
digitalWrite(washGLED, HIGH);
} else if (washNeedVal <= 66 && washNeedVal > 33) {
digitalWrite(washGLED, LOW);
digitalWrite(washRLED, LOW);
digitalWrite(washYLED, HIGH);
} else if (washNeedVal <= 33 && washNeedVal >= 0) {
digitalWrite(washGLED, LOW);
digitalWrite(washYLED, LOW);
digitalWrite(washRLED, HIGH);
}
//PLAY LED INDICATORS
if (playNeedVal > 66) {
digitalWrite(playYLED, LOW); //Making sure that the other LEDs are off
digitalWrite(playRLED, LOW);
digitalWrite(playGLED, HIGH);
} else if (playNeedVal <= 66 && playNeedVal > 33) {
digitalWrite(playGLED, LOW);
digitalWrite(playRLED, LOW);
digitalWrite(playYLED, HIGH);
} else if (playNeedVal <= 33 && playNeedVal >= 0) {
digitalWrite(playGLED, LOW);
digitalWrite(playYLED, LOW);
digitalWrite(playRLED, HIGH);
}
////////////////////////////////////////////////////////////////////////////////////////////////
// Check if the Play Need Value increase button is pressed
if (digitalRead(3) == HIGH && freshButton == true) {
playNeedVal = playNeedVal + 1;
freshButton = false;
} else if (digitalRead(3) == LOW) {
freshButton = true;
}
// Read and process slider value
int sensorValue = analogRead(A0);
if (sensorValue >= 900) {
reachedMax = true;
} else if (sensorValue <= 100 && reachedMax) {
reachedMax = false;
washNeedVal += 10; // Increase Wash Need Value
}
// Logic for decrementing need values every second
if (millis() – lastUpdateTime > 1000) {
washNeedVal = max(0, washNeedVal – washDecreaseAmnt); // Decrement Wash Need Value
playNeedVal = max(0, playNeedVal – playDecreaseAmnt); // Decrement Play Need Value by 2
lastUpdateTime = millis();
}
////////////////////////////////////////////////////////////////////////////////////////////////
// Print current state
Serial.print(“Wash Need Value: “);
Serial.print(washNeedVal);
Serial.print(“, Play Need Value: “);
Serial.println(playNeedVal);
}
// Game end condition
if (washNeedVal <= 0 || playNeedVal <= 0) {
gameStat = false; // Deactivate game state
endSignal();
Serial.println(“Game Over”); // Print game over message
// Logic for handling game end can be added here
if (digitalRead(startButton) == HIGH) {
washNeedVal = 80;
playNeedVal = 79;
endFlashCount = 0;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////// LEVEL COMPLETE CHECK
if (washNeedVal > 95 && playNeedVal > 95) {
gameStat = false;
nextLevelSignal();
}
}
//////////////////////////////////////////////////////////////////////////////////////////////// GAME END SIGNAL
void endSignal() {
if (washNeedVal <= 0) {
digitalWrite(visLED, LOW);
digitalWrite(washGLED, LOW);
digitalWrite(washYLED, LOW);
digitalWrite(washRLED, LOW);
digitalWrite(playGLED, LOW);
digitalWrite(playYLED, LOW);
digitalWrite(playRLED, LOW);
//begin game end flash process
if (endFlashCount < 4) {
digitalWrite(washRLED, HIGH);
tone(buzzer, 1000);
delay(250);
digitalWrite(washRLED, LOW);
noTone(buzzer);
delay(250);
endFlashCount = endFlashCount + 1;
} else if (endFlashCount < 5) {
digitalWrite(washRLED, HIGH);
tone(buzzer, 1000);
delay(1500);
digitalWrite(washRLED, LOW);
noTone(buzzer);
delay(250);
endFlashCount = endFlashCount + 1;
levelCount = 1;
}
}
////////////////////////////////////////////////////////////////////////////////
}
//////////////////////////////////////////////////////////////////////////////// NEXT LEVEL SIGNAL
void nextLevelSignal() {
tone(buzzer, 100);
delay(500);
tone(buzzer, 300);
delay(500);
tone(buzzer, 600);
delay(500);
tone(buzzer, 900);
delay(500);
tone(buzzer, 1500);
delay(500);
noTone(buzzer);
digitalWrite(playGLED, LOW);
digitalWrite(playYLED, LOW);
digitalWrite(playRLED, LOW);
digitalWrite(washGLED, LOW);
digitalWrite(washYLED, LOW);
digitalWrite(washRLED, LOW);
delay(2000);
levelDisplayed = false;
levelCount++;
countdownDisplayed = false;
gameStat = true;
washNeedVal = 80; // Wash Need Value initialization
playNeedVal = 79; // Play Need Value initialization
}
//////////////////////////////////////////////////////////////////////////////// WIN GAME SIGNAL
void gameWinSignal() {
digitalWrite(playGLED, LOW);
digitalWrite(playYLED, LOW);
digitalWrite(playRLED, LOW);
digitalWrite(washGLED, LOW);
digitalWrite(washYLED, LOW);
digitalWrite(washRLED, LOW);
digitalWrite(levelLED, HIGH);
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 = 1000 / noteDurations[thisNote];
tone(buzzer, melody[thisNote], noteDuration);
// To distinguish the notes, set a brief silence between them.
// The duration of the silence is about 1.3 times the note duration, which
// makes the melody sound more distinct.
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// Stop the tone playing:
noTone(buzzer);
}
digitalWrite (levelLED, LOW);
 
levelDisplayed = false;
levelCount++;
levelCount = 1;
countdownDisplayed = true;
gameStat = false;
digitalWrite(visLED, LOW);
Serial.println(String(“wash: “)+washNeedVal + String(” play: “)+playNeedVal);
}
////////////////////////////////////////////////////////////////////////////////

 

CONCLUSIONS

With this project, we aimed to create something fun and entertaining that could help people practice multitasking and motor skills, with a theme of being a responsible pet owner. I feel that our project fits my own definition of interaction, with both the player and the project receiving and outputting information to each other. With the skill and component limitations, there are still hiccups in this interaction as the user might still get confused by the project, not knowing what to do. With more time and better knowledge on informational output components, I think that the project could have communicated better what the goal of the game is and what the player needs to do to reach this goal. I also feel that we could’ve added more needs and complexity within the game given more time and resources. I think that one of the most impotant things that I learned from this project was that putting code together takes a lot more time than you would think, and that it is always important to label, comment and organize your code as you work on it so that you don’t get lost. Another thing that I learned is that we should be aware of our time and resources and not get too ambitious since we had to cut a lot of ideas. 

Demonstration Video (Click me!)

DISASSEMBLY

 
APPENDIX