CONCEPTION AND DESIGN:
In understanding how users were to interact with my project, I wanted the physical layout of my maze to be as clear as possible to the user without a detailed explanation or a given set of instructions. The user should be able to decipher how to play the game without any prior knowledge just by observing the physical components of the project. Accounting for such decisions, I decided to place a joystick at the very front of the project, implicitly communicating to the user of the most direct action to control the maze. Behind the joystick is the maze itself, notifying the user that the joystick should be able to control the physical component of the maze. I additionally contemplated using 2 joysticks instead of 1, in order for them to control a separate axis and servo motor, but decided this could possibly confuse the user into which joystick were to control which motor and axis, forcing them to remember which axes to control. In addition, I wanted the user to realize the objective of the game, that they had to complete the maze from start to finish. I added a ‘start’ and ‘finish’ label to both openings of the maze, in order to be more easily recognized by the user to which opening was the start and finish. I used cardboard to ‘prototype’ my project, as it gave me the most direct control over the sizes and design of the physical layout, especially in the maze. I could alter the difficulty of the physical maze and its walls, by cutting the cardboard to be shorter or longer, or hot gluing a dead end together to increase the difficulty of a certain path. These dead ends or different pathways allows the user to challenge the user to find the means of escaping the ‘obstacles’ and finishing the maze. I hoped that the maze could boost problem solving skills, and increase the user’s patience and persistence levels. If they fell into a dead end, they would have to restart the path and find another path in order to complete their goal of escaping the maze. The physical 3-dimensional aspect of the maze, in comparison to the typical 2-dimensional maze, allows for increased hand-eye coordination of both using the joystick and looking at the maze and the different way it tilts.
Regarding the physical elements of the maze, I used both a joystick and 2 servo motors. I used the joystick to better control the 4 directions that the maze could tilt in, allowing for the most accessible way of controlling the maze. The joystick is capable of communicating 2D motion (2-axis) to Arduino, meaning that by using 2 servo motors, I could make the overall project in 3D instead of just incorporating 2-dimensional motion. The joystick uses 2 independent 10K potentiometers (one for each axis), providing analog input in the form of an effortless control stick form. I used the two servo motors to control the x-axis and y-axis of the maze, allowing it to tilt both up & down and left & right. The servo motors can precisely control the position of their shaft, so they were the perfect choice to control the axes of the maze. In order to simultaneously control the x-axis and y-axis of the maze, there needed to be a servo motor attached to two different walls within the maze, one attached to a larger square surrounding the maze, and one attached to the physical maze itself. This way, the servo motors could individually control each axis without interference of the other axis, or without limiting the motions of one motor.
Another option I experimented with was the digital tilt sensor, a sensor capable of detecting the orientation of an object, and giving an output of either High or Low. I rejected this component because the digital tilt sensor typically is used alongside an LED or buzzer, or another component that reacts to the two outputs given by the sensor. Instead, I wanted the user to be able to have more control over how much they were allowed to tilt the maze, instead of being restricted to being high or low. Additionally, I was not recording the input of the orientation of the maze, and therefore did not need the degree of how much the sensor was being tilted. Thus, I decided to use the servo motors with the joystick, to give the user as much control as possible to however much they wanted to tilt the maze. These components were best suited for my product purpose, as it allowed for total rotation of every direction of the maze, and the servo motors reacted quite smoothly given the input from the joystick. The speed at which the servo motors went could additionally be controlled through Arduino, giving me more command over how fast the maze could tilt, which would be less possible if I were to have used a sensor instead.
FABRICATION AND PRODUCTION:
During the User Testing Session, one of my servo motors failed to work, meaning only the y-axis of my maze was able to tilt. At this time, I did not glue down the servo horn to the maze, and did not screw in the horn into the motor, meaning the horn would constantly pop out if it tilted too much. Therefore, I had to ensure each wall was corresponding to a different motor, so that the maze could rotate in each direction. I additionally created a box for the physical maze to sit on, so it would be the perfect height under the projector. I originally had the projector on the floor with its legs almost completely extended, but in order for the user to better access the maze, I then moved it onto the table directly perpendicular to the maze. This way, the user’s view was not obstructed by the projector in front of the maze. The various production choices I made were to better allow for the movement of the two separate axes, and to make the design more clear to the user.
CONCLUSIONS:
The goal of my project was to create a fun, interactive game that would allow the user to improve their problem solving skills, cognitive thought processes, while increasing their patience and persistence levels through solving a maze. My project aligns with the definition of interaction that includes three steps: input, output, and processing, as outlined in Introduction to Physical Computing (Igoe & O’Sullivan, 20). This maze closely aligns with how I define interactivity, as the user is constantly giving input through moving the joystick in different directions in order to tilt the maze, while the maze is moving the ball throughout its different pathways. Interaction can additionally be described as “a cyclic process in which two actors alternately listen, think, and speak,” as outlined in The Art of Interactive Design (5). There must be a continuous loop of the user and the device interacting with one another, seen in the device tilting and the ball rolling in response to how the user decides to interact and move the joystick. Based on my definition of interaction and my expectation of the audience’s response, the audience closely interacted with my object through first controlling the joystick, which would tilt the maze in a specific direction. In response to this, the ball moves and navigates the maze, then the user must strategically maneuver the joystick in order to avoid the red squares, or the obstacle. In this way, the user is closely interacting with the project at all times, as they have certain obstacles to avoid in order to complete the maze successfully. If I had more time, I would attempt to projection mapping, in order to have the projection accurately map the coordinates of the maze. This way, it would not distort the projection whenever the user would tilt the maze. I already attempted to use color tracking in order to track the position of the ball, hoping to map if and when the ball would touch the red obstacles, thereby allowing the user to know when they have hit an obstacle. In addition, if I could somehow successfully track all these components, I could give a score or time upon successful completion of the game, and create a scoreboard of the fastest times completed. I learned from my setbacks that they are utterly necessary in order to improve any iteration of a project or design, as only through setbacks can you determine what is necessary to enhance any elements of the project. I took away from my accomplishments that people enjoyed playing the game, especially in its physical aspect of tilting the maze and following the ball from start to finish. The significance of this game allows us to realize that even in our daily fast-paced, busy lives, we must take a second to exercise our cognitive capabilities and improve our patience levels and reactions to daily triggers. By incorporating these mentally challenging skills in this game, we can simultaneously enjoy a fun, interactive device while promoting better mental capabilities.
Code for Processing:
boolean[][] grid = new boolean[12][12];
void setup () {
background(0);
fullScreen();
for (int x = 0; x<12; x++) {
for (int y = 0; y<12; y++) {
float r = random(100);
if (r < 2) { // chance of a square being red
grid[x][y] = true;
} else {
grid[x][y] = false;
}
}
}
}
void draw() {
fill(255);
translate(width/2-300, height/2-300);
rect(0, 0, 600, 600);
rect(0, 0, 100, 100);
rect(100, 0, 100, 100);
rect(200, 0, 100, 100);
for (int x = 0; x<12; x++) {
for (int y = 0; y<12; y++) {
if(grid[x][y] == true) {
if(millis() % 3500 < 1000) {
fill(255, 0, 0);
} else {
fill(255);
}
} else {
fill(255);
}
rect(x*50, y*50, 50, 50);
}
}
}
Code for Arduino:
#include <Servo.h>
Servo servo1;
Servo servo2;
int x_key = A1;
int y_key = A0;
int x_pos;
int y_pos;
int servo1_pin = 8;
int servo2_pin = 9;
int initial_position = 90; // horizontal servo
int initial_position1 = 90;
void setup ( ) {
Serial.begin(9600) ;
servo1.attach (servo1_pin) ;
servo2.attach (servo2_pin) ;
servo1.write(initial_position);
servo2.write(initial_position1);
pinMode (x_key, INPUT) ;
pinMode (y_key, INPUT) ;
}
void loop ( ) {
x_pos = analogRead(x_key) ;
y_pos = analogRead(y_key) ;
// servo at pin 8
if (x_pos < 300) {
if (initial_position < 10) {
}
else {
initial_position = initial_position – 4;
servo2.write (initial_position);
delay (100);
}
}
if (x_pos > 700) {
if (initial_position > 180) {
}
else {
initial_position = initial_position + 4;
servo2.write ( initial_position );
delay (100);
}
}
if (y_pos < 300) {
if (initial_position1 > 180) {
}
else {
initial_position1 = initial_position1 + 4;
servo1.write ( initial_position1 ) ;
delay (100);
}
}
if (y_pos > 700) {
if (initial_position1 < 10) {
}
else {
initial_position1 = initial_position1 – 4;
servo1.write ( initial_position1 ) ;
delay (100);
}
}
}