Servos

/ / navigation

Making motions with servo motors

A Servo is a small device that has an output shaft. This shaft can be positioned to specific angular positions by sending the servo a coded signal. As long as the coded signal exists on the input line, the servo will maintain the angular position of the shaft. As the coded signal changes, the angular position of the shaft changes. In practice, servos are used in radio controlled airplanes to position control surfaces like the elevators and rudders. They are also used in radio controlled cars, puppets, and of course, robots.

What's inside:

The servo motor has some control circuits and a potentiometer (a variable resistor) that is connected to the output shaft. This pot allows the control circuitry to monitor the current angle of the servo motor. If the shaft is at the correct angle, then the motor shuts off. If the circuit finds that the angle is not correct, it will turn the motor the correct direction until the angle is correct. The output shaft of the servo is capable of traveling somewhere around 180 degrees. Usually, its somewhere in the 210 degree range, but it varies by manufacturer. A normal servo is used to control an angular motion of between 0 and 180 degrees. A normal servo is mechanically not capable of turning any farther due to a mechanical stop built on to the main output gear.

The amount of power applied to the motor is proportional to the distance it needs to travel. So, if the shaft needs to turn a large distance, the motor will run at full speed. If it needs to turn only a small amount, the motor will run at a slower speed. This is called proportional control.

Angles of Rotation:

Continuous Rotation servos
The continuous rotation servos keep on rotating when pulsed with power. The most common continuous rotation servos from Parallax rotate in one direction when pulsed with power with a delay above 1500 microseconds and the other way when pulsed with a delay below 1500 microseconds.

This program will make the continuous rotation servo go 100 steps one way then 100 steps the other way.

#define motoPin 9 

void setup(){ 
 pinMode(motoPin,OUTPUT); 
} 
void loop(){ 
 for(int i = 0; i < 100; i++);{ 
     digitalWrite(motoPin,HIGH); 
     delayMicroseconds(1850); 
     digitalWrite(motoPin,LOW); 
     delayMicroseconds(1850);  
 } 
 for(int j = 0; j < 100; j++);{ 
     digitalWrite(motoPin,HIGH); 
     delayMicroseconds(1250); 
     digitalWrite(motoPin,LOW); 
     delayMicroseconds(1250);  
 } 
}

What servos are good for

Roboticists, movie effects people, and puppeteers use them extensively
Any time you need controlled, repeatable motion
Can turn rotation into linear movement with clever mechanical levers

Where you find them

The underpinnings of one of the five transforming dresses featured in Hussein Chalayan's latest runway show. Wires within the tubes connect to motors at the bottom of the dress. The motors reel in wires attached to the outer layer of the garment, altering its shape.

When using the servo, it is helpful to mark the servo horn. This allows you to follow the rotation:

Connect the servo to the Microcontroller like this:

The computer can't really output analog values, but it can fake it. It fakes it using Pulse Width Modulation or PWM.
This program moves a servo across its full range:

But doesn't Arduino have PWM?

Yes Arduino has built-in PWM on pins 3, 5,6, 9,10,11, and you can use analogWrite(pin,value) to write an analog value (PWM wave) to a pin. You can light a LED at varying brightnesses or drive a motor at various speeds. After a call to analogWrite(), the pin will generate a steady wave until the next call to analogWrite (or a call to digitalRead or digitalWrite on the same pin). But it operates at a high, fixed frequency and isn't usable for servos. The PWM speed used for analogWrite() is set to 490Hz currently. It's not something changeable without understanding more about how AVRs work. So when programming AVRs in C outside of Arduino, PWM speed can be set to just about any value.

Here's the good news, the Servo library takes care of this for you:

Exercise

Wire up the servo and a potentimeter:

You are going to drive the servo with a potentiomer.

#include <Servo.h>
Servo myServo;
int pos=0;
int analogSensor=0;

void setup(){
  myServo.attach(9);
  myServo.write(0);
  Serial.begin(9600);
  
}
void loop() { 
  pos=analogRead(analogSensor);
  Serial.println(pos);
  pos=map(pos,0,750,0,180);
    myServo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
 
}

Servo Critters

From my class:

Others:

//twitchie v0.5
//Raphael Abrams

#define servoPinA 3     // Control pin for servo motor
#define servoPinB 9     // Control pin for servo motor
#define servoPinC 10     // Control pin for servo motor
#define Led 10          // activity light
#define minangle 550    // Minimum servo position
#define maxangle 2400   // Maximum servo position
#define trigger 0       // the analog pin that the sensor's on
#define AWAKEN 200
#define SLEEPY 50


char SEEDS[256] __attribute__((progmem)) = {
  208,75,137,110,218,247,165,23,248,216,204,59,118,35,193,29,83,158,93,57,224,194,3,207,205,149,203,22,129,171,10,
  142,251,99,249,244,144,16,17,238,37,197,111,151,4,192,104,7,95,150,67,101,69,15,132,186,87,156,206,27,166,20,182, 
  163,92,198,119,213,180,61,152,39,185,19,58,45,33,64,24,160,40,222,172,131,227,221,105,108,177,183,73,43,157,12,199,
  113,9,245,126,130,106,120,210,215,31,167,246,76,139,195,239,50,229,169,55,122,212,30,112,6,85,141,82,236,21,32,89,
  219,173,188,127,74,214,187,190,176,62,123,189,121,184,148,225,34,1,196,28,49,46,79,77,54,117,240,175,242,140,231,
  13,128,25,97,146,228,179,116,70,53,178,18,254,78,109,155,241,233,81,255,159,202,102,2,174,14,147,234,60,8,84,52,98,
  100,230,145,211,125,11,181,164,26,90,134,161,36,71,223,143,232,136,63,68,51,96,243,66,65,235,47,154,237,252,72,209,
  114,138,115,86,250,5,94,133,42,44,88,226,103,253,124,168,91,48,217,56,80,135,220,107,191,201,162,153,38,170,41,200,0};


/////////////////////////////////////////////////////////////////
void setup() {
  pinMode(servoPinA, OUTPUT);  // Set servo pin as an output pin
  pinMode(servoPinB, OUTPUT);  // Set servo pin as an output pin
  pinMode(servoPinC, OUTPUT);  // Set servo pin as an output pin

  pinMode(Led, OUTPUT);  // Set servo pin as an output pin
  Serial.begin(9600);
}
/////////////////////////////////////////////////////////////////
void loop() {
  ledflash(3,200);
  Serial.println("I... am... ALIIIIVE!!!!!");
  purr(3,20,4);  
  while(1){
    analogWrite(Led,random(1,200));
    randomSeed(millis());
    if(analogRead(trigger)>AWAKEN){
      Serial.println("WAKEY!!!");

      burst(random(10,150),random(2,20),1);
      delay(200);   
      burst(random(10,150),random(2,32),0);
      delay(random(200,2500));
      quiver(1, random(3,10),random(3,10),random(30,140));
      //    purr(random(1,10),20,random(2,15));
    }
    if(analogRead(trigger)<SLEEPY){
      Serial.println("TIRED");
      quiver(0, random(3,10),random(3,10),random(30,140));
      timedsleep(random(10,50));
    }
    if(analogRead(trigger)<SLEEPY){
      Serial.println("TIRED");
      quiver(0, random(3,10),random(3,10),random(30,140));
      timedsleep(random(10,50));
      purr(3,20,4);
    }
  }
}
//  burst(100,10,1);//perfect!
//  burst(10,10,0);
//  purr(3,20,4);
//  quiver(5,5,100);
////////////////////////////////////////////////
////////////////////////////////////////////////


void ledflash(int number, int duration) {  
  for(int i=number;i>0;i--){
    delay(duration/2);
    digitalWrite(Led, HIGH);   // sets the LED on  
    delay(duration/2);                  // waits for a second  
    digitalWrite(Led, LOW);    // sets the LED off  
  }
} 

//////////////////////////////////////////////////////////////
void servo(char pin, int angle){
  // protect the servos from pulses that move them too far
  if(angle>maxangle){
    angle=maxangle;
  }
  if(angle<minangle){
    angle=minangle;
  }

  // now figure out which one should move, and move it toward the angle specified
  // this will only move the servo by one pulse, 
  // so you will need to call this a few times to get it all the way there
  if(pin=='A' || pin=='a'){
    digitalWrite(servoPinA, HIGH);
  }
  if(pin=='B' || pin=='b'){
    digitalWrite(servoPinB, HIGH);
  }
  if(pin=='C' || pin=='c'){
    digitalWrite(servoPinC, HIGH);
  }


  delayMicroseconds(angle);       // Length of the pulse sets the motor position

  if(pin=='A' || pin=='a'){
    digitalWrite(servoPinA, LOW);
  }
  if(pin=='B' || pin=='b'){
    digitalWrite(servoPinB, LOW);
  }
  if(pin=='C' || pin=='c'){
    digitalWrite(servoPinC, LOW);
  }

}


void burst(char quantity, char slowness, char type){
  int c, holdcount ; 
  int rhold0, rhold1, rhold2, rhold3, rhold4, rhold5, rhold6, rhold7;
  if (type==0){
    for ( int i=quantity; i>0; i--){
      if (analogRead(trigger) < SLEEPY ) { 
        return;
      }
      Serial.print("whee! ");
      rhold0 = random(minangle,maxangle);
      rhold1 = random(minangle,maxangle);
      rhold2 = random(minangle,maxangle);

      holdcount = random(1,10);
      for ( c=slowness; c>0; c--){
        servo('a',rhold0);
        servo('b',rhold1);
        servo('c',rhold2);

        delay(holdcount);
      }
    }
  }
  if (type==1){
    for ( ; quantity>0; quantity--){
      if (analogRead(trigger) < SLEEPY ) { 
        return;
      }
      Serial.print("wh00t! ");
      rhold0 = random(minangle,maxangle);
      rhold1 = random(minangle,maxangle);
      rhold2 = random(minangle,maxangle);

      holdcount = random(1,10);
      for ( c=holdcount; c>0; c--){ 
        servo('a',rhold0);
        delay(slowness);
      }
      holdcount = random(1,10);
      for ( c=holdcount; c>0; c--){
        servo('b',rhold1); 
        delay(slowness);
      }
      holdcount = random(1,10);
      for ( c=holdcount; c>0; c--){
        servo('c',rhold2);
        delay(slowness);
      }

    }
  }
}

///////////////////////////////////////////////////////////////////////////////
void purr(int duration, int offset, int reps){
  int c,i,ii; 
  int start0, start1, start2;
  int finish0, finish1, finish2;

  start0 = random(minangle,maxangle);
  start1 = random(minangle,maxangle);
  start2 = random(minangle,maxangle);

  Serial.print("pu");
  for(i=reps;i>0;i--){
    Serial.print("r");
    if (analogRead(trigger) < SLEEPY ) { 
      return;
    }
    finish0 = random(minangle,maxangle);
    finish1 = random(minangle,maxangle);
    finish2 = random(minangle,maxangle);

    for ( ii=duration; ii>0; ii--){

      if (start0>(finish0+offset)){
        start0=start0-offset;
      }
      else if (start0<(finish0-offset)){
        start0=start0+offset;
      }
      else {
        start0=finish0;
      }

      if (start1>(finish1+offset)){
        start1=start1-offset;
      }
      else if (start1<(finish1-offset)){
        start1=start1+offset;
      }
      else {
        start1=finish1;
      }

      if (start2>(finish2+offset)){
        start2=start2-offset;
      }
      else if (start2<(finish2-offset)){
        start2=start2+offset;
      }
      else {
        start2=finish2;
      }

    



      if (start0 != finish0){
        servo('a',start0);
      }
      if (start1 != finish1){
        servo('b',start1);
      }
      if (start2 != finish2){
        servo('c',start2);
      }


      delay(25);
    }
  }
}

////////////////////////////////////////////////////////////////////////////
void quiver(char quittable, char duration,char slowness, char intensity){
  int c, holdtime ; 
  int rhold0, rhold1, rhold2, rhold3;
  Serial.print("qu");
  for ( ; duration>0; duration--){
    rhold0 = random(minangle,maxangle);
    rhold1 = random(minangle,maxangle);
    rhold2 = random(minangle,maxangle);

    holdtime = random(2,25);
    if ((quittable)&&(analogRead(trigger) < SLEEPY)) { 
      return;
    }
    Serial.print("i");
    for ( c=slowness; c>0; c--){
      servo('a',rhold0);
      servo('b',rhold1);
      servo('c',rhold2);


      delay(holdtime);
      servo('a',rhold0+intensity);
      servo('b',rhold1+intensity);
      servo('c',rhold2+intensity);

      delay(holdtime);
    }
  }
  Serial.println("ver");
}

/////////////////////////////////////////////////////////////////////////
void timedsleep(int duration){
  int c;
  Serial.print("I'm sleepy! I'm going to sleep for ");
  Serial.print(duration, DEC);
  Serial.print(" Z's... getting... ");
  Serial.print("sle");
  for ( ; duration >0; duration --){
    for (c=4;c>0;c--){
      delay(150);
      Serial.print("e");
      if (analogRead(trigger) > AWAKEN ) { 
        Serial.print("  Oh! you woke me!");
        return;
      }
    }
  }
  Serial.println("py ");
}