The Ultrasonic Sensor by Adalberto Sharpley

The Ultrasonic Sensor In my opinion, this is the coolest part about building this robot. It is here that we give our robot some very elementary autonomous capability with an ultrasonic distance sensor. This is an amazing little device that will quickly and accurately report the distance an object is away from out robot. With this we program our robot to have some basic collision avoidance.

this sensor is sorta kinda like a little miniature radar. It works by emitting a sound pulse, and measuring how long it takes for the pulse to reflect back ( humans cannot hear the sound, hence the name ultrasonic). Velocity = distance / time ( i.e. mile per hour ). So then distance = velocity * time, the ultrasonic sensor will report the time it takes the pulse to reflect, we actually want half that amount, since the pulse going there and back is actually twice the distance to the object. Then we just need the velocity, which for us is the speed of sound in air.

To demonstrate this and get started with the sensor, lets hook up the sensor to the Arduino, and write a simple program that displays the distance measured to the Serial Monitor. There are three pins on the sensor, Vcc and Gnd, which supply power, and SIG . Connect the SIG pin to port 11.

I found the following code online, you can find it, and a good description of it here.

const int pingPin = 11; unsigned int duration, inches; void setup() { Serial.begin(9600); } void loop() {

pinMode(pingPin, OUTPUT);

// Set pin to OUTPUT

digitalWrite(pingPin, LOW);

// Ensure pin is low

delayMicroseconds(2); digitalWrite(pingPin, HIGH);

// Start ranging

delayMicroseconds(5);

digitalWrite(pingPin, LOW);

// End ranging

pinMode(pingPin, INPUT);

// Set pin to INPUT

with 5 microsecond burst

duration = pulseIn(pingPin, HIGH); // Read echo pulse inches = duration / 74 / 2;

// Convert to inches

Serial.println(inches);

// Display result

delay(200);

// Short delay

}

An very good explanation and example calculation is provided at the link I referenced for this code. The key part is that the distance to the object in front of the sensor is equal to the time reported divided by 74, divided by 2. I got this to work simply using my hand.

There is an interesting little quirk about using the ultrasonic distance sensor, it sometimes wonâ&#x20AC;&#x2122;t work, and the way to get it to work is to disconnect and then reconnect the PWR wire, with the others still connected. Put another way you should hook up the PWR wire last. Now that we know how to use the ultrasonic sensor, lets incorporate it into our robot. All we need to do for the hardware is connect 3 wires (PWR, GND, SIG) SIG is connected to port 11. We also need to add some code to make use of the sensor. This is an area where we could get pretty sophisticated trying to add Artificial Intelligence, and make our robot find its way around. Lets keep it simple for now and just have tracky stop, backup, and turn left when an obstacle is encountered. Here is the code to do it. const int pingPin = 6;

// test for obstacle int duration, inches=3; pinMode(pingPin, OUTPUT);

// Set pin to OUTPUT

digitalWrite(pingPin, LOW);

// Ensure pin is low

delayMicroseconds(2); digitalWrite(pingPin, HIGH);

// Start ranging

delayMicroseconds(5);

// with 5 microsecond burst

digitalWrite(pingPin, LOW);

// End ranging

pinMode(pingPin, INPUT);

// Set pin to INPUT

duration = pulseIn(pingPin, HIGH); // Read echo pulse inches = duration / 74 / 2;

// Convert to inches

Serial.println(inches);

// Display result

delay(200);

// Short delay

if( inches < 3 && inches > 0) { Serial.println("obstacle detected"); tracky.Stop(); tracky.DriveBackward(); delay(1000); // go backwards briefly tracky.TurnLeft(); tracky.Stop(); tracky.DriveForward(); } delay(200); And finally here is the full code implementing both remote control and the ultrasonic sensor!

// adds second motor and 2 button control #include <IRremote.h> // pin assignments const int pingPin = 6; // need to set these const int RECV_PIN = 4; const int directionPinA = 12; const int directionPinB = 13; const int motorPinA = 3; const int motorPinB = 11; const int brakePinA = 9; const int brakePinB = 8; // hex code assigned to a button press const long forward_button = 0xFD807F;

// uses 'VOL+' button

const long stop_button = 0xFDA05F;

// uses 'Play' button

const long reverse_button = 0xFD906F;

// uses 'VOL-' button

const long left_button = 0xFD20DF;

// uses 'prev' button

const long right_button = 0xFD609F;

// uses 'next' button

const long repeat = 0xFFFFFFFF; // global vars const int AFORWARD = LOW; const int BFORWARD = HIGH; IRrecv irrecv(RECV_PIN); decode_results results; long current_command = 0; long previous_command = 0; // speed is used globally for motion and steering const int MAX_SPEED = 255; // use speed 255 // main class to represent our robot class Robot { private: int _lts; // left track speed int _rts; // right track speed int _ltd; // left track direction int _rtd; // right track direction void drive(int lts, int rts, int ltd, int rtd); public: Robot(int lts, int rts, int ltd, int rtd); void Stop(); // engage both brakes void DriveForward(); // both forward void DriveBackward(); // both backward void TurnLeft(); // opposite directions void TurnRight(); // opposite directions };

// create a new robot Robot tracky(0, 0, AFORWARD, BFORWARD); // our robot is named tracky void setup() { Serial.begin(9600); irrecv.enableIRIn(); // Start the receiver // setup channels A pinMode(motorPinA, OUTPUT); //Initiates Motor Channel A pin pinMode(brakePinA, OUTPUT); //Initiates Brake Channel A pin // setup Channel B pinMode(motorPinB, OUTPUT); //Initiates Motor Channel B pin pinMode(brakePinB, OUTPUT);

//Initiates Brake Channel B pin

digitalWrite(brakePinA, LOW);

// disengage the Brake for channel A

digitalWrite(brakePinB, LOW);

// disengage the brake for channel B

// setup ports for ultrasonic sensor pinMode(pingPin, OUTPUT); } void loop() { // test for obstacle int duration, inches=3; pinMode(pingPin, OUTPUT);

// Set pin to OUTPUT

digitalWrite(pingPin, LOW);

// Ensure pin is low

delayMicroseconds(2); digitalWrite(pingPin, HIGH);

// Start ranging

delayMicroseconds(5);

digitalWrite(pingPin, LOW);

// End ranging

with 5 microsecond burst

pinMode(pingPin, INPUT);

// Set pin to INPUT

duration = pulseIn(pingPin, HIGH); // Read echo pulse inches = duration / 74 / 2;

// Convert to inches

Serial.println(inches);

// Display result

delay(200);

// Short delay

// results is an instance of a

decode_results class, decode() returns an int Serial.println(results.value, HEX); if( results.value == repeat ) { current_command = previous_command; } else { current_command = results.value; previous_command = current_command; } // channel A is the left motor as viewed from a "driver" viewpoint"

// channel B is the right motor as viewed from a "driver" viewpoint" switch (current_command) { //Serial.println("in switch statement"); case forward_button: tracky.DriveForward(); break; case stop_button: tracky.Stop(); break; case reverse_button: tracky.DriveBackward(); break; case left_button: tracky.TurnLeft(); break; case right_button: tracky.TurnRight(); break; } irrecv.resume(); // Receive the next value } } Robot::Robot(int lts, int rts, int ltd, int rtd) { _lts = lts; _rts = rts; _ltd = ltd; _rtd = rtd; } void Robot::drive(int lts, int rts, int ltd, int rtd) {

//Serial.println(lts); digitalWrite(directionPinA, ltd); // Establishes direction of Channel A //digitalWrite(brakePinA, LOW);

// Disengage the Brake for Channel

A analogWrite(motorPinA, lts);

// Spins the motor on Channel A

//Serial.println(rts); digitalWrite(directionPinB, rtd); // Establishes direction of Channel B //digitalWrite(brakePinB, LOW);

// Disengage the Brake for Channel

B analogWrite(motorPinB, rts);

// Spins the motor on Channel B at

full speed } void Robot::Stop() { //Serial.println("Stop"); //digitalWrite(brakePinA, HIGH);

// engage the Brake for channel A

//digitalWrite(brakePinB, HIGH);

// engage the brake for channel B

_lts = 0; _rts = 0; drive(_lts, _rts, _ltd, _rtd); } void Robot::DriveForward() { //Serial.println("Forward"); _lts = MAX_SPEED; _rts = MAX_SPEED; _ltd = AFORWARD; _rtd = BFORWARD; drive(_lts, _rts, _ltd, _rtd);

} void Robot::DriveBackward() { //Serial.println("Backwards"); _lts = MAX_SPEED; _rts = MAX_SPEED; _ltd = !AFORWARD; _rtd = !BFORWARD; drive(_lts, _rts, _ltd, _rtd); } void Robot::TurnLeft() { //Serial.println("Turn Left"); Serial.println(_lts); Serial.println(_rts); // the robot does not have to be moving to turn, we will spin in place drive(MAX_SPEED, MAX_SPEED, !AFORWARD, BFORWARD); // drive the left track in the opposite direction delay(750); drive(_lts, _rts, _ltd, _rtd); // resume whatever we were doing when this function was called } void Robot::TurnRight() { //Serial.println("Turn Right"); // the robot does not have to be moving to turn, we will spin in place drive(MAX_SPEED, MAX_SPEED, AFORWARD, !BFORWARD); // drive the left track in the opposite direction delay(500);

drive(_lts, _rts, _ltd, _rtd); // resume whatever we were doing when this function was called }