This is the page that I made for the Building the Future class (16-199) taught
by Prof. Chris Atkeson. For my final project, I
developed image tracking software. For the last nine months, I have been
working with Ravi Balasubramanian
on his graduate and thesis work in the field of legless locomotion. This is
seminal work that has been previously unexplored. I am responsible for building
and keeping a working prototype of our system. We call this system the Rocking
and Rolling Robot, or RRRobot for short. Here is a
picture of the robot: While Ravi does extremely
difficult theoretical work involving the kinematics and dynamics of this
system, I design the software and hardware to test the theory. We use a
Cerebellum (created at CMU) to control the hobby servos that position the
reaction arms.
A first step in this project was to create a
software model that would allow the robot to produce arm motions that follow
specified gaits. The solution that I came up with was to use a program running
on a PC to create data arrays that would be stored in the program memory. I
wrote a program that would run on the PC, take input parameters for the various
gaits (sinusoidal, square wave, triangle wave, etc), and generate an array of
servo positions. These position arrays would represent the servo positions with
resolutions of 1/100th of a second.
I spent some time perfecting the art of having one
program write another program. I eventually added calibration features so that
in Cerebellum program, the servos could be zeroed for more precise control of
the robot.
After we had a working version of RRRobot, we began testing to see whether RRRobot could follow paths predicted by Mathematica
simulations of the system. Our preliminary tests involved videotaping RRRobot over the period of several minutes and observing
its motion. The problem with this method is that RRRobot
moves slowly, and we want to compare the motion at a high level of detail. The
solution was to write software to track the motion of RRRobot.
Writing the software that tracks the motion of the
robot was one of the most intensive programming projects I have done thus
far. It required me to become familiar
with many new concepts and explore efficient API’s that can process
graphics. I chose C++ as the language
because of its speed, direct memory access, and a wide variety of API’s that
are available for different applications.
For the memory intensive graphical processing, I used the Intel
Performance Primitives library. In
particular, I used their optimized routine for thresholding
of the image and pixel counting. Finally,
I used the Fast Light Tool Kit (FLTK) for the GUI interface.
After several months of programming off and on, I finally
reached a finished project. The detailed
methods that I used in the program can be found here. If you are interested in designing your own
Rocking and Rolling Robot, you can find instructions here. Questions or comments are welcome. You can email me at bmeeder
at Andrew dot CMU.edu