I came across this project a while back that lets you “see” with ultrasound:

The ultrasonic haptic vision system enables a person to navigate hallways and around large objects without sight, through the use of an ultrasonic rangefinder that haptically interfaces with the user via tiny vibrating motors mounted on the user’s head.

It looked so cool I decided I must have one of my own. And being a newly minted Arduino owner, I figured no electronics project was out of my reach

First I changed the design around a little. Here’s what mine ended up looking like:

My Changes

Instead of having the ultrasonic sensor rotate around your head, and give you distances in every direction, I have it simply tell you the distance to the nearest object in the direction you’re facing. I thought this might make for a more intuitive “interface”. I also used a stylish baseball cap instead of a dorky hardhat.

Instead of mounting the whole Arduino right on the hat, I decided to just include the components of the Arduino I needed. This is called building a Standalone Arduino. You can run your Arduino sketch unmodified but with only a few inexpensive components. This way I won’t be tempted to cannibalize my nifty hat for its Arduino for whatever project comes along next.

Here is a tutorial for building a standalone Arduino. (And here is another.)

What I used

PING))) Ultrasonic Sensor:

This guy sends out an ultrasonic pulse from one of these two transducers and listens for the echo with the other one. You can calculate the distance from the length of time it takes the echo to return.

The hat ($5 from Walmart)

And some miscellaneous parts:

• PRT-00091 9V Snap Connector
• PRT-08811 ProtoBoard - Square 2″
• PRT-07942 DIP Sockets Solder Tail - 28-Pin 0.3″
• Mini vibration motor (MOT105A2B)
• Elastic material for battery “holder” and thread to sew it on.
• The parts for the standalone Arduino are listed here(Note: I used this ATAMega328)

Construction

I built everything on a breadboard to make sure it worked. I then soldered everything to the protoboard:

(I won’t show you the other side of this which would reveal my horrendous soldering mistakes.)

I popped the ATMega chip into my regular Arduino and loaded the sketch onto it. Then I popped it out and put it into the chip seat on the new protoboard. Since everything is wired up just like an Arduino, the sketch can run unmodified. This method also required that my ATMega328 already had an Arduino boot loader loaded.

I set the vibrating motor in the flap inside the hat. I cut off part of a pen case and glued the moter in that. This lets the motor spin freely without worrying about fabric interfering.

Results:

It works OK. I can find things like doorways and walls with my eyes covered!

My main complaint is that there isn’t very much variability in the vibration motor. The program it’s running converts the distance in inches to the object you’re facing into a voltage to send to the motor (pulse width modulation). E.g, seven feet away means almost no voltage and the motor spins slowly, one foot away means lots of voltage so it vibrates more. However I can effectively only “feel” three states: something in front of me, nothing in front of me, and something really close to me. I was hoping I could scan my head up and down stairs and feel the variation between each step, but the motor just can’t get that fine grained.

If you make your own, you might want to find a better motor, or have several motors where close objects make say three motors run, and far objects only one. Or maybe just make it beep instead of vibrate and use auditory cues to find your way around.

All in all it was a great learning experience, and hopefully I’ll find a practical use for it soon …

The Arduino sketch (the program the micro controller runs):

/*
Read distance using Ping sensor, and vibrate
motor by how close distance is to sensor.
(Most of code comes from http://www.arduino.cc/en/Tutorial/Ping)

Greg Pinero
July 2009
*/

#define debug //debug for debugging, anything else otherwise
const int pingPin = 7;
const int vibPin = 6;
int pulseOut = 0;

void setup() {
  // initialize serial communication:
  #ifdef debug
  Serial.begin(9600);
  #endif
  pinMode(vibPin,OUTPUT);
}

void loop()
{
  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters:
  long duration, inches, cm;
  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);
  // The same pin is used to read the signal from the PING))): a HIGH
  // pulse whose duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);
  // convert the time into a distance
  inches = microsecondsToInches(duration);
  //vibrate proportionally to closeness
  pulseOut = inchesToPulse(inches);
  analogWrite(vibPin,pulseOut);
  #ifdef debug
  Serial.print(inches);
  Serial.println();
  Serial.print(pulseOut);
  Serial.println();
  Serial.println();
  #endif
  delay(100);
  analogWrite(vibPin,0);
}

float inchesToPulse(int inches)
{
  //curved function so closer distances have more variation
  int MaxInches = 133;
  int minPulseOut = 70; //vib motor won't spin below ~50-70
  //(3 was way too steep) Only felt motor within a foot or two
  float powerConst = 1.5; //steepness 1 for line >1 for steeper
  int pulseOut;
  pulseOut = (int)(pow(((MaxInches - (float)inches)/MaxInches),powerConst) * (255.0-minPulseOut)) + minPulseOut;
  if (pulseOut < = minPulseOut) {pulseOut = 0;}
  return pulseOut;
}

long microsecondsToInches(long microseconds)
{
  // According to Parallax's datasheet for the PING))), there are
  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
  // second).  This gives the distance travelled by the ping, outbound
  // and return, so we divide by 2 to get the distance of the obstacle.
  // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
  return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;
}

This entry was posted on Tuesday, August 18th, 2009 at 7:47 pm and is filed under other. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.