Jellyfish!

This technique involved sewing a strand of Flexinol onto one side of the paper.  When the SMA contracts it causes the paper to fold in on itself creating this movement.  

In order to translate this to the EcoFlex we needed to find a way to affix it.  We tried a similar approach, sewing the SMA onto one side of the silicone, however initial attempts were not successful.  We have various theories as to why this was the case.  For one, the silicone is sticky and the SMA may not have been strong enough to release it from the table.  Another consideration is the thickness of the silicone and thus the amount of force it requires to bend it.  

For the second attempt a much thinner piece of silicone was used with the SMA itself sewn around and through the silicone.  This showed promise as we verified the SMA could be powerful enough to actuate the silicone.

For the final version of the jellyfish we wanted to simulate a swimming motion.  To enable this we needed to be able to pull on the silicone from several sides.  This was accomplished by sending several individual strands down different parts of the bell shape.  Initially they were all connected to one conductor wire at the top and another at the bottom.  However, since the .010" gauge SMA requires 1 Amp to fully actuate, by running several in parallel we were going to need just as many amps to get them all to move.  Because amps are harder to come by in DC bricks than volts they were rewired from parallel to series.

In order to hold the SMA in place another coat of Ecoflex was poured and painted on the top of the SMA.

Driving the SMA from Arudino
Because of the high current draw required and the fact that Arduino can only source about 40mA we needed to use a switching circuit to drive the SMA.  The initial attempt was to use the same power circuit used in the "Drummer Wanted" project.  However when this was connected the Arduino did not have enough power to light up the surface mount LEDs used to illuminate the jelly.

 

With the bell made and SMA embedded, it was time to test if it worked.



We felt this deserved its own step.

In order to achieve these states we used a red LED and a series of UV LEDs.  The hope was that by coating the jelly with black-light tracer it would give off a realistic glow under the UV lights which are reasonably close to the blue shown in the "buglar alarm" state in the above video (around 26 seconds in).

Initially we attempted to make the silicone glow by adding the black-light tracer to the silicone mix before it set, we then embedded a test UV LED in the silicone test the behavior.  Unfortunately the silicone with the tracer mixed in did not diffuse the light as much as we had hoped.  We found that we got slightly better results by simply "painting" the tracer on the outside of the silicone.

In the end the surface mount UV LEDs were soldered to a ring on the interior of the jellyfish which was connected to ground.  The 6 LEDs had individual wires fed through the middle so they could be individually addressed and blinked.  Place the ring on the interior of the bell, and secure by pouring a little silicone over the ring.

Here is the breadboard prototype of the blink routine:

Here is a short video showing the jelly "swimming", going into a threat response and then going back to swimming.

Here is the Arduino code used:
/////////////////////////////////////////////////////////////
//
// Jellyfish!
//
// Jiffer Harriman and Dana Hughes
/////////////////////////////////////////////////////////////

#include <StopWatch.h>

// set pin numbers:
const int leds[] = {2, 3, 4, 5, 6, 7};
const int smaPin = 9;
const int lightPin = A5;
const int glowPin = 11;

// initial states
int ledStates[] = {LOW, LOW, LOW, LOW, LOW, LOW};
// keep track of how long its been
long previousMillis = 0;       
long interval = 100;           // interval at which to blink (milliseconds)

// are you threatening me?
boolean attack;
boolean stroke;
float sun;

// leaky integrator variables
float alpha = .5;
// a0
float a0_in = 0.0;
float a0_last = 0.0;
float a0_out = 0.0;
float a0_out_last = 0.0;
// a1
float a1_in = 0.0;
float a1_last = 0.0;
float a1_out = 0.0;
float a1_out_last = 0.0;
// a2
float a2_in = 0.0;
float a2_last = 0.0;
float a2_out = 0.0;
float a2_out_last = 0.0;
// thresholding variables
float a0_diff = 0.0;
float W0 = 0.0;

float a1_diff = 0.0;
float W1 = 0.0;

float a2_diff = 0.0;
float W2 = 0.0;

float THRESHOLD = .99;

// timer -- http://www.arduino.cc/playground/Code/StopWatchClass
StopWatch timer;
StopWatch swimTimer;

void setup() {
  Serial.begin(9600);
 
  // set led pins for out
  for (int i = 0; i < 6; i++){
    pinMode(leds[i], OUTPUT);
  } 
 
  //
  attack = false;
  stroke = false;
  // start the stopwatch
  timer.start();
  swimTimer.start();
}

void loop()
{
  sun = analogRead(lightPin) / 2.;
  Serial.println(sun);
  delay(10);
   analogWrite(glowPin, sun);
  if(checkShake()){
    attack = 1;
    int ledStates[] = {LOW, HIGH, LOW, LOW, LOW, LOW};
  }
  else if(timer.elapsed() > 9000 && attack == 1)
  {
    attack = 0;
    for (int i = 0; i < 6; i++){
      ledStates[i] = LOW;
      for (int i = 0; i < 6; i++){
        digitalWrite(leds[i], ledStates[i]);
      }
    }
    swimTimer.reset();
    swimTimer.start();
    stroke = 0;
  }
 
  if(attack){ 
    blinkThoseLEDs();
  }
  else
    swim();
 
  if (stroke)
    // turn on muscle wire pin
    digitalWrite(smaPin, HIGH);
  else  // turn off
    digitalWrite(smaPin, LOW);
}

boolean checkShake(){
  // leaky integrator x3
  a0_in = analogRead(A0);
  a0_out = a0_in * alpha + (1 - alpha) * a0_out_last;
  a0_out_last = a0_out;

  a1_in = analogRead(A1);
  a1_out = a1_in * alpha + (1 - alpha) * a1_out_last;
  a1_out_last = a1_out;

  a2_in = analogRead(A2);
  a2_out = a2_in * alpha + (1 - alpha) * a2_out_last;
  a2_out_last = a2_out;
 
  // Detect onsets
  a0_diff = abs(a0_in - a0_out_last);
  W0 = a0_diff / a0_out;
 
  a1_diff = abs(a1_in - a1_out_last);
  W1 = a1_diff / a1_out;
 
  a2_diff = abs(a2_in - a2_out_last);
  W2 = a2_diff / a2_out;
 
  // registered a beat
  boolean ouch = false;
  if(W0 > THRESHOLD || W1 > THRESHOLD || W2 > THRESHOLD)
  {

    ouch = true;
    // reset the timer
    timer.reset();
    timer.start();
   
    // stop swimming! you're being attacked
    swimTimer.reset();
    swimTimer.start();
    stroke = 0;
   
  }

  return ouch;
}

void blinkThoseLEDs(){
  unsigned long currentMillis = millis();

  if(currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;  

  // which one went last?
    int lastOn;
   
    for (int i = 0; i < 6; i++){
      if (ledStates[i] == HIGH)
      {
        ledStates[i] = LOW;
        lastOn = i;
      }
    }
   
    if (lastOn > 4){
      lastOn = -1;
    }
    ledStates[lastOn+1] = HIGH;
    for (int i = 0; i < 6; i++){
      digitalWrite(leds[i], ledStates[i]);
    }
  }
}

void swim(){
  if (swimTimer.elapsed() > 6000 && stroke == 0)
  {
    stroke = 1;
  }
  else if(swimTimer.elapsed() > 10000)
  {
    stroke = 0;
    swimTimer.reset();
    swimTimer.start();
  }
}