Personal range finder

With this project I focused on making an affordable personal range finder as an assistive device.

The goal was to create a portable device that could help in physically navigating different environments. There are many concerns when dealing with alternative navigation (not using your given sense for what it is commonly used for), the largest challenge is to make a usable translation from one experience to another. In making this translation it is important to consider the normative motion and logic that goes into that particular sense. If you are successful you can trigger the logical actuations that are normally linked for that sense, giving the user a much quicker learning curve. In making a device that encompasses the logic of physical space, perceived time was a important focus. I wanted to make a device that would output a specific building sensation. This sensation is akin to a surface overtaking your visual field or walking into a wall with your arm as a buffer. When doing this you calculate physically the steady bend of your arm as you move in closer to the wall or the steady relation of your size to the visual plane. Both these methods involved a constant linear progression. Information that jumps a point in perception would be no good in transferring information, every new sensation had to be fixed in terms of its previous and post-sensation.

I decided to use a small stepper motor to actuate the physical information, this gave me great accuracy in terms of knowing where and how much the interface is outputting. My goal was to have the output strap to the forearm of the user. After trouble shooting many methods of sensation, I came to the conclusion that the simplest and most effective force transfer was with a single point of pressure that varies according to a object distance. The closer you are to a object the more pressure is applied the farther away the less the pressure. This system works fairly reliably, but because of the lack of sensitivity of the forearm it only can describe about ten feet of space accurately. After that the rate of movement through a space is greater than the increment of information that is applied to the arm.

I tried to use an approach that could be versatile as possible leaving room for easy changes of use. That translated in to trying to keep the cost of production (not development!) to fewer than fifty dollars retail and have the power source as a common nine-volt battery. Also the design was for maximum simplicity and scale ability so instead of a arm mount it could easily be front mounted and could clip to a shirt and be used for crowd navigation. I am also thinking of developing a glove that would be used for small distance (6 inch or less) that could be used in industry (car mechanics, fabrication, ect.) or as assistive technology so you would always have a sense of where your hands are. Needless to say it is not a perfect interface and the resolution is not enough to use it as a sole tool of navigation but I think it does supply fifty dollars worth of help that people could use.

This is the code it works realy well for having many steppers:

int rangeRead();
int averager();
void step();
void step1();
void step2();
void step3();
void step4();
void blink(int howManyTimes);
int speed = 20;
int button = 0; ////////////option of button
int count =0;
int F1 = 0;//////////////flags in the step function to say when it is done
int F2 = 0;
int F3 = 0;
int F4 = 0;
int distance = 0;
int stepperPos = 0;
int buffer = 2;
int RXPin = 2;
int AnalogOutPut = 0;
int offset = 6;
int sIn[10];
int reading[2];///////numbers to be averaged
int loopNumber; // a counter
int aveNumber; ///////////number to be averaged starts with zero if two then say 1
int avDistance;
int avDistance1;
boolean loopFlag =0;
//////////////////////////////////////////////////////

void setup() {
Serial.begin(9600);
pinMode(RXPin,OUTPUT);
pinMode(2,INPUT);
pinMode(8,OUTPUT);//////////first stepper motors out
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
pinMode(11,OUTPUT);////////end first stepper
pinMode(4,OUTPUT);//////////second stepper motors out
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);////////end second stepper
avDistance = 0;
count=0;
loopNumber = 0; // a counter how many times the programs excuted
aveNumber=2; ///////////number to be averaged starts with zero if two then say 1
// start program with a half-second delay:
delay(500);
//stepperPos = 119;
// blink the reset LED 3 times:
blink(3);
}

////////////////loop///////////////////////////////////////

void loop() {
if (loopFlag == 1){ //////////////tells if a averaging "if" statment occured
loopNumber = 0;
loopFlag=0; //////// resets flag
}

// Serial.println(avDistance1);
stepperPos = count;
distance = rangeRead();
//Serial.println(distance);
reading[loopNumber] = distance; /////////// analog value getting put in an array
// Serial.println( reading[loopNumber]);
avDistance1 =( averager() / 2); /////////////divide by three to get a 80 step movment
Serial.println(avDistance1); // button = digitalRead(2); //////////////// button if you want to use

if (avDistance1 - buffer > stepperPos) { //Step the motor forward one step: to braket say and stepperPos is less than somthing then...
forwardStep(8,9,10,11); //first stepper // change all the range numbers in the if statments
//Serial.println(count);
}
if( avDistance1 + buffer < stepperPos){ ////////// buffer gives inbetween area of no movment(gets rid of jerkyness)
backwardStep(8,9,10,11); //first stepper

}
if (avDistance1 - buffer > stepperPos) { //Step the motor forward one step: to braket say and stepperPos is less than somthing then...
forwardStep(4,5,6,7); //first stepper // change all the range numbers in the if statments
//Serial.println(count);
}
if( avDistance1 + buffer < stepperPos){ ////////// buffer gives inbetween area of no movment(gets rid of jerkyness)
backwardStep(4,5,6,7); //first stepper

}
}

//////////////////////averager/////////////////////////
int averager(){
//Serial.println( reading[4]);
if (loopNumber == aveNumber){ ////////////if its taken the amount of readings we want to average
int num = 0;
for (int x = 0; x < aveNumber; x++){
num = num + reading[x];
// Serial.println(reading[x]);
} /////////// adds analog num
//Serial.println(num);
avDistance = num / aveNumber; ////////////////averages out added analog value by how many we looked at
loopFlag = 1; /////////////// resets loop number to 0
}
loopNumber++; /////////////////////how many times this loops gone
return avDistance;
}
//////////////////////////backward step////////////////////////////////
void backwardStep(int _w,int _x, int _y, int _z){
_w=_w;
_x=_x;
_y=_y;
_z=_z;
step4( _w, _x, _y, _z);
count--;
distance = analogRead(0);
stepperPos = count ;
delay(speed);
step3( _w, _x, _y, _z);
count--;
distance = analogRead(0);
stepperPos = count ;
delay(speed);
step2( _w, _x, _y, _z);
count--;
distance = analogRead(0);
stepperPos = count ;
delay(speed);
step1( _w, _x, _y, _z);
count--;
distance = analogRead(0);
stepperPos = count ;
delay(speed);
//Serial.println (distance);
//Serial.println (count);
}

//////////////////// Blink the reset LED://///////////////////////////
void blink(int howManyTimes) {
int i;
for (i=0; i< howManyTimes; i++) {
digitalWrite(13, HIGH);
delay(200);
digitalWrite(13, LOW);
delay(200);
}
}

////////////////////ez range function/////////////////////////////////
int rangeRead() {
// Reads the Analog output of the MAXSonar® EZ1™ (AN Pin) and returns the target range as a Byte
int RangeA = 0;

digitalWrite (RXPin, 0); //' Turn off the EZ1™ just in case we started with it on
digitalWrite (RXPin, 1); // ' Turn on the EZ1™
delay(50); // ' Wait about 50 ms

RangeA = (analogRead(0) - offset); //' Read the ADC -6 to give a "zero" reading

return RangeA;
}
////////////////////////forward step////////////////////////////////////////////////////////
void forwardStep(int _w,int _x, int _y, int _z){
_w=_w;
_x=_x;
_y=_y;
_z=_z;
step1( _w, _x, _y, _z);
count++;
distance = analogRead(0);
stepperPos = count ;
delay(speed);
step2( _w, _x, _y, _z);
count++;
distance = analogRead(0);
stepperPos = count ;
delay(speed);
step3( _w, _x, _y, _z);
count++;
distance = analogRead(0);
stepperPos = count ;
delay(speed);
step4( _w, _x, _y, _z);
count++;
distance = analogRead(0);
stepperPos = count ;
delay(speed);
// Serial.println (distance);
// Serial.println (stepperPos);
}

///////////////stepper coil set step////////////////////
void step(int _w,int _x, int _y, int _z){ // clear step
digitalWrite (_w, LOW);
digitalWrite (_x, LOW);
digitalWrite (_y, LOW);
digitalWrite (11, LOW);
}
void step1(int _w,int _x, int _y, int _z){
if( F4= 1){
digitalWrite (_w, HIGH);
digitalWrite (_x, HIGH);
digitalWrite (_y, LOW);
digitalWrite (_z, LOW);
F4 = 0;
F1 = 1;
}
}
void step2(int _w,int _x, int _y, int _z){
if( F1= 1){
digitalWrite (_w, LOW);
digitalWrite (_x, HIGH);
digitalWrite (_y, HIGH);
digitalWrite (_z, LOW);
F1 = 0;
F2 = 1;
}
}
void step3(int _w,int _x, int _y, int _z){
if( F2= 1){
digitalWrite (_w, LOW);
digitalWrite (_x, LOW);
digitalWrite (_y, HIGH);
digitalWrite (_z, HIGH);
F2 = 0;
F3 = 1;
}
}
void step4(int _w,int _x, int _y, int _z){
if( F3= 1){
digitalWrite (_w, HIGH);
digitalWrite (_x, LOW);
digitalWrite (_y, LOW);
digitalWrite (_z, HIGH);
F3 = 0;
F4 = 1;
}
}
/////////////////////////end steps/////////////////////////////////

The tricky part to using the srf series range finder with the arduino is the I2c bus interface it is a fairly straightforward protocol (a good reference is at http://www.robot-electronics.co.uk/htm/using_the_i2c_bus.htm) but would take a lot of typing if you did it from scratch. It is basically a handshake method where the arduino slaves the srf range finder to its clock pulses and tells it when and from where the rangefinder will send information. It sends out info on the leading edge of the clock pulse and receives it on the falling edge, but the signals state (bit passing) never changes while the clock state is high, except to signal a start or stop to a communication. So the easiest way to communicate with your range finder is to use the code found on the Wiring web site (it is the sibling of arduino but even more user friendly it seems) and use the “wire” library (here’s the link http://wiring.org.co/reference/libraries/Wire/index.html). I took that code and modified it to include changing the address, the sensitivity and the range settings for the srf range finder (it should be talked about although maybe a bit muddled in the pamphlet that comes with the range finder). Also be sure to use the arduino 06 platform when implementing the library or it won’t compile, that was a big problem for me. So either use the code on the Wiring web site or take a look at mine (in the extended entry along with the pins to use) I hope this helps. Good luck!
Ps it took me a really long time to do the water colors so i hope you enjoy them.

#include Wire.h
////////////////////use below pins for input and out put/////////////////////////
/////////*************On the Arduino, SDA is on analog input pin 4, and SCL on analog input pin 5.****************///////////////////////

// I2C SRF10 or SRF08 Devantech Ultrasonic Ranger Finder
// by Nicholas Zambetti
// and James Tichenor

void setup()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
// start serial communication at 9600bps
}

int reading = 0;

void loop()

////////////////sensitivity adjust/////////////////////////////////////////////
{ Wire.beginTransmission(0x70); // transmit to device #112 (0x70)
// the address specified in the datasheet is 224 (0xE0)
// but i2c adressing uses the high 7 bits so it's 112
Wire.send(0x01); // sets register pointer to the command register (0x01) reg 1
Wire.send(0x21); // command sensor to analog gain (sensitivity of sensor)
// use 0x51 for centimeters
// use 0x52 for ping microseconds
Wire.endTransmission(); // stop transmitting
//////////////////////range select////////////////////////////
Wire.beginTransmission(0x70); // transmit to device #112 (0x70)
// the address specified in the datasheet is 224 (0xE0)
// but i2c adressing uses the high 7 bits so it's 112
Wire.send(0x20); // sets register pointer to the command register (0x10) reg 2
Wire.send(0x00); // command sensor to analog range (distance)
// use 0x51 for centimeters
// use 0x52 for ping microseconds
Wire.endTransmission(); // stop transmitting

//////////////////////////// step 1: instruct sensor to read echoes ///////////////////////////////////////
Wire.beginTransmission(0x70); // transmit to device #112 (0x70)
// the address specified in the datasheet is 224 (0xE0)
// but i2c adressing uses the high 7 bits so it's 112
Wire.send(0x00); // sets register pointer to the command register (0x00) write
Wire.send(0x50); // command sensor to measure in "inches" (0x50)
// use 0x51 for centimeters
// use 0x52 for ping microseconds
Wire.endTransmission(); // stop transmitting

//////////////// step 2: wait for readings to happen ///////////////////////////////////////////////
delay(70); // datasheet suggests at least 65 milliseconds

////////////// step 3: instruct sensor to return a particular echo reading ////////////////////////////
Wire.beginTransmission(0x70); // transmit to device #112
Wire.send(0x02); // sets register pointer to echo #1 register (0x02)
Wire.endTransmission(); // stop transmitting

//////////////// step 4: request reading from sensor /////////////////////////
Wire.requestFrom(0x70, 2); // request 2 bytes from slave device #112

/////////////// step 5: receive reading from sensor ////////////////////////////
if(2 <= Wire.available()) // if two bytes were received
{
reading = Wire.receive(); // receive high byte (overwrites previous reading)
reading = reading << 8; // shift high byte to be high 8 bits
reading |= Wire.receive(); // receive low byte as lower 8 bits
Serial.println(reading); // print the reading
}

delay(250); // wait a bit since people have to read the output
}


/*

// The following code changes the address of a Devantech Ultrasonic Range Finder (SRF10 or SRF08)
// usage: changeAddress(0x70, 0xE6);

void changeAddress(byte oldAddress, byte newAddress)
{
Wire.beginTransmission(oldAddress);
Wire.send(0x00);
Wire.send(0xA0);
Wire.endTransmission();

Wire.beginTransmission(oldAddress);
Wire.send(0x00);
Wire.send(0xAA);
Wire.endTransmission();

Wire.beginTransmission(oldAddress);
Wire.send(0x00);
Wire.send(0xA5);
Wire.endTransmission();

Wire.beginTransmission(oldAddress);
Wire.send(0x00);
Wire.send(newAddress);
Wire.endTransmission();
}

*/

I had many hours working with these guys especially the srf10 in the above picture; I had to learn about the I2c bus communication to get it running. I did find code for it finally on the wiring website there is code from the wire. class that makes bus communication a snap but you have to down load the arduino 06 if you want to call the class in arduino. the other sensor the sense ez is a real plug and play sensor and the focal area of the sound cone is very narrow and really accurate i can't recommend this sensor enough. i will post the code when i finish writing it but it is very simple to use. the srf10 has a much bigger range but it detects anything in a 180 degree sweep from center up to three feet on the sides and below it so you have to either really point it up or raise it three feet off the ground. not so good for my application.

i got the servo working finally, although i couldn't get the port addressing to work from tom igoes code example. just allot of repeat typing. it runs off of 12 volts and sinks about 250mA under a load so if i use a battery it won't be running for that long. ill have to think about that i am using a hbridge right now i can't decide if i need the enable pin or if i should switch to a darlington array for easier wiring.

Taken from notes and attempted to make semi readable.

My observations deal with TV’s in public or social spaces and ups package-tracking devices. First the TVs; I watched the interactions that took place between the audience in a laundry mat and the TV that was mounted on the wall. The audience watches the TV as a group, everyone is aware of the reactions that are accruing. As social information comes in off the TV it is gauged and agreed upon by the viewers in the room mostly with the help of laugh tracks. People also look to the TV to deemphasize their own psychic space in the room to turn from being judged to judging. It is not viewed as a machine not even as a surrogate. To change the channel is a bold move.

The specific information might be questioned but the role of the TV in space is solid, it is the center of decisions. It gets an objective placing in the social thought processes, it doesn’t have a personality it is personality. It is seen as a fixture, a unilateral place of reference. The only interaction possible is a change of reference by switching channels, you can’t say what is, but only choose what reference you will listen to from the ones presented. This causes a full emersion with the TVs space, it is hard to use the laundry mats references and the TVs at the same time. Why are people less willing to use the laundry mats reference over the TVs, the shows are not that exiting? You are not in the TV space so you are not required to participate or rather you don’t have the power to change it so you don’t have responsibility to do anything. What if you did have an impact on the physical/ mental space?

Ups package tracking devices. The tracking devices that are used by the ups guys are very interesting. The interface on them is one of the most dynamic that I have seen. I asked to take a quick look at the device last time I was getting a package. The face of the device was very simple but was used for many functions. The interface was based on the doubling up of buttons when performing different functions. Very much like telephone buttons with the letters and numbers. The button functions were very intuitive on the ups device and configured as needed from a general to specific input that automatically changed with the progression of the interaction. The functions I saw were scheduling, location and package data entry, they all were either chosen or ran automatically based on the last entry. The data retrieval was streamlined to take the most pertinent info for the best results first and then if that didn’t generate an answer more specific data could be added to the request. Also the physical layout was very nice in terms of the inputs, it had a lcd read write screen and then a QWERTY input board and four other scroll and search buttons that allowed you to sort and look at information in different ways. It got me thinking about how the functionality of a personal device changes with an adequate interface and cuts down on processing and programming. I think it will be a very large issue with the advent of the “all in one devices” that are becoming what our personal organizers cameras and telephones are now. Physical design is more a representation of idea than the software inside; the thing in terms of what it is to you and what it can do must inform you. A shoe can also hammer in a nail. Lines denote time linear progression with a start and end circles give you a unlimited scroll but no reference points a grouping of buttons denote their function as much as whats on the button. Are you able to be hit two at a time or can they only function individually

Here are some basic "circuits" I used to function as switches for ac current controlled by the arduino. The arduino puts power to a transistor, which controls the relays. The resistors are used to drop the base voltage because the transistors need a good voltage differential between base and emitter to operate.

This opamp seemed to work better than the lmn356 I got more gain and the output numbers didn’t fluctuate as much. The circuit is just two op amps in series the first cleans the ac voltage from the mic with a capacitor and then "rides" it on a 2.5 volt dc current so you get 0 as the base value and not a negative number. The second takes that signal and grounds the base voltage and then amplifies it so you get an output value of 0 to ~ 4v if you yell into the mic. The basics of an op amp is a comparator circuit, the circuit takes two positive voltages into an inverted and non-inverted input then compares them. If the non-inverted voltage is higher then it saturates to a positive voltage if the inverted is larger then it saturates negative or “low”. The key to the amplifier circuit is a feedback resistor (R2, R3) between the output of the circuit and the inverted input. This sends back a “dampening” voltage to the input not allowing it to fully saturate and controls the output voltage. This signal is ok but there are kits out there that give you a great range (the super snooper kit) and you don’t have to worry about trouble shooting them, but this opamp gives numbers that seem to be smoother than other op amp circuits so it worked well for the microcontroller application. to see the schematic click on view image.