Worry Capsule Tree Documentation


Project Overview

Worries surround us every day. However, as time passed, we always realize how trivial those problems are in comparison. Worry Capsule Tree is an interactive installation that stores people’s current worries and sends them back in the future, thus allowing its users to retrieve their previous worries and revisit the past selves.

Collaborators and Roles

Xiran Yang – Voice Recognition/Database Server/Physical Computing/Fabrication

Hau Yuan – Visual Programming/Physical Computing/Fabrication

Technical Features

Coding: Voice Recognition(p5.speech.js)/Database Server (M-Lab)/Interface(After Effects/p5.js)/Serial Communication

Physical Computing: Arduino MEGA/USB microphone/Jumbo RGB LEDs/Neopixel RGB Lights

Fabrication: Soldering/Laser Cutting

How it works?

1 – Start

At the beginning, user would see both physical and digital animation.

2 – Say “Hello” to trigger next step

In this step, users have to say “Hello” to go to the next step. The purpose of this step is to let users know the microphone in front of them is part of the interaction. By doing so, users would know where and how to use the voice input in the recording process later.

2-2 – Say “Hello” to trigger next step

After users say “Hello,” the screen will reply “I am listening” to them. Besides, the tree installation will change its color to respond.

3 – Input user’s name

To ask the information form users without letting them feel like their privacy are invading like conducting an online survey, I incorporated this step by using a conversation to ask user’s name.

“Pardon me for not asking your name! How may I address you?”

Apart from this purpose, I call user’s name twice in the conversation of the following steps to increase the intimacy and engagement of the experience.

4 – Read the introduction to the tree

The first, second, and third steps are an opening which aims to allow users dissolve into this experience. The fourth is the stage gives the whole context and idea of this tree. The following is the introduction:

Would you like to travel back in time?

In times of introspection, do you ever realize how trivial those problems are in comparison?

Are you under a lot of stress? What’s worrying you now?

Please tell me in one sentence and allow me to carry your anxieties in safekeeping.

Perhaps in the future, you may want access to them.

Once you are ready, please click start to record.

5 – Start to record

At the end of the introduction, the “start to record” button would pop-up. When users feel ready to talk, they can click the button to start.

6 & 7- Recording and Stop Recording

When users finish recording, they can click this button to stop.

8 – See the sentence they said in text format

Users will see what that said and the date and time of this moment.

9 – Upload to the tree

When users click “upload to the tree,” the worries would “conceptually upload to the tree. The screen would show the animation first, and then the LED strips would light up gradually from the bottom of the tree to the top, which aim to convey an uploading image.
Technically, the program won’t save users’ data to the database until the last step.

10 – Input user’s email

After users enter their email and click finish, their information and the worries they said will be packaged and store in the database.

How we decided to make it?

Idea development

The original idea of Worry Capsule Tree comes from the one of the creators, Yuan’s desire to release daily stress by keeping his anxiety into a certain device. After Yuan talked to me, this idea of telling and storing worries reminded me of a time capsule, whose function is to help people store memories that are accessible a long time later. 

Both of us liked the concept of storing current anxiety and retrieve it in the future. It, on one hand, helps release the stress we have now, and on the other hand, also provides us with a chance to re-visit the past selves and see how much we have overcome and grown.

Since we decided to build something that deals with emotions and memories, the questions of “how would the users best communicate with this capsule” and “how do they emotionally engage with the device” becomes very important.

These questions triggered us to first think about the appearance of our device.Our first thought is the image of a tree. Trees have the ability absorb substances from the environment and convert it to nutritious fruits. We think it’s a metaphor for transforming people’s anxiety to their assets in the future. Therefore, we decided to build a worry capsule tree which can respond to the users and store their worries.

In addition, based on our personal experience, we figured out two ways that the users can interact with this tree, which are: writing down their worries to the tree and telling their worries to the tree.

In order to know which way makes people feel more comfortable to interact with the tree, we did user testing and research.

Our very first prototype

Based on our research, about half of the testers prefer speaking to the tree while the other half prefer writing their worries down. Since both of us prefer speaking to the tree over writing down our worries to the tree. We finally decided to create an interactive capsule tree which can listen to its users and store their worries.

We also thought about the design of the tree. We proposed two type of designs firstly.

Xiran’s proposal:


Yuan’s proposal:

We decided to follow my proposal, a more sculptural design because we thought it looked more interesting and can create more intimacy between our tree and the users.


After finalizing the idea, we started to think about how to realize this idea. We figured out that our tree will need to have four functions, which are:

  • Receive users’ voice input
  • Visualize that voice inputting progress
  • Store the voice input
  • Send back the voice input to the user in the future

We decided to use the p5.speech library to receive voice input and transfer the audio input into a text file, use M-lab service to store all the received information into a database, visualize the progress of storing and uploading worries by changing the tree’s behavior and send back the worries to the users through an email postcard.

Therefore, our project breaks down into three major parts: Physical Computing, Coding, and Fabrication.

Coding: (p5.js/HTML/CSS)

  1. Use p5.speech.js library to do voice recognition;
  2. Use M-Lab service to store voice input and users’ information;
  3. User Interface design/P5-Arduino Serial Communication

Physical Computing

  1. Design different light patterns;
  2. Test different materials and light behaviors using switch and sensors;
  3. Connect the behaviors of lights to the user interface by doing serial communication;


  1. Design the tree’s appearance;
  2. Decide what materials to use;
  3. Fabricate the tree;

How we made it?



Components & Materials

There are three main parts in this in installation:

  1. Load-bearing structure:
    The base of the structure consists of a wood panel and three legs. The space between the wood panel and the ground allows us to easily manage and manipulate the circuits and microcontroller beneath it. We chose copper pipe as the spine of the tree structure. Apart from giving rigidity to the tree, the shallow space in the middle of the pipe can hide and concentrate all the wires from top to the bottom of the tree.
  2. Light source:
    There are three RGB LEDs, six White LEDs, and three Neo-Pixels(each has 30 pixels) on this tree. The positions are shown as follows:

    Bird’s eye view:

Coding: (p5.js/HTML/CSS)

Voice recognition

The voice recognition is done by p5.speech.library which can translate audio input into text.

Store information in a database

I used M-Lab’s database server. Basically, you need to register an account at M-lab, create a database, then a collection. Each account will have an API key, you will be able to use that API key to access your database, upload data and view all the documents you have sent to that database.

Easy Tutorial on how to use M-lab to create database and upload data

M-lab’s tutorial (Also easy to follow)

These two websites provide some very good tutorials on how to set up a database at M-Lab and store data into it.

While M-lab’s own sample code is written in Jquery, I used p5.js to do the same thing. I majorly used HttpPost() function to push information (voice text array) into my database.

Once you are able to create your database in M-lab and have sent some data into it, in the database you have created, it will look something like this:

User Interface Design

All animations are done by After Effects and are embedded and organized into the interface using p5 DOM library.

Serial Communication:

We used p5.serialport.js library to do serial communication. Basically everytime when we want the computer side to trigger the tree to change its behavior, we send one-byte binary (a number) from the computer to Arduino by doing p5-to-Arduino serial communication.

*You can view our code here (We used p5.speech.js and p5.serialport.js libraries. But animations and all libraries are excluded from the code down below)

Physical Computing

We used Jumbo RGB LEDs, Neopixel RGB LED strips as well as some white Jumbo LEDs.

We first tested all the behaviors of the lights by just doing Arduino, using some switches and a sound sensor.

After we made sure that everything worked well on Arduino, we used serial communication to allow the computer to control the behaviors of all lights.

Our Final code is shared below:

Pcomp Week #9 Final Project

This week I was keeping building on my final project idea. My basic idea was that I want to create a physical game. The game is composed with a physical fabricated installation. There will be a protagonist in the game, ideally a little girl; and this little girl’s mission is to go to different spots to complete a mission. This missions will contain physical interactions with the audience. I want the interaction to be people blow something. So I kind of want to set the theme of my game around “wind” and “blowing”. Therefore, the project, as I was thinking will probably become an interactive installation with visuals projected onto it and the audience will be able to interact with it by “blowing”.

However, as I keep thinking about the project, I feel like something is missing. Though I was able to think about the mechanism and interface of the project, I feel the concept, or in other words, the story, the meaning behind this project is missing. I do not want to create something just for some sort of fancy interaction. I really want to deliver an important piece of message that the viewers are able to take away with.

I feel like working on myself gets me into a puzzle that I am not able to get out alone, therefore, I decided to collaborate with other people.

I later decided to work with Yuan Hau. We met and exchanged our thoughts and ideas. I really appreciate his concept of storing people’s worries/stress and send that particular worry back to the person sometime later. I think it is an interesting concept that we together can build a lot on.

As a result of our discussion, our project will be:

construction/fabrication-wise: a tree-shape installation with “time capsule” hung on it

mechanism-wise: we want the audience to either tell or write down a worry they currently have. Once the worry is received by Arduino, it will trigger one time capsule to be filled.

We also want this worry to be secretly stored somewhere on the computer and after a certain period of time, this worry will be sent back to the person who once had it.

So basically as we planned this whole project will ideally contain three parts: the physical installation (the tree), Arduino and sensors, digital interface.

We want to test during the playing test:

  • Which way do people prefer to document their worries: writing or speaking;
  • Why that way works better?

Pcomp Week #8 Final Project Idea

For the final project, I want to combine creative coding, physical computing, and projection mapping together to build an interactive installation.  I want to combine these three elements into a story that the audience will be able to take away with them after visiting my project.

My final idea is an expansion of my midterm project. Since I really like my midterm dandelion project, I want to keep on working and build something more based on that. So basically I would like to create more visuals in p5 and by using Arduino to allow people change the visuals by controlling certain sensors. I want the visuals to all go beyond just a computer screen so I would like to have them all project onto a sculptural interface I build.

Here is a break down of my plan:

  1. Keep looking for inspirations and started testing things(different sensors, projections).

Gabe’s projection projects:

I want to test projections on these but not limited to items:

  • acrylic globe
  • glass bottle
  • glass cup filled with water


2. Keep working on different visuals and think about the storyline.

my undergrad capstone.

I already have some sketches which I can build based off:

I need to do more brainstorming and come up with a complete storyline.

3. Finalize the idea and start working on it/testing it. Again and again and again…

Pcomp Week #7 – Serial Communication [Dandelion]

For this project, I want to build some dandelion visuals and allow [wind] to control them —when someone blows at a sensor, the dandelion will respond to that wind and blows away.

I started in p5.js to create some visual sketches.

Version 1:

Version 2:

Version 3:

I am kind  of happy with the third version so I moved on to Arduino and serial communication.

I use two potentiometers to control the size of each little leave of the dandelion and the transparency of the sketch respectively. I use an earphone and the microphone library (input) to control the blowing of the dandelion.

Two demos:

  1. size and transparency control:

2. blowing control:

Pcomp Week #4 – Analog Input/Output

For this week, I tried to make an mp3 player.

I used a DFPlayer mini, a micro sd card, a speaker, three push buttons, a potentiometer several 10k resistors and some wires to finish this project.

I referred to this youtube tutorial to connect the dfplay mini. After finishing that, I added a potentiometer to the circuit and used map function to let the potentiometer control the volume of the music.

#include <DFPlayer_Mini_Mp3.h>

/// http://educ8s.tv/arduino-mp3-player/

#include "SoftwareSerial.h"
SoftwareSerial mySerial(10, 11);
# define Start_Byte 0x7E
# define Version_Byte 0xFF
# define Command_Length 0x06
# define End_Byte 0xEF
# define Acknowledge 0x00 //Returns info with command 0x41 [0x01: info, 0x00: no info]


# define PotPin A0 //added

int buttonNext = 2;
int buttonPause = 3;
int buttonPrevious = 4;
boolean isPlaying = false;
int oldAnalogReading = -1;


void setup () {

pinMode(buttonPause, INPUT);
digitalWrite(buttonPause, HIGH);
pinMode(buttonNext, INPUT);
digitalWrite(buttonNext, HIGH);
pinMode(buttonPrevious, INPUT);
digitalWrite(buttonPrevious, HIGH);

mySerial.begin (9600);
Serial.begin (9600);//added

isPlaying = true;


void loop () {

int v = analogRead(PotPin);
if (v != oldAnalogReading ) {
int newv = map(v, 20, 1020, 0, 25);
setVolume(newv); // added
oldAnalogReading = v;

if (digitalRead(buttonPause) == ACTIVATED)
if (isPlaying)
isPlaying = false;
} else
isPlaying = true;


if (digitalRead(buttonNext) == ACTIVATED)
if (isPlaying)

if (digitalRead(buttonPrevious) == ACTIVATED)
if (isPlaying)

void playFirst() {

execute_CMD(0x3F, 0, 0);
execute_CMD(0x11, 0, 1);

void pause()
execute_CMD(0x0E, 0, 0);

void play()
execute_CMD(0x0D, 0, 1);

void playNext()
execute_CMD(0x01, 0, 1);

void playPrevious()
execute_CMD(0x02, 0, 1);

void setVolume(int volume)
execute_CMD(0x06, 0, volume); // Set the volume (0x00~0x30)

void execute_CMD(byte CMD, byte Par1, byte Par2)
// Excecute the command and parameters
// Calculate the checksum (2 bytes)
word checksum = -(Version_Byte + Command_Length + CMD + Acknowledge + Par1 + Par2);
// Build the command line
byte Command_line[10] = { Start_Byte, Version_Byte, Command_Length, CMD, Acknowledge,
Par1, Par2, highByte(checksum), lowByte(checksum), End_Byte
//Send the command line to the module
for (byte k = 0; k < 10; k++)
mySerial.write( Command_line[k]);