Category Archives: General Posts

BloodMoney

Screen Shot 2014-12-10 at 7.15.02 PM

The Project

This final project is meant to be a culmination of the concepts that were learned throughout this Wearable Computing class. I had two main goals:

1. Make something useful. (It solves a problem in the world)

2. Make something finished. (It’s more product than project)

Ideation

I began looking for problems to be solved. The first and most stressful problem that comes to mind is money. I have problems saving money! It’s so easy to tap a credit card and get what you want. It’s no wonder that everyone is drowning in credit card debt!

Just watch the following video, our society is encouraging people to spend money with a quick (and fun) tap.

So how do I solve the problem of over-spending? Make it harder to spend! I began designing ways to make it hurt when you spend.

Screen Shot 2014-12-10 at 7.36.27 PM
Initially I thought the wallet would bite you or bleed when you spend.
wallet
My next design involved a spinning blade. Pain-Wallet I also considered a little pocket poker.
Screen Shot 2014-12-10 at 6.44.52 PM
Ultimately I decided to go with a hand shocker! Classic negative reinforcement.

So it was decided, I would electrocute the user when they pulled out their credit card… but how do you give somebody a little shock without really injuring them?

Building Wallet v.1 The Pain Wallet

Parts List:

1. Three 1.5v batteries in series 2. Transistor 3. Heat + Voltage regulator

Shocking User: I found this tutorial online for making a hand shocker but instead of risking injury with a home made shocker, I went to a prank shop and purchased an electric pen.

Screen Shot 2014-12-10 at 6.52.18 PM

I used the shocking pen and, surprise surprise it hurt. I opened it up to see how it works:

Screen Shot 2014-12-10 at 6.59.50 PMOn the left are the elements of the shocker and on the right is a diagram of what is inside including power, a transistor and conductive elements to be touched by the user. It’s quite a simple circuit but it took time for me to learn what each part does.

Detecting Wallet Use: I started to build the shocker into the wallet and sewed a switch with conductive thread. Initially the shock would happen using a complex Temboo chain of events that went like this:

Screen Shot 2014-12-10 at 7.20.44 PM

Talking to Connor Campbell about simplifying the project, we realized that when the user removes the card, the circuit could be completed and the shocker would be powered! I sewed this switch with conductive thread into my first wallet.

Screen Shot 2014-12-10 at 7.13.51 PM
A cross stitch of conductive thread on either side of the pocket.
Screen Shot 2014-12-10 at 7.14.07 PM
When the card is removed, the circuit completes and the shocker is powered!

After building the Pain Wallet, I had some time left so I tried building a second version of the wallet with a slightly different concept.

Building Wallet v.2 The Shame Wallet

Parts list:

1. Lilypad Arduino 2. Two TMB-12 Buzzers  3. One ROB-08449 Vibe Motor 4. Conductive thread, wires and solder

The Idea: Wallet v.2 is less about personal pain and more about public embarrassment. In our society, debt isn’t just easy to acquire… it’s encouraged! Check out this video:

Without using electric shocks, how could a wallet stop people from wanting to use their credit card? Something that is more realistic for a user to keep in their pockets.

I decided to use an embarrassing and stressful device – the buzzer! I also added a vibration motor to add to the tactile feel of the wallet.

Screen Shot 2014-12-10 at 8.21.35 PM
The vibe motor is sewn in with conductive thread.
Screen Shot 2014-12-10 at 7.14.17 PM
A shot of the final circuit soldered, taped and sewn in.

Here is a video of the project in it’s early stages:

Once again, I made a circuit that closes when the credit card is removed, this time hooking it up to a Lilypad Arduino. When the switch closes the Lilypad activates a buzzer/vibe sequence which is quite stressful.

Here is the final use video:

The Code:

The code for this project is pretty simple, I referenced this helpful instruction guide for using switches with Lilypad.

Find the code on Github here.

Final Reflections

I’m truly proud of these two wallets. Yes, I made something pretty simple but I think the best designs are simple. They reflect my current push towards being a serious designer of problem-solving artifacts. I want to make more items which make a statement or directly solve problems.

I do not plan to take these projects apart! For once I will leave them soldered and stitched together and simply buy another Lilypad for my next project. After some modifications I will be able to present these wallets as concept prototypes at public shows.

Thank you for your guidance in this course Jackson, I look forward to more designing for the body.

LightUp Dress

The inspiration for this project comes from the many Disney films I’ve watched in the past. The main focus of this product is not the dress itself, but the idea of wearing a dress. When you wear a dress, you want it to feel elegant, pretty, and magical. Just as the princesses in Disney films feel as they transform with the dresses, the sparkles that fly out, the fireworks in the background…etc.

maxresdefault

The idea was that I would recreate this using LEDs and accelerometer embedded within the dress.

 

Parts

  • Lilypad
  • ADXL 335 (for lilypad)
  • LED string
  • Dress
  • Conductive Thread
  • Resistor

 

Process

I first tried to design and make a dress of my own but due to my lack of tailoring skills, I quickly gave up on my pile of fabric and went out and bought a dress.

SAM_1246 SAM_1247

SAM_1242 SAM_1243 SAM_1244 SAM_1245 SAM_1248 SAM_1251

Code

/*
LilyPad ADXL335 Dress

Dec 9th, 2014
Kenix Po
*/

//———-Variables———-
//
//—–Constants—–
const int xpin = A5; // x-axis
const int ypin = A3; // y-axis
const int zpin = A4; // z-axis
//
int dressThreshold = 100;
int dressPin = 5;
int dressLight = 0;
//———-[test]———-
//Smoothing
const int numReadings = 10;
//
int xreadings[numReadings];      // the readings from the analog input
int xindex = 0;                  // the index of the current reading
int xtotal = 0;                  // the running total
int xaverage = 0;                // the average
//
int yreadings[numReadings];      // the readings from the analog input
int yindex = 0;                  // the index of the current reading
int ytotal = 0;                  // the running total
int yaverage = 0;                // the average
//
int zreadings[numReadings];      // the readings from the analog input
int zindex = 0;                  // the index of the current reading
int ztotal = 0;                  // the running total
int zaverage = 0;                // the average

void setup(){
//
Serial.begin(9600);
//
//
pinMode(xpin, INPUT);
pinMode(ypin, INPUT);
pinMode(zpin, INPUT);
pinMode(dressPin, OUTPUT);
//
for (int thisReading = 0; thisReading < numReadings; thisReading++)
xreadings[thisReading] = 0;
//
for (int thisReading = 0; thisReading < numReadings; thisReading++)
yreadings[thisReading] = 0;
//
for (int thisReading = 0; thisReading < numReadings; thisReading++)
zreadings[thisReading] = 0;
}//setUp ends

void loop(){
//
//—–Readings[input]—–
//
// subtract the last reading:
xtotal= xtotal – xreadings[xindex];
// read from the sensor:
xreadings[xindex] = analogRead(xpin);
// add the reading to the total:
xtotal= xtotal + xreadings[xindex];
// advance to the next position in the array:
xindex = xindex + 1;

// if we’re at the end of the array…
if (xindex >= numReadings)
// …wrap around to the beginning:
xindex = 0;

// calculate the average:
xaverage = xtotal / numReadings;
//
delay(1);

// subtract the last reading:
ytotal= ytotal – yreadings[yindex];
// read from the sensor:
yreadings[yindex] = analogRead(ypin);
// add the reading to the total:
ytotal= ytotal + yreadings[yindex];
// advance to the next position in the array:
yindex = yindex + 1;

// if we’re at the end of the array…
if (yindex >= numReadings)
// …wrap around to the beginning:
yindex = 0;

// calculate the average:
yaverage = ytotal / numReadings;
//
delay(1);

// subtract the last reading:
ztotal= ztotal – zreadings[zindex];
// read from the sensor:
zreadings[zindex] = analogRead(zpin);
// add the reading to the total:
ztotal= ztotal + zreadings[zindex];
// advance to the next position in the array:
zindex = zindex + 1;

// if we’re at the end of the array…
if (zindex >= numReadings)
// …wrap around to the beginning:
zindex = 0;

// calculate the average:
zaverage = ztotal / numReadings;
//
delay(1);

//—–Dress LightUp—–
if( zaverage <= (dressThreshold – 20) || zaverage >= (dressThreshold + 20)){
//
if (dressLight <= 255){
dressLight = dressLight + 10;
analogWrite(dressPin, dressLight);
//
}
}
else if((zaverage <= dressThreshold + 20) && (zaverage >= dressThreshold – 20)){

dressLight = 0;
/* while(dressLight >= 0){
//
dressLight = dressLight – 10;
}
analogWrite(dressPin, dressLight);
//
*/
}
//
//—–Serial Monitor Display—–
Serial.print(xaverage);
Serial.print(“\t”);
//
Serial.print(yaverage);
Serial.print(“\t”);
//
Serial.print(zaverage);
Serial.print(“\n”);
//
delay(500);// delay before next reading:
}//loop ends

Circuit

Screen Shot 2014-12-09 at 5.13.02 PM

 

Heartrate LED tutu skirt

 

 

UPDATED ON 12/12/2014: Click here for my process

lightworkinglighttutu

My concept for the final project is inspired by the costumes from the VS fashion show, I think it would be interesting to incorporate the user’s heart rate and LED light into the costume. I designed and made the bustier top, tutu skirt and a long tulle train as the costume. By attaching the heart rate sensor onto the user’s fingers, the sensor will detect the user’s heartbeat, and using the LED light as the output, they should blink frequently as the user’s heart rate become faster. So the audience can tell how nervous or excited is the performer by reading the LED light on the tutu.

I used mostly lace and tulle for the costume, because I found those fabric are commonly used for most of the lingerie from the  VS fashion show (lace and tulle are elegant and sexy!) The theme of my costume would be called “The Bloom of Dark Nature” because of the roses and vines on the skirt and my arm, the heart rate sensor is connected to my finger, which looks like my blood is making the roses bloom. I also decided to add artificial black roses and ribbon to the costume so they can hide some parts of the circuit and to make it looks more visually pleasing.

Coding:

/*
This Arduino program reads data from the pulse sensor and outputs flashes to the open heart LED display.
*/

#include <avr/pgmspace.h>

//Defines the pins used for Heart
int pin1 =6;
int pin2 =10;
int pin3 =11;
//Sets how long in Microseconds each LED is on for.
int blinkdelay = 100;

//Sets how many times each frame repeats. The larger
//the number, the longer each frame is displayed
//before moving onto the next one.
int runspeed = 5;

const int pins[] = {
pin1,pin2,pin3};

const int heartpins[27][2] ={
{pin3, pin1},
{pin1, pin3},
{pin2, pin1},
{pin1, pin2}

};

byte heart[][27] PROGMEM ={
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,1,1,0,1,1,0,0,1,1,1,1,1,0,0,1,1,1,0,0,1,0,0},
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
{2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};

// Pins
//const int ledPin = 13;
const int sensePin = 5;

// LED blink variables
int ledState = LOW;
long ledOnMillis = 0;
long ledOnInterval = 50;

// Hearbeat detect variables
int newHeartReading = 0;
int lastHeartReading = 0;
int Delta = 0;
int recentReadings[8] = {0,0,0,0,0,0,0,0};
int historySize = 8;
int recentTotal = 0;
int readingsIndex = 0;
boolean highChange = false;
int totalThreshold = 2;

// Heartbeat Timing
long lastHeartbeatTime = 0;
long debounceDelay = 150;
int currentHeartrate = 0;

void setup() {
// initialize the serial communication:
//Serial.begin(9600);
// initialize the digital pin as an output:
//pinMode(ledPin, OUTPUT);
}

void loop() {
// Turn off LED
//digitalWrite(ledPin, LOW);

// Read analogue pin.
newHeartReading = analogRead(sensePin);
//Serial.println(newHeartReading);
//Calculate Delta
Delta = newHeartReading – lastHeartReading;
lastHeartReading = newHeartReading;

// Find new recent total
recentTotal = recentTotal – recentReadings[readingsIndex] + Delta;
// replace indexed recent value
recentReadings[readingsIndex] = Delta;
// increment index
readingsIndex = (readingsIndex + 1) % historySize;

//Debug
//Serial.println(recentTotal);

// Decide whether to start an LED Blink.
if (recentTotal >= totalThreshold) {
// Possible heartbeart, check time
if (millis() – lastHeartbeatTime >= debounceDelay) {
// Heartbeat
//digitalWrite(ledPin, HIGH);
currentHeartrate = 60000 / (millis() – lastHeartbeatTime);
lastHeartbeatTime = millis();
// Print Results
Serial.println(“Beat”);
if (currentHeartrate <= 200) {
//Serial.println(currentHeartrate);
play();}
}
}
delay(10); }

void turnon(int led) {
int pospin = heartpins[led][0];
int negpin = heartpins[led][1];
pinMode (pospin, OUTPUT);
pinMode (negpin, OUTPUT);
digitalWrite (pospin, HIGH);
digitalWrite (negpin, LOW);
}
void alloff() {
for(int i = 0; i < 6; i++) {
pinMode (pins[i], INPUT);
}
}
void play() {
boolean run = true;
byte k;
int t = 0;
while(run == true) {
for(int i = 0; i < runspeed; i++) {
for(int j = 0; j < 27; j++) {
k = pgm_read_byte(&(heart[t][j]));
if (k == 2) {
t = 0;
run = false;
}
else if(k == 1) {
turnon(j);
delayMicroseconds(blinkdelay);
alloff();
}
else if(k == 0) {
delayMicroseconds(blinkdelay);
}
}
} t++;
}
}
void blinkall(int numblink) {
alloff();
for(int n = 0;n < numblink;n++) {
for(int i = 0; i < runspeed; i++) {
for(int j = 0; j < 27; j++) {
turnon(j);
delay(blinkdelay);
alloff();
}
}
delay(500);
}
}
void sequenceon() {
for(int i = 0; i < 27; i++) {
turnon(i);
delay(800);
alloff();
delay(800);
}
}