Melody Makes

[melodymakes]

Responsive Light Therapy Box

video demo from Melody Quintana on Vimeo.

Midterm Project, SVA Interaction Design MFA

Melody Quintana and Sarah Henry

Many people find that bright light therapy helps to improve their symptoms of seasonal mood and sleep disorders. This kind of treatment requires daily time commitment and consistency. The responsive light box seeks to help therapy recipients integrate light box sessions more seamlessly into their lives.

Rather than manually time and track their daily therapy sessions, therapy recipients can receive automatically-timed sessions based on their own customized activity and sleep states. The light box shines full-spectrum white light during the day, and orange light at night to promote the production of natural melatonin to help people sleep better.

Background and goals

Currently when a person uses a light box, he needs to manage his own phototherapy treatment sessions every day. This entails carving out time to sit in front of the light box, figuring out how long the session should last, and remembering to do this the next day. Falling off a treatment schedule or ending treatment before winter is over can quickly bring back symptoms.

Here's what a typical light box looks like. The size, shape and incredible brightness call a great amount of attention to the device, creating the possibility of awkward tension if it's used in a social environment such as a person's office desk.

Our design goals were twofold:

1. Responsiveness 

A light box should learn about who it’s serving and cater to that person’s unique needs. Our goal was to build a light box that senses how much therapy someone needs based on his or her current levels of activity and sleep, and them automatically times each session appropriately. The activity and sleep data come from the recipient's Fitbit – a wristband they wear throughout the day that monitors their step count and sleep habits, among other things. 

To help with energizing during the day or calming at night, we also set out to make our light box time-aware. If it's being used during the day, it provides full-spectrum light and if it's being used at night it provides orange light, which studies have shown helps people sleep better than white light.

2. Attractiveness

Someone who needs light therapy shouldn't have to hide out at home for 30 minutes everyday; the sessions should fit in more seamlessly with their daily routine. To avoid feelings of embarrassment or discomfort, we set out to make our light box function dually as a tool for therapy and a delightful piece of artwork for an office desk. 

Sketches

When discussing how we might construct the piece, we entertained many different ideas. 

Ultimately, we decided to design the box around the experience of sitting at a computer, with the idea that therapy sessions can most efficiently be completed while the recipient checks email, does work or watches TV shows and movies. The box is triangular in shape to encourage the therapy recipient to set it catty-corner to his or her computer, with the light facing his or her eyes.

We also played with several ideas for how to make the box visually appealing. A couple of our original sketches are below. In the end we went with a pretty sweet laser-cut vinyl print over opaque acrylic for a soft, zenny feel.

Wiring

For an in-depth look at how we set up our wiring to work with an A/C outlet, Arduino and breadboard, check out my post on wiring the light box.

Code

To find out how we extracted data from the Fitbit API, sent it to Processing for analysis and then to Arduino, read my post on coding the light box.

Construction

Want to learn how we made the physical object? Take a look at my post on building the lightbox.

[melodymakes]

A closer look: Coding up the light box

This blog post explains how we built the software that runs a responsive light therapy box I built with Sarah Henry.  To summarize the general framework for our approach, we:

Created a Fitbit API account to access our test user's Fitbit data.

Ported the data over to a Google spreadsheet – we followed this very helpful tutorial to help get over this hurdle.

Created a Processing sketch that called the Google spreadsheet API to extract the subsets of data we needed. Jer Thorpe's tutorials on working with the Google Spreadsheets API and beginning with Processing and data viz were instrumental in this step.

Built out conditionals to break down the dataset and encoded each possible action with a character to tell Arduino what to do. 

Set up serial communication with Arduino, which could then switch on or off the lightbox for an amount of time based on the characters it read from Processing. Here we also added functions that control a small strip of 4 LEDs at the bottom of our lightbox. The LEDs provide a visual indicator of how long the session will last and progress in time. 

Admittedly, we're still programming novices so some of the code here can definitely be cleaned up, but it works as a proof-of-concept! Here's the code.

Processing

import processing.serial.*; Serial port;

int m = month(); int d = day()-1; int y = year (); int h = hour(); int activityScore; int sleepScore;

SimpleSpreadsheetManager sm; void setup() { size(100,100); background(255); //set up serial port //println(Serial.list()); //port = new Serial(this, Serial.list()[8], 9600); port = new Serial(this, "/dev/cu.usbmodem1421", 9600); SimpleSpreadsheetManager sm = new SimpleSpreadsheetManager(); sm.init("fitbitData","[email protected]", "melodyandsarah"); sm.fetchSheetByKey("0AovW6Hn1k3yfdE03QlhUdzNvQnQ1R1c2cWlOUVAyYnc", 0);

//variables String yesterday = m + "/" + d + "/" + y; int sleepScore; int timeOfDay; boolean found_day = false;

//find the cell with yesterday's date for (int i=1; i<sm.getNumberOfRows(); i++){ if(sm.getCellValue(0,i).equals(yesterday)){ found_day = true; //get activity and sleep scores activityScore = int(sm.getCellValue(3,i)); println(activityScore); sleepScore = int(sm.getCellValue(12,i)); } }

if (!found_day) { println("ERROR FINDING DAY!!!"); }

//Convert scores to corresponding chars

}

void draw() { //serial communication for time of day if(h<= 18){ port.write('X'); println("X = Day"); } else{port.write('Y'); println("X = Evening"); } //ACTIVITY CONDITIONALS if(activityScore>=1000){ port.write('A'); println("A"); } if(activityScore<=999 && activityScore>=750){ port.write('B'); println("B"); } if(activityScore<=749 && activityScore>=500){ port.write('C'); println("C"); } if(activityScore<=449 && activityScore>=0){ port.write('D'); println("D"); } //SLEEP CONDITIONALS //Good sleep range: 7.5 - 9 hours if(sleepScore>=450 && sleepScore<=540){ port.write('E'); println("E"); } //Fair sleep range: 6.5 - 7.5 hours OR 9 - 10.5 hours if(sleepScore>=390 && sleepScore<=449){ port.write('F'); println("F"); } if(sleepScore>=541 && sleepScore<=630){ port.write('F'); println("F"); } //Not great sleep range: 5 - 6.5 hours OR 10.5 - 11.5 hours if(sleepScore>=300 && sleepScore<=389){ port.write('G'); println("G"); } if(sleepScore>=631 && sleepScore<=690){ port.write('G'); println("G"); } //Bad sleep range: under 5 hours OR over 11.5 hours if(sleepScore<=299){ port.write('H'); println("H"); } if(sleepScore>=691){ port.write('H'); println("H"); } }

Arduino

int led1 = 8; int led2 = 9; int led3 = 10; int led4 = 11; int blueBulb = 12; int orangeBulb = 3;

int incomingByte; int activity; int sleep; int time;

int delayS = 1000; int delayA = 5000; int delayB = 10000; int delayC = 15000; int delayD = 20000; int forever = 3600000;

void setup() { // initialize serial communication: Serial.begin(9600); delay(1000);

// initialize the bulbs as outputs: pinMode(blueBulb, OUTPUT); pinMode(orangeBulb, OUTPUT); }

void loop() { // see if there's incoming serial data: if (Serial.available() > 0) { //add a buffer: delay(100); // read the oldest byte in the serial buffer: incomingByte = Serial.read();

//if if's a char that matches any in the 'activity' set, store it: if (incomingByte == 'A' || incomingByte == 'B'|| incomingByte == 'C' || incomingByte == 'D'){ activity = incomingByte; } else if (incomingByte == 'E' || incomingByte == 'F'|| incomingByte == 'G'|| incomingByte == 'H'){ sleep = incomingByte; // x = before 6pm, y = after 6pm } else if (incomingByte == 'X'|| incomingByte == 'Y'){ time = incomingByte; //add 32 statements here if(activity == 'A' && sleep =='H' && time == 'X'){ digitalWrite(blueBulb, HIGH); delay(delayA); digitalWrite(blueBulb, LOW); delay(forever); } } }}

[melodymakes]

A closer look: Wiring the light box

This blog post explains the electrical wiring that's inside a responsive light therapy box I built with Sarah Henry. To summarize the general framework for our approach, we:

Acquired and put together a relay kit that would make it possible to link two 120-Volt fluorescent bulbs to an Arduino board that only supports 5 Volts. (It took lots of soldering prowess to put together!)

Spliced an extension chord so that we'd only need one cable for both bulbs, and connected power and ground through each socket.

Connected the relays to the Arduino board using the 5V power pin, ground pin, and digital pins for each of the bulbs.

Connected 4 LEDs to the Arduino via a breadboard to create a visual affordance for how long each session lasts and progress in time. 

Here are a few articles that we used for reference:

Tutorial on splicing a relay into a lamp cord and connecting this to an Arduino:  http://www.glacialwanderer.com/hobbyrobotics/?p=9

Further discussion on the Arduino forums about the relay: http://forum.arduino.cc/index.php?topic=125257.0

Beefcake relay kit that we used: https://www.sparkfun.com/products/11042

A more expensive but safer relay kit: http://www.adafruit.com/products/268?gclid=CP3r_6HiqroCFUGd4Aod038AIA

Eric’s tutorial on relays: http://teaching.ericforman.com/5v-spdt-relay/

Sparkfun tutorial: https://www.sparkfun.com/tutorials/119 

Photos

Circuit schematic

Beefcake relay board

Soldering away!

Connecting the circuitry

[melodymakes]

A closer look: Building the light box

This blog post explains the physical construction of a responsive light therapy box I built with Sarah Henry. Here are the steps we took to create its zenny look and feel:

Planned, measured and cut the main pieces of out medium-density fiberboard (MDF) 

Mitered the joints to bevel them together for a smooth fit

Cut out the frame and the acryllic sheet with a laser printer

Attached the pieces together with wood glue

Secured the wiring to the bottom triangle, making sure that the bottoms of each relay did not make contact with anything conductive 

Sanded the acrylic sheet for a soft, muted feel

Traced a zenny vector image in Adobe Illustrator

Cut out the image out of vinyl with a laser printer

Applied the image to the acrylic sheet

Fit the acrylic sheet inside the frame window

A special thank you to the folks at SVA's Visible Futures Lab for helping out a couple of wood-working/laser-cutting novices like us. Snapshots of our process below!

[melodymakes]

Homemade USB Donlge

The goal of this week's assignment was to get some practice using the multimeter. We were tasked with taking a USB cable and creating a whimsical homemade dongle.

Here's where I began – snip snip!

Using wire strippers, I examined the wires at the pinout – two for data (white and green), two for power (red) and ground (black). 

Then I used my multimeter to test how much voltage the USB provided when it was plugged into my computer, which was 5V. 

Then it was time to design my circuit. I wanted to work with blue and white LEDs, but since both of these colors contain higher voltage amounts than other colors, I would have to use a parallel circuit if I wanted to use more than one at a time.

Here's a schematic of what I went with:

And here's my final piece. I took a good luck charm that's been following me around for that past few years and made him a pedestal. Hello little friend!

[melodymakes]

Serial Communication: Etch-a-Sketch

This week our task was to construct one example of communicating between the Arduino and Processing environments. Amy, Michie and I put our heads together and set out to simulate the experience of an Etch A Sketch toy using two potentiometers as knobs and a Processing sketch as the interface. Here's a peek behind our approach and a summary of our successes and failures. 

Setting up the breadboard and Arduino shield

We essentially used the same circuit that's featured in this virtual color mixer tutorial. Two potentiometers are connected to analog pins A0 and A1 in the Arduino board. Here's a snapshot of our setup:

Coding in Arduino

This code reads two analog sensors (the potentiometers) and sends their values serially:

Coding in Processing

I've pasted our Processing below, but here is a summary in humanspeak. First we:

import our serial data

declare our variables

Then in setup, we:

draw the background and border

open our port

In the draw loop, we:

make a line whose x and y coordinates are based on the potentiometers' values

And in a separate serial event, we:

get the ACII string

trim off any white space

split the string on the commas and convert the resulting substrings into an integer array

put the numbers in color variables

CODE

import processing.serial.*; float x0; float y0; float leftPotPin; float rightPotPin; Serial myPort; void setup() { size(350,500); background(#FC0A0A); fill(175); rect(30,30,290,440);

ellipse(26,275,30,30);

ellipse(374,275,30,30);

println(Serial.list()); myPort = new Serial(this, Serial.list()[8], 9600); myPort.bufferUntil('\n'); } void draw() {

println("leftPotPin=" + leftPotPin); line(x0,y0,leftPotPin,rightPotPin); x0=leftPotPin; y0=rightPotPin;

} void serialEvent(Serial myPort) { // get the ASCII string: String inString = myPort.readStringUntil('\n'); if (inString != null) { // trim off any whitespace: inString = trim(inString); float[] colors = float(split(inString, ","));

if (colors.length >=2) { leftPotPin = map(colors[0], 0, 1023, 0, 255); rightPotPin = map(colors[1], 0, 1023, 0, 255); } } }

Finished product

Here's an example sketch we made using the potentiometers to draw horizontal and vertical lines. It's supposed to represent a cityscape!

Things we didn't figure out

Because we worked off the virtual color mixer tutorial's source code, the analog values were already set to map to the RGB color range (0-255). We tried to change this range so that instead of only going from 0-255, the line coordinates would map from 0-width and 0-height. However, simply changing this value in the map function that was unsuccessful and caused the drawing app to stop working. Therefore, this drawing app oddly only works within an x/y coordinate range of 0-255.

We didn't figure out a way to constrain it so that the line would only draw within the gray area the sketch and not spill into the red border.

Sometimes the line doesn't draw clearly and there are jumps in its behavior. This may be a result of not making good enough connections between the wires themselves (perhaps soldering would help).

The drawing starts at whatever values the potentiometers happen to be set on, which can look pretty quirky if both potentiometer values are not set to 0 before you run the app.

[melodymakes]

Dino Comes to Life

This weekend took a turn for the worst when I came down with a stomach virus that had me out of commission Sunday night and all of Monday. However, I was able to sketch out a plan for my next project – a more complex toy using sensors and If() statements to make more interesting things happen.

I'm hoping to take this stuffed Dino and make him a collar that activates 4 different colored LEDs when you pat his head, based on how far your hand is from his hair.

Here's the prototype on a breadboard:

I'd ultimately like to take the photocell circuit out of the breadboard and put it up in Dino's hair. I'll need to solder the parts together to make it work. As for the LEDs, there are four: red, green, blue and white. Each one lights up when the sensor reads a different level of brightness, on a scale that goes from dark to dim to medium to bright. I'll stick a paper bow tie over the breadboard with holes for the LEDs for that aspect.

Finally, here is the code I've programmed into the Arduino. I used Switch() functions because this allows you to choose between several discrete options.

---

const int sensorMin = 0; // sensor minimum, discovered through experiment const int sensorMax = 600; // sensor maximum, discovered through experiment

int ledPin2 = 2; // LED connected to digital pin 2 int ledPin3 = 3; // LED connected to digital pin 3 int ledPin4 = 4; // LED connected to digital pin 4 int ledPin5 = 5; // LED connected to digital pin 5

void setup() {

// initialize serial communication: Serial.begin(9600); pinMode(ledPin2, OUTPUT); // sets the digital pin as output pinMode(ledPin3, OUTPUT); // sets the digital pin as output pinMode(ledPin4, OUTPUT); // sets the digital pin as output pinMode(ledPin5, OUTPUT); // sets the digital pin as output }

void loop() { // read the sensor: int sensorReading = analogRead(A0); // map the sensor range to a range of four options: int range = map(sensorReading, sensorMin, sensorMax, 0, 3);

// do something different depending on the // range value: switch (range) { case 0: // your hand is on the sensor Serial.println("dark"); digitalWrite(ledPin2, HIGH); // sets the LED on delay(1000); // waits for a second digitalWrite(ledPin2, LOW); // sets the LED off delay(1000); // waits for a second break; case 1: // your hand is close to the sensor Serial.println("dim"); digitalWrite(ledPin3, HIGH); // sets the LED on delay(1000); // waits for a second digitalWrite(ledPin3, LOW); // sets the LED off delay(1000); // waits for a second break; case 2: // your hand is a few inches from the sensor Serial.println("medium"); digitalWrite(ledPin4, HIGH); // sets the LED on delay(1000); // waits for a second digitalWrite(ledPin4, LOW); // sets the LED off delay(1000); // waits for a second break; case 3: // your hand is nowhere near the sensor Serial.println("bright"); digitalWrite(ledPin5, HIGH); // sets the LED on delay(1000); // waits for a second digitalWrite(ledPin5, LOW); // sets the LED off delay(1000); // waits for a second break; } delay(1); // delay in between reads for stability }

[melodymakes]

Media Art Piece

This weekend, I went to the Dumbo Arts Festival with fellow classmates Hanna and Effy. We saw lots of cool projections and media art, including this fun instrumental piece in an exhibit from NYU's ITP program:

DRUM from Melody Quintana on Vimeo.

How does it work?

It seems like there's a photocell or motion sensor on the tip of the drumstick that detects when a user's hand is in a preset range. The wires connected to that sensor must have been hidden within the drumstick, which leads to a metal podium next to the snare drum. That's likely where the pre-programmed Arduino is.

When activated, the drumstick taps a brief tune that loops while the user's hand is detected by the sensor. In the code, this is probably done with the digitalRead and digitalWrite functions, because the tapping loop is either on or off – it doesn't vary based on how close or far away the user's hand is. A conditional "if" statement can then be used to turn "on" the tapping loop when the sensor detects a user's hand. 

The tapping loop itself could be controlled by a motor that's also connected to the Arduino. Going out on a limb here but it could be something as basic as:   

digitalWrite(drumStick, HIGH); // motor moves the drumstick down delay(100); // waits for a tenth of a second digitalWrite(drumStick, LOW); // motor moves the drumstick up delay(100); // waits for a tenth of a second

Of course, there would be varying "delay" times that make up the melody. 

[melodymakes]

Enhancing my switch with Arduino

This week we were asked to make an enhancement to our homemade switch using Arduino. After completing a few tutorials, I decided to make the light inside the lantern blink. 

This time instead of using a breadboard, I'm using a programmable Arduino board. Here's a diagram that explains how everything connects. The long leg of the LED attaches to a 220 Ohm resistor, which inserts into the pin #13 in the Arduino board.

After completing this setup, I uploaded the blink LED program onto the board by attaching it to my computer with a USB. Then, I removed the USB chord and attached a barrel plug to the Arduino board. The plug ultimately connects to my 9-volt battery, and the program runs without a connection to my computer because I already uploaded the program onto the board.

Voila! Blinking lantern light.

Here are some shots of other Arduino tests and tutorials I completed along the way.

1. Let there be light!

I used this analog in tutorial to make Arduino turn on a green LED. The brightness of the light varies when you turn the potentiometer knob. Here's the circuit:

2. Programming a light to turn on with a pushbutton

This pushbutton tutorial turns on an LED when you push the tiny button pictured in the center of the breadboard. Here are some shots of the code, circuit and switch.

[melodymakes]

Baby's first switch

When we think of computers, we usually think of screens and keyboards, typing and clicking. A basic tenant of interaction design is that computers – and the way we interact with them – can be more than that. They can sense other things we do and serve us in ways beyond our imaginations.

Physical Computing is a class about exploring this concept and learning how to build physically interactive technology.

Assignment #1: Object with homemade switch

My very first assignment for the class was to build an object with some LEDs and a homemade circuit with a switch. Rather than a predictable on/off switch, the lights should be activated with an unconventional interaction.

I made a mason jar lantern that simply turns on when you put the lid on the jar. Here's what it looks like when it's open and unlit:

And here's what it looks like closed and the LEDs are on:

Tada! Simple and delightful. 

How it works

This is a series circuit. Here's how each component conducts the flow of electricity:

The electric current begins from a battery power source.

I attached aluminum foil to this source to conduct the current. The foil extends to the top of the jar and touches the inner lid of the jar – also lined with foil – when the jar is closed.

A red "power" AWG wire also touches the inner lid of the jar when it's closed and turns on the switch. When the jar is open, the switch is off and there is no electric flow.

The other end of the same red AWG wire is attached to a resistor to help control the flow of current. 

The resistor is connected to the first LED.

The first LED is connected to the second LED.

The second LED is connected to the third LED.

The third LED is connected to a black "ground" AWG wire that connects the circuit to the ground side of the battery.

With the help of a small breadboard, I was able to build this circuit without having to solder or attach components in a fancy way.

Here's a look at the circuitry inside the jar. You can see the red power wire peeking out at the top, just waiting to make contact with the lid of the jar!

From a different angle, you can see the battery behind the breadboard:

And here's a video of the project at work:

Baby's first switch! from Melody Quintana on Vimeo.