Showing posts with label Erin Curry. Show all posts
Showing posts with label Erin Curry. Show all posts

Wednesday, December 12, 2012

Erin | Final Project Statement

This work addresses concepts surrounding(mis)navigation, presence and absence, and transformation from one state to the next. Through the gesture of lighting a match and holding it above a lens, a sequence of panels containing drawn moth carcasses appear and dissolve behind the panes of a window ending in dust. This gesture and the context of an altar-like experience intends to evoke connotations of investigation, ritual, memorial, and passage. The moths depicted are all found and collected as a result of their attraction to light.


I’m most interested in poetic intersections:
• Why do humans and moths share an attraction to flame and light especially in darkness?
• Can the illumination 
• How does the act of lighting a match to reveal a narrative of dissolution involve us in an act of immolation as defined as (1) to kill as a sacrifice, (2) to kill (oneself) by fire, and (3) to destroy? 
• Can the moth's attraction to flame be an effective metaphor for our need to investigate mystery?
• Can this work serve to evoke scientific as well as spiritual investigation?
• Does investigation of this nature help or hinder our individual journeys?
• I'm borrowing a bit from comic conventions as well by using the window panes as panel sequences. There is a story to be told. What are the viewer's limitations both in terms of attention and the span of a burning match threatening to burn oneself?

Though the work functions well enough now there are several points that need fine tuning. 

1. Affordance: The class was primed to know how to approach the work, but others who I’ve had interact with the work are not. How can I better indicate an affordance? Two things I’m considering is using a larger lens and creating a shield around it which will help direct people and the matchlight more appropriately. The lens is more compelling than a candle though I'm a little wary of pushing the precious altar-ness too much. Can an empty jar work better? Should I indicate there is an end to reach? What might be the possible solutions? 

2. Light quality: Something both Orlando and Katerie pointed out was the light has a sense of lightening bugs rather than moth associated flame. I’m seeking to hack warm light LEDs from Xmas lights and changing the code to flicker more. It’s requiring a bit of stare time as I find the slower fade more contemplative and I'm not yet convinced flickery-ness isn't too distracting and slow for the length of the match. 

3. Presentation of the work: How to light a work that needs darkness to perform, but is still formally important? This is my greatest concern at the moment. Should the floor of the work be lit? Should I shade the gallery lighting so the window is only in shadow? Should the spotlight be replaced with a lower wattage?

4. Construction: Still haven’t fully embraced whether I should hide the light sensor wire or embrace it by extending it looped on the floor2. The level of surprise of the newly initiated is pretty satisfying, so I’m considering letting it be magic. 

4. Working Title: Navigate/Immolate  (directive, definitive)

Previous related work:
A number of years ago I made a series of fragmented drawings of insects drawn to my porch by light where they found their death. 

Progression to the next work:
I’m considering making a moth light trap trap and drawing the silhouettes of the moths that land on it. 







This will be documented properly over the break. 

Erin | process
















Tuesday, December 4, 2012

Erin | led and light sensor code evolution



basic code to make the led come on when light sensor senses above a certain range and off when not. 


//Final Project Light Sensor to turn on led - working to turn light on or off
//To Do
// 1. make the light glowy (PWM)
// 2. make more (groups of) lights glowy at intervals (preferably at random)
// 3. (if time) make the  if (ldr) sensitivity connected to a potentiometer for ease in installation
// 4. (if time) make the led brightnesses on potentiometer as well.

int ledPin = 9;  // led pin on 9
int ldrPin = 0;   // LDR on Analog Pin 0
int ldrValue = 0;  // Value read from the LDR
float sinVal;
int ledVal;

#define DEBOUNCE 5  // button debouncer


void setup() {
  // nothing to do here
  pinMode(ledPin,OUTPUT);
  pinMode(ldrPin,INPUT);
Serial.begin(9600);
Serial.flush();

}

void loop() {
   ldrValue = analogRead(ldrPin); // read the value from the LDR
        Serial.println(ldrValue);
        // tone(ledPin,1000); // play a 1000Hz tone from the piezo
        delay(500);  // wait a bit
        //digitalWrite(ledPin, LOW);
        if (ldrValue <= 250) {
          digitalWrite(ledPin, HIGH); //turn led on
        }
        else {
          digitalWrite(ledPin, LOW);//turn led off
        delay(25);
      }
}

________
now trying to achieve some of the goals listed above including fade. 
So far I've tried two kinds, but can't seem to make it fade in and hold when sensor is triggered and fade out and hold when sensor is not getting enough light. 

//Final Project Light Sensor to fade in led - this code fades in and out until no light reaches the lightsensor

int ledPin = 9;  // led on Pin 9
int ldrPin = 0;   // LDR on Analog Pin 0
int ldrValue = 0;  // Value read from the LDR
float sinVal;
int ledVal;

#define DEBOUNCE 5  // button debouncer


void setup() {
  // nothing to do here
  pinMode(ledPin,OUTPUT);
  pinMode(ldrPin,INPUT);
Serial.begin(9600);
Serial.flush();

}

void loop() {
   ldrValue = analogRead(ldrPin); // read the value from the LDR
        Serial.println(ldrValue);
        // wait a bit
        
        if (ldrValue <= 250) {
          for (int x=0; x<180; x++){
        // convert degrees to radians then obtain sin value
        sinVal = (sin(x*(3.1412/180)));
        ledVal = int(sinVal*255);
        analogWrite(ledPin, ledVal);
        delay(25);
       
        //digitalWrite(ledPin, HIGH); //turn led on
        }}
        else {
          digitalWrite(ledPin, LOW);//turn led off
        // delay(25);
      }
}





_________________________
Another approach

//Final Project Light Sensor to turn on led - working to fade light on or off
// using arduino fade tutorial http://arduino.cc/en/Tutorial/Fade
// it's 
int ledPin = 9;  // led on Pin 9
int ldrPin = 0;   // LDR on Analog Pin 0
int ldrValue = 0;  // Value read from the LDR

int brightness = 0;     // how bright the LED is
int dimness = 0;
int fadeAmount = 1;    // how many points to fade the LED by

#define DEBOUNCE 5  // button debouncer


void setup() {
  pinMode(ledPin,OUTPUT);
  pinMode(ldrPin,INPUT);
Serial.begin(9600);
Serial.flush();
}

void loop() {
   ldrValue = analogRead(ldrPin); // read the value from the LDR
        Serial.println(ldrValue);
                    
        if (ldrValue <= 250) {
          analogWrite(ledPin, brightness);
            brightness = brightness + fadeAmount;

              
        }
        else {
          digitalWrite(ledPin, LOW); //turn off light immediately
         // this bit of code i've cut out with //s is weird 
         // because if the sensor recieves too little light 
         // the led stays where it was the moment the sensor was covered
         
         // analogWrite(ledPin, brightness); 
         // brightness = brightness - fadeAmount;

         //(brightness == 0 || brightness == 255);{
        
        //fadeAmount = -fadeAmount ; 
       //  }
        
        delay(30);
      
   }}

__________
This is my back up code. It is not ideal. 

//Final Project Light Sensor  
// working to turn lights on or off in sequence when ldr is triggered and off after the sequence completes if the ldr is not triggered
// 3. (if time) make the  if ldr sensitivity connected to a potentiometer for ease in installation
// 4. (if time) make the led brightnesses on potentiometer as well.

int ledPin1 = 11;  // led Pin 9
int ledPin2 = 10;
int ledPin3 = 9;
int ledPin4 = 6;
int ledPin5 = 5;
int ledPin6 = 3;
int ldrPin = 0;   // LDR on Analog Pin 0
int ldrValue = 0;  // Value read from the LDR
float sinVal;
int ledVal;

#define DEBOUNCE 5  // button debouncer ?? I don't know if this is doing anything. 


void setup() {
  pinMode(ledPin1,OUTPUT);
  pinMode(ledPin2,OUTPUT);
  pinMode(ledPin3,OUTPUT);
  pinMode(ledPin4,OUTPUT);
  pinMode(ledPin5,OUTPUT);
  pinMode(ledPin6,OUTPUT);

  pinMode(ldrPin,INPUT);
Serial.begin(9600);   // helpful to see how much light the sensor is reading
Serial.flush();

}

void loop() {
   ldrValue = analogRead(ldrPin); // read the value from the LDR
        Serial.println(ldrValue);
        delay(25);  // wait a bit to slow down the reading
        
        if (ldrValue <= 250) {  // if time is left at the end, I would like this sensitivity to be determined by a potentiometer
          // * I would prefer to have the lights glow on and off in sequence. 
          // ** and would like the sequence to only run once. 
          // *** and stop if the ldr sensor is not getting enough light sensitivity
          digitalWrite(ledPin1, HIGH); //turn led on
          delay(500);
          digitalWrite(ledPin1, LOW); //turn led on
          delay(100);
          digitalWrite(ledPin2, HIGH); //turn led on
          delay(400);
          digitalWrite(ledPin3, HIGH); //turn led on
          delay(100);
          digitalWrite(ledPin2, LOW); //turn led on
          digitalWrite(ledPin3, LOW); //turn led on
           digitalWrite(ledPin4, HIGH); //turn led on
          delay(500);
          digitalWrite(ledPin4, LOW); //turn led on
          delay(100);
          digitalWrite(ledPin5, HIGH); //turn led on
          delay(1000);
          digitalWrite(ledPin5, LOW); //turn led on
          delay(100);

        }
        else {
          digitalWrite(ledPin1, LOW);//turn led off
        delay(25);
      }
}






________________________
This is using an array and fade. 
/*
  This Code was written to sequence the PWM pins
  on an Arduino. In this was the LEDs will fade on
  and off one after the next.
  
  There should be an LED attached with resistor form
  each PWM pin to Ground
  
  Code written by:
  Dan Joyce and Lauren Stec
  
  addition of ldr sensor by Erin Curry
*/

//Declares PMW ports in an array named woot
int woot[] = {3,5,6,9,10,11};                                            
int ldrPin = 0;   // LDR on Analog Pin 0
int ldrValue = 0;  // Value read from the LDR

void setup()                                                        
{
pinMode(ldrPin,INPUT);
Serial.begin(9600);
Serial.flush();
 

}

void loop ()
{
     ldrValue = analogRead(ldrPin); // read the value from the LDR
     Serial.println(ldrValue);
     delay(10); 
   {if (ldrValue <= 250) 
       {
  //for loop. "x" declares the position of the integers listed in the array (6 positions).
  for(int x = 0; x <= 5; x++)    
  {
    //for loop. declares fade-in setting (0-255)
    for(int value = 0; value <= 255; value+=5)                   
    {
      //Calls for the PWM pin as listed in the array and performs an analogWrite.
      analogWrite(woot[x], value);                                
     delay(30);
       //   
    }
    for (int value = 255; value>= 0; value-=5)        
    {
      analogWrite(woot[x], value);        
      delay(30); 
    }
  }}}}

   // else {
     // for(int x = 0; x <= 5; x++)   
      //analogWrite(woot[x],LOW);
 


This is modified to allow more direct fade adjustment. 
/*
  This Code was written to sequence the PWM pins
  on an Arduino. In this was the LEDs will fade on
  and off one after the next.
  
  There should be an LED attached with resistor form
  each PWM pin to Ground
  
  initial Code written by:
  Dan Joyce and Lauren Stec
  
  addition of ldr sensor by Erin Curry
  I've also removed the array to allow each pin to be called one by one. 
  (I know it's not efficent this way, but I'm able to see exactly which light is called AND 
  change the rate of fade to be specific for each led by changing the delay 
  which allows me to have some drawings lit longer than others and would allow change the tempo of reading.)
  I've also added a call to read the light sensor before moving onto the next light
  this code interrupts the light, but not the sequence, for example if the "candlelight" 
  source goes out and then back on the led sequence picks up where it would have been without any interruption. 
  [i.e. skipping led2 and 3 and picking up at 4.]
 This is not what I'm looking for. 
 I want the sensor to be read continually (or even between each led lighting up) and
 if the ldr doesn't sense enough light, the sequence should stop.
 When enough light is sensed again the sequence should start from the beginning. 
 
  
*/

int ledPin1 = 11;  // led Pin 9
int ledPin2 = 10;
int ledPin3 = 9;
int ledPin4 = 6;
int ledPin5 = 5;
int ledPin6 = 3;                                          
int ldrPin = 0;   // LDR on Analog Pin 0
int ldrValue = 0;  // Value read from the LDR

void setup()                                                        
{
pinMode(ldrPin,INPUT);
Serial.begin(9600);
Serial.flush();
 

}

void loop ()
{
     ldrValue = analogRead(ldrPin); // read the value from the LDR
     Serial.println(ldrValue);
     delay(10); 
   {if (ldrValue <= 250) //condition to be met can be altered here.
       {
 
  {
    //for loop. declares fade-in setting (0-255)
    for(int value = 0; value <= 255; value+=5)                   
    {
      //Calls for the PWM pin as listed in the array and performs an analogWrite.
      analogWrite(ledPin1, value);                                
     delay(30);
       //   
    }
    for (int value = 255; value>= 0; value-=5)        
    {
      analogWrite(ledPin1, value);        
      delay(30); 
    }
  }}}

 ldrValue = analogRead(ldrPin); // read the value from the LDR
     Serial.println(ldrValue);
     delay(10); 
   {if (ldrValue <= 250) 
       {
  //for loop. "x" declares the position of the integers listed in the array (6 positions).
  //for(int x = 0; x <= 5; x++)    
  {
    //for loop. declares fade-in setting (0-255)
    for(int value = 0; value <= 255; value+=5)                   
    {
      //Calls for the PWM pin as listed in the array and performs an analogWrite.
      analogWrite(ledPin2, value);                                
     delay(30);
       //   
    }
    for (int value = 255; value>= 0; value-=5)        
    {
      analogWrite(ledPin2, value);        
      delay(30); 
    }
  }}}
 ldrValue = analogRead(ldrPin); // read the value from the LDR
     Serial.println(ldrValue);
     delay(10); 
   {if (ldrValue <= 250) 
       {
  //for loop. "x" declares the position of the integers listed in the array (6 positions).
  //for(int x = 0; x <= 5; x++)    
  {
    //for loop. declares fade-in setting (0-255)
    for(int value = 0; value <= 255; value+=5)                   
    {
      //Calls for the PWM pin as listed in the array and performs an analogWrite.
      analogWrite(ledPin3, value);                                
     delay(30);
       //   
    }
    for (int value = 255; value>= 0; value-=5)        
    {
      analogWrite(ledPin3, value);        
      delay(30); 
    }
  }}}
   ldrValue = analogRead(ldrPin); // read the value from the LDR
     Serial.println(ldrValue);
     delay(10); 
   {if (ldrValue <= 250) 
       {
  //for loop. "x" declares the position of the integers listed in the array (6 positions).
  //for(int x = 0; x <= 5; x++)    
  {
    //for loop. declares fade-in setting (0-255)
    for(int value = 0; value <= 255; value+=5)                   
    {
      //Calls for the PWM pin as listed in the array and performs an analogWrite.
      analogWrite(ledPin4, value);                                
     delay(30);
       //   
    }
    for (int value = 255; value>= 0; value-=5)        
    {
      analogWrite(ledPin4, value);        
      delay(30); 
    }
  }}}
}

   // else {
     // for(int x = 0; x <= 5; x++)   
      //analogWrite(woot[x],LOW);
 

Nisa helped with my code in exchange for some help with her final project and worked out a brillant solution. 
int ledPin1 = 11;  // led Pin 9
int ledPin2 = 10;
int ledPin3 = 9;
int ledPin4 = 6;
int ledPin5 = 5;
int ledPin6 = 3;                                          
int ldrPin = 0;   // LDR on Analog Pin 0
int ldrValue = 0;  // Value read from the LDR

int a = 0; //variable to check if led 1 has already been triggered
int b = 0; //variable to check if led 2 has already been triggered
int c = 0; //variable to check if led 3 has already been triggered


void setup() {
  pinMode(ldrPin,INPUT);
  Serial.begin(9600);
  Serial.flush();
  analogWrite(ledPin1, 0);
}

void loop () {
  ldrValue = analogRead(ldrPin); // read the value from the LDR
  Serial.println(ldrValue);
  delay(10);
  
  if (ldrValue>=700) {
    analogWrite(ledPin1, LOW);
    analogWrite(ledPin2, LOW);
    analogWrite(ledPin3, LOW);
    analogWrite(ledPin4, LOW);
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);\
               a = 0;
               b = 0;
               c = 0;
  }
  
      if (ldrValue <=699 && a == 0 && b == 0 && c == 0) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(30);
                analogWrite(ledPin1, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(30);
              analogWrite(ledPin1, value);        
               }
             a = 1;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }

      if (ldrValue <=699 && a == 1 && b == 0 && c == 0) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(30);
                analogWrite(ledPin2, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(30);
              analogWrite(ledPin2, value);        
               }
             a = 1;
             b = 1;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }

      if (ldrValue <=699 && a == 1 && b == 1 && c == 0) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(30);
                analogWrite(ledPin3, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(30);
              analogWrite(ledPin3, value);        
               }
             a = 1;
             b = 1;
             c = 1;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }

      if (ldrValue <=699 && a == 1 && b == 1 && c == 1) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(30);
                analogWrite(ledPin4, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(30);
              analogWrite(ledPin4, value);        
               }
             a = 0;
             b = 0;
             c = 0;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }

}

And here is the final code modified for the "story".
int ledPin1 = 11;  // led Pin 9
int ledPin2 = 10;
int ledPin3 = 9;
int ledPin4 = 6;
int ledPin5 = 5;
int ledPin6 = 3;                                          
int ldrPin = 0;   // LDR on Analog Pin 0
int ldrValue = 0;  // Value read from the LDR

int a = 0; //variable to check if led 1 has already been triggered
int b = 0; //variable to check if led 2 has already been triggered
int c = 0; //variable to check if led 3 has already been triggered
int d = 0; // led 4 triggered?
int e = 0; // led 5 triggered?

void setup() {
  pinMode(ldrPin,INPUT);
  Serial.begin(9600);
  Serial.flush();
  analogWrite(ledPin1, 0);
}

void loop () {
  ldrValue = analogRead(ldrPin); // read the value from the LDR
  Serial.println(ldrValue);
  delay(10);
  
  if (ldrValue>260) {
    analogWrite(ledPin1, LOW);
    analogWrite(ledPin2, LOW);
    analogWrite(ledPin3, LOW);
    analogWrite(ledPin4, LOW);
    analogWrite(ledPin5, LOW);
    analogWrite(ledPin6, LOW);

               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);\
               a = 0;
               b = 0;
               c = 0;
               d = 0;
               e = 0;
  }
  
      if (ldrValue <=260 && a == 0 && b == 0 && c == 0 && d == 0 && e == 0) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(30);
                analogWrite(ledPin1, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(30);
              analogWrite(ledPin1, value);        
               }
             a = 1;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }

      if (ldrValue <=260 && a == 1 && b == 0 && c == 0 && d == 0 && e == 0) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(30);
                analogWrite(ledPin2, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(30);
              analogWrite(ledPin2, value);        
               }
             a = 1;
             b = 1;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }

      if (ldrValue <=260 && a == 1 && b == 1 && c == 0 && d == 0 && e == 0) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(30);
                analogWrite(ledPin3, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(30);
              analogWrite(ledPin3, value);        
               }
             a = 1;
             b = 1;
             c = 1;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }

      if (ldrValue <=260 && a == 1 && b == 1 && c == 1 && d == 0 && e == 0) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(30);
                analogWrite(ledPin4, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(10);
              analogWrite(ledPin4, value);        
               }
             a = 1;
             b = 1;
             c = 1;
             d = 1;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }
             
          
 if (ldrValue <=260 && a == 1 && b == 1 && c == 1 && d == 1 && e == 0) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(20);
                analogWrite(ledPin5, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(5);
              analogWrite(ledPin5, value); 
             }
             for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(10);
                analogWrite(ledPin5, value);                                 
                }
             for (int value = 255; value>= 0; value-=5) { //fade led1 out
                delay(40);
              analogWrite(ledPin5, value);        
               }
             a = 1;
             b = 1;
             c = 1;
             d = 1;
             e = 1;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }
             
              if (ldrValue <=260 && a == 1 && b == 1 && c == 1 && d == 1 && e == 1) {
            for(int value = 0; value <= 255; value+=5) { //fade led1 in
                delay(30);
                analogWrite(ledPin6, value);                                 
                }
             for (int value = 255; value>= 0; value-=2) { //fade led1 out
                delay(120);
              analogWrite(ledPin6, value);        
               }
             a = 0;
             b = 0;
             c = 0;
             d = 0;
             e = 0;
               ldrValue = analogRead(ldrPin); // read the value from the LDR
               Serial.println(ldrValue);
             }

}

It was mentioned during crit that the light should perhaps be less glowy and more flickery and consider non-white leds. I'm not sure I'd like the light to flicker much for story except get that to happen more in the 5th stage. After searching I found there are warm white christmas leds which I could hack to use, they are relatively expensive on line as a pack of bulbs . . .

Monday, November 12, 2012

HYE, KATIRICA, ERIN: CH 07_ PROJECT 19/ 20/ 21_ LED MATRIX ANIMATION


LED MATRIX TEST


CH07_ PROJECT 19_ SIMPLE ANIMATION 





 CH07_PROJECT 20_ROLLING ANIMATION




CH07_PROJECT 21 











Erin | Sdcard and real time clock





Thursday, November 8, 2012

Erin | Final Project Process (draft)

My previous work has contained themes of order and disorder and more recently has begun edging towards the space between presence and non-presence. Translucency, layers, mark-making, language or rather some denial or discomfort with it (especially in terms of the ineffable as being the failure of words to adequately express experience). My processes often require a careful attention to my materials and remaining responsive to accidents and happenstance while attempting to elicit form. It is a dialogue. Sometimes I feel the way I'm working is a bit like walking through a fog. I know the general direction I should be headed, but I'm waiting to see what emerges as I work.

At the moment a number of studies in my studio include things very responsive to the air currents of the room, one is a very light piece of Japanese gampi ("silk tissue") and the other is actual silk. I'm fascinated by the way they seem to breathe in here. They are seductive analog sensors.

This video of the silkworms I raised this past spring is something I think of in terms of translucency and markmaking among other ideas. 

I want to access a sense of atmosphere. How quiet can I make the work and still say something? I want to make work that visually whispers. 

One of my ideas was to create a drawing that harnessed the visually breathing in some work I made over the summer that move in response to the air currents in the room. I considered how two paper layers might move against and away from the bottom layer to reveal or obscure the image on the back layer. 


a more perfect blue from Erin Curry on Vimeo.

I like the way this reveals the unseen air currents, while the composition of the drawings change as the layers contact and separate. It would be interesting to exert more control and make the shifts more pronounced. This could be accomplished through the placement of RC fans below the drawings to move them. Or perhaps having a electric current complete when the layers contact one another in particular points. 


Then, I thought I'd like to make something that closed (a page that folded or a bag/crushed paper) or shied away using flexinol to shape my material. The image that kept coming to mind was sensitive briar which was a plant I played with as a kid. How might our relationship to text or other information change as is shied away from us? Or revealed itself when we are still?


[ I also considered and rejected a frame loom weaving that as the shuttle carrying the weft came in contact with the warp threads, sound from the farm the sheep were raised would play. or perhaps a loom made with a beehive frame would use the sound of the hive and a textile mill to talk about industry, but that's language I'm familiar with and it seems a little too direct to me right now. I'm more interested in developing a vocabulary that speaks to the ideas about presence and absence mentioned earlier]


This clip is of a study made on sanded acrylic sheet with graphite. I'm envisioning a work that emerges. 




Now that I write it, I'm clearly influenced by the silkworm, though I didn't consciously realize it until now. I'm intrigued by the way the build up of the drawing builds a physical presence through opacity and the material of graphite, while obscuring the view behind it, in essence, revealing presence while creating mystery.

The relationship of how a drawing machine like this might work best is something I need to consider more carefully, on one hand perhaps these marks can be made by a machine that makes them in darkness and when someone approaches it lights up from within and stops like chattering birds startled to silence. On the other hand, a work that is made only when the viewer is present speaks to how presence and attention can make a something minute meaningful. 

Otherwise I'm creating small analog compasses in my studio using a piece of cork, magnet and sewing needle in a cup of water. how can these small gestures speak to finding one's orientation in making, in the world?



What if the turning of the compass needle was the switch to activate the work? 
Or perhaps better, if the petri dish were extended on a lazy susan-like table and the device was oriented along the needle to activate the switch how might that change our relationship to something revealed?

Katerie pointed out this link about DIY transducers. Of course these are attractive. 
 http://we-make-money-not-art.com/archives/2011/01/diy-transducers.php#.UKKV_YXo9Xs 

interesting link about spider silk studies done at FSU. 
http://spectrum.ieee.org/semiconductors/materials/spider-silk-weaves-new-path-for-electronics
" Working with silk from the same type of spider the FSU team used, he found that it transferred heat even better than such excellent conductors as aluminum and iron and that the conductivity improved as the silk was stretched. He measured a conductivity of 416 watts per meter-kelvin, compared with 401 W/m-K for copper. That property may lead to better heat sinks for microelectronics."

It has high thermal conductivity properties while silkmoth silk has very low conductivity. 


Meanwhile I'm looking forward to experimenting with the flexinol I ordered. 

link dump:
https://www.youtube.com/watch?v=Y7jjqXh7bB4
http://letsmakerobots.com/node/23086
http://hlt.media.mit.edu/?p=1448
http://robotany.blogspot.com/2006/04/using-flexinol-wire.html
http://web.media.mit.edu/~marcelo/paper/index.html -pulp computing
http://hlt.media.mit.edu/?p=1370 
Use Vaseline as a resist and a bath of salt and vinegar to etch away the copper from copper fabric to make circuits and sensors.

Thinking about machines and poetic spaces came across Evan Holm's work which seems like something closer to what I'm looking for.


Submerged Turntable from Brian Lilla on Vimeo.
| Drawing Machine #1 | Evan Holm from Evan Holm on Vimeo.

I particularly enjoy the sense of fantasy about these pieces which taps into the elements of the hybridization of natural materials and aging technology. As well as the triggering of magical realism and fascination with the magic of real things present in certain works of fiction (Murakami and Gabriel Garcia Marquez come to mind). Thinking too about Ponyo where a variety magical things happen, but perhaps the most delightful moment is when the mother makes ramen for Ponyo and the boy. She carefully mixes everything, covers the meal with the lid and a few minutes later reveals a cooked meal to the delight of Ponyo. How does this moment differ from the delight of the class in making a simple motor with a battery, magnet, and copper wire? How can this be triggered artfully?

Thinking more about some gestures can be a trigger for something else.  I'd like to use the gesture of lighting a candle to trigger a lightsensor which used LEDs to illuminate other areas of the room, or a drawing. The candles would be lit for only a short time (either because the candle would run out or a small fan would blow it out) which would turn off the effect elsewhere.