We got back from vacation and what was waiting for us?Our four new LV-MaxSonar-EZ2 Range Finders to give us a total of five sensors for our robot.This will give us one looking forward, two at
45 degrees and two at 90 degrees.The
pictures below show how we mounted them.You may also notice the nice table that our robot is sitting on.Kailey, my eight-year-old daughter, made it
for me this afternoon.
Below is the diagram of how I wired all of the sensors.For the actual wiring I have one of the
sensors wired on a second breadboard because I did not have enough room to put
all five on one small breadboard and I also had an extra breadboard so why try
to cram it all on one.
Now you may be asking, what can we do with all those
sensors?One project is going to be to
expand on our autonomous robot that we showed in this post and give the robot a much broader view of the world.The other project we want to do is to have
the robot send the sensor readings back to a controller so we can control the
robot when we are not in the same room as the robot.This second project would be useful if the
robot was exploring someplace where we could not go like a different planet or
small caverns.I also want to eventually
connect a camera to the robot and stream video back.
My concern with the second project is how will we
communicate back with the controller.In
some earlier projects I used Bluetooth but I am thinking in the long term that
Bluetooth is not going to be the answer for my needs.I was
thinking about adding a WIFI USB adapter however I think the power drain will
be too much when I connect the robot to the EasyAcc power bank.So after thinking about the problem quite a
bit and doing a lot of reading, I decided to order a Spark Core. I ordered it from MakerShed and should be here this week.The Spark Core has WIFI built in and I can
have it act as my communication module that will relay commands from the
controller to the BeagleBone Black.This
should also allow us to use our iPhone/iPad to control our robot.
I am still debating on the language to use for our robot. If I can offload the communication piece from the BeagleBone to the Spark Core, I will probably use Javascript/Bonescript but I am still considering Python.
You may be asking yourself; why would I choose Javascript
for the first prototype of our autonomous robot?The answer is really simple, I wanted to see
if I could write it in Javascript and I also wondered how effective Javascript
would be at controlling an autonomous robot.First, lets see a video of our prototype in action:
In the My first working robot, it’s alive – Part 2 post, I wrote a python module that defined the basic movements of robot like
changing speeds, changing direction, going forward and stop.In this post, the first thing we will do is
to write a similar Javascript module that we can load with Node.js.Here is the Javascript code for this module:
var b = require('bonescript')
var PIN_SPEED_RIGHT = "P8_13";
var PIN_SPEED_LEFT = "P8_19";
var PIN_DIR_LEFT = "P8_14";
var PIN_DIR_RIGHT = "P8_16";
var MAX_SPEED=1;
var MIN_SPEED=.25;
var CHANGE_RATE=.05;
var STOP_SPEED=0;
var FORWARD_DIR=1;
var REVERSE_DIR=0;
var current_speed_right = STOP_SPEED;
var current_speed_left = STOP_SPEED;
var current_dir_right = FORWARD_DIR;
var current_dir_left = FORWARD_DIR;
//initiate rover
function initRover() {
b.pinMode(PIN_DIR_LEFT,b.OUTPUT);
b.pinMode(PIN_DIR_RIGHT,
b.OUTPUT);
}
exports.initRover = initRover;
//Utility rover to check if the speed is within
range
function checkSpeed(speed) {
if
(speed < MIN_SPEED && speed != STOP_SPEED)
speed
= MIN_SPEED;
if
(speed > MAX_SPEED)
speed
= MAX_SPEED;
return
speed;
}
//Utility sleep
function sleep(milliseconds) {
var
currentTime = new Date().getTime();
while
(currentTime + milliseconds >= new Date().getTime()) {
check_speed(speed): Verifies that the speed
is within the acceptable ranges. This function returns the speed that was
passed in if it was within the acceptable range otherwise it returns the
MAX_SPEED or MIN_SPEED depending on if the speed that was passed in was too
high or too low.
sleep():Pauses the execution of the script
for a specified amount of time.
set_right_speed():
Sets the
speed of the right track.
set_left_speed(): Sets the speed of the
left track.
set_speed(): Sets the speed of both
tracks.
increase_right_speed(): Increases the speed of
the right track.
increase_left_speed(): Increases the speed of
the left track.
increase_speed(): increases the speed of
both tracks.
decrease_right_speed(): Decreases the speed of
the right track.
decrease_left_speed(): Decrease the speed of
the left track.
decrease_speed(): Decrease the speed of
both tracks.
forward_right_dir(): Sets the direction of
the right track to forward.
forward_left_dir(): Sets the direction of
the left track to forward.
forward_dir(): Sets the direction of
both tracks to forward.
reverse_right_dir():
Sets the
direction of the right track to reverse.
reverse_left_dir(): Sets the direction of
the left track to reverse.
reverse_dir():
Sets the
direction of both tracks to reverse.
stop_left():
Stops the
left track.
stop_right(): Stops the right track.
all_stop(): Stops both tracks.
full_speed_left():
Sets the left
track to full speed.
full_speed_right(): Sets the right track to
full speed.
all_full_speed(): Sets both tracks to
full speed.
spin_right(speed):
Spins the
robot in the right direction at the speed passed in.
spin_left(speed): Spins the robot in the
left direction at the speed passed in.
Now lets take a look at the code that will control our
robot.This has very basic and simple
logic for our first prototype.The robot
moves forward until it is within 18 inches of an object.Once it is within 18 inches of an object it
continuous to turn right until it has over 18 inches of clearance.Here
is the code:
if
(moving == roverStateEnum.COMPLETE_STOP || moving == roverStateEnum.STOPPED) {
console.log("Forward");
rover.initRover();
rover.forwardDirection();
current_speed
= min_speed;
rover.setSpeed(current_speed);
if
(interval == 0) {
console.log("setting
interval");
setInterval(read,check_interval);
interval = 1;
}
moving
= roverStateEnum.FORWARD;
b.digitalWrite(ledPin,
b.HIGH);
} else {
console.log("Stop");
rover.allStop();
moving
= roverStateEnum.COMPLETE_STOP;
b.digitalWrite(ledPin,
b.LOW);
}
}
function read() {
b.analogRead(sensorPin,sensorStatus);
}
function sensorStatus(v) {
var
distanceInches;
var
analogVoltage = v.value*1.8;
distanceInches
= analogVoltage/0.002148;
console.log("Object
at " + parseFloat(distanceInches).toFixed(2) + " inches away");
if
(distanceInches < detect_length && moving !=
roverStateEnum.COMPLETE_STOP) {
console.log("Stopping
and spinning");
rover.allStop();
rover.spinRoverRight(min_speed);
moving
= roverStateEnum.SPIN_RIGHT;
rover.sleep(500);
rover.allStop();
rover.sleep(500);
moving
= roverStateEnum.STOPPED;
} else
if (moving == roverStateEnum.STOPPED) {
console.log("Going
Forward");
rover.forwardDirection();
rover.setSpeed(current_speed);
moving
= roverStateEnum.FORWARD;
}
}
We start off by importing our rover module and also the
Bonescript module.We then define the
pins used for an LED, a button and the MaxSonar sensor.We use the LED to show when the rover is
running and the button is used to start and stop the rover.I wired the LED and button exactly as I did
in the Using Javascript with Bonescript to program the BeagleBone Black (http://myroboticadventure.blogspot.com/2014/06/using-javascript-with-bonescript-to.html)
post.
We then define an enum that we will use to define what type
of movement the robot is currently doing.Next we define several variables, these are:
current_speed:The current
speed of the robot.
min_speed:The minimum speed
we want the robot to go
moving:The current moving
state of the robot
check_interval:How often we
want to check the MaxSonar sensor.This
is in milliseconds.
interval:If 0, the robot is
not checking the MaxSonar for distance, if 1 it is already checking.
detect_length:Is the
length, in inches, that will force the robot to turn.
We set the mode of the LED pin to OUTPUT which means we will
be writing to the pin and we set the mode of the button pin to INPUT which
means we will be reading from the pin.We use the attachInterrupt function
to call the buttonChange function every
time the button is pushed.Finally we
turn on the LED, by calling the digitalWrite
function, to let us know that the robot is ready to go.
The buttonChange
function is called whenever the button is pressed.If the current moving state of the robot is roverStateEnum.COMPLETE_STOP or roverStateEnum.STOPPED then we start the rover
moving forward and also use the setInterval()
function to begin checking the MaxSonar every half second.If the current state is anything other than roverStateEnum.COMPLETE_STOP or roverStateEnum.STOPPED then we stop the rover.
The read function is called every half second to check the
MaxSonar sensor for the current distance.When the distance comes back from the MaxSonar sensor, it calls the sensorStatus() function.In the sensorStatus()
function, if there is an object closer than the distance defined by the detect_length variable (18 inches) and the
current state of the robot is not roverStateEnum.COMPLETE_STOP,
then we stop the robot and spin to the right for half a second.
This example is just the start of our autonomous robot and
we currently have four more MaxSonar sensors on order so our robot can look at
the world around it and decide where and how to turn.Not sure if I want to use Javascript or
Python to develop this in but will have to make the decision soon.
