Category: Assignment-10

Stephanie and Minnar – Jellyfish

Our project is a mechanical jellyfish whose tentacles scrunch as it bobs up and down. The top is a wire armature with fabric wrapped around it, and the tentacles are acetate plastic strips that have been hand cut and laser cut. Clear fishing line connects the tentacles and suspends the jellyfish from a stepper motor that controls its vertical movement. Some fishing line runs from the top of the jellyfish up to two ball bearings, the stepper motor, and a counterweight. The rest connects the tentacles together and is anchored to the bottom of the wooden frame structure. Pulling the string upwards pulls our tentacles upward, causing them to scrunch.
We were inspired by this youtube video and by the movements of real jellyfish. http://www.youtube.com/watch?v=JAULjWIwJBg
We wanted to create a puppet that would elegantly mimic the gestures of a jellyfish with only one motor. First we fabricated a small, non-motorized prototype to experiment with how to best execute the gesture of the tentacles, then worked on how to bring it to life with Arduino. Using a servo motor would have been easy, but we were turned off by the loud squeaky sounds that they make. We experimented with muscle wire as a means to pull our jellyfish up, but it was difficult because muscle wire only shrinks 3-5% of its length. Instead we chose to use a stepper motor, and went through several before we found one that was powerful enough to raise and lower the jellyfish. Adding the on/off switch was also a challenge because we were unfamiliar with the circuitry of the stepper motor. Luckily, we got a lot of great advice from Ali Momeni and Robb.

We went through several sketches before arriving at our final design.

Code:

#include 
 
// Map our pins to constants to make things easier to keep track of
int pushButton = 7;
const int pwmA = 3;
const int pwmB = 11;
const int brakeA = 9;
const int brakeB = 8;
const int dirA = 12;
const int dirB = 13;
boolean forward = true;
 
// The amount of steps for a full revolution of your motor.
// 360 / stepAngle
const int STEPS = 500;
int currentStep = 0;
 
// Initialize the Stepper class
Stepper myStepper(STEPS, dirA, dirB);
 
void setup() {
  // Set the RPM of the motor
  myStepper.setSpeed(8);
 
  // Turn on pulse width modulation
  pinMode(pushButton, INPUT); 
 
  pinMode(pwmA, OUTPUT);
  digitalWrite(pwmA, HIGH);
  pinMode(pwmB, OUTPUT);
  digitalWrite(pwmB, HIGH);
  // Turn off the brakes
  pinMode(brakeA, OUTPUT);
  digitalWrite(brakeA, LOW);
  pinMode(brakeB, OUTPUT);
  digitalWrite(brakeB, LOW);
 
  Serial.begin(9600);
}
 
void loop() {
 
  if (digitalRead(pushButton)==1){
    Serial.println ("steppin'!");
 
    if(forward){
      myStepper.step(1);
      currentStep +=1;
    } else {
    myStepper.step(-1);
    currentStep +=1;
    }
 
    if (currentStep == STEPS){
      forward = not forward;
      currentStep = 0;
    }
  }
}

Note: Fritzing does not have support for the Arduino motor shield we used.

Luo Yi Tan – Assignment 10 Automaton

It’s a rather unhappy cat looking at a bird.

Since it was the first time I was making something like this, I wanted to make it simple. At first I just wanted a mechanism to make a figure move back and forth in a linear way. I wanted to use a cam, but needed full rotation to do so, and my DC motor had problems, like not spinning as slow as I wanted it to, and stopping when I tried to slow it down. So I switched to trying to make a rack and pinion instead.

I went through several prototypes before settling on this, mainly because I spent most of the time figuring out how the automino kit works and looking up various rack and pinion setups online.  Several problems I had was getting the gear to rotate along the rack without slipping, and getting the gear on the rack at just the right height. Lots of tinkering was involved to get it to run by itself without me holding onto any of the parts.

The cat was the result of me needing a weight to hold the servo for the rack and pinion in place, and shaping it from some clay I had. I thought it was only natural for it to be looking at a bird.

Here’s the Fritzing diagram:

And the code:

#include 
Servo servo1, servo2;  // servo control object
int button = 2;
int period = 500;
 
void setup()
{
  servo1.attach(9);
  servo2.attach(10);
  Serial.begin(9600);
} 
 
void loop() {
  if(digitalRead(button) == LOW) {
      servo1.attach(9);
  servo2.attach(10);
    for (int angle = 0; angle  0; angle -= 1) {
      servo1.write(angle);
      delay (10); 
    }
    servo2.write(0);
    delay(500);
  }
  else {
    servo1.detach();
    servo2.detach();
  }
}

Assignment 10 – Rosey and Connie

Our project started as an idea to see how light could be altered by clear shapes moving around it. We wanted to have a series of gears that would turn and move around strings of clear shapes in interesting ways. One of the earlier problems we encountered was the positioning of the gears, which unfortunately made us reconsider the design and just put them along the top of the box instead of all over just so we knew they would work consistently. The next problem we had was simply being able to make at the gears turn with only one motor. Though we began developing a solution, it was brought to our attention that we would have probably needed another layer on top of our current one to hold everything in place and would need something stronger like a rubber band to rotate everything. Despite these mechanical issues, I do believe that we have made a satisfactory prototype of a light-based work especially when it is viewed in the dark. I am proud of the starburst effect that emits from the box due to the strands of clear shapes and I like that it almost looks like a water-reflected surface when the gears do rotate. Overall, I feel like while we had our share of construction issues while making this project, it was definitely not a waste and rather something that we learned a lot from with some level of success.

EMS documentation from Rosey Denton on Vimeo.

Oliver and Michael – Automaton

Our goal for this project was to give our automaton less than admirable human qualities juxtaposed against a desperate will to survive and be free. Our hopes were to capture the gesture of the struggle to free oneself from a straight jacket. As we head towards artificial intelligence with great advances in computing technology and science we began to question if artificial emotion will be developed as well. Is it possible to an intelligent computer to have emotional or mental sickness?

We created this automaton using two servo motors attached to laser-cut wooden framework and gears. It wears a hand-sewn straight jacket to constrain its motion. The figure is attached to a metal box with an on-off switch on the outside and all of the wiring, the Arduino, and the breadboard inside.

The automaton’s movement has three stages: frantic motion, reserved motion, and rest. The servo angles and delay times use a constrained randomized method to simulate struggle.

 

Photos:

   

 

Video:

 

Fritzing diagram:

 

Code:

// less than and greater than signs messed up the code on this 
// blog post so I had to spell out "is less than" and 
// "is greater than"
 
#include Servo.h
 
Servo servo1, servo2;
const int buzzerPin = 4;
const int franticReps = 18;
const int reservedReps = 7;
int position;
 
void setup() {
  servo1.attach(8);
  servo2.attach(9);
  pinMode(buzzerPin, OUTPUT);
}
 
void loop() {
  int m=0;
  // frantic motion
  while (m is less than franticReps){
    franticMotion();
    m++;
  }
  // reserved motion
  int n=0;
  while (n is less than reservedReps){
    reservedMotion();
    n++;
  }
  // rest
  delay(random(8000,10000));
}
 
void reservedMotion() {
  for(position=40; position is less than 140; position+=4) {
    // shoulders
    servo1.write(position);
    // elbows
    servo2.write(position);
    delay(30);
  }
  for(position=140; position is greater than 40; position-=4) {
    // shoulders
    servo1.write(position);
    // elbows
    servo2.write(position);
    delay(30);
  }
}
 
void franticMotion() {
  // shoulders
  servo1.write(random(20,60));
  // elbows
  servo2.write(180);
  delay(random(200));
  // shoulders
  servo1.write(random(120,160));
  // elbows
  servo2.write(0);
  delay(random(200));
}

Assignment 10 [prototype] – Kyna

Currently I only have a working prototype. The prototype uses two servo motors for motion (literally the most naive implementation, haha), but the final product will probably use the gear motor/cam setup so it’s less jerky.

Assignment 10, Automaton, Josh Lopez-Binder

While playing around with legos I found that an odd sort of wave could be produced from a chain of links.  This chain has the property that each link is limited in rotation by its neighbor links due to little pegs.  I thought it would be neat to make a little machine that replicates this wave.  After considerable time messing around with various linkages and cranks, I found  that a combination of a crank and a four bar linkage + crank moved the first link in a way that would create the wave I desired. Naively, I thought that I could use this to run a much longer chain without modifications.

I copied the lego configuration into a CAD model and built a housing for the motor with the gearbox, the arduino, and a battery.  I lazer cut all of this out of 1/8 inch acrylic. My major mistake was assuming that the gearbox would produce a enough torque to easily drive the mechanism.  Of course this was a ridiculous assumption (and a lazy one), and the mechanism hardly works as a result.  It is much too fast and the motor seems to die after a few rotations.  I think I need to find a better motor/gearbox or use a stepper.

Recently, I realized that what I was trying to make was a soliton, a solitary wave that moves through a medium like a particle.  I also realized that my method of driving one link while the opposite end remains pinned is much too complex.  This method does not allow for a large number of links (this would require a larger linkage), which is what I had hoped for.  The more elegant method would be to pin both ends of the chain, at a distance that required a few of the links to splay out into the wave, and simple rotate each end alternately to pass the wave back and forth.  Oy!

 

 

 

 

int motorPin = 9;
int switchPin = 2;
boolean runMotor = false;
int clickTime = 10;
 
void setup(){
  Serial.begin(9600);
  pinMode(motorPin, OUTPUT);
  pinMode(switchPin, INPUT);
}
 
void loop(){
  if(digitalRead(switchPin) == LOW){
   runMotor = !runMotor;
  } 
 
  if(runMotor){
    Serial.println("motor HIGH");
    digitalWrite(motorPin, HIGH);
  } 
  else{
    Serial.println("motor LOW");
    digitalWrite(motorPin, LOW);
 
  }
  //delay(100);
 
}

Assignment 10

An Automaton: Due Wednesday, November 14th

We know how to control actuators (servos and DC motors). Now let’s try to actuate something interesting, in an interesting way.

Working in (optional) two-person teams, make an automaton / kinetic sculpture / mechanical thingy with the following characteristics:

  • It produces a complex and meaningful gesture or movement sequence;
  • It employs at least one laser-cut piece of your own design;
  • It integrates non-laser-cut elements. For example: try non-rigid, non-structural materials (springs, jelly, feathers, balloons, leaves, taxidermy, doll parts, etc.).
  • It has an on-off switch or “GO” button which causes it to enact or start its movement sequence.

Don’t make it interactive or responsive to the environment; focus on the “actuation” and the design of an interesting gesture. The only ‘interactivity’ will be the on/off switch or the “start” pushbutton. Consider, though, some of the other kinds of things you can add to your project: sound from the piezo sound; the cellphone vibrator motor; LED lights…..

For advice on building automatons, please consult this wonderful out-of-print resource (PDF).

You are strongly encouraged to use the Automino kit for assembling the frame of your automaton. On Wednesday 11/7, you will be lasercutting these.

To submit and present your assignment, include the following:

  • An embedded YouTube video (no longer than two minutes) showing video documentation of your project. Show the project executing its motion design, and then give a technical talk-through of its physical design.
  • A text (200 words) describing your project, your design process, and any precursors which may have inspired.
  • Scans of sketches, if possible.
  • An arduino circuit design, rendered using Fritzing.
  • Arduino code, embedded into your blog post using the WP-Syntax plugin.
Comments Off on Assignment 10 Posted in