Soundscape Headpiece

Concept/Objective

The creation of the soundscape headpiece is to translate visual information into sound through this synthesia-esq device. It is a comment on the individual’s relationship to the space through sound.

Research

Experience Research: Through the observation of my own experience within public space I have witnessed a number of individuals blasting their music as a form of escape from the space they inhabit, but one cannot truly escape the space and their music acts as a distraction from reality.

Text Research: Sensorium embodied experience, technology and contemporary art (Auditory Chapter by Michael Bull pg. 112-114)

Electronics Research: MP3 Player Shield  Tutorial by Bill Porter

Relatable Projects: Veasyble

 

Parts and Materials

(from left to right) 1- noise cancellation headphones   2- Arduino Duemilanove with Mp3 shield attached     3-Battery Pack     4-monoculars (taken from a fisher price binocular toy) 5- scuba goggles

(not shown below) 6- photocell  7- 10 K ohm resistor  8-wires  9- PCB board

                

Electronic Process

The first step was to figure out the innard workings of the device that I was going to create which involved getting to know the mp3 player shield. There were diagrams and codes on the spark fun website but I found this to be quite confusing jargon and just wanted the basics and found the tutorial by Bill Porter to be a lot more simplified in order to get the device working with what I essentially needed. One main part that I got confused with was how to import a library to the arduino program which is done by downloading the library on the site and making a libraries folder within the arduino program and then import all the files from the downloaded library into the folder made. This makes sure all the processing coding for the simplified coding is contained within the arduino program.

I attached the photocell to the monoculars to intensify the range of the photocell so it would act as a motion/proximity/light sensor all in one. I also created a small PCB board to host all the electronics that need to be attached to one another using rainbow wire to make it more compact and clean.

             

 

Once I found out how to use the mp3 player shield this was my first iteration of the code:

#include <SPI.h>
#include <SdFat.h>
#include <SdFatUtil.h>
#include <SFEMP3Shield.h>

SFEMP3Shield MP3player;

const int sensorPin = A0;

int SensorValue;

int sensorValue = 0;         // the sensor value
int sensorMin = 1023;        // minimum sensor value
int sensorMax = 0;           // maximum sensor value

int SensorRange;
int sensorsect;

void setup() {

Serial.begin(9600);
pinMode (sensorPin, INPUT);

//start the shield
MP3player.begin();

pinMode(13, OUTPUT);
digitalWrite(13, HIGH);
Serial.println(“calibrating…”);

// calibrate during the first five seconds
while (millis() < 5000) {
sensorValue = analogRead(sensorPin);

// record the maximum sensor value
if (sensorValue > sensorMax) {
sensorMax = sensorValue;
}

// record the minimum sensor value
if (sensorValue < sensorMin) {
sensorMin = sensorValue;
}
}

// signal the end of the calibration period
digitalWrite(13, LOW);
SensorRange = sensorMax-sensorMin;
sensorsect= SensorRange/3;
Serial.println(“calibration complete”);
}

//do something else now
void loop() {

SensorValue=analogRead(sensorPin);

if (sensorValue >= sensorMin && sensorValue <=sensorMin + sensorsect) {
MP3player.playTrack(1);
MP3player.stopTrack();
Serial.println(“playing track 1″);
}
else if (sensorValue >= sensorMin + sensorsect && sensorValue <= sensorsect*2) {
MP3player.playTrack(2);
Serial.println(“playing track 2″);
}

Serial.print(“Sensor Value: “);
Serial.print(sensorValue);
Serial.print(“, Sensor Min: “);
Serial.print(sensorMin);
Serial.print(“, Sensor Max: “);
Serial.print(sensorMax);
Serial.print(“, Sensor Range: “);
Serial.print(SensorRange);
Serial.print(“, Sensor Section: “);
Serial.println(sensorsect);
}

Fabrication Process

1- Once figuring out what components I needed to incorporate inside the headpiece I started to measure out a top, side and bottom view to get an idea of the shape I would need to encase all the electronics.

              

2- Once I got the dimensions for the shape I lamenated 5 1′ thick MDF (Medium-density fibreboard- which is compressed sawdust into a board form) together using wood glue and used clamps to keep it together. As part of the process I realized I did not incorporate the black part of the scuba goggles so I had to stack up 3 more pieces of MDF into the bottom shape and this time used one of the machines in the woodshop to compress the wood together. In the lamenation process I made sure to give at least 1-3 hours of wait time for the woodglue to dry. I drew and cut out the top and bottom view of the headpiece. I had to make sure I had straight edges when cutting on the bandsaw so when the top view was cut out I keep the cut out parts and attached it back together to cut the bottom of the headpiece so that it was easier and more accurate when being cut.

           

3- After lamentating and cutting the MDF it was time to sculpt the MDF and LOTs and LOTS of sanding!!

4- After having the basic shape of the dome shape I had to create a box to vaccuform the object to create the casing for all the electronic components. This was done by measuring out 4 inches from the object to create a thick enough border, and create a 2inch frame for the top of the box. the sides were measured into a rectangular shape of 8′ by 10′ which was big enough to encase the 7′ diameter vacuum.

     

5- in the next step I am creating a hole throughout the whole domed structure using a welding rod and drill so that when being vaccuformed I will be able to blow air through the object to get it out from the mold easily.

 

6- I will then vaccuform the object using 60 thou PET

7- once I have the hollowed shape of the form I will put the electronics inside and measure out the backside of the construction I will need to mold out of the MDF and vacuform once again.

8- I will create compartments for the electronics on the scuba goggles to fit inside and make any final adjustments.
Final Processing Process

The Helpless Wearable – Final Documentation

Concept and Objective

I wanted to create a wearable version of Norman Whites The Helpless Robot.  I wanted to try using conductive thread and try to solve the problem I faced in previous projects of making a speaker small but loud.

 

Research

http://www.year01.com/archive/helpless/

http://www.fashioningtech.com/profiles/blogs/conductive-thread-overview

 

Parts and Materials:
Gap Sweater
Conductive Thread
Speaker
Speaker Wire
Arduino Uno
3 AA Batteries
Mp3 Player Shield
Person
Tank Top

 

Code - 

/*
 4-28-2011
 Spark Fun Electronics 2011
 Nathan Seidle
 Mitch McGoey
 
 This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license).
 
 MP3 Player Example with control - this code monitors A0 through A5. If A0 is pulled low then track 1 plays.
 Same for A1 through A4. If A5 is pulled low then the track # simply advances.
 
 This code is heavily based on the MP3 Player Example code. Please be sure to review it for more comments and gotchas.
 
 While track is playing, Arduino scans to see if pins change. If pins change, stop playin track, check pins again to get 
 trigger # and then decide what new track to play.
 Mitch McGoey has messed around with Erics original code adjusting the volume controls as well as the loudness of the speaker attached.
He has also changed the pin values and timing so the file will play for a certain amount of time and reset when the switch is tripped.
 */

#include <SPI.h>

#define TRUE  0
#define FALSE  1

//Add the SdFat Libraries
#include <SdFat.h>
#include <SdFatUtil.h> 

//Create the variables to be used by SdFat Library
Sd2Card card;
SdVolume volume;
SdFile root;
SdFile track;

//This is the name of the file on the microSD card you would like to play
//Stick with normal 8.3 nomeclature. All lower-case works well.
//Note: you must name the tracks on the SD card with 001, 002, 003, etc. 
//For example, the code is expecting to play 'track002.mp3', not track2.mp3.
char trackName[] = "track001.mp3";
int trackNumber = 1;
int previousTrigger = 1; //This indicates that we've already triggered on 1

long lastCheck; //This stores the last millisecond since we had a trigger

char errorMsg[100]; //This is a generic array used for sprintf of error messages

int trigger0 = A0;
int trigger1 = A1;
int trigger2 = A2;
int trigger3 = A3;
int trigger4 = A4;
int trigger5 = A5;

//MP3 Player Shield pin mapping. See the schematic
#define MP3_XCS 6 //Control Chip Select Pin (for accessing SPI Control/Status registers)
#define MP3_XDCS 7 //Data Chip Select / BSYNC Pin
#define MP3_DREQ 2 //Data Request Pin: Player asks for more data
#define MP3_RESET 8 //Reset is active low
//Remember you have to edit the Sd2PinMap.h of the sdfatlib library to correct control the SD card.

//VS10xx SCI Registers
#define SCI_MODE 0x00
#define SCI_STATUS 0x01
#define SCI_BASS 0x02
#define SCI_CLOCKF 0x03
#define SCI_DECODE_TIME 0x04
#define SCI_AUDATA 0x05
#define SCI_WRAM 0x06
#define SCI_WRAMADDR 0x07
#define SCI_HDAT0 0x08
#define SCI_HDAT1 0x09
#define SCI_AIADDR 0x0A
#define SCI_VOL 0x0B
#define SCI_AICTRL0 0x0C
#define SCI_AICTRL1 0x0D
#define SCI_AICTRL2 0x0E
#define SCI_AICTRL3 0x0F

void setup() {
  //Setup the triggers as inputs
  pinMode(trigger0, INPUT);
  pinMode(trigger1, INPUT);
  pinMode(trigger2, INPUT);
  pinMode(trigger3, INPUT);
  pinMode(trigger4, INPUT);
  pinMode(trigger5, INPUT);

  //Enable pullups on triggers
  digitalWrite(trigger0, HIGH);
  digitalWrite(trigger1, HIGH);
  digitalWrite(trigger2, HIGH);
  digitalWrite(trigger3, HIGH);
  digitalWrite(trigger4, HIGH);
  digitalWrite(trigger5, HIGH);

  pinMode(MP3_DREQ, INPUT);
  pinMode(MP3_XCS, OUTPUT);
  pinMode(MP3_XDCS, OUTPUT);
  pinMode(MP3_RESET, OUTPUT);

  digitalWrite(MP3_XCS, HIGH); //Deselect Control
  digitalWrite(MP3_XDCS, HIGH); //Deselect Data
  digitalWrite(MP3_RESET, LOW); //Put VS1053 into hardware reset

  Serial.begin(57600); //Use serial for debugging 
  Serial.println("MP3 Player Example using Control");

  //Setup SD card interface
  pinMode(10, OUTPUT);       //Pin 10 must be set as an output for the SD communication to work.
  if (!card.init(SPI_FULL_SPEED))  Serial.println("Error: Card init"); //Initialize the SD card and configure the I/O pins.
  if (!volume.init(&card)) Serial.println("Error: Volume ini"); //Initialize a volume on the SD card.
  if (!root.openRoot(&volume)) Serial.println("Error: Opening root"); //Open the root directory in the volume. 

  //We have no need to setup SPI for VS1053 because this has already been done by the SDfatlib

  //From page 12 of datasheet, max SCI reads are CLKI/7. Input clock is 12.288MHz. 
  //Internal clock multiplier is 1.0x after power up. 
  //Therefore, max SPI speed is 1.75MHz. We will use 1MHz to be safe.
  SPI.setClockDivider(SPI_CLOCK_DIV16); //Set SPI bus speed to 1MHz (16MHz / 16 = 1MHz)
  SPI.transfer(0xFF); //Throw a dummy byte at the bus

  //Initialize VS1053 chip 
  delay(10);
  digitalWrite(MP3_RESET, HIGH); //Bring up VS1053

  Mp3SetVolume(01, 01); //Set initial volume (20 = -10dB) LOUD
  //Mp3SetVolume(40, 40); //Set initial volume (20 = -10dB) Manageable
  //Mp3SetVolume(80, 80); //Set initial volume (20 = -10dB) More quiet

  //Now that we have the VS1053 up and running, increase the internal clock multiplier and up our SPI rate
  Mp3WriteRegister(SCI_CLOCKF, 0x60, 0x00); //Set multiplier to 3.0x

  //From page 12 of datasheet, max SCI reads are CLKI/7. Input clock is 12.288MHz. 
  //Internal clock multiplier is now 3x.
  //Therefore, max SPI speed is 5MHz. 4MHz will be safe.
  SPI.setClockDivider(SPI_CLOCK_DIV4); //Set SPI bus speed to 4MHz (16MHz / 4 = 4MHz)

  //MP3 IC setup complete

  trackNumber = 1; //Setup to play track001 by default

  previousTrigger = 255; //Setup the new vs old trigger
}

void loop(){
  //Let's look for a trigger activation
  int triggerNumber = 255;

  while(triggerNumber == 255) triggerNumber = checkTriggers(); //Wait for a trigger to be activated

  if(triggerNumber == 5) trackNumber++; //Simply advance the track
  if(trackNumber > 10) trackNumber = 1; //Loop tracks

  if(triggerNumber == 0) trackNumber = 1; //Play a certain track
  if(triggerNumber == 1) trackNumber = 2;
  if(triggerNumber == 2) trackNumber = 3;
  if(triggerNumber == 3) trackNumber = 4;
  if(triggerNumber == 4) trackNumber = 5;

  //Let's play a track of a given number
  sprintf(trackName, "track%03d.mp3", trackNumber); //Splice the new file number into this file name
  playMP3(trackName); //Go play trackXXX.mp3
}

//checkTriggers checks the level of the various inputs
//It returns 255 if no trigger is activated
//Otherwise, it returns the number of the first trigger it sees
int checkTriggers(void) {

#define DEBOUNCE  100

  int foundTrigger = 255;
/*
  //Once a trigger is activated, we don't want to trigger on it perpetually
  //But after 3 seconds, reset the previous trigger number
  if( (previousTrigger != 255) && (millis() - lastCheck) > 3000) {
    lastCheck = millis();
    previousTrigger = 255;
    Serial.println("Previous trigger reset");
  }
  */

  //Debounce button, then check again
  if(digitalRead(trigger0) == HIGH){ 
    delay(DEBOUNCE); 
    if(digitalRead(trigger0) == HIGH) foundTrigger = 0;
  }
  else if(digitalRead(trigger1) == HIGH ){ 
    delay(DEBOUNCE); 
    if(digitalRead(trigger1) == HIGH) foundTrigger = 1;
  }
  else if(digitalRead(trigger2) == HIGH){ 
    delay(DEBOUNCE); 
    if(digitalRead(trigger2) == HIGH) foundTrigger = 2;
  }
  else if(digitalRead(trigger3) == HIGH){ 
    delay(DEBOUNCE); 
    if(digitalRead(trigger3) == HIGH) foundTrigger = 3;
  }
  else if(digitalRead(trigger4) == HIGH){ 
    delay(DEBOUNCE); 
    if(digitalRead(trigger4) == HIGH) foundTrigger = 4;
  }
  else if(digitalRead(trigger5) == HIGH){ 
    delay(DEBOUNCE); 
    if(digitalRead(trigger5) == HIGH) foundTrigger = 5;
  }

  if(foundTrigger != previousTrigger){ //We've got a new trigger!
    previousTrigger = foundTrigger; 

    Serial.print("T");
    Serial.println(foundTrigger, DEC);

    return(foundTrigger);
  }
  else
    return(255); //No triggers pulled low (activated)
}

//PlayMP3 plays a given file name
//It pulls 32 byte chunks from the SD card and throws them at the VS1053
//We monitor the DREQ (data request pin). If it goes low then we determine if
//we need new data or not. If yes, pull new from SD card. Then throw the data
//at the VS1053 until it is full.
void playMP3(char* fileName) {

  if (!track.open(&root, fileName, O_READ)) { //Open the file in read mode.
    sprintf(errorMsg, "Failed to open %s", fileName);
    Serial.println(errorMsg);
    return;
  }

  sprintf(errorMsg, "Playing track %s", fileName);
  Serial.println(errorMsg);

  uint8_t mp3DataBuffer[32]; //Buffer of 32 bytes. VS1053 can take 32 bytes at a go.
  int need_data = TRUE; 

  while(1) {
    while(!digitalRead(MP3_DREQ)) { 
      //DREQ is low while the receive buffer is full
      //You can do something else here, the buffer of the MP3 is full and happy.
      //Maybe set the volume or test to see how much we can delay before we hear audible glitches

      //If the MP3 IC is happy, but we need to read new data from the SD, now is a great time to do so
      if(need_data == TRUE) {
        if(!track.read(mp3DataBuffer, sizeof(mp3DataBuffer))) { //Try reading 32 new bytes of the song
          //Oh no! There is no data left to read!
          //Time to exit
          break;
        }
        need_data = FALSE;
      }

      //Check to see if we need to bail on this track
      if(checkTriggers() != 255) { 
        Serial.println("Exiting MP3!");
        track.close(); //Close this track!
        previousTrigger = 255; //Trick the next check into thinking we haven't seen a previous trigger
        return;
      }
    }

    if(need_data == TRUE){ //This is here in case we haven't had any free time to load new data
      if(!track.read(mp3DataBuffer, sizeof(mp3DataBuffer))) { //Go out to SD card and try reading 32 new bytes of the song
        //Oh no! There is no data left to read!
        //Time to exit
        break;
      }
      need_data = FALSE;
    }

    //Once DREQ is released (high) we now feed 32 bytes of data to the VS1053 from our SD read buffer
    digitalWrite(MP3_XDCS, LOW); //Select Data
    for(int y = 0 ; y < sizeof(mp3DataBuffer) ; y++)
      SPI.transfer(mp3DataBuffer[y]); // Send SPI byte

    digitalWrite(MP3_XDCS, HIGH); //Deselect Data
    need_data = TRUE; //We've just dumped 32 bytes into VS1053 so our SD read buffer is empty. Set flag so we go get more data
  }

  while(!digitalRead(MP3_DREQ)) ; //Wait for DREQ to go high indicating transfer is complete
  digitalWrite(MP3_XDCS, HIGH); //Deselect Data

  track.close(); //Close out this track

  sprintf(errorMsg, "Track %s done!", fileName);
  Serial.println(errorMsg);
}
















Final project – Toothbrush game

Design objectives:

to entertain user;

to enrich the brushing teeth user experience;

to indicate the time and certain area in the mouth while brushing teeth

to make tooth brush interactive;

to encourage user to protect their teeth well.

Concept: This is a game with a daily life product- tooth brush. We need to brush teeth every day to keep it healthy. From the dentist’s advise, 2 mins should be the best time for tooth brushing, but rarely people do that, because it’s really a boring process- just doing the mechanical movement” up and down” for 2 whole minute, it’s boring , isn’t it ? Then this toothbrush game comes, the user need to brush their teeth in the certain time and zone using their tooth brush to kill the bad bacteria in the mouth. Brushing teeth and playing game can be in same time, make life fun.

process: The detecting position of the tooth brush is the most challenging point in the process. At begining, I was trying to use accelerometer to detect the position, but after testing the different sensors, turned out it only can give different value while moving faster or slower, it’s not showing the position at all. Then I change the idea to use the specific color with webcamera to detect position, which is not accurate but possible to achieve for me with this time and my limited ability. Instead, I use accelerometer to doing the clicking funciton, that is, user need to shake hard enough in order to kill the enemy where brush meets it.

below shows the physical part design process.

at first I thinked about to use nature clay then bake it, but since the color is not pretty, and oven in school is hard to book, I use the paper clay instead.

this is the prototype I made with paper clay. It’s really easy to mould. When it’s still wet, the surface is quite smooth, but when it’s getting dry, there starts to appear alot of fissures on the surface, then I gave up the idea of using this material. Then I bought a new clay which can self-harden. There’re two parts of that, they need to be mixed together and can be mould. It smell so bad actually.

Comparing to the nature clay and paper clay, this one is harder, I put the arduino in it to measure the space for it. Leave a little stick at top to  stick in the brush top which is changable. Then wait it for couple of hours till it’s becoming hard, then shape it with knife, and smooth the outside surface.


I use the same material to build the base of the tooth brush, which is a old guy with few hair. Becaue he’s old and becoming bald. But he’s proud of his healthy teeth, so he like to show off his big teeth.

for the screen of projection, I use the fence from garden, which is foldable, then stick 2 layers at top, to make it a suitable size for pico projector.

character design for the game

processing code

Arduino code – standard firmata

Process on going: Refine the shape, play with Xbee, think of better projection method & detecting way, enrich game content.

Final Project Documentation

Project Title: Neck/ Ankle Movement Inhibiter

Concept/ Objective:

Throughout the exploration of my body of work, I have considered the relationships that occur between our bodies and technology; and have questioned whether or not this unnatural assimilation has been something that is more beneficial, or consequential.

When considering the notion of assimilation, and bringing it to some sort of physical representation, I thought about creating a wearable device that didn’t really have any clear purpose, beyond being strapped along side the body and being able to conform it’s movements to the body’s. This fusion between these two variables creates a conjoinment that is based upon some form of dependency; the human body is unable to transform without the object, and the object is unable to come alive without the body that hosts it.

 

Intended Scenario:

I wish for the wearer to intervene within a public space, and experiment with how the viewer(s) interact with an individual. The viewers may be attracted to the idea of investigating this hybrid being, to better understand what has happened to this body, and the purpose of its existence. On the other hand, they may regard the individual as someone who is burdened and humiliated by this device, and potentially feel the desire to avoid this person’s presence, not having the performer’s reputation taint how the rest of the world perceive the viewer, through associate.

 

Parts/ Materials:

  1. Acrylic Cuffs: These parts wrap around specific body parts (ankle/ neck), and are meant to bridge the body with the full piece.
  1. Wooden Ligaments: These are long sections that are fabricated and based on human anatomical design.
  1. Springs: These provide resistance to the movement of the piece.

 

 

Challenges:

By making an apparatus that is made of materials (wood/plastic) that are meant to fuse to the body, the main challenge was for it to imitate its natural movements through its unnatural design.

 

Through the times that the work’s wearability was tested, there were instances where the piece wasn’t supported properly by the body the way I had envisioned it; the length of the parts and the weight of the wood were problematic variables that made the piece drag on the floor in attempt to maneuver through space in it. This also created discomforting points of pressure on specific areas of the wearer.

The rigidity and density of the materiality of the work made for it to be more difficult than intended to explore a flexible range in movements, beyond stepping forward and backward.

 

Successes:

The experience for the viewer, by witnessing the work being worn by someone, was re-enforced by the sounds the springs made. This gave the piece a sound element that allowed for this flesh-to-flesh experience to become multi-sensory.

Prototype in motion:

IMG_4853-1

Social Reactive Cap documentation

 

Concept: http://blog.ocad.ca/wordpress/gdes3b44-fw2011-01/2012/03/social-reactive-cap/

 

Process:

Ideation:

 

 

 

 

 

 

After exploring different ways of how the hat/cap would mechanically work and different choices of existing hat/cap types and invented designs, I chose to use a normal cap plus a relatively hidden mechanism design mainly because this way people wouldn’t easily tell it’s a special cap and expect it to do unusual things, thereby experiencing the concept with more surprise and authenticity.

 

Code:

#include <Servo.h>  //includes all info in the universal servo library

Servo myservo;  // create servo object to control the servo(s)

int sensorValue; //includes the sensor

void setup() {

myservo.attach(9);  // attaches the servo(s) on pin 9 to the servo object

}

void loop() {

int sensorValue = analogRead(A0);  // sensor connected to analog 0

if (sensorValue < 150){
myservo.write(0);
delay(200);
}

if (sensorValue > 150 && sensorValue < 300){
myservo.write(45);
delay(200);
}

if (sensorValue > 300){
myservo.write(90);
delay(200);
}

}

Code reference sources:

http://arduino.cc/en/Tutorial/Knob

http://blog.ocad.ca/wordpress/gdes3b44-fw2010-01/2011/04/badass-enhancing-social-alienation/

 

Physical:

 

 

 

 

 

 

To be updated upon finishing the final cap.

Laced Up Leather

Aiming for a seamless pairing of ornamentation and utility, Laced Up Leather uses a laser cutter to translate a DFX file into physical reality. Lace was traditionally precious due to the laborious process of creation. Using a laser cutter to quickly create complex patterns allows for lacework to be integrated into utilitarian objects. The Laced Up Leather belt combines feminine ornament with functionality, which is often absent from women’s wear. Designed to be economical and reproducible, the pattern fits into a 17×23 inch rectangle with less than four square inches of waste.

When I set out to create this work, I wanted to learn how to use Adobe Illustrator to design a pattern to be laser cut, and learn how to use the laser cutter. I wanted to create a piece that could be reproduced by other people who have access to these tools, but unfortunately that aspect of the work never got resolved. The feedback I received from those I asked about the work were weary about the ability of other users to produce this product. I do hope to resolve this aspect eventually, but as of right now I do not have a working tutorial.

This piece is intended to be durable enough for everyday wear, and has held up well so far. The inclusion of nylon webbing in the final iteration has helped to combat the natural stretch of the leather, but in future versions I will use interfacing on the back sections of the belt to stabilize the material there as well.

This is the pattern, altered slightly for visibility and clarity, that makes up the belt. Because the laser does not remove material, and the leather does not fray, the pattern pieces can be right up next to one another.

Materials:

  • leather, 19×23
  • nylon webbing, 3/4 inch, 24 inches
  • snaps, 3
  • grommets, 7
  • belt buckle, 2 inches wide
  • thread
  • industrial sewing machine
  • laser cutter, bed size at least 18×24 inches

Once the leather is cut, the pieces are all sewn together on an industrial sewing machine. Hardware is then installed, which I bought at the leather shop at Queen and Cameron. The only thing beyond what was in the kit that I needed was a hammer. I have a hammer.

When I began prototyping, I had a pretty good idea of what I wanted in my mind. So I cut a piece of canvas that was 18×24, the size of the laser cutter I would be working with and started sketching a pattern. I had worked with leather in the past, so I anticipated the stretchiness factor. To combat this, my original plan was a one inch fold at the top of the piece, and doubled leather for the rear section. This gave me a general idea of where things should go, and I started plotting on illustrator to create my layout. At the same time, I was tracing a sketch for the lace pattern from my sketchbook. This was maybe the most difficult part of the project for me, even though I chose to keep the design as simple as possible. I have a long way to go with illustrator, but my basic knowledge carried me through.

Once I had the file all figured out, I was ready to try it. I took my laptop and a USB stick over to Site3, and in my first evening managed to sample cutting on leather a little bit as well as make a fabric prototype.

This prototype really exposed what the problems were in my design including weak spots in the lace pattern, and design issues in the overall piece. I was able to integrate them into my illustrator file, creating a more refined layout. I then laser cut the design again, this time in leather and created a third prototype. I wore this belt every day for about a week, and once again design flaws became evident. The leather was too thin, the pocket was creating stress where it was snapped to the belt and it was hard to access my keys. The belt was too long for my body, even at the widest point of my hips, by nearly 10 inches. When I redesigned to solve these problems, I removed 6 inches from the diameter of the belt to create flaps that would be sewn onto the back of the pocket. This allows the pocket to slip on and off from the belt. I added a new piece, made out of leather that was disused in the previous pattern that would function as a key holder.

I really appreciated having so long to iterate this project. There were challenges every step of the way but with the luxury of time, a challenge is interesting and exciting instead of a reason to tear out your hair. I am proud of this project, I think it successfully achieves the majority of the goals I had set out for myself. That being said, rarely do I prototype so effectively, and the success of this piece is only because of the flaws of the ones that came before it.

I am interested in the possibility of manufacturing this as a product. It’s been a long (long, long, long) standing goal of mine to run a small business, but I never produced anything that would be particularly commercially viable. But I think I have finally developed something that is reproducible enough to manufacture with relative ease.

There are myriad examples of nifty utility belts and laser cut fashions. I have never seen them together, as of yet, making me feel innovative (even if I just jammed two ideas together).