Peripheral – Project

Here is the link for the full blog entry:

http://boriskourt.com/2013/04/12/from-an-oled-screen-to-technosapien/

 

Final Project- Reactive Summer Shirt

 

Concept:

A woman’s summer shirt that changes colors as it reacts with warm temperature. This screen-printed black colored pattern when exposed to heat higher than 24C changes its color to red, creating a sense of interaction between the wearer and its own surroundings. It reflects good weather outdoors when enjoying the warm summer breeze.

Exploring more in depth thermochromic ink and its applications into textile design.

Objective:

Making everyday wearable an interactive experience for the wearer. It has come to my attention that ready to wear fashion is still in need of interactive components that enhance the wearer and explore other methods of communication.

Intended Scenario:

This shirt is to be worn mainly in summer or warm temperature environments, in order for the ink to make effect. The best scenario will be outdoors in a hot summer day.

 

Process sketches:

Materials:

– 1 yard of silk-wool blend

– black thermochromic ink

– two screens

– red fabric ink

– black cotton fabric for details on shirt

– Pattern draft for shirt

 

Process:

The design for this shirt has very simple lines and and detailed black border on the neck and armholes. The design was first made on paper, taken to Illustrator and screen-printed on fabric with a red base first, and on top the thermochromic layer. The fabric was cut prior to screen-printing in order to get an even design. When the fabric was ready and dry, I proceeded to sew everything, and add the black border details at the end.

 

Challenges:

The most challenging part was the screen-printing process and sewing. When you screen print with two screens, you always have to make sure that they both align exactly one on top of the other so the results look professional.

Pattern drafting was another of my challenges, I started by measuring the body and creating a pattern from scratch, but I realized that it was taking me too l long to figure it out and the pattern did not look good. So instead I decided to buy a pattern from the internet, which I printed and proceeded to cut the fabric. The sewing part was challenging because of the black edge detail I added to the shirt, although I’m glad I did it because the shirt looks professional.

Successes:

Even though I had difficulty sewing together the shirt, I really liked the outcome of it, it fits really well and the choice of fabric was the right one; the softness of the silk creates a nice and soft drape. Also the pattern that I intended to work with, gives the shirt a modern and simple look, which creates an interesting effect with the ink.

Adding the thermochromic ink not as a layer but in different sections of the shirt, makes the shirt really stand out and create almost an illusion with the pattern and color. And it also lets the fabric keep its own soft qualities and not make it stiff.

Next Steps:

It would be great to make a line of shirts with different patterns and try other colors of thermochromic ink and trying to create different effects with graphics and colors, I believe it is a good and innovative product that can be of interest for people to wear.

 

 

 

 

 

Chelα : Wearable Robotic Hand – Final Project

Introduction

Chelα is a wearable electronic robotic hand, inspired by the pincerlike claw of a crustacean or arachnid, that can be controlled via a flex-sensor glove. It is intended to create an interest in the re-regotiation of the body in the case of an amputated limb.

The completed iteration of this project consists of a one-finger glove that is fastened at the wrist which contains two batteries, a Lilypad, and a flex sensor. A second component, the metal claw, is gripped by the user on the hand wearing the glove and then a servo motor (located on the claw) is plugged into the Lilypad in order to function. When you flex your finger, the claw will begin to close (and vice versa).

 

Concept and Inspiration

The concept for the piece is inspired by a TED Talk delivered by Aimee Mullins, the model-actress-olympian-(double amputee).  In her TED talk, she discussed how she went to present her prosthetic legs at a museum to a group of children. These children would be unsupervised by adults (to limit bias) for the first two minutes of the presentation, where they would be free to poke and prod at the bag of prosthetic legs that Aimee brought for them to inspect.  The children came out of the experience without having been affected by society’s pre conceived notions on amputees being disabled, and instead thought Aimee was lucky to be able to choose from 12 pairs of legs as she pleased.

The idea for this piece is to ultimately show non-amputees “what they’re missing out on” by not being able to use this robotic arm under other circumstances. What they are limited to because of the fact that they don’t quite have the opportunity to renegotiate a space on their body. With this piece people are given a glimpse as to what else is possible for that space on their body.

Materials

  • Metal Claw
  • Med. servo motor
  • Lilypad Arduino
  • 14″ flex sensor
  • Neoprene
  • Thread
  • 2 x lithium ion battery
  • Step-up breakout
  • Electrical tape
  • 2 x 8″ screws
  • Velcro strap

Process 

I started off this project by gathering all my materials and then beginning to work on my code. I created a sketch that I still use now only with some slight modifications. This beginning phase was when I tested the circuit to make sure the flex sensor would work as I wanted it to (to fluidly control the servo motor). The circuit was very successful and after some tinkering (I discovered the servo motor needed its own source of power) my claw opened and closed with the use of the flex sensor.

 

 

Once everything was soldered I encountered a larger issue. The circuit was only working so well because it was being plugged in and being powered by the 5v of an Arduino while the signal from the flex sensor was being powered by the Lilypad. This meant that my project was no longer functional once being powered by batteries (which were 3.7v). I tried many different methods, with the help of others, of using a step up breakout board to the battery powering the servo, trying multiple kinds of batteries… all sorts of things. Nothing was working…but that’s nothing that a trip to Creatron cannot fix! I was told that the grounds of my sensor and motor need to be shared, while solely the power needs to be separate. This worked wonders and finally my project was working without the need to be plugged in!

After this feat I had to actually consider the wearability of the claw, which at this point was only a floating flex sensor that opened and closed a metal claw with a servo motor. I decided to pick up some really nice black neoprene-like fabric at King Textiles. They provided great customer service so I highly recommend this place to anyone who needs fabric! With this fabric I made and cut out some patterns to sew together a full glove, but this pattern was quickly altered after the final critique of this class where it was suggested I just sew the one finger instead of all five. I then sewed on the Lilypad, battery pouches, velcro straps, and the flex sensor to the finger of the glove. Finally, I created a larger grip for the claw so that users could pick it up comfortably, and then designed a pattern of where fingers should be placed on the grip itself for convenience. I inevitably ran into lots of issues with shorting and such, but ultimately it was functional and ready for the show.

 

Next Steps

To my surprise at this show I was approached to apply for two grants for inclusive technologies! Needless to say this will be my focus for the next short while. This project was intended to be a stepping stone for my thesis next year which will involve the development of actual upper limb prosthesis that fit a certain aesthetic I am slowly discovering. I believe this project was extremely successful in accomplishing this and I am really proud of the outcome! Big thanks to Katie and Boris for all their support!

Code
Arduino:

#include <Servo.h>
Servo servo1;
int flexposition; // Input value from the analog pin.
int servoposition; // Output value to the servo.

long previousTalker = 0; // will store last time LED was updated
long previousServo = 0;
// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval = 15; // interval at which to blink (milliseconds)

void setup() {
Serial.begin(9600);
servo1.attach(5);
}

void loop() {

//servoposition = 180;

unsigned long currentMillis = millis();

if (currentMillis – previousServo > interval) {
flexposition = analogRead(A3);
servoposition = map(flexposition, 300, 600, 15, 180);
servoposition = constrain(servoposition, 15, 180);

previousServo = currentMillis;

servo1.write(servoposition);
}

if(currentMillis – previousTalker > 200) {

previousTalker = currentMillis;

Serial.println(“sensor: “);
Serial.print(flexposition);
Serial.println(” “);
Serial.println(“servo: “);
Serial.print(servoposition);
Serial.println(” “);

}

}

 

 

Final Project – Cultural Crossroads: “White-Washed”

Concept

This project was an exploration into character creation using wearable technology and textiles. I have an ongoing project in anticipation for my thesis that explores my connection (or lack thereof) to my Chinese heritage, resulting in a sense of “Otherness” within my own heritage. The comic I intend to create will be set in a fantasy world, so I wanted to create a creature that could exist within that world.

Intended Scenario

This is a wearable piece that can be used for performances and events such as Halloween. For me, it was a chance to explore costume and character work with the inclusion of wearable technology that could influence ideas in my comic and vice versa.

Inspiration

Mike Mignola is the creator of Hellboy and has been the main inspiration for my comic. Hellboy encounters being “Other” in the movie, but in the comics there is a lot more myth and legend surrounding the supernatural creatures and worlds. The creatures are also fantastic and Hellboy continues to inspire me to push creature concepts.

Rachael Kess is a student who did Wearable 1 and 2 and also did felt masks that focused on soft cyborg/human interaction. She also did a performance piece with one of her masks, which could be something I could do with my piece or any future pieces using the same techniques used to create the mask.

Parts and Materials

Merino wool
Coopworth wool
felting needles
10 warm white LEDs
Shapelock + boiling water
white thread
conductive fiber
conductive thread
2xAAA  batteries+holder

Process

Needle felting is the process of bringing fibers with “scales” together and compacted (compared to their wooly loose state). I made sheets of needle felted wool, then combined them to form a general shape. Originally I was going to do a kirin/quilin which is a Chinese unicorn, but I couldn’t get the face right and I decided to do a dragon instead since the dragon is more of an iconic Chinese myth than the kirin.

Shapelock is one of my favourite materials to work with! It’s a plastic that can be melted with boiling water and then shaped. I connected the horn LEDs through parallel circuits so that if one horn cut out, the others wouldn’t be affected. This was a bit challenging, but in the end all of the LEDs worked.

I also used Shapelock for the teeth! This was the most trickiest part since I had already formed the mask and putting the teeth in were essentially like stitching in dentures for my dragon. Luckily I didn’t short anything because I was able to sew different paths into the wool, which also has a lot of resistance. The thread I used this time was from Sparkfun which was thinner and had less resistance. This made connecting everything so much easier than using the Creatron thread.

This was the table set-up and some modelling by Hillary Predko at the Technosapien show! Funfun.

The card with the description reads:

Cultural Crossroads is an exploration of Otherness, specifically Cassi Wong-Lee’s experience of being an outcast within her own heritage. “White-Washed” is a reflection of Cassi’s Chinese blood and folklore fused with her Western upbringing. This dragon mask part of a larger project that plans to incorporate illustration and costume to produce a narrative in a fantasy world that explores community, stigma, and culture.

The sketches are some ideas for my character that I will incorporate into my comic. Through this project, I’ve actually been inspired to make my character one of the last dragons of light, creating another layer of Otherness and incorporating the light aspect from the mask. In the comic, he will have two forms and his full dragon form will have glowing horns, claws, eyes, and teeth.

Challenges

The most challenging part was the teeth. I had no plan beforehand regarding how to put the teeth in, so I was lucky that I could adjust the Shapelock and use the wool to sew pathways. Next time, I will make a plan to make different planes of the mask and do the circuit sewing PRIOR to connecting all the pieces. Also next time I will felt the wool more so that there are less fluffy bits interfering with my circuit sewing and building resistance.

Successes

I was very happy with combining textile techniques with wearable technology and new materials. I really like the conductive thread from Sparkfun, so I will buy that kind instead of the Creatron one. I also will continue to use Shapelock and find new ways to use it. Maybe I’ll try making hand pieces to match the mask!

Next steps

In the future, I hope to explore more felt masks, altered LEDs, and maybe even some performance to put the mask to use. I will keep refining my dragon character for my comic, but I have learned from this process since my comic ideas and mask ideas have influenced each other very much. Wearable technology is something I will continue to play around with for my own work in thesis and influencing ideas of technology in my comic.

 

The Flight Shirt – Final Project

 

Introduction

The flight shirt displays the flight path between Toronto and four cities. It explores the idea of data visualization on the body and the effect it has on fashion and aesthetics. This project was inspired by my partner who is a flight attendant with Air Canada. If I want to know where he is, I can just look down at my shirt to see where his plane might be. It also explores the idea of personal interpretation of data and what it reveals about ourselves to other people.

Instructions

The shirt is controlled by an android app via bluetooth and flight tracking is based on a built in schedule.

1. Press connect to connect to bluetooth

2. Choose a direction by pressing “Outbnd” or deselect it by pressing it again.

3. Choose a route to track (FRA is Frankfurt, MUC is Munich, NRT is Tokyo and HKG is Hong Kong)

4. Press Start

5. To stop tracking press stop

6. To disconnect bluetooth connection press Connect to deselect

Video

Inspirations

This project was inspired by previous work I have done with visualizing schedules and other data visualization projects such as Aaron Koblin’s Flight Pattern project:

http://www.aaronkoblin.com/work/flightpatterns/

Parts, Materials and Circuit:

  • 1 x Lilypad Arduino
  • 1 x Lilypad LiPo circuit
  • 1 x Bluetooth Mate Silver
  • 1 x 3.7 800mAH Lithium Battery
  • 5 x Lilypad Yellow LED’s
  • 5 x Lilypad Red LED’s
  • 4 x LIlypad Green LED’s
  • 4 x Lilypad Blue LED’s
  • Conductive Thread
  • Conductive Fabric
  • Gaffer Tape

Assembly Process

I started this project by getting a shirt printed at Freshly Baked T’s on Queen West. Although this was an added expense it did save a lot of time and effort in creating a graphic.

I then took a long sleeve T-shirt and put it under the graphic T. I sewed the neck lines together so I could align the graphic pattern with the LEDs

Once the LED placements were marked. I then began to make the circuit by ironing on pieces of conductive fabric. I started off in the left hand corner and worked my way from left to right, top to bottom.

The conductive fabric I used has an iron on adhesive on the back. However it is non-conductive and so I initially hand sewed the pieces together using conductive thread however that was cumbersome and took a long time.

I then tried Bare conductive paint as a cold soldering technique

Testing with a volt meter the connection appeared to be stable

After completing the circuit pathways I began to sew on the LEDs

Then the LilyPad Arduino

I used Gaffer tape as an insulating material to overlay conductive fabric and to insulate the conductive thread that was exposed

I then began to test my circuit and discovered that some LED’s had very intermittent connections. It turned out the Bare conductive paint was cracking and causing open circuits along the pathways. I then decided to use a sewing machine and conductive thread to join the pieces of conductive fabric instead

After more testing I was satisfied with the results and I began to sew on the LilyPad LiPo circuit to convert a lithium battery from 3.7V to 5V as this was required for the bluetooth module.

After testing and code development (please scroll to the end of this post for the code) the biggest challenge was final assembly which required the LED’s to align with the pattern. Although I initially marked where the LED’s should go, the fabric was stretchy and the markings shifted. This created a big challenge in properly aligning the LEDs. I decided to sew small stitches from the LED to where it should be placed on the graphic T-shirt.

Next Steps

If I had more time to redo or continue this project I would implement the suggestions made in class on making the shirt more subtle. I would integrate the graphic with the LED’s better by creating a new design without the dashed lines. Instead of colour LED’s I would use white ones so it would pique someone’s curiosity if they saw it. I would also explore the idea of personal data visualization as a complete abstraction where only the wearer would know what the light patterns mean. Finally instead of a fixed schedule I would explore how to automate the flight data from the internet either through a paid subscription service or through scrapping a webpage for the data.

Arduino Code:

#include <Event.h>
#include <Timer.h>

// Demo Code for SerialCommand Library
// Steven Cogswell
// May 2011

#include <SerialCommand.h>
#define arduinoLED 13 // Arduino LED on board

SerialCommand sCmd; // The demo SerialCommand object

Timer LEDTimer1; // have 18 timers for 18 led’s
Timer LEDTimer2;
int LEDTimerEvent [20];
void setup() {

for (int i = 2; i < 20; i++) {
pinMode(i, OUTPUT);
digitalWrite(i, LOW);
}

Serial.begin(57600);

// Setup callbacks for SerialCommand commands
sCmd.addCommand(“ON”, LED_on); // Turns LED on
sCmd.addCommand(“OFF”, LED_off); // Turns LED off
sCmd.addCommand(“ALLOFF”, All_off);

sCmd.setDefaultHandler(unrecognized); // Handler for command that isn’t matched (says “What?”)

}

void loop() {
sCmd.readSerial(); // We don’t do much, just process serial commands

}

void All_off() {
for (int i = 2; i < 20; i++) {
digitalWrite(i, LOW);

}
}

void LED_on() {
char *arg;

int PinNumber;
int LastStation;
int ClockSpeed;

arg = sCmd.next();
if (arg != NULL) {
PinNumber = atoi(arg);

}

digitalWrite(PinNumber, HIGH);

}

void LED_off() {
char *arg;
int PinNumber;
int LastStation;
int ClockSpeed;

arg = sCmd.next();
if (arg != NULL) {
PinNumber = atoi(arg);

}
digitalWrite(PinNumber, LOW);

}

 

// This gets set as the default handler, and gets called when no other command matches.
void unrecognized(const char *command) {
//Serial.println(“What?”);
}

Processing Code:

Flight Shirt

import controlP5.*;
import processing.serial.*;

ControlP5 Buttons;
ControlFont ButtonFont;

PFont timeFont;

ArrayList Stations;
//Variable Speed clock variables
int LastTime = 0;
int VarSeconds;
int VarMinute;
int VarHour;
String TimeStamp;
String DisplayTime;

int sliderValue = 1000;

int TimeX = 656;
int TimeY = 620;

int TimeScrollX = 631;
int TimeScrollY = 689;

int TimeScrollW = 162;
int TimeScrollH = 30;

int ClockSpeed;
final int MaxClockSpeed = 0;
boolean Outbound;
boolean StartProgram;
boolean ScheduleMode;

int StartBtnValue;
int StopBtnValue;
int LastBtnValue;
long lastDebounceTime = 0;
long debounceDelay = 50;
String LineChosen;
int DelayTimer;
boolean FlashNextStation;

PImage backgroundImg;
Serial myPort;

void setup() {
// Setup screen and fonts
size (1024,768);
//backgroundImg = loadImage(“background.png”);

println(“Available serial ports:”);
println(Serial.list());

String portName = Serial.list()[4];
myPort = new Serial(this, portName, 57600);

PFont font = createFont(“arial”,30, true);
ButtonFont = new ControlFont(createFont(“arial”,20),20);

Buttons = new ControlP5(this);

timeFont = loadFont(“MyriadPro-Regular-69.vlw”);

Buttons.addToggle(“Direction”)
.setPosition(821, 636)
.setSize(69,29)
;

Buttons.addButton(“Start”)
.setPosition(632, 636)
.setSize(69,29)
.setValue(0)
;
Buttons.addButton(“Stop”)
.setPosition(727, 636)
.setSize(69, 29)
.setValue(0)
;

Buttons.addSlider(“Speed”)
.setPosition(631, 689)
.setSize(258,20)
.setRange(1000,0)
.setValue(1000)
;

//record the time that application starts
VarSeconds = second();
VarMinute = minute();
VarHour = hour();
TimeStamp = null;

DelayTimer = millis();

Stations = new ArrayList();

//Load the file
InitializeLineData();

}

void draw () {

background(0, 0, 0);

if (StartProgram == true) {
//println(“program start”);
UpdateClock();
CheckSchedule();
}

}

void Direction(boolean Flag) {
Outbound = Flag;
println(“Outbound value: ” + Outbound);
String Command = “ALLOFF” + ‘\n’;
myPort.write(Command);
}

void Speed(int SpeedValue) {
ClockSpeed = SpeedValue;
println(“Sliding value: ” + SpeedValue);
}

public void controlEvent(ControlEvent theEvent) {
println(theEvent.getController().getName());

}

public void Start(int theValue) {
StartProgram = true;
}

public void Stop (int theValue) {
StartProgram = false;
String Command = “ALLOFF” + ‘\n’;
myPort.write(Command);

}

void InitializeLineData() {
String[] LineData = loadStrings(“flights.txt”);
Outbound = false;
StartProgram = false;
FlashNextStation = false;
ScheduleMode = true;

ClockSpeed = 1000;

//go through each line
for (int i = 0; i < LineData.length; i++) {
// each line contains Staiton Name and Times, create Array with this
String[] StationData = splitTokens(LineData[i], “,”);
//println(StationData);
boolean Direction;

boolean LastStation;
if (int(StationData[0]) == 1) {
LastStation = true;
} else {
LastStation = false;
}

String StationName = StationData[1];

if (int(StationData[2]) == 1) {
Direction = true;
} else {
Direction = false;
}

//extract travel times

// storet he times in a new array
String[] Time = new String[StationData.length-3];
//println(Time.length);

for (int j = 0; j < Time.length; j++) {
Time[j] = StationData[j+3];
}
println(Time);
// Store station name and times in a class that will split hours and minutes
Station s = new Station(StationName, Time, Direction, LastStation);
println(s.Outbound + ” “+ s.Name + ” ” + s.LastStation + ” “);
for (int k = 0; k < s.Hours.length; k++) {
println(s.Hours[k] + “:” + s.Minutes[k]);
}

Stations.add(s);
}

}

void CheckSchedule() {

String ArduinoCommand;
String LastStationFlag;
int StopTimeHour;

for (int i = 0; i < Stations.size(); i ++) {

Station station = (Station) Stations.get(i);
// check to see if down direction button pressed
if (station.Outbound == Outbound) {
// scroll through each time at each station and check to see if it matches
// if it’s not a last station then flash the arduino
if (station.LastStation == true) {
LastStationFlag = “1”;
} else {
LastStationFlag = “0”;
}

// check on times
// if hours go past midnight:

if (station.Hours[0] > station.Hours[1]) {
// flight passes through midnight
// temporarily add 24 hours to make comparison
StopTimeHour = station.Hours[1] + 24;
} else {
// if not past midnight then keep as is:
StopTimeHour = station.Hours[1];
}

//if ((station.Hours[0] >= VarHour && station.Minutes[0] >= VarMinute) && (StopTimeHour < VarHour && station.Minutes[1] < VarMinute)) {
if (station.Hours[0] == VarHour && station.Minutes[0] == VarMinute) {
if (station.LEDOn[0] == false) {
println(“Direction: ” + station.Outbound);
println(“Start Hour: ” + station.Hours[0] + ” Var Hour: ” + VarHour);
println(“Start Minute: ” + station.Minutes[0] + ” Var Minute: ” + VarMinute);
println(“End Hour: ” + StopTimeHour + ” Var Hour: ” + VarHour);
println(“End Minute: ” + station.Minutes[1] + “Var Minute: ” + VarMinute);
//arduino.digitalWrite(station.PinNumber, Arduino.HIGH);
//DisplayImage(station.FileName, station.x, station.y);
// send arduino pin number to flash

ArduinoCommand = “ON” + ” ” + station.Name + ” ” + LastStationFlag + ” ” + ClockSpeed + “\n”;
myPort.write(ArduinoCommand);

station.LEDOn[0] = true;
println(ArduinoCommand);
//println (“Index: ” + j + ” ” + station.Name + ” ” + station.Outbound + ” ON – Time – ” + station.Hours[j] + “:” + station.Minutes[j]);
//noLoop();
}

} else if (station.Hours[1] == VarHour && station.Minutes[1] == VarMinute) {
//println(“Trans File Name: ” + station.TransFileName);

if (station.LEDOn[0] == true) {
ArduinoCommand = “OFF” + ” ” + station.Name + ” ” + LastStationFlag + ” ” + ClockSpeed + “\n”;
myPort.write(ArduinoCommand);
//arduino.digitalWrite(station.PinNumber, Arduino.LOW);
station.LEDOn[0] = false;
println(ArduinoCommand);
//println (“Index: ” + j + ” ” + station.Name + ” ” + station.Outbound + ” OFF – Time – ” + station.Hours[j] + “:” + station.Minutes[j]);
//noLoop();
}

}
// if it’s the last station then only check first times

}
}
}

void DisplayImage(String FileName, int x, int y) {
PImage img;
img = loadImage(FileName);
image(img, x, y);

}

void RemoveImage(String StationName, int x, int y) {

}

void UpdateClock () {

String DisplayHours;
String DisplayMinutes;
String DisplayTime;
String DisplaySeconds;

if (VarMinute >= 0 && VarMinute <=9) {
DisplayMinutes = “0” + str(VarMinute);
} else {
DisplayMinutes = str(VarMinute);
}
if (VarHour >=0 && VarHour <=9) {
DisplayHours = “0” + str(VarHour);
} else {
DisplayHours = str(VarHour);
}
if (VarSeconds >=0 && VarSeconds <=9) {
DisplaySeconds = “0” + str(VarSeconds);
} else {
DisplaySeconds = str(VarSeconds);
}

DisplayTime = DisplayHours + “:” + DisplayMinutes + “:” + DisplaySeconds;
textFont(timeFont, 30);
fill(#FFFFFF);
text(DisplayTime, TimeX,TimeY);
//println(VarHour + “:” + VarMinute + “:” + VarSeconds);

if( millis() – LastTime > ClockSpeed ){
LastTime = millis();

if (ClockSpeed <= 1000 && ClockSpeed >= 750) {
VarSeconds++;
//println(“normal increase”);
} else if (ClockSpeed < 750 && ClockSpeed >= 500) {
VarSeconds+=15;
} else if (ClockSpeed < 500 && ClockSpeed >= 250) {
VarSeconds+=30;
//println(“fast increase”);
} else if (ClockSpeed < 250 && ClockSpeed >= 0) {
VarSeconds+=60;
//println(“super fast”);
}

if (VarSeconds > 59) {
VarSeconds = 0;
VarMinute++;

if (VarMinute > 59) {
VarMinute = 0;
VarHour++;

if (VarHour > 23) {
VarHour = 0;
}
}
}
}
}

Station Class

class Station {

boolean LastStation;
String Name;

boolean Outbound;
int[] Hours;
int[] Minutes;
String[] Time;

boolean[] LEDOn;

Station (String Name, String[] Time, boolean Outbound, boolean LastStation) {

this.Name = Name;
this.Outbound = Outbound;
this.LastStation = LastStation;
println(“Pin: ” + this.Name + ” Outbound: ” + this.Outbound + ” Last Station: ” + this.LastStation);

Hours = new int[Time.length];
Minutes = new int[Time.length];
LEDOn = new boolean[Time.length];

for (int i = 0; i < Time.length; i ++) {

this.Time = split(Time[i], ‘:’);
println(“Class Hours: ” + Time[0]);
Hours[i] = int(this.Time[0]);
println(“Class Minutes: ” + Time[1]);
Minutes[i] = int(this.Time[1]);
LEDOn[i] = false;

}

}
}

Thermochromic Ink Research

Here is a link to find more information about the ink that I used and other related products for textiles and other materials:

http://www.hallcrest.com/tic.cfm

http://www.colorchange.com/thermochromic

The ink that I bough  is black and reacts at 24 C. You can get other colors and temperatures depending on the use. This one is specifically for screen printing on textiles, but you can find other similar inks for paper, cardboard or other materials.

 

Process:

I was very interested in exploring Thermochromic ink and its applications into pattern design for textiles. So I first designed two simple geometric patterns on Illustrator. Each pattern had 2 layers, one for  normal ink (in this case I used red and black) and the other layer for thermochromic ink.

I made 4 different screens and applied the ink combining it with the normal one to create different effects. I was pleased with the results, because you can create really strong effects by applying the ink in different places on the garment.

The photos show experimentation only with 100% cotton, which works very well; it has a plain weave, that’s flat, durable and creates a good surface for printing; it is also light weight, which allows fast heat absorption. Other types of fabric such as silk blends with heavy weight take longer to react and the ink doesn’t blend very well onto the fabric. I find the light and plain weaves give better results. It is also important to take into account the amount of thermochromic ink applied onto each design, because it tends to stiffen the fabric a lot, and if you care about the flow and drape of the fabric, it is better to apply smaller amounts.

 

 

LED Diffusion Techniques

For my final project in wearable technology I want to make my LED’s have a diffused glow as well as shape them to have a larger surface area. I found many different techniques for doing this that achieve similar, but different effects. I’ll post links to the projects I found.

Paint:
http://www.instructables.com/id/LED-diffusion/

This method is just for diffusing the light. Simply by painting the LED white, you can make it glow all around instead of lighting in one direction. I’m sure you could use other colour paints to colour as well as diffuse it.

 

sanded_led

Sanding:

http://www.youtube.com/watch?v=x9oFzZA6WeY
http://www.youtube.com/watch?v=fkep8nHUMdA

This technique is used to diffuse the LED, and again, give it a glow. It’s very effective and easy to do. I used a nail file on mine.

 

Hot Glue:
http://www.instructables.com/id/Hot-Glue-LED-Diffusion/
http://www.instructables.com/id/Faucet-Night-Light/

hotglue_led

This method is for changing the shape of your LED’s. It can be used to sculpt them and give them a glow effect. To shape the hot glue, use toothpicks and the glue gun, and when you’re happy with it, stick it in ice water to cool it fast. To make the glow even more diffused, try sanding the LED before putting hot glue on it. You can also buy coloured and glitter glue sticks, so I’m looking into using this for my final project, to create a glitter clear light with my LED’s. The next link is a website that sells these coloured glue sticks, for really cheap too!

http://www.glu-stix.com/shop/page/category/Category/1765e4b138152633395eee4fa8fa04d7.html

 

Resin Mold:
http://www.instructables.com/id/homebrewed-shaped-LED-heart-LED/

This is a fairly difficult technique for an inexperienced mold maker, and frankly the start-up materials are expensive. I chose against this method for my project, but I wish I could use a resin material to mold my LED’s, the final product is very professional. You could diffuse this LED shape using sanding or paint as well. You could also probably use a dollar store ice cube tray as your mold for any type of molding material such as silicone, or make your own mold if you had the right materials and knowledge.

Final Project Proposal – Robotic Arm

Introduction

For my final project, I have decided to create a robotic arm powered by a servo motor that a user can control with the use of a special glove / arm band.

Concept

The concept for the piece is inspired by a TED Talk delivered by Aimee Mullins, the (double amputee)-model-actress-olympian.  In her TED talk, she discussed how she went to present her prosthetic legs at a museum to a group of children. These children would be unsupervised by adults for the first two minutes of the presentation, where they would be free to poke and prod at the bag of prosthetic legs that Aimee brought for them to inspect.  Children came out of the experience without having the chance to have been affected by society’s pre conceived notions on amputees being disabled, and instead thought Aimee was lucky to be able to choose from 12 pairs of legs as she pleased.

The idea for this piece is to ultimately show non-amputees “what they’re missing out on” by not being able to use this robotic arm under other circumstances. What they are limited to because of the fact that they don’t quite have the opportunity to renegotiate a space on their body. With this piece people are given a glimpse as to what else is possible for that space on their body.

 

Materials

  • Metal Claw
  • servo motor
  • Lilypad Arduino board
  • lilypad LEDs
  • flex sensor
  • glove
  • metal bar for gripping
  • thimble
  • lithium ion battery
  • step-up breakout

Plan

  • create the circuit for the servo motor to be powered by the lilypad board via the step up breakout
  • mount the robotic claw to a T shaped metal bar
  • create flex-sensor glove
  • integrate everything together with a arm/wrist band that extends slightly past the hand*
  • Potentially anodize the claw to dye it an interesting colour

 

*