Midterm Project Documentation – Interaction Lab (S24 Andrew Garcia)
Context and Significance
It was a long process to get to the final idea for my midterm project. My partner and I cycled through many projects that were cool at first glance, such as a mechanical gauntlet, coke can piano, or missile launcher. But none of them really clicked with me or had the special factor that I was looking for.
Drawings for one our our first ideas.
The art projects in Stephen Wilson’s book, Art + Science Now were not cool simply because of their technical difficulty or the mechanics that went into their creation, but also because of the emotions they evoked in participants or viewers. I was inspired by those examples, I wanted to create something that wasn’t just “cool” but also had an additional story or meaning. It was by the suggestion of Professor Andy that we finally leaned away from “game” and more towards “art” (although both aspects are still there in the final idea).
From a technical viewpoint, “Peony From Home” is not particularly innovative. We used the same mechanism from a project in a YouTube video shared with us by Prof. Andy to replicate a flower’s blooming motion and the creation of the peony petals followed a method from a YouTube tutorial. What is significant about our project is the personal meaning to us, the creators, and the different meanings that it can have to each player. I have peonies in my backyard in my childhood home back in the suburbs of Chicago — big, dark pink ones with thick, fluffy petals and single-layered white ones with vibrant yellow centers. My mom once said that peonies were her favorite flower. For me, creating a peony would be like bringing a piece of home to this new environment, but the gamified aspect of the project would make interacting with it fulfilling and fun aside from the sentimental aspect.
Conception and Design
Since I wanted players to feel like they were actually taking care of a plant, I designed the three game pieces (watering can, fertilizer, and sunlight) to more or less look like their real-life counterparts. The final elephant shape for the watering can was because elephant-shaped watering cans are a real thing, and we used a burlap-like material for the fertilizer bag, since it gives the feeling of a farm setting. Two out of the three game pieces more or less retained their original design, which I drew with the intention of making their purposes very clear.
Old plan for what the three game pieces would look like. I originally planned for them to just be cardboard cutouts.
Later plan for the making of the watering can
The criteria I followed was that the materials and designs looked realistic enough to convey the overall message to the players, but not realistic to the point that it no longer looked cute or fun.
I used organza fabric for the flower petals since it looked the best (I had high aesthetic standards for the project) and there was a large supply of organza available in the studio. We bought kid-sized rubber sports balls for the blooming component and tested them by cutting one in half, sticking in some pins, and seeing how it folded in and expanded when being pulled from the inside by a string. Once we determined that the rubber of the ball was thick enough to properly hold the pins and collapsed in the desired manner, we decided to go with it. If it hadn’t been flexible enough, we would’ve had to find a different ball.
Testing the rubber ball’s behavior when being pulled by a string from inside
The rest of the project mostly used cardboard, which was also the best and most versatile material available to us. I simply looked for materials that were in abundance and easy to experiment and work with so I could play around and freely mess up to find out the optimal techniques. One idea that I rejected was using a flowerpot for the base of the flower since I wanted the base to look more natural, like a dirt mound. Of course, this doesn’t make any technical difference and was just a personal preference. In retrospect, if I had simply used the flowerpot offered by Prof. Andy, I would saved some time in the making. But overall, there weren’t any alternative materials that would have made a significant or improved difference from our final result, and the priority wasn’t the selection of materials but the final, overall visual harmony and experience the project gave.
Fabrication and Production
There were three main components of our project: the Arduino code, the mechanisms (servo motor, sensors, LEDs, etc.), and the handcrafted hardware (game pieces, flower). On the first day, my partner and I didn’t have a methodical process drawn out and were mostly discussing what materials we needed. I started by gathering materials; grabbing cloth that we thought looked pretty, collecting cardboard, and finding a ball. My partner bought a mini toy basketball, which I used to experiment with by sticking in some mini flower petals glued onto pins.
Very preliminary experiment of how the petals would be attached to the ball.
This was the central mechanism of our project, and once we determined that this type of ball worked the way we wanted it to, we made the elephant watering can out of cardboard.
Elephant watering can made using a clay box-making I learned in middle school (which I also coincidentally used to make a pink clay elephant at the time). I drew the elephant shape freehand and in one go.
The next most important component was the servo motor, which would be controlling the ball’s collapse and expansion. It took a couple of tries to figure out how exactly to set up the servo motor for it to pull the string. After setting up the system using the 180 degree servo motors provided in our kits, it didn’t seem strong enough. Looking back, it was probably possible; we just didn’t properly extend the motor horn or place the motor directly below the ball. We tried switching to a stepper motor the next day, but the string couldn’t be secured, so we switched back to a stronger servo motor we borrowed from Prof. Andy.
While we were struggling with the motor mechanism, my partner and I crafted the other game pieces. I cut the sun out of cardboard and layered the pieces following a technique that I saw in class, then cut out a section to insert the button into.
Early version of the sun button connected to the circuit. I later replaced the center with an LED and hid the button in a patch of clouds.
Throughout, I coordinated with my partner by discussing our schedules and when we would be able to meet up to work together in the IMA studio. He had a habit of coming to school early in the morning and I had a habit of staying late into the night, so sometimes we made progress individually as well. I spent one day writing the code for the different game pieces, writing each section separately and testing them one by one with their corresponding sensors before combining everything into one sketch.
// fertilizer
int reedSensor;
void setup() {
Serial.begin(9600);
pinMode(3, INPUT);
}
void loop() {
// read the input on analog pin 0
//tempSensor = map(tempSensor, 51, 63, 0, 11);
reedSensor = digitalRead(3);
// print out the value of the sensor
Serial.print("Reed Sensor: ");
Serial.println(reedSensor);
// delay for stability
delay(500);
if (reedSensor == 1) {
Serial.println("sensor activated");
}
}
Code written in a different file for the reed sensor before I combined it with the main project file
I made heavy use of conditional statements (mainly if statements) for the game pieces, since the fulfillment of each sensor’s “criterion” was necessary for the flower to bloom. For the blooming of the flower at the end, I wrote a separate state for the flower to move to so that the blooming motion wouldn’t be interrupted.
All sensors connected to one circuit after code was combined
I often referred back to our class slides and recitation diagrams to see how reed sensors, LEDs, and buttons were connected to the breadboard.
Prof. Andy helped us greatly with the assembly of our prototype by providing a PVC pipe that he drilled holes into and attached the servo motor onto. Before that, my partner and I were still thinking of various ways to position the servo motor beneath the flower stem, all of which were difficult to set up. With the PVC pipe, we finally had the problem of the project’s main mechanism resolved.
We had all the basic components in our prototype prepared by user testing day, with the mini leaves, tube, servo motor, and three game pieces connected to the circuit. However, due to mistakes in connecting the cables, only our sun button worked and there was no reaction besides the serial monitor in the Arduino program displaying that the flower entered the bloom state. From what we described of our project idea, our testers liked the concept. The primary feedback we received was to add more affordances to each individual game piece rather than a single one, that being the flower blooming. Additionally, since we had yet to color our game pieces, it wasn’t completely clear that the elephant was a watering can and that the spiky button was a sun.
Our flower prototype for user testing day
After user testing, I finally wrote a more organized to-do list (born out of the notes that I took from player feedback) for the final three days we had before the final version of our project was due. This feedback was why I ended up painting the elephant blue (and adding strips of cloth coming out of the elephant’s nose), adding clouds to the sun button and taping it to an elevated position instead of just placing it on the table. It was definitely helpful because as the creator, since I understood what I was making, I expected others to understand what they saw. I didn’t realize how the components may not be straightforward to those who hadn’t seen the project before. I also added affordances to each game piece by writing code for an LED that would light up once the criteria were fulfilled, along with another tilt sensor for the fertilizer bag, since many players instinctively wanted to mimic a pouring motion using the bag.
Demonstrating the individual affordances I added to each game piece
I finally started making the flower petals after the servo motor and game pieces were all working. I drew three different sizes for the petals (small to big from center going outwards) and made cardboard templates out of them. As demonstrated by the organza flower YouTube video I found, as a synthetic material, organza can be cut with a soldering iron.
Cutting out the flower petals using templates and a soldering iron
Then, I glued three wire segments onto each petal so that they could be stuck into the ball and shaped in a curve. I made more layers for the flower than instructed in the video since I wanted the flower to look fuller. This proved difficult to balance: not enough layers and the flower looked bald; too many layers and the ball would become inflexible from all the pins and not properly collapse and expand.
Completed flower head. I decided on a white-to-pink gradient with three leaves on the outside to make the flower more visually interesting had it just been completely white.
At the same time, my partner made a square pyramid as a base for the flower to hold the PVC pipe stem in place. After completing the flower, covering the stem with green cloth, and covering the square pyramid with brown yarn, the appearance of the project was finally coming together. We assembled the pieces the morning of the presentation day.
Flower finally looking like a flower
Throughout, the struggles we encountered included unstable circuits. Even after connecting cables and sensors to the breadboard and confirming that the code worked correctly, the cables would sometimes fall out or disconnect since we had extended them with longer cables. This proved to be a troublesome setback, as it felt like we were taking steps backward each time our project “broke.” Other times, we would connect the cables to the breadboard incorrectly or insert them into the wrong pins on the Arduino Uno.
Conclusion
Through my project, I wanted to provide a fun and simple gardening experience with a rewarding result to the players. My intention was for players to have to figure out with little instruction what to do with the game pieces to accomplish the goal of making the flower bloom. The game pieces had lights that would light up and indicate to the player that they had done something right. The sensors “listened” for the player’s input and “responded” with an affordance, which fulfilled. At the end, when all criteria were fulfilled, the project gave an overall response through the blooming of the flower.
Activating the flower bloom with the game pieces
I wouldn’t say that there was a “thinking” aspect besides the code that dictated to the microcontroller how to respond to certain inputs. Aside from this, the project was only responsive if the player did the right things. At all other times, the player would be at a loss trying to figure out what to do. Ultimately, I had to give more instruction and guidance to the players than I had hoped for since they didn’t have more time to spend ruminating. Viscerally, the players who tested our project and audience who watched expressed appreciation of the flower and game pieces’ appearance. They said they could imagine it being in a children’s museum or an interactive activity for children. However, the players were confused by the requirements to bloom the flower. It wasn’t behaviorally obvious. For example, there wasn’t a one-to-one connection between the learned behavior of how water cans should be used and how the watering can we made was supposed to be used. Like a bad door or drawer, the flower and its game pieces could have used more affordances for the players to more easily bridge the Gulf of Execution.
The aspect that direly needs improvement is the flower’s blooming mechanism. Possibly because I got greedy and stuck too many petals on the ball, the ball lost its flexibility and speed in expanding to its original shape when the string loosened. The result was, the blooming of the flower happened extremely slowly, almost unnoticeably, and was missing the wow factor that I was hoping for. I could have removed some petals or checked if the pins underneath had gotten stuck together. This connects to the Gulf of Evaluation.
Flower blooming motion
The base also could have been stabler and larger. On the inside of the square pyramid, the pipe would still sometimes fall over since the base stuck onto the end wasn’t large enough. The pyramid also couldn’t properly fit the breadboard, microcontroller, and wires inside, which looked a little messy and took away from the overall aesthetic. Finally, I could definitely remove some of the sensors, considering how much difficulty players had in figuring out the game. For example, reducing the watering can to just a tilt sensor with no sliding potentiometer.
If I had finished the project done a few rounds of testing ahead of time, I would have been able to revise the product instead of encountering these problems only during the presentation. For the final project, I’ll know to plan rough personal deadlines and finish well before the actual presentation. I would’ve been able to make changes accordingly after seeing the struggle that players faced in the lack of clues that the game pieces gave.
Overall, it was an incredible learning experience, especially as my first interactive project involving both hardware and software components made from scratch. The overall concept was pretty straightforward, but my partner and I got tripped up by many obstacles along the way not because it was challenging, but because we were newbies. No doubt, if I were to remake this project from scratch, I would likely only spend half as much time. Such experience can only be gotten by getting hands-on and will definitely prove useful for my final project at the end of the semester. At the very least, I’ve gained confidence in my aesthetic sense and handcrafting skills, and next time, I’ll seek to challenge my technical and coding skills more.
Disassembly
Appendix
Materials List
- Sliding potentiometer x1
- Tilt sensors x2
- Reed switch and magnet x1
- LEDs x3 (blue, green, yellow)
- Button x1 (white)
- 35kg 180 degree servo motor
- Jumper cables (M/M, F/M)
- Breadboard
- Arduino Uno microcontroller
- Red, black, blue, green cables (extensions)
- Electrical tape
- Cardboard
- Half a toy ball
- PVC pipe
- Red Bull can (for securing the pipe)
- Metal zip tie (for securing the servo motor)
- White and green organza cloth; pink mesh cloth (petals)
- Silver wire (pins for petals)
- Hot glue
- Acrylic paint
- Burlap cloth and plastic bag (fertilizer game piece)
- Blue mesh cloth (“water” coming out of elephant trunk)
- Cotton (“clouds” for sun game piece)
- Green cloth (stem)
- Brown yarn (dirt mound)
Full Code
// fertilizer: have reed sensor connected
// water: sliding potentiometer + tilt sensor
// sun: button (req: press 3 times)
#include
Servo myservo;
// fertilizer
int reedSensor;
int fertTiltSensor;
// water
int sliderPin;
int waterTiltSensor;
//sun
long sunButtonStartTime;
int val;
int prevVal;
int buttonPressCount = 0;
bool fertilizer = false;
bool water = false;
bool sun = false;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
myservo.attach(9);
// fertilizer
// reed switch
pinMode(3, INPUT);
// tilt sensor
pinMode(10, INPUT);
// white LED
pinMode(11, OUTPUT);
// water
// tilt sensor
pinMode(A0, INPUT);
// sliding potentiometer
pinMode(7, INPUT);
// blue LED
pinMode(12, OUTPUT);
// sunlight
pinMode(LED_BUILTIN, OUTPUT);
// yellow button
pinMode(2, INPUT);
}
void loop() {
reedSensor = digitalRead(3);
sliderPin = analogRead(A0);
waterTiltSensor = digitalRead(7);
fertTiltSensor = digitalRead(10);
val = digitalRead(2);
if (reedSensor == 1 && fertTiltSensor == 1) {
fertilizer = true;
Serial.println("Fertilizer applied");
digitalWrite(11, HIGH);
} else {
fertilizer = false;
Serial.println("Fertilizer not applied");
digitalWrite(11, LOW);
}
if (sliderPin > 255 && sliderPin < 355 && waterTiltSensor == 1) {
water = true;
Serial.println("Watered");
digitalWrite(12, HIGH);
} else {
Serial.println("No water :(");
digitalWrite(12, LOW);
}
if (prevVal == LOW && val == HIGH) {
buttonPressCount ++;
Serial.print("Button pressed: ");
sunButtonStartTime = millis();
Serial.println(buttonPressCount);
}
if (buttonPressCount == 3) {
sun = true;
}
// if button is pressed a 4th time, the sun deactivates again
if (buttonPressCount > 3) {
buttonPressCount = 0;
sun = false;
digitalWrite(LED_BUILTIN, LOW);
Serial.println("Sun not activated");
}
if (sun == true) {
// yellow LED shines
digitalWrite(LED_BUILTIN, HIGH);
Serial.println("Sun activated");
}
if (fertilizer == true && water == true && sun == true) {
// move to different state so flower bloom will not be interrupted
// even if any of three values go back to false
bloomState();
}
prevVal = val;
delay(100);
}
void bloomState() {
//servo motor moves
Serial.println("!!Flower bloom!!");
digitalWrite(LED_BUILTIN, HIGH);
myservo.write(0);
delay(5000);
myservo.write(180); // rotate the motor counter-clockwise
delay(5000);
}