Figure 3-2 shows the wiring diagram for the Ping sensor and Arduino. Build the circuit, and then compile and upload the code using the Arduino IDE.

To see the readings, use the serial monitor (Arduino IDE→Tools→Serial Monitor). If you get gibberish instead of text, make sure that you specify the same speed (bit/s or “baud”) in both your code (Serial.begin) and the Arduino Serial Monitor.

Even though there is a lot of code in this example, it’s easy to reuse it so you can measure distance in your own projects. Just copy the supporting parts of the code (the distanceCm() function and global variables) and paste them into your own code. You can then measure distance with this line of code:

int d=distanceCm();

Because Ping works by listening to the echo of sound, its placement is quite important. If you always get the same reading (such as 2 cm), make sure that the wide beam of sound isn’t bouncing off of something, like the edge of your breadboard or a table. If you put Ping onto the edge of a breadboard, you’re not going to get reflections from it.

You can easily put Ping farther away from Arduino by using a servo extension cable, of the male-female type. Ping has just three pins, so it fits this type of cable perfectly.

Example 3-1 shows the complete code for reading a Ping ultrasonic distance sensor.

Figure 3-2. Ping sensor circuit for Arduino

// distance_ping.ino - distance using ultrasonic ping sensor
// (c) BotBook.com - Karvinen, Karvinen, Valtokari

int pingPin = 2;
float v=331.5+0.6*20; // m/s  // 

void setup()
{
  Serial.begin(115200);
}

float distanceCm(){
  // send sound pulse
  pinMode(pingPin, OUTPUT); // 
  digitalWrite(pingPin, LOW);
  delayMicroseconds(3); // 
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5); // 
  digitalWrite(pingPin, LOW);

  // listen for echo
  pinMode(pingPin, INPUT);
  float tUs = pulseIn(pingPin, HIGH); // microseconds  // 
  float t = tUs / 1000.0 / 1000.0 / 2; // s  // 
  float d = t*v; // m  // 
  return d*100; // cm
}

void loop()
{
  int d=distanceCm();   // 
  Serial.println(d, DEC);       // 
  delay(200); // ms     // 
}

Build the circuit for Ping in Raspberry Pi as shown in Figure 3-3, and then run the code listed in Example 3-2.

Figure 3-3. Ping sensor circuit for Raspberry Pi

# distance_ping.py - print distance
# (c) BotBook.com - Karvinen, Karvinen, Valtokari
import time # 
import botbook_gpio as gpio # 

def readDistanceCm():
        sigPin=22
        v=(331.5+0.6*20)

        gpio.interruptMode(sigPin, "both")      # 

        gpio.mode(sigPin, "out")        # 
        gpio.write(sigPin, gpio.LOW)    # 
        time.sleep(0.5) # s

        gpio.write(sigPin, gpio.HIGH)   # 
        time.sleep(1/1000.0/1000.0)     # 
        gpio.mode(sigPin, "in") # 

        #Read high pulse width
        t = gpio.pulseInHigh(sigPin) # s        # 
        d = t*v
        d = d/2 # 
        return d*100    # cm

def main():
        d = readDistanceCm()    # 
        print "Distance is %.2f cm" % d # 
        time.sleep(0.5)

if __name__ == "__main__":
        main()

Build the circuit as shown in Figure 3-5 and upload the code.

Figure 3-5. HC-SR04 sensor circuit for Arduino

// hc_sr04.ino - print distance to serial
// (c) BotBook.com - Karvinen, Karvinen, Valtokari

int trigPin = 8;
int echoPin = 7;
float v=331.5+0.6*20; // m/s

void setup()
{
  Serial.begin(115200);
  pinMode(trigPin, OUTPUT);     // 
  pinMode(echoPin, INPUT);      // 
}

float distanceM(){
  // send sound pulse
  digitalWrite(trigPin, LOW);
  delayMicroseconds(3);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(trigPin, LOW);

  // listen for echo
  float tUs = pulseIn(echoPin, HIGH); // microseconds
  float t = tUs / 1000.0 / 1000.0 / 2; // s
  float d = t*v; // m
  return d*100; // cm
}

void loop()     // 
{
  int d=distanceM();
  Serial.println(d, DEC);
  delay(200); // ms
}

Build the circuit (Figure 3-6) and upload the code shown in Example 3-4. Take notice that in addition to jumper wires, you also need to add two 10 kOhm resistors. (To identify resistors, you can use the method described in The Third Stripe Rule.) The code is very similar to Ping.

# hc-sr04.py - print distance to object in cm
# (c) BotBook.com - Karvinen, Karvinen, Valtokari
import time
import botbook_gpio as gpio

def readDistanceCm():
        triggerPin = 22 # 
        echoPin = 27

        v=(331.5+0.6*20) # m/s

        gpio.mode(triggerPin, "out")

        gpio.mode(echoPin, "in")
        gpio.interruptMode(echoPin, "both")

        gpio.write(triggerPin, gpio.LOW)
        time.sleep(0.5)

        gpio.write(triggerPin, gpio.HIGH)
        time.sleep(1/1000.0/1000.0)
        gpio.write(triggerPin, gpio.LOW)

        t = gpio.pulseInHigh(echoPin) # s

        d = t*v
        d = d/2
        return d*100    # cm

def main():
        d = readDistanceCm()    # 
        print "Distance is %.2f cm" % d
        time.sleep(0.5)

if __name__ == "__main__":
        main()

Figure 3-6. HC-SR04 sensor circuit for Raspberry Pi

Thunderstorm nearby? You can estimate the distance to where lightning is striking by comparing the time between seeing lightning and hearing the thunder. Count the number of seconds after you see a lightning flash. Each second corresponds to 330 meters to the location of the strike (the actual number differs depending on the air temperature; we’ll get into this shortly).

To play with the math, 330 meters/second * 3 seconds = 990 meters, so the sound moves roughly one kilometer in 3 seconds (and roughly one mile in 5 seconds). We see light nearly instantly, but the sound takes more time to reach us.

An ultrasonic sensor typically measures distances from 3 cm to 6 m. If you buy a distance measuring tool (“ultrasonic tape measure”) from a hardware store, it can go farther, about 20 m (it uses a cone to project sound and a thermometer to calibrate the speed of sound for the current air temperature).

The time it takes for sound to travel 1 centimeter is very short, just 30 microseconds: 30 millionths of a second. How to come up with this number?

For a difficult problem, especially one involving very small or very large numbers, it’s helpful to model it as an analogous problem using familiar, everyday quantities. For example, if I drive for two hours (t) at the speed (v) of 50 km per hour, isn’t that an annoyingly slow trip? But with t and v, you can calculate the distance (d):

t = 2 h

v = 50 km/h

d = t*v = 2 h * 50 km / h =
    2*50 km * h/h = 100 km

That seemed easy. Now we know that two hours is equivalent to 100 km in this system. Let’s try the exact same formula with a very short time (3.33 milliseconds), much faster speed, and base units of meters and seconds. (A milli- prefix means one thousandth, so a millisecond is one thousandth of a second.)

t = 3.33 ms = 0.00333 s

v = 330 m/s

d = t*v = 0.00333 s * 330 m/s = 1.10 m

This is how you can measure distance in your program with the ultrasonic ping sensor: if it takes 3.33 milliseconds for the reflected sound to return to you, it’s traveled 1.1 m.

If you read code written by others, you might also see someone count a pace for sound. Instead of noting meters per second, many examples count the inverse, seconds per meter, expressed as milliseconds/meter here:

1/v = 1/(330 m/s) = 0.00303 s/m = 3.03 ms/m

It takes about 3 milliseconds for sound to move a meter.

Sound moves faster when it’s warm. Sound is the vibration of air, and the vibrations move better if air molecules are already vibrating with heat. If you live in a warm place, we envy you because you probably need less calibration. In the north of Finland, it might be +22 C inside and -40 C outside, resulting in over 60 C difference in temperature. A change this big will clearly affect measurements. Temperature (T) affects the speed of sound (r) according to the formula

v = (331.3+0.606*T) m/s

This formula gives the speed of sound in practice (343 m/s at 20 C). If you start getting fancy with it, you could be calibrating for many factors. If you climb to a mountain or live in a submarine, you must also take into account the change in air pressure. If you go from the Sahara to a laundry room, calibrate for air humidity, too. That said, common commercial ultrasonic distance measuring tools tend to calibrate for temperature only.

When you use these calculations in your code, just put them in the beginning of the code. Arduino or Raspberry Pi can calculate them in an instant, and calculations outside loop() are performed only once anyway. Be sure to comment these calculations, and you will thank yourself when you can understand your code a week later.

You can easily fool an ultrasonic sensor so that it thinks there is nothing in front of it. Attach the sensor to a helping hand tool (aka third hand tool) and point it at a solid, flat object. Upload the code and open the serial monitor as you did earlier in this chapter. Now you should get a normal distance reading.

Next, try putting a soft pillow or similar plush object between the sensor and the solid object (see Figure 3-7). Check the serial monitor again. Is the solid object still there?

Inclined planes are another Achilles’ heel of ultrasonic sound sensors. Remove the soft object and start tilting the solid flat object that is facing the sensor. Keep checking the serial monitor as you tilt the object to a steeper angle.

Why does this happen? Soft objects (like our Monty Python killer rabbit in Figure 3-7) absorb so much sound that there’s not enough echo. On the other hand, an inclined plane echoes the sound, but in the wrong direction (not back at the sensor). This is similar to how a stealth aircraft fools radar.

Figure 3-7. Testing ping sensor with a soft object

Figure 3-10 shows how to connect Arduino to the infrared sensor. The sketch is shown in Example 3-5.

Figure 3-10. Infrared sensor connections on Arduino

// adjustable_infrared_sensor_switch.ino - print detection to serial and light LED.
// (c) BotBook.com - Karvinen, Karvinen, Valtokari

const int sensorPin = 8;
const int ledPin = 13;

//Sensor value
int switchState = 0;

void setup() {
  Serial.begin(115200); // 
  pinMode(sensorPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  switchState = digitalRead(sensorPin); // 
  Serial.println(switchState);  // 
  if(switchState == 0) {
    digitalWrite(ledPin, HIGH);
    Serial.println("Object detected!"); // 
  } else {
    digitalWrite(ledPin, LOW);
  }
  delay(10); // ms      // 
}

Figure 3-11 shows the wiring diagram for Raspberry Pi and the switch. The corresponding Python code is in Example 3-6.

Figure 3-11. Infrared sensor connections on Raspberry Pi

# adjustable-infrared-sensor-switch.py - read infrared switch
# (c) BotBook.com - Karvinen, Karvinen, Valtokari
import time
import botbook_gpio as gpio     # 

def main():
        switchPin = 27
        gpio.mode(switchPin, "in")      # 
        x = gpio.read(switchPin)        # 
        if( x == gpio.LOW ):    # 
                print "Something is inside detection range"
        else:
                print "There is nothing inside detection range"
        time.sleep(0.1)

if __name__ == "__main__":
        main()

Figure 3-16 shows the wiring diagram for Arduino and the compound eye. The Arduino sketch is shown in Example 3-7.

Figure 3-16. Compound eye connections on Arduino

// compound_eye.ino - print distance and direction values to serial
// (c) BotBook.com - Karvinen, Karvinen, Valtokari

const int irEnablePin = 8;      // 
const int irUpPin = 0;
const int irDownPin = 2;
const int irLeftPin = 1;
const int irRightPin = 3;

int distance = 0;       // 
int irUpValue = 0;
int irDownValue = 0;
int irLeftValue = 0;
int irRightValue = 0;

void setup() {
  Serial.begin(115200);
  pinMode(irEnablePin, OUTPUT);
}

void loop() {
  readSensor(); // 
  Serial.print("Values: "); // 
  Serial.print("irUpValue"); Serial.print(irUpValue); Serial.print(",");
  Serial.print("irDownValue"); Serial.print(irDownValue); Serial.print(",");
  Serial.print("irLeftValue"); Serial.print(irLeftValue); Serial.print(",");
  Serial.print("irRightValue"); Serial.print(irRightValue); Serial.print(",");
  Serial.print("distance"); Serial.println(distance);
  delay(100);
}

void readSensor() {
  digitalWrite(irEnablePin, HIGH);      // 
  delay(5); // ms       // 
  irUpValue = analogRead(irUpPin);
  irDownValue = analogRead(irDownPin);
  irLeftValue = analogRead(irLeftPin);
  irRightValue = analogRead(irRightPin);

  int ambientLight = 0; // 
  digitalWrite(irEnablePin, LOW);       // 
  delay(5);
  ambientLight = analogRead(irUpPin);   // 
  irUpValue = irUpValue - ambientLight; // 

  ambientLight = analogRead(irDownPin);
  irDownValue = irDownValue - ambientLight;

  ambientLight = analogRead(irLeftPin);
  irLeftValue = irLeftValue - ambientLight;

  ambientLight = analogRead(irRightPin);
  irRightValue = irRightValue - ambientLight;

  distance = (irUpValue+irDownValue+irLeftValue+irRightValue) / 4;      // 
}

The IR compound eye contains eight infrared-sensitive sensors, which are connected in pairs, so there is a total of four sensors you can read. Each IR sensor is read as an analog resistance sensor.

The Raspberry Pi requires an external ADC (analog-to-digital converter) to read the IR sensors. One MCP3002 chip can read two analog inputs. Because we need to read four sensors, we use two MCP3002 chips.

This circuit (shown in Figure 3-17) has many things in it, but the principle is simple: there are four analog resistance sensors, and you read them one by one. Build the circuit as shown, and then run the code shown in Example 3-8.

Figure 3-17. Compound eye connections on Raspberry Pi

# compound_eye.py - read distance and direction.
# (c) BotBook.com - Karvinen, Karvinen, Valtokari

import time
import botbook_gpio as gpio     # 
import botbook_mcp3002 as mcp   # 

irUpValue = 0   # 
irDownValue = 0
irLeftValue = 0
irRightValue = 0
distance = 0

def readCompoundEye():
        global irUpValue,irDownValue,irLeftValue,irRightValue,distance  # 
        ledPin = 25
        gpio.mode(ledPin, "out")        # 
        gpio.write(ledPin, gpio.HIGH)
        #Wait for sensors to get ready
        time.sleep(0.05)        # 

        irUpValue = mcp.readAnalog(0, 0)        # 
        irDownValue = mcp.readAnalog(1, 0)
        irLeftValue = mcp.readAnalog(0, 1)
        irRightValue = mcp.readAnalog(1, 1)

        ambientLight = 0
        gpio.write(ledPin, gpio.LOW)    # 
        time.sleep(0.05)
        ambientLight = mcp.readAnalog(0, 0)     # 
        irUpValue = irUpValue - ambientLight    # 
        ambientLight = mcp.readAnalog(1, 0)     # 
        irDownValue = irDownValue - ambientLight
        ambientLight = mcp.readAnalog(0, 1)
        irLeftValue = irLeftValue - ambientLight
        ambientLight = mcp.readAnalog(1, 1)
        irRightValue = irRightValue - ambientLight

        distance = (irUpValue+irDownValue+irLeftValue+irRightValue)/4   # 

def main():
        global irUpValue,irDownValue,irLeftValue,irRightValue,distance
        while True:     # 
                readCompoundEye()       # 
                print "Values:"
                print "Up: %f" % irUpValue
                print "Down: %f" % irDownValue
                print "Left: %f" % irLeftValue
                print "Right: %f" % irRightValue
                print "Distance: %f" % distance
                time.sleep(0.5) # s     # 

if __name__ == "__main__":
        main()

The compound eye has quite a few connections by itself. Combined with the ADCs, this means a lot of jumper wires.

The MCP3002 analog-to-digital converter uses the SPI protocol. SPI is quite a complicated protocol, but you can install the SpiDev library to handle the details.

The SpiDev library is required by all code that uses import spidev. This includes the potentiometer code for Raspberry Pi, and every analog resistance sensor used in this book, because SpiDev is imported by botbook_mcp3002.

On your Raspberry Pi, open a terminal. First, install prerequisites:

$ sudo apt-get update
$ sudo apt-get -y install git python-dev

Download the latest version of SpiDev from its version control site:

$ git clone https://github.com/doceme/py-spidev.git
$ cd py-spidev/

And install it to your system:

$ sudo python setup.py install

Next, you need to enable the SPI module on the Raspberry Pi. First, make sure it is not disabled. Edit the /etc/modprobe.d/raspi-blacklist.conf with the command sudoedit /etc/modprobe.d/raspi-blacklist.conf and delete this line:

blacklist spi-bcm2708

Save the file: press Control-X, type y, and then press Enter or Return.

To allow access to SPI without root, copy the udev file from Example 3-9 (or from the example code in the botbook_mcp3002 directory) into place:

$ sudo cp 99-spi.rules /etc/udev/rules.d/99-spi.rules

# /etc/udev/rules.d/99-spi.rules - SPI without root on Raspberry Pi
# Copyright 2013 http://BotBook.com

SUBSYSTEM=="spidev", MODE="0666"

Reboot your Raspberry Pi, open LXTerminal, and confirm that you can see the SPI devices and that the ownership is correct:

$ ls -l /dev/spi*

The listing should show two files, and they should list permissions of crw-rw-rwT. If not, go over the preceding steps again.

Now you can use MCP3002 chip and other SPI devices with Raspberry Pi.

The Raspberry Pi circuit for IR compound eye is quite complicated. Even though it’s not hard to understand, it has a lot of wires to connect. To build a simpler system, you could either use a another ADC or an Arduino (see Pi + Arduino).

To get by with just one ADC chip, you could use MCP3008 ADC, which has eight inputs. That would require modifying the botbook_mcp3002 library, though. You could also look into using Adafruit’s MCP3008 code (see https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code).

In the Posture Alarm project, you’ll learn how to:

A piezoelectric crystal changes shape when you apply voltage to it. By using alternating current (AC) or a simple on-off square wave, you can make the piezo crystal vibrate. This makes the air vibrate, and air vibration is sound. In this case, an annoying sound.

Figure 3-19. A piezo speaker

The most common piezo element beeps when you send it a square wave (Figure 3-19). A square wave varies between HIGH (5 V for Arduino) and LOW (0 V).

You can easily create a square wave by repeatedly turning a data pin on and off with digitalWrite. Alternatively, you could use the built-in tone() function that uses a more advanced and complicated implementation to produce the same wave.

Figure 3-20. Piezo beeper connected

// piezo_beep.ino - beep on a given frequency with a piezo speaker
// (c) BotBook.com - Karvinen, Karvinen, Valtokari

int speakerPin = 10;

void wave(int pin, float frequency, int duration)       // 
{
  float period=1/frequency*1000*1000; // microseconds (us)      // 
  long int startTime=millis();  // 
  while(millis()-startTime < duration) {        // 
    digitalWrite(pin, HIGH);    // 
    delayMicroseconds(period/2);
    digitalWrite(pin, LOW);
    delayMicroseconds(period/2);
  }
}

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

void loop()
{
  wave(speakerPin, 440, 500);   // 
  delay(500);
}

It’s time to advance from a beep to a whole new world of notes: the alarm.

// piezo_alarmtone.ino - use piezospeaker to sound alarm sound
// (c) BotBook.com - Karvinen, Karvinen, Valtokari

int speakerPin = 10;

void wave(int pin, float frequency, int duration)       // 
{
  float period=1 / frequency * 1000 * 1000; // microseconds (us)
  long int startTime=millis();
  while(millis()-startTime < duration) {
    digitalWrite(pin, HIGH);
    delayMicroseconds(period/2);
    digitalWrite(pin, LOW);
    delayMicroseconds(period/2);
  }
}

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

void loop()
{
  wave(speakerPin, 440, 40);    // 
  delay(25);
  wave(speakerPin, 300, 20);
  wave(speakerPin, 540, 40);
  delay(25);
  wave(speakerPin, 440, 20);
  wave(speakerPin, 640, 40);
  delay(25);
  wave(speakerPin, 540, 20);
}

Build the posture alarm circuit (Figure 3-21). Upload the code and prepare for a life with better posture—or endless alarm.

Figure 3-21. Posture alarm build

// posture_alarm.ino - sound an alarm when IR switch detects bad posture
// (c) BotBook.com - Karvinen, Karvinen, Valtokari

int speakerPin = 10;
const int sensorPin = 2;
int switchState = 0;

void wave(int pin, float frequency, int duration)       // 
{
  float period=1/frequency*1000*1000; // microseconds (us)
  long int startTime=millis();
  while(millis()-startTime < duration) {
    digitalWrite(pin, HIGH);
    delayMicroseconds(period/2);
    digitalWrite(pin, LOW);
    delayMicroseconds(period/2);
  }
}

void alarm() // 
{
  wave(speakerPin, 440, 40);
  delay(25);
  wave(speakerPin, 300, 20);
  wave(speakerPin, 540, 40);
  delay(25);
  wave(speakerPin, 440, 20);
  wave(speakerPin, 640, 40);
  delay(25);
  wave(speakerPin, 540, 20);
}

void setup()
{
  pinMode(speakerPin, OUTPUT);
  Serial.begin(115200);
  pinMode(sensorPin, INPUT);
}

void loop()
{
  switchState = digitalRead(sensorPin);
  Serial.println(switchState,BIN);
  if (switchState==0) { // 
    alarm(); // 
  }
  delay(10);
}

Prototypes are more impressive and robust when you put them inside an enclosure. We used a box for Arduino made by SmartProjects, because it happened to be an exact fit for this project. First we sprayed the whole thing black and made a hole for the infrared sensor with a 19 mm drill bit (see Figure 3-22).

Figure 3-22. Hole for the infrared sensor

We removed the little hatch from the back of the chassis to make the sensor fit inside better and to be able to adjust the distance screw later (see Figure 3-23).

We attached the sensor in place with the plastic nuts that are part of it. You can slide the Arduino through the posts in the chassis, and it will stay put nicely, as shown in Figure 3-24.

Figure 3-23. From the back of the chassis, you can adjust the distance screw

Figure 3-24. Insides of posture alarm

Close the enclosure by pushing the top and bottom half together, and you’re ready to start protecting your posture (see Figure 3-18). This box has a ready-made hole for the USB cable, so now you actually have a neat-looking USB gadget to decorate your workspace.

You have now learned to measure distance using multiple methods. Your projects can know if something is near or how far it is to objects nearby. With more than one sensor, you can create more sophisticated behaviors. For example, combine two IR sensors with a servo motor and make it turn toward the direction of the nearest detected object. This way you would have a simple hand follower. Two IR receivers in a rover robot would enable it to follow flame. How will you use distance sensors in your projects?