Tuesday, October 29, 2013

Wearable - Make and Where?

What kinds of Wearables can I make, what mediums can I use, and where can I go to show my work?

What kinds of things do I make?
sewing projects
wood work - birdhouses
floral arrangements
video
websites
photography
3D animation
painting
drawing
pottery
paper sculpture
jewelry crafting
baking
cooking
DIY projects

Where do I walk around?
mall
park
campus
work
library
running trail
apartment complex
store
downtown Rochester
downtown New Baltimore
movie theater
cidermill

Friday, October 25, 2013

Wearable Artists

Nick Cave

http://www.jackshainman.com/artist-images9.html

Rebecca Horn

Pencil Mask

http://anna-rebeccahorn.blogspot.com/2009/11/pencil-mask.html

Finger Gloves

http://www.medienkunstnetz.de/works/fingerhandschuhe/

Oskar Schlemmer

The Triadic Ballet

http://cosmicmachine.blogspot.com/2011/03/oskar-schlemmertriadic-ballet.html

Drawings and Costumes

http://thinkingform.com/2013/09/04/thinking-oskar-schlemmer-09-04-1888/

Krzysztof Wodiczko

Aegis: Equipment for a City of Strangers

http://www.artnet.com/magazine/features/saltz/saltz3-29-2.asp

Dis-Armor Project

http://cavs.mit.edu/artist/id.417-418.html

http://web.media.mit.edu/~monster/screambody/

See “Blendie” and “Scream Body”

“Long before implants, splicing, and cyborgs, people and machines co-evolved as companion species. Critical infoldings happen in the connections between people and machines, and my work in Machine Therapy investigates these engagements. The machines (some made by me, some found) have expressive engaging behaviors, strength of character, negotiative egos and neurotic propensities.”

(from media.mit.edu/~monster/ )

Hussein Chalayan

http://husseinchalayan.com/#/home/

Leigh Bowery

CV Dazzle, by Adam Harvey

Camouflage from face detection

http://ahprojects.com/projects/cv-dazzle

Tuesday, October 22, 2013

Servo Motor and the Flex Sensor

The code with explanation:

SparkFun Inventor's Kit

Example sketch 09

FLEX SENSOR

Use the "flex sensor" to change the position of a servo

In the previous sketch, we learned how to command a servo to

mode to different positions. In this sketch, we'll introduce

a new sensor, and use it to control the servo.

A flex sensor is a plastic strip with a conductive coating.

When the strip is straight, the coating will be a certain

resistance. When the strip is bent, the particles in the coating

get further apart, increasing the resistance. You can use this

sensor to sense finger movement in gloves, door hinges, stuffed

animals, etc. See http://www.sparkfun.com/tutorials/270 for

more information.

Hardware connections:

Flex sensor:

The flex sensor is the plastic strip with black stripes.

It senses bending away from the striped side.

The flex sensor has two pins, and since it's a resistor,

the pins are interchangable.

Connect one of the pins to ANALOG IN pin 0 on the Arduino.

Connect the same pin, through a 10K Ohm resistor (brown

black orange) to GND.

Connect the other pin to 5V.

Servo:

The servo has a cable attached to it with three wires.

Because the cable ends in a socket, you can use jumper wires

to connect between the Arduino and the servo. Just plug the

jumper wires directly into the socket.

Connect the RED wire (power) to 5 Volts (5V)

Connect the WHITE wire (signal) to digital pin 9

Connect the BLACK wire (ground) to ground (GND)

Note that servos can use a lot of power, which can cause your

Arduino to reset or behave erratically. If you're using large

servos or many of them, it's best to provide them with their

own separate 5V supply. See this Arduino Forum thread for info:

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1239464763

This sketch was written by SparkFun Electronics,

with lots of help from the Arduino community.

This code is completely free for any use.

Visit http://learn.sparkfun.com/products/2 for SIK information.

Visit http://www.arduino.cc to learn about the Arduino.

Version 2.0 6/2012 MDG

// Include the servo library to add servo-control functions:

#include <Servo.h>

// Create a servo "object", called servo1. Each servo object

// controls one servo (you can have a maximum of 12):

Servo servo1;

// Define the analog input pin to measure flex sensor position:

const int flexpin = 0;

void setup()

{

// Use the serial monitor window to help debug our sketch:

Serial.begin(9600);

// Enable control of a servo on pin 9:

servo1.attach(9);

}

void loop()

{

int flexposition; // Input value from the analog pin.

int servoposition; // Output value to the servo.

// Read the position of the flex sensor (0 to 1023):

flexposition = analogRead(flexpin);

// Because the voltage divider circuit only returns a portion

// of the 0-1023 range of analogRead(), we'll map() that range

// to the servo's range of 0 to 180 degrees. The flex sensors

// we use are usually in the 600-900 range:

servoposition = map(flexposition, 600, 900, 0, 180);

servoposition = constrain(servoposition, 0, 180);

// Now we'll command the servo to move to that position:

servo1.write(servoposition);

// Because every flex sensor has a slightly different resistance,

// the 600-900 range may not exactly cover the flex sensor's

// output. To help tune our program, we'll use the serial port to

// print out our values to the serial monitor window:

Serial.print("sensor: ");

Serial.print(flexposition);

Serial.print(" servo: ");

Serial.println(servoposition);

// Note that all of the above lines are "print" except for the

// last line which is "println". This puts everything on the

// same line, then sends a final carriage return to move to

// the next line.

// After you upload the sketch, turn on the serial monitor

// (the magnifying-glass icon to the right of the icon bar).

// You'll be able to see the sensor values. Bend the flex sensor

// and note its minimum and maximum values. If you replace the

// 600 and 900 in the map() function above, you'll exactly match

// the flex sensor's range with the servo's range.

delay(20); // wait 20ms between servo updates

}

Monday, October 21, 2013

Wearables

What functions do wearable technologies have?

Some different activities that wearables are either required when doing or chosen based on social norms include camping, business, carrying water or other supplies like groceries, school, military, religious events, privacy versus public.

Wearables change greatly in multi-cultural settings and when spanning time periods. Also there are many differences in fashion and function, though many times they are combined.

Wearables and Machines:

google glass
watches
cell phones
earphones
heart rate monitors
prosthetics
limbs, organs, skin, blood, biological components
animals, test tube, fetal cells
hybrid (machine and biology)

Proshetics:
(as technology art)

impractical or not useful
atypical
more difficult
something very specific or unusual, easier in a specific setting or with a specific person
private or personal
be made for someone specific
testing boundaries of the body
comentary

site - body
medium - technology
product - wearable

More examples:

shirts
shoes
pants
skirts
ties
belts
hats
gloves
scarves
rings
necklaces
earrings
jackets
sweaters
coats
socks
sandals
bandannas
purses
holsters
ponchos
undergarments
prosthetic
bracelets
boots
caste
glasses
contacts
hearing aids
masks

Tuesday, October 8, 2013

Separate Circuits

Six LEDs on separate circuits.

Code:

/*
SparkFun Inventor's Kit
Example sketch 04

MULTIPLE LEDs

Make eight LEDs dance. Dance LEDs, dance!

Hardware connections:

You'll need eight LEDs, and eight 330 Ohm resistors
(orange-orange-brown).

For each LED, connect the negative side (shorter leg)
to a 330 Ohm resistor.

Connect the other side of the resistors to GND.

Connect the positive side (longer leg) of the LEDs
to Arduino digital pins 2 through 9.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn about the Arduino.

Version 2.0 6/2012 MDG
*/

// To keep track of all the LED pins, we'll use an "array".
// An array lets you store a group of variables, and refer to them
// by their position, or "index". Here we're creating an array of
// eight integers, and initializing them to a set of values:

int ledPins[] = {2,3,4,5,6,7,8,9};

// The first element of an array is index 0.
// We've put the value "2" in index 0, "3" in index 1, etc.
// The final index in the above array is 7, which contains
// the value "9".

// We're using the values in this array to specify the pin numbers
// that the eight LEDs are connected to. LED 0 is connected to
// pin 2, LED 1 is connected to pin 3, etc.

void setup()
{
int index;

// In this sketch, we'll use "for() loops" to step variables from
// one value to another, and perform a set of instructions for
// each step. For() loops are a very handy way to get numbers to
// count up or down.

// Every for() loop has three statements separated by
// semicolons (;):

// 1. Something to do before starting
// 2. A test to perform; as long as it's true, keep looping
// 3. Something to do after each loop (increase a variable)

// For the for() loop below, these are the three statements:

// 1. index = 0; Before starting, make index = 0.
// 2. index <= 7; If index is less or equal to 7,
// run the following code.
// (When index = 8, continue with the sketch.)
// 3. index++ Putting "++" after a variable means
// "add one to it".
// (You can also use "index = index + 1".)

// Every time you go through the loop, the statements following
// the for() (within the brackets) will run.

// When the test in statement 2 is finally false, the sketch
// will continue.

// Here we'll use a for() loop to initialize all the LED pins
// to outputs. This is much easier than writing eight separate
// statements to do the same thing.

// This for() loop will make index = 0, then run the pinMode()
// statement within the brackets. It will then do the same thing
// for index = 2, index = 3, etc. all the way to index = 7.

for(index = 0; index <= 7; index++)
{
pinMode(ledPins[index],OUTPUT);
// ledPins[index] is replaced by the value in the array.
// For example, ledPins[0] is 2
}
}

void loop()
{
// This loop() calls functions that we've written further below.
// We've disabled some of these by commenting them out (putting
// "//" in front of them). To try different LED displays, remove
// the "//" in front of the ones you'd like to run, and add "//"
// in front of those you don't to comment out (and disable) those
// lines.

oneAfterAnotherNoLoop(); // Light up all the LEDs in turn

//oneAfterAnotherLoop(); // Same as oneAfterAnotherNoLoop,
// but with much less typing

//oneOnAtATime(); // Turn on one LED at a time,
// scrolling down the line

//pingPong(); // Light the LEDs middle to the edges

//marquee(); // Chase lights like you see on signs

//randomLED(); // Blink LEDs randomly
}

/*
oneAfterAnotherNoLoop()

This function will light one LED, delay for delayTime, then light
the next LED, and repeat until all the LEDs are on. It will then
turn them off in the reverse order.

This function does NOT use a for() loop. We've done it the hard way
to show you how much easier life can be when you use for() loops.
Take a look at oneAfterAnotherLoop() further down, which does
exactly the same thing with much less typing.
*/

void oneAfterAnotherNoLoop()
{
int delayTime = 100; // time (milliseconds) to pause between LEDs
// make this smaller for faster switching

// turn all the LEDs on:

digitalWrite(ledPins[0], HIGH); //Turns on LED #0 (pin 2)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[1], HIGH); //Turns on LED #1 (pin 3)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[2], HIGH); //Turns on LED #2 (pin 4)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[3], HIGH); //Turns on LED #3 (pin 5)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[4], HIGH); //Turns on LED #4 (pin 6)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[5], HIGH); //Turns on LED #5 (pin 7)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[6], HIGH); //Turns on LED #6 (pin 8)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[7], HIGH); //Turns on LED #7 (pin 9)
delay(delayTime); //wait delayTime milliseconds

// turn all the LEDs off:

digitalWrite(ledPins[7], LOW); //Turn off LED #7 (pin 9)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[6], LOW); //Turn off LED #6 (pin 8)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[5], LOW); //Turn off LED #5 (pin 7)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[4], LOW); //Turn off LED #4 (pin 6)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[3], LOW); //Turn off LED #3 (pin 5)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[2], LOW); //Turn off LED #2 (pin 4)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[1], LOW); //Turn off LED #1 (pin 3)
delay(delayTime); //wait delayTime milliseconds
digitalWrite(ledPins[0], LOW); //Turn off LED #0 (pin 2)
delay(delayTime); //wait delayTime milliseconds
}

/*
oneAfterAnotherLoop()

This function does exactly the same thing as oneAfterAnotherNoLoop(),
but it takes advantage of for() loops and the array to do it with
much less typing.
*/

void oneAfterAnotherLoop()
{
int index;
int delayTime = 100; // milliseconds to pause between LEDs
// make this smaller for faster switching

// Turn all the LEDs on:

// This for() loop will step index from 0 to 7
// (putting "++" after a variable means add one to it)
// and will then use digitalWrite() to turn that LED on.

for(index = 0; index <= 7; index++)
{
digitalWrite(ledPins[index], HIGH);
delay(delayTime);
}

// Turn all the LEDs off:

// This for() loop will step index from 7 to 0
// (putting "--" after a variable means subtract one from it)
// and will then use digitalWrite() to turn that LED off.

for(index = 7; index >= 0; index--)
{
digitalWrite(ledPins[index], LOW);
delay(delayTime);
}
}

/*
oneOnAtATime()

This function will step through the LEDs,
lighting only one at at time.
*/

void oneOnAtATime()
{
int index;
int delayTime = 100; // milliseconds to pause between LEDs
// make this smaller for faster switching

// step through the LEDs, from 0 to 7

for(index = 0; index <= 7; index++)
{
digitalWrite(ledPins[index], HIGH); // turn LED on
delay(delayTime); // pause to slow down
digitalWrite(ledPins[index], LOW); // turn LED off
}
}

/*
pingPong()

This function will step through the LEDs,
lighting one at at time in both directions.
*/

void pingPong()
{
int index;
int delayTime = 100; // milliseconds to pause between LEDs
// make this smaller for faster switching

// step through the LEDs, from 0 to 7

for(index = 0; index <= 7; index++)
{
digitalWrite(ledPins[index], HIGH); // turn LED on
delay(delayTime); // pause to slow down
digitalWrite(ledPins[index], LOW); // turn LED off
}

// step through the LEDs, from 7 to 0

for(index = 7; index >= 0; index--)
{
digitalWrite(ledPins[index], HIGH); // turn LED on
delay(delayTime); // pause to slow down
digitalWrite(ledPins[index], LOW); // turn LED off
}
}

/*
marquee()

This function will mimic "chase lights" like those around signs.
*/

void marquee()
{
int index;
int delayTime = 200; // milliseconds to pause between LEDs
// Make this smaller for faster switching

// Step through the first four LEDs
// (We'll light up one in the lower 4 and one in the upper 4)

for(index = 0; index <= 3; index++) // Step from 0 to 3
{
digitalWrite(ledPins[index], HIGH); // Turn a LED on
digitalWrite(ledPins[index+4], HIGH); // Skip four, and turn that LED on
delay(delayTime); // Pause to slow down the sequence
digitalWrite(ledPins[index], LOW); // Turn the LED off
digitalWrite(ledPins[index+4], LOW); // Skip four, and turn that LED off
}
}

/*
randomLED()

This function will turn on random LEDs. Can you modify it so it
also lights them for random times?
*/

void randomLED()
{
int index;
int delayTime;

// The random() function will return a semi-random number each
// time it is called. See http://arduino.cc/en/Reference/Random
// for tips on how to make random() even more random.

index = random(8); // pick a random number between 0 and 7
delayTime = 100;

digitalWrite(ledPins[index], HIGH); // turn LED on
delay(delayTime); // pause to slow down
digitalWrite(ledPins[index], LOW); // turn LED off
}

Technology and Nature

Why do you think artists working with advanced technologies often feel compelled and/or inspired to mimic nature or work in close collaboration with it? What are some of qualities of the inherent relationship between technology and nature?

I think that artists working with advanced technologies often feel compelled and/or inspired to mimic nature or work in close collaboration with it because nature is such a constant force in the world and always has been. Nature is old, full of mysteries and history. It is surrounded by myths and legends, and yet there are still new discoveries made in this age. Whereas technology is new, a foreigner of the future in where mankind is still learning of its potential and capacities. Nature has set rules in how things work and what limits it has. Technologies have these as well, however there true laws of how far it can be pushed is still not known. With advanced technologies there is such a large difference with its cold and maniacal quality whereas nature is organic and full of life. To combined them to make a hybrid or comparison of either there great differences or interesting similarities creates dynamic and fascinating concepts of work. It is an interesting thing that when using nature with technologies the outcome of the project can have either an abstract, organic or a precise and non-organic look or feel. One does not always dominate the other.

Some of qualities of the inherent relationship between technology and nature include the behaviors in which each have with their “environments”. For example, on a computer, moving a mouse on the screen is caused by many parts of both physical components as well as coding to receive the desired effect. On the other side of the same idea, in nature, a tree growing in a forest depends on the amount of sunlight, water it receives, and other conditions in which it is trying to thrive. Both nature and technology exist with a cause and effect relationship with its environment and other matter that comes in contact. When putting together nature with technologies it creates a new set of rules in which things can coincide to create the outcome the artist is attempting. Not only must each follow the cause and effect rules already in place, new rules much be created for them to work in unison. Which oddly work well together, of course there being issues with human error or the unpredictability of nature. But the fundamental constructs of nature and technology seem to go hand in hand as though they were always meant to. However, there is always the argument that nature shaped humans as we are, and humans created advanced technologies. Therefore humans influenced the fundamentals of technologies from our influences of nature. This may be where the connects in nature and technology originated.

Robotic Artists:

David Bowen

http://www.dwbowen.com/portfolio.html

Look at video of at least two or three of the following works:

growth rendering device

tele-present water

tele-present wind

swarm

fly tweet

Blyth Hazen and Jennifer Hall

Acupuncture for Temporal Fruit

http://www.dowhile.org/physical/projects/acupuncture/index.html

http://www.blythhazen.com/acupuncture.html

Alan Rath

Any three videos on http://www.alanrath.org/

U-Ram Choe

http://www.uram.net/eng_new/intro_en.html

2011 Custos Cavum

2009 Opertus Lunula Umbra

any examples from 2006 or 2007

Mark Malmberg

http://www.markmalmberg.com/mobiles2.0/index.html

Albireo 2010

Colleen Ludwig

www.colleenludwig.com

Shiver