meisjohn's Projects

Let's Add Sensors, Part 2

2011-02-03T01:19:00.001-05:00

In my last post, we worked through digital inputs using push-buttons, and we also started looking at interrupts. This time we'll start looking at how to interface an analog sensor. These sensors can be range-finders (I have a Sharp GP2D12), potentiometers (adjustable resistors) and environmental sensors (temperature, humidity, force, accelerometer, gyros, et cetera.)

Now that we know what we're dealing with, let's get down to business...

The analog pins are extremely easy to read, in fact, all you need is

int sensorValue = analogRead(SENSOR_PIN);

No setting up of pins, no starting of any magic converters, just go and read the thing. Not bad.

Now that you know how to read your analog input, you need to make sense of it. This is when you'll need to look at the datasheet for your sensor. You can look at the one for my sensor above. In there, you'll probably find some sort of chart that maps the output voltage to whatever it is measuring (in this case, Volts-to-cm.) Here's the one for my sensor:

Now, keeping in mind that the 10-bit A/D converter will give us 1024 possible results and I'm not that completely concerned with precision (and I'm lazy), we can pick some points on the graph. Another thing to consider is that the A/D converter doesn't return volts, it gives you a number from 0 to 1023 equaling 0 to 5 volts. I eye-balled the chart above and came up with the following values:

Volts	A/D Value	Distance
2.4	490	10
2.0	408	13
1.6	327	17
1.4	286	20
1.0	204	30
0.80	163	38
0.70	143	40
0.65	133	50
0.50	102	60
0.45	92	70
0.40	82	80

Alternatively, you could calibrate this table to your exact sensor by following this tutorial and using a ruler and adjust the values accordingly. I'm not particularly concerned with precision at the moment, but I may come back to that option later.

After we have our distance points, we'll use our handy geometry skills to make a slope between two known points using the following slope equations:

y = m * x + c

where:
y = value x = distance m = slope c = constant adjustment

and:

m = (y1 - y2) / (x1 - x2)

where:
x1, y1 = the first known point on our graph x2, y2 = the second known point on our graph

Another thing to keep in mind is sensor timing. Using the timing chart from the datasheet we see that that the sensor will only be able to provide data so quickly, and there's a delay between the measurement and the availability of the data. Knowing this, we need to add an initial delay in the setup routine and a delay between every time we read the sensor data.

If we stop our sketch with just a loop that continuously reads the data and logs it to Serial, it would give us a ridiculous amount of output. So, we're going to combine this sketch with the last one and modify it to only output once when the button is pressed, sort of like a camera shutter.

Here's what we've got going so far:

 
/*
 *  Analog Sensor Test (Sharp GP2D12)
 *  with button for logging enable.
 *
 */


// This identifies the interrupt number for our chipset:
//   0 = digial pin 2
//   1 = digital pin 3
#define INTERRUPT_NUM 1 

// set up the button pin to match the interrupt number.
#define BUTTON_PIN 3 
// set up the a pin drive the button
#define DRIVER_PIN 4 

// identify the current LED state this is volatile because 
// the toggleLed routine which changes the value will be
// called from an interrupt. This is important because 
// we'll be using this variable in our loop routine.
volatile int button_state = HIGH; 

// our sensor has a maximum time between the measurement and
// the data being ready to read.  This is just an initial 
// delay that is only added on the start of the program.
#define SENSOR_INIT_DELAY 5

// our sensor has a delay between read-times of 48ms, meaning
// new data is only available every 48 ms.
#define SENSOR_DELAY 48

// select the analog pin we're going to use
#define SENSOR_PIN A0

struct ValueToDist {
  int value;
  int dist;
};

// We need to identify values to feed to our algorithm
// and since we know that the sensor is only ranged from
// 0 - 2.5V, we can ignore half the data points, additionally
// we're going to give a relatively small sample set (compared
// to the 1024 possible values)
ValueToDist valueDistTable[] =
 { {490, 10},
   {408, 13},
   {327, 17},
   {286, 20},
   {204, 30},
   {163, 38},
   {143, 40},
   {133, 50},
   {102, 60},
   {92,  70},
   {82,  80} };

int getDistance( int value )
{
  ValueToDist left;
  ValueToDist right;
  float slope;
  float c;
  
  int result = -1;
  
  // Test for the value being out of bounds
  if (value > valueDistTable[0].value || 
      value < valueDistTable[11].value )
  {
    Serial.println("value out of bounds");
    result = -1;
  }
  // test for the value at the closer edge of valid values
  else if ( value == valueDistTable[0].value )
  {
    result = valueDistTable[0].dist;
  }
  // test for the value at the further edge of valid values
  else if ( value == valueDistTable[11].value)
  {
    result = valueDistTable[11].dist;
  }
  // handle all other points in between
  else
  {
    // loop through the table, except the last one
    for (int i = 0; i < 11; i++ )
    {
      // if the value is between the current and next point
      if ( value <= valueDistTable[i].value && 
           value > valueDistTable[i+1].value )
      {

         Serial.print("found value range, upper =");
         Serial.print(valueDistTable[i].value);
         Serial.print(" lower =");
         Serial.println(valueDistTable[i+1].value );

         // using a simple slope algorithm to find
         // the value on the line between two known
         // points
         //   value=slope * dist + c
         left=valueDistTable[i];
         right=valueDistTable[i+1];

         // calculate the slope from the known points
         slope = ( (left.value - right.value) / (left.dist - right.dist));
         // get the slope constant using one of the known points
         c = left.value-slope*left.dist;

         // get the results from the algorithm
         result=int((value - c) / slope);

         // break out of the loop, because we've found what we're looking for
         break;
      }
    }
  }  
  
  return result;
}

void toggleLed()
{
  // read in the current state of the button
  button_state=digitalRead(BUTTON_PIN);
}

void setup()
{
  // add the driver pin
  pinMode(DRIVER_PIN, OUTPUT);
  // set the driver pin to LOW
  digitalWrite(DRIVER_PIN, LOW);
  
  // add the driver pin
  pinMode(BUTTON_PIN, INPUT);
  // enable the pull-up register
  digitalWrite(BUTTON_PIN, HIGH);
  
  // Identify the routine and conditions for our interrupt. An interrupt
  // can have only one routine attached, and that routine takes no inputs
  // and returns no output.  The specified routine will be called in 
  // the midst of the normal loop processing, so any variables that are
  // changed should probably be marked as volatile, if they are real-time
  // critical.  For our purposes, it's not necessary, but it may be 
  // significant if we have more robust processing of data changed in an 
  // interrupt routine.
  attachInterrupt(INTERRUPT_NUM, toggleLed, CHANGE); 
 
  // start serial port at 9600 bps:
  Serial.begin(9600);

  delay(SENSOR_INIT_DELAY);
}

void loop()
{
  // As noted above, the sensor can only translate data so
  // quickly, so each time through loop, we need to delay 
  // the read of the next sensor value
  delay(SENSOR_DELAY);                  

  // only calculate the distance if the button is pressed
  if (LOW == button_state)
  {
    // read the value from the sensor:
    int sensorValue = analogRead(SENSOR_PIN);
    int dist = getDistance(sensorValue);

    // if the button is being pressed, send the data to the
    // serial interface.
    Serial.print("sensor val = ");
    Serial.print(sensorValue);
    Serial.print("  distance = " );
    Serial.println(dist);
    
    // reset the button state so that we only get one reading
 // per button press
    button_state=HIGH;
  }
}

Here's the fritzing diagram of our setup:

and here's the link for the code.

Let's Add Sensors, Part 1

2011-01-26T00:00:00.000-05:00

Now that we can act on the physical realm, let's add sensors to observe it. There's all sorts of sensors out there, but there three basic interfaces to those sensors, digital, analog or via some sort of higher-level communications protocol (i2c, serial, parallel, et cetera).

I've got some of each of these, so we'll go through and try them each out one-by-one. Let's pick the digital inputs first.

To demonstrate this interface, I'm going to use a push-button switch. These things are everywhere. Most of mine were harvested from an old VCR. This is the simplest sensor for use with your arduino, because, well, the output is either 1 or 0. (We will ignore debounce for now.)

Since you can read the input simply by reading in the pin, the easiest thing to do would be to put this logic into your loop() routine and do it repetitively. Alternatively, you could set up an interrupt. Interrupts are special creatures that allow a routine (commonly referred to as an Interrupt Service Routine, ISR for short) to get called when a pin's state changes. By migrating your "on change" code into the ISR, you're doing less work on every loop.

I'm deciding to go the interrupt path, because it allows me to demonstrate more things at once, and well, it sounds like more fun. My sketch will have a button that turns off our LED from the previous examples. The button will trigger the toggleLed() ISR. Also, for the sake of simplifying the electronics, the pin adjacent to the BUTTON_PIN (I'm calling it DRIVE_PIN) will be used to identify the button state and the button will be between the two pins. When the button is pressed, the BUTTON_PIN will observe a low state (based on the state of the DRIVE_PIN) and vice-versa. To ensure that the BUTTON_PIN state is high by default, we are using internal pull-up resistors in the chip. The schematic for this set-up is below:

/*
   * Push Button Test
   *
   */
   
  #define LED_PIN 13         
  #define INTERRUPT_NUM 1         // This identifies the interrupt number for
                                  // our chipset:
                                  //   0 = digial pin 2
                                  //   1 = digital pin 3
                                
  #define BUTTON_PIN 3            // set up the button pin to match the interrupt
                                  // number.
  #define DRIVER_PIN 4            // set up the a pin drive the button

  volatile int led_state = HIGH;  // identify the current LED state
                                  // this is volatile because the toggleLed
                                  // routine which changes the value will be
                                  // called from an interrupt. 

  void toggleLed()
  {
    // read in the current state of the button
    // and enable the LED state based on the button state
    led_state=digitalRead(BUTTON_PIN);
    
    // write the new state out to the LED pin
    digitalWrite(LED_PIN, led_state);
  }


  void setup()
  {
    // set up the same LED as we have been
    pinMode(LED_PIN, OUTPUT);
    
    // add the driver pin
    pinMode(DRIVER_PIN, OUTPUT);
    // set the driver pin to LOW
    digitalWrite(DRIVER_PIN, LOW);
    
    // add the driver pin
    pinMode(BUTTON_PIN, INPUT);
    // enable the pull-up register
    digitalWrite(BUTTON_PIN, HIGH);
    
    // Identify the routine and conditions for our interrupt. An interrupt
    // can have only one routine attached, and that routine takes no inputs
    // and returns no output.  The specified routine will be called in 
    // the midst of the normal loop processing, so any variables that are
    // changed should probably be marked as volatile, if they are real-time
    // critical.  For our purposes, it's not necessary, but it may be 
    // significant if we have more robust processing of data changed in an 
    // interrupt routine.
    attachInterrupt(INTERRUPT_NUM, toggleLed, CHANGE); 
  }

  void loop()
  {
    // nothing to do here, since it's all taken care of in the interrupt
  }

Now, we can control the state of the LED manually by pressing a button. This isn't earth shattering or particularly complex, but it does demonstrate a couple of principles (ISRs, Digital write, digital read, internal pull-up resistors.) Another interesting note is that you don't need to actually read the interrupt pin in the ISR, it could be used to trigger something completely different, like reading different pins' values, or enabling some additional behavior, or even waking up the arduino (think back to the sleep mode we entered in the last post).

Looking forward, and applying what we've learned...

Eventually, I'm thinking that I'll use these buttons to detect when my little bot has bumped into something. Because the arduino only has 2 interrupt pins, I'm going to need to be creative when doing this. I've got an assortment of ICs, so I think I'm going to "XOR" their states together to drive the ISR pin, so that I can have the ISR trigger when any of their states change. I will also connect them to digital pins, so that in the ISR, we can read all the inputs. I plan to use the 74LS86N Quad 2-input XOR gate from my goody-bag.

Up Next: Servo and Serial

2011-01-22T04:24:00.000-05:00

Okay, we've got the computer and the arduino board working together. Let's start doing something interesting, like driving a Servo. Again, I did a little research on the Arduino website, and started with one of the sample sketches.

This has me thinking back to college where I spent many hours getting a Motorola HC12 to drive a servo. You had to enable the right pins, configure your PWM channels to make sure your duty cycles matched the servo specifications, break out the old monster of an oscilloscope to figure out what you're actually sending, when it doesn't work-- all in assembly code.

So, how do you do it with Arduino?

 
#define SERVO_PIN 11

Servo myservo;  // create servo object to control a servo 
                // a maximum of eight servo objects can be created 

void setup () 
{
  myservo.attach(SERVO_PIN);  // attaches the servo pin to the servo object 

}

void loop ()
{
  myservo.write(45); // go to the first quarter position
  delay(1000);
  myservo.write(90); // go to the middle point
  delay(1000);
  myservo.write(135); // go to the last quarter position
  delay(1000);
}

Are you kidding me? It almost makes me want to cry when I think how much time I spent debugging a similar procedure just a few years ago.

Okay, now I've got software affecting the physical realm. This is where robotics starts to get really exciting. (I said starts...) So, what to do next?

Let's throw that blinky LED back in and have the servo move a little smoother through it's full range of motion. I'm going to set the LED the same way as the previous post, call a new routine to toggle it, and a couple of loops for the servo.

 
for(pos = 0; pos < 180; pos += 5)  // goes from 0 degrees to 180 degrees 
{                                  // in steps of 5 degrees
  myservo.write(pos);              // tell servo to go to position in variable 'pos' 
  delay(50);                       // waits 50ms for the servo to reach the position 
  toggleLed();
} 

for(pos = 180; pos>=0; pos-=5)     // goes from 180 degrees to 0 degrees 
{                                
  myservo.write(pos);              // tell servo to go to position in variable 'pos' 
  delay(50);                       // waits 50ms for the servo to reach the position 
  toggleLed();
}

Nice, now we've got some smooth motion, and some blinking action too. Okay, now we've got this going back and forth fairly smoothly, ad infinitum. Let's see if we can take some control over the situation here... let's take advantage of the Serial connection.

The Serial interface is nearly as simple as the Servo one. You can read and write to your computer over the USB cable, so when you open the Serial Monitor in the Arduino Environment, you can read what it has to say, and tell it to do things. So, let's make an interface to tell the servo to move somewhere.

 
char buffer[9];      // a buffer to store data coming back from the serial interface
char buffer_pos = 0; // the current position into the buffer

void setup() 
{ 
  // start serial port at 9600 bps:
  Serial.begin(9600);

  ...
} 

void loop() 
{ 
  int read_val;  // variable to store the integer from the Serial.read() method
                 // this is the ASCII value of what is typed in at the Serial
                 // Monitor window
  
  // if we've got something ready from the serial interface
  if ( Serial.available() > 0 )  
  {
    // read in the data, up to the max size of the buffer.
    while( -1 != (read_val = Serial.read() ) && buffer_pos < 8)
    {
      // put the value in the buffer, and increment the position
      buffer[buffer_pos++] = read_val;  
    }
    buffer[buffer_pos] = '\0';       // terminate the string.
    Serial.print("Read in value: "); // add some feedback to the Serial Monitor
    Serial.println(buffer);          //   so we know the command was received
    pos = atoi(buffer);              // turn the input data into an integer value
    pos = (pos < 170 ? pos : 170);   // clamp the input values at reasonable 
    pos = (pos > 0 ? pos : 0);       //  values for your servo.  Mine is finicky ~ 180
    Serial.print("Moving to ");      // Tell Serial Monitor where we're actually going
    Serial.print(pos);
    myservo.write(pos);              // And go there.
    toggleLed();
    delay(1000); 
    buffer_pos = 0;                  // Clean up after ourselves.
    memset(buffer,0,9);
  }
}

Nice, now we have manual control over the servo, and we're able to see where it is going, and where it has been, all this using only a few pins on the Arduino.

Okay, now that we can make it go, let's figure out how to make it stop. Arduino doesn't have a "stop" command that I've been able to find yet, but avr does have power controls. Let's just tell it to go to sleep and reduce as much power as it can.

 

#include <avr/sleep.h>

void loop()
{
  ...

    if (pos == -1)                   // If we've received the "all done" command 
    {
      set_sleep_mode(SLEEP_MODE_PWR_DOWN); // set the sleep mode
      sleep_enable();                // enable sleeping
      sleep_mode();                  // then activate the sleep mode
    }

  ...
}

Okay, now we can conserve our power when we've completed our task.

Let's put everything we've learned here together.

A link for the source code is here.

 
/* Serial Servo Control
 *
 * Derived from:
 *   Sweep by BARRAGAN <http://barraganstudio.com>
 */

#include <Servo.h>
#include <stdlib.h> //atoi
#include <avr/sleep.h>

#define LED_PIN 13
#define SERVO_PIN 11

Servo myservo;       // create servo object to control a servo 
                     // a maximum of eight servo objects can be created 

int pos = 0;         // variable to store the servo position 
char led_state = 0;  // variable to store the state of the LED
char buffer[9];      // buffer for storing the inputs from the Serial
                     //   interface
char buffer_pos = 0; // current writing position for the buffer


void toggleLed()
{
  // If the LED is on
  if (led_state) 
  { 
    // then turn it off.
    digitalWrite(LED_PIN,LOW);
  }
  else
  {
    // otherwise, turn it on
    digitalWrite(LED_PIN,HIGH);
  }
  
  // toggle the LED state variable
  led_state=!led_state;
}

void setup() 
{ 
  // start serial port at 9600 bps:
  Serial.begin(9600);

  pinMode(LED_PIN, OUTPUT);  // enable the LED pin
  myservo.attach(SERVO_PIN); // attaches the servo pin to the servo object 

} 
 
 
void loop() 
{ 
  int read_val;  // variable to store the integer from the Serial.read() method
                 // this is the ASCII value of what is typed in at the Serial
                 // Monitor window
                 
  // if we've got something ready from the serial interface
  if ( Serial.available() > 0 )
  {
    // read in the data, up to the max size of the buffer.
    while( -1 != (read_val = Serial.read() ) && buffer_pos < 8)
    {
      // put the value in the buffer, and increment the position
      buffer[buffer_pos++] = read_val;
    }
    buffer[buffer_pos] = '\0';       // terminate the string.
    Serial.print("Read in value: "); // add some feedback to the Serial Monitor
    Serial.println(buffer);          //   so we know the command was received
    pos = atoi(buffer);              // turn the input data into an integer value
    if (pos == -1)                   // If we've received the "all done" command
    {
      set_sleep_mode(SLEEP_MODE_PWR_DOWN);  // set the sleep mode
      sleep_enable();                // enable sleeping
      sleep_mode();                  // then activate the sleep mode
    }
    pos = (pos < 170 ? pos : 170);   // clamp the input values at reasonable 
    pos = (pos > 0 ? pos : 0);       //  values for your servo.  Mine is finicky ~ 180
    Serial.print("Moving to ");      // Tell Serial Monitor where we're actually going
    Serial.print(pos);
    myservo.write(pos);              // And go there
    toggleLed();
    delay(10000); 
    buffer_pos = 0;                  // And clean up after ourselves.
    memset(buffer,0,9);
  }
  else
  {
    
    Serial.println("Moving 0 to 180");
    for(pos = 0; pos < 180; pos += 5)  // goes from 0 degrees to 180 degrees 
    {                                  // in steps of 5 degrees
      myservo.write(pos);              // tell servo to go to position in variable 'pos' 
      delay(50);                       // waits 50ms for the servo to reach the position 
      toggleLed();
    } 
    Serial.println("Moving 180 to 0");
    for(pos = 180; pos>=0; pos-=5)     // goes from 180 degrees to 0 degrees 
    {                                
      myservo.write(pos);              // tell servo to go to position in variable 'pos' 
      delay(50);                       // waits 50ms for the servo to reach the position 
      toggleLed();
    } 
  }
}

Connecting to Arduino & My First Sketch

2011-01-22T00:29:00.003-05:00

I just received my first Arduino board (the Uno) as part of my spoils from the SparkFun Electronics free day.

My goal? Toy around, clearly. But seriously, I'd like to build some sort of autonomous robot eventually. I'd love to get my kids involved at some level, but they're still very young. We'll see how that works out eventually.

First things first, though... let's get a blinky app going.

I'm currently using the arduino environment to get started. I may switch to the Eclipse AVR plugin, but that's for another day.

Here's my first sketch:

 
/*
 * First Arduino sketch - Blinky
 *
 */
 
 
#define LED_PIN 13

void turnOnLedShort(char pin);
void turnOnLedLong(char pin);


void setup() {                
  pinMode(LED_PIN, OUTPUT);    
}

void loop() {
  // Morse Code "SOS"

  // S
  turnOnLedShort(LED_PIN);
  turnOnLedShort(LED_PIN);
  turnOnLedShort(LED_PIN);  

  // O
  turnOnLedLong(LED_PIN);
  turnOnLedLong(LED_PIN);
  turnOnLedLong(LED_PIN);  

  // S
  turnOnLedShort(LED_PIN);
  turnOnLedShort(LED_PIN);
  turnOnLedShort(LED_PIN);  
  
  delay(1000);
}


void turnOnLedShort(char pin)
{
  digitalWrite(pin, HIGH); 
  delay(500);
  digitalWrite(pin, LOW);
  delay(500);
}

void turnOnLedLong(char pin)
{
  digitalWrite(pin, HIGH); 
  delay(1000);
  digitalWrite(pin, LOW);
  delay(500);
}

Once the program was written, I needed to connect to the Arduino board. Plugged it into my USB port and got this in my dmesg output:

 
usb 6-1: new full speed USB device using ohci_hcd and address 2
usb 6-1: New USB device found, idVendor=2341, idProduct=0001 
usb 6-1: New USB device strings: Mfr=1, Product=2, SerialNumber=220
usb 6-1: Product: Arduino Uno
usb 6-1: Manufacturer: Arduino (www.arduino.cc)
usb 6-1: SerialNumber: 012345689ABCDEF
usb 6-1: configuration #1 chosen from 1 choice
cdc_acm 6-1:1.0: ttyACM0: USB ACM device
usbcore: registered new interface driver cdc_acm
cdc_acm: v0.26:USB Abstract Control Model driver for USB modems and ISDN adapters

Nice, it connected... The out of the box blinking test program was working fine, so the Uno had power, and it was functional. Let's upload my program!

First, you've got to configure your arduino envionment. To do that, change your Arduino preferences file (~/.arduino/preferences.txt). Change the line:

serial.port=COM1

to:

serial.port=/dev/ttyACM0

Open the Arduino envionment, compile my sketch, and click upload... Here we go!

 
processing.app.SerialNotFoundException: Serial port '/dev/ttyACM0' not found.  Did you select the right one from the Tools > Serial Port menu?
        at processing.app.Serial.<init>(Serial.java:153)
        at processing.app.Serial.<init>(Serial.java:76)
        at processing.app.debug.Uploader.flushSerialBuffer(Uploader.java:75)
        at processing.app.debug.AvrdudeUploader.uploadViaBootloader(AvrdudeUploader.java:93)
        at processing.app.debug.AvrdudeUploader.uploadUsingPreferences(AvrdudeUploader.java:56)
        at processing.app.Sketch.upload(Sketch.java:1603)
        at processing.app.Sketch.exportApplet(Sketch.java:1568)
        at processing.app.Sketch.exportApplet(Sketch.java:1524)
        at processing.app.Editor$DefaultExportHandler.run(Editor.java:2293)
        at java.lang.Thread.run(Unknown Source)

Fail. Okay, Google can help me, and so I sought after an answer. After a little while, it was apparent that the permissions for the device were wrong. I could have just switched to root, and chmod it, but that'd be a temporary solution. I decided to write a udev rule for arduino instead. Here's what I came up with for /lib/udev/rules.d/90-arduino.rules (Your path may be different. I'm running Slackware Linux.)

 
KERNEL=="ttyACM*", ATTRS{product}=="Arduino*", SYMLINK+="arduino%n", MODE="0666"

Restarted udev, and plugged the Uno back in, clicked the "Upload" button again. "Done uploading." in the status bar. Success! My little arduino board is now blinking - - - __ __ __ - - -.