Learning to Program the Arduino

Listing 7. Servo Control Sketch

/*
 * servo1: servo1.pde

 * Servo control from the Serial port
 *
 * Slower, faster, Center and Stop a Servo with an LED Blinky
 * Created: 1 June, 2011, Amit Saha (http://echorand.me)
 * Adapted from http://principialabs.com/arduino-serial-servo-control/
 */

/** Adjust these values for your servo and setup, if necessary **/
int servoPin     =  2;    // control pin for servo motor
int minPulse     =  500;  // minimum servo position
int maxPulse     =  3000; // maximum servo position
int turnRate     =  10;  // servo turn rate increment (larger value, 
                            faster rate)
int refreshTime  =  20;   // time (ms) between pulses (50Hz)

int OFF=0; // This variable will be used to get/set the status of the servo

/** The Arduino will calculate these values for you **/
int centerServo;         // center servo position
int pulseWidth;          // servo pulse width
int moveServo;           // raw user input
long lastPulse   = 0;    // recorded time (ms) of the last pulse

/* LED setup*/
int ledPin=13;


void setup() {
  pinMode(ledPin, OUTPUT); // LED Blink
  pinMode(servoPin, OUTPUT);  // Set servo pin as an output pin
  centerServo = maxPulse - ((maxPulse - minPulse)/2);
  pulseWidth = 0;
  Serial.begin(9600);
  Serial.println("      Arduino Serial Servo Control");
  Serial.println("Keys:'(s)lower' or '(f)aster', spacebar to center 
and o to stop");
  Serial.println();

  moveServo = 60;
}

void loop() {
  // wait for serial input
  if (Serial.available() > 0) {
    // read the incoming byte:
    moveServo = Serial.read();

    // ASCII 's' is 115, ASCII 'f' is 102, 'o' is 111, 'spacebar' is 32
    if (moveServo == 115) { pulseWidth = pulseWidth - turnRate; OFF=0;}
//slower
    if (moveServo == 102) { pulseWidth = pulseWidth + turnRate;OFF=0; }
//faster
    if (moveServo == 32) { pulseWidth = centerServo; OFF=0;} //center
    if (moveServo == 111) { OFF= 1;} //STOP

    // limit the servo pulse at min and max
    if (pulseWidth > maxPulse) { pulseWidth = maxPulse; }
    if (pulseWidth < minPulse) { pulseWidth = minPulse; }

  }

  // pulse the servo every 20 ms (refreshTime) with current pulseWidth
  // this will hold the servo's position if unchanged, or move it if
  // changed
  if (OFF == 0)
  {
    /* Turn ON the LED*/
    digitalWrite(ledPin,HIGH);

    if (millis() - lastPulse >= refreshTime) {
      digitalWrite(servoPin, HIGH);   // start the pulse
      delayMicroseconds(pulseWidth);  // pulse width
      digitalWrite(servoPin, LOW);    // stop the pulse
      lastPulse = millis();           // save the time of the last pulse
    }
  }
  else
  {
     /* Turn OFF the LED*/
    digitalWrite(ledPin,LOW);

    //Stop the servo
    digitalWrite(servoPin, LOW);
  }
}

Once the sketch is uploaded, open a serial communication channel using screen (feel free to substitute it with your favorite terminal communication program). Type screen /dev/tttyACM0 9600, and you should see the "servo prompt" at your service:

Arduino Serial Servo Control
Keys:'(s)lower' or '(f)aster', spacebar to center and o to stop

Pressing the keys to the servo should produce the desired behavior. If you see the code listing for the servo mechanism, you will see that the key to controlling the speed is basically the duration of the delay (variable pulseWidth) between sending a HIGH and LOW signal to the servo. Here, we are simulating an analog behavior using the important technique called Pulse Width Modulation, which you can read about elsewhere.

If you have gotten this servo example up and running, you also might want to check out the other example sketches for working with servos in the Arduino IDE under File→Examples→Servo.

A Peek under the Hood

I'm drawing toward the close of this article, and I hope you have had a lot of fun. However, if you are like me, you already have started wondering what's going on behind the scenes—the journey of the processing sketch to the bytes getting executed on the Arduino board.

The real work behind the scenes is done by the GNU C/C++ compilers, linkers and libraries for the AVR microcontroller. If you hold the Shift key when you compile your sketch, you will see that the commands - avr-g++, avr-g++, avr-ar and avr-objcopy are invoked. First, your Arduino sketch is converted to a suitable C++ file (with the .cpp extension), which then is compiled, linked and finally converted to the hex file that is uploaded to the Arduino board. You can see all these intermediate files in the /tmp/build*.tmp directory. Knowledge of this build process can enable you to bypass the IDE for your Arduino development by writing an appropriate Makefile. See the "Command-Line Arduino development" article listed in Resources for an example.

Conclusion

I've described a few simple but cool things that can be done with an Arduino, but this article barely scratches the surface. A number of excellent books are available that list a great number of Arduino projects you can build for fun and profit. These are, of course, in addition to all the excellent on-line resources available. During exploring Arduino purely from the various blog posts on the Web and a trial-and-error-based approach to learning, I discovered many great projects in the Arduino ecosystem. Be sure to see the Resources for this article for some of the most interesting Arduino books, articles and projects.

Also note that wires are good, but only when you want to limit yourself to the confines of your tabletop or even your room. If you want your Arduino to be out there, decoupled from your host machine, you need to explore ways of wireless communication. Say hello to XBee modules, which allow communication with the ZigBee communication standard.

And before I end, you might face issues with erratic serial communication. Especially during extended periods of experimenting with serial communication, I found that the serial ports would remain locked or just be plainly not accessible from the host computer. My advice is to be patient. Unplug and plug back in a few times, and try killing the lock file manually. Now, you should be good to go.

Acknowledgements

Thanks to the awesome Arduino community members for their documentation and numerous other bloggers on the Web. The Arduino circuit diagrams were drawn with Fritzing (http://fritzing.org).

Resources

Author's Code for This Article: https://bitbucket.org/amitksaha/articles_code/src/6bed469945fd/arduino_article

Plumbing for the Arduino: http://www.concurrency.cc/book

PureData (Audio Processing and Visualization): http://puredata.info

Firefly Experiments (bridging the gap between Grasshopper, the Arduino microcontroller, the Internet and beyond): http://www.fireflyexperiments.com

Arduino: http://arduino.cc

Processing Language: http://processing.org

Arduino Hardware (I/O Boards): http://www.arduino.cc/en/Main/Hardware

Arduino Uno: http://arduino.cc/en/Main/ArduinoBoardUno

Sparkfun's Starter Kit for the Arduino: http://www.sparkfun.com/products/10174

Installing Arduino on Linux (for different distributions): http://www.arduino.cc/playground/Learning/Linux

Command-Line Arduino Development: http://shallowsky.com/software/arduino/arduino-cmdline.html

Getting Started with Arduino by Massimo Banzi, O'Reilly Media/Make: http://shop.oreilly.com/product/9780596155520.do

Programming Interactivity: A Designer's Guide to Processing, Arduino, and openFrameworks by Joshua Noble, O'Reilly: http://shop.oreilly.com/product/9780596154158.do

Arduino Cookbook by Michael Margolis, O'Reilly: http://shop.oreilly.com/product/0636920022244.do

Arduino Language Reference: http://www.arduino.cc/en/Reference/HomePage

Tom Igoe's Physical Computing Page: http://www.tigoe.net/pcomp

Experimenter's Guide for Arduino: http://ardx.org/src/guide/2/ARDX-EG-ADAF-WEB.pdf

Arduino Tutorials (tronixstuff): http://tronixstuff.wordpress.com

Principia Labs, Arduino Serial Servo Control: http://principialabs.com/arduino-serial-servo-control

Make's Arduino Web Site: http://blog.makezine.com/arduino

Arduino Tutorial on Lady Ada: http://www.ladyada.net/learn/arduino