The P3DX, Custom Dock and ActivMedia Robot Programming Tools
Adam Milstein
ARIA/Saphira Mid level control system for robot. Handles communication, multitasking, display,
hardware. Provides architecture for quickly writing robot control
programs. Provides enough depth to access all functions. Also contains systems for high level control of the
robot.
ARIA Low to mid level control systems. Establishes and maintains connection to robot and
other hardware Stores data from sensors and provides accessor
methods Provides control methods on the order of speed and
direction. Resolver for running multiple tasks controlling the
robot.
Behaviours ArAction subclasses, once started, are called every cycle
and return a desired velocity and heading for the robot. Must be a short algorithm to determine the return values. Each ArAction runs at a priority and on each iteration
returns its desired action with a strength between 1.0 and 0.
Starting at the highest priority. Computes average of all motion requests, weighted by strength. Any leftover strength (is sum < 1.0) is given to the next lower
priority level. ArActions can be disabled or enabled individually at
various priorities.
ArActionDesired *ActionGo::fire(ArActionDesired currentDesired) {
double range;
double speed;
// reset the actionDesired (must be done)
myDesired.reset();
// if the sonar is null we can't do anything, so deactivate
if (mySonar == NULL) {
deactivate();
return NULL;
}
// get the range off the sonar
range = mySonar->currentReadingPolar(-70, 70) - myRobot->getRobotRadius();
// if the range is greater than the stop distance, find some speed to go
if (range > myStopDistance) {
// just an arbitrary speed based on the range
speed = range * .3;
// if that speed is greater than our max, cap it
if (speed > myMaxSpeed)
speed = myMaxSpeed;
// now set the velocity
myDesired.setVel(speed);
// the range was less than the stop distance, so just stop
} else {
myDesired.setVel(0);
}
// return a pointer to the actionDesired, so resolver knows what to do
return &myDesired;
}
Task Tasks are called every cycle, but they are only run for
their share of the available time Used for long term processing, such as localization or
path planning. Use ArASyncTask, ArRecurrentTask, or SfUTask ArASyncTask: invoked and keeps running ArRecurrentTask: has a method to restart once it
ends, used for long running but finite computation that must be repeated
SfUTask: Saphira wrapper for task called every cycle.
void myAsyncTask::task() { // main task we are doing
while (counter <= end) { // print N times, once per second
sfMessage("Async task counter: %d", counter++);
ArUtil::sleep(1000);
lock(); // lock out the sync loop, so we can change values
if (myproc)
myproc->counter = 0;
unlock(); // unlock and go
}
sfMessage("Async computation finished");
}
void myProcess::process() {
if (Done()) {
sfMessage("Async task done, suspending uTask");
suspendTask();
}
else
sfMessage("uTask at %d", counter++);
}
ArRobot Get information from the robot and send direct
commands setVel, setHeading, move, comInt, … Also findRangeDevice to get a particular sensor
Then Current/CumulativeReadingPolar/Box Returns the closest sensor reading in a box or sector in
relative position to the robot
ClearDirectMotion enables behaviours and clears direct motion commands
…
Behaviours vs. Direct Motion 2 methods of controlling the robot. But incompatible. Using direct motion commands disables behaviours Behaviours will still run, but will have no effect on the
robot. Use ClearDirectMotion() to reenable behaviours Don’t mix them
Saphira Graphical interface on top of Aria Adds methods for connecting to the robot Manual control Structure for writing control programs and running
them together and interactively. Provides a simulator to test programs without using
the robot.
The LPS display!
Convenience Variables SfROBOT : an instance of SfRobot which subclasses
ArRobot. Points to the actual robot. Sf::sonar() : An SfRangeDevice, to get the sonar
readings. Sf::sonar()->ourRangeDevice->currentReadingBox(…)
Sf::laser() : Another SfRangeDevice. Sf::frame : More useful than you might think. Don’t
forget it exists if you are using the LPS for keyboard/mouse events.
LPS Local perceptual space Saphira’s graphical display Shows robot position, sensor readings, walls, and
anything else. Any class which extends SfArtifact will have its draw
method called on every graphics update. Can also read mouse and keyboard for interface. Provides keyboard control of robot. Text output window for the sfMessage function
C++ Any function written in C++ can be made available to
the Saphira interactive language, Colbert. All ARIA functionality can be used in the C++ code,
and exported if necessary Code is build into a special dll. Dlls can be loaded from saphira.
sfLoadInit performs initialization. A dll can declare its functions, variables, and behaviours
available to the Saphira command line.
In Windows, must use Studio.Net Include Saphira.h, export.h and link Sf.lib and Aria.lib For Linux, you’re on your own.
Colbert Saphira’s interactive language. Uses a C like syntax. No dynamic allocation. Can load libraries, other colbert .act files, world maps Can call any exported functions, change exported
variables, start and stop actions, call direct motion commands.
Colbert .act files can contain any colbert commands together with behaviours that can be used as normal.
loadlib testload; // need this for sfStalledMotor() def
int MOVEVAL; MOVEVAL = 250;
int BACKVAL; BACKVAL = 200;
int TURNDEG; TURNDEG = 40;
act getout(int dist, int turnDeg) {
if (sfStalledMotor(sfLEFT))
turnDeg = -turnDeg;
turn (turnDeg) timeout 10; // just in case, we timeout
move(dist) timeout 10;
behaviors; // resume behavioral actions
succeed;
}
act bng() {
while(1) {
waitfor(sfStalledMotor(sfLEFT) || sfStalledMotor(sfRIGHT));
remove getout; // halt this activity if it's going
stop(); // stop the robot
move (-BACKVAL) timeout 30; // just in case, we timeout here
start getout(MOVEVAL, TURNDEG) noblock;
}
}
start bng;
trace bng;
Pioneer Simulator Provides a simulated robot and reports slightly
incorrect data back to Saphira. Can import a map so that it can report sensor
readings. The first iteration of any program will drive the robot
at full speed into the wall, so it’s useful to use the simulator until the code works.
Only provides sonar, but the code is available in case you need more simulation.
Modules Localization: Localizes the robot using any available
sensors on either a scan map or a line map. Gradient navigation: Creates a path for the robot
between 2 points within the map and avoids obstacles detected by the sensors.
These modules can run on there own, controlled through the LPS, or they can be integrated into other modules
Extra Libraries Laser Mapping and Navigation: ARIA and utility
programs to record laser readings and use them to generate a map. Then navigate on that map.
ArSpeech: Speech recognition and synthesis VisLib: a vision processing library ACTS: a blob tracker
Documentation C:\Program Files\Saphira\docs Saphira-Reference.html Aria-Reference\main.html The best Saphira documentation is the header files.
The Dock Connect power to correct ports. Switches for arms. Bypass cables Contact plate LEDs Charger problems!
Details Camera: see me for instructions, I’ve been working
on it for 2 years, you don’t want to reproduce it. Matlab can be called from C++ The program must be a Saphira Dll. Speech synthesis works, recognition needs a better
mike. Talk to me about what you want to do, Aria/Saphira is
powerful if you can find what you’re looking for.
Example An example docking behaviour.
Note: ArAction, laser, voltage, SfArtifact, functions
Questions?