31 Mar 2008 RoboDo
RoboDo - Toddler
RoboDo will eventually be a biped humanoid, but that is a
long way off. For the moment, I will concern myself with
laying the foundations. The RoboDo series of bots is
building towards the main project goal.
The latest incarnation in the series is RoboDo Toddler,
based on the Lego NXT system. RoboDo Toddler is actually
like 2 robots in one.
The top section contains an NXT controller, an ultrasonic
sensor with 180 degrees of motion (right-left), and 2 sound
sensors. The top section will handle the decision making
The bottom section features an NXT controller, 2 touch
sensors, and 2 light sensors.
The top part looks around and maps out where the bot can and
can't go from it's current position. It then decides what to
do, sets the numerical variable "order" to a number
representing its choice, then sends the value to the bottom
section via bluetooth.
The bottom section sits and waits for a message. When one is
received, it executes the order if possible. It then returns
a status message to the top section and waits for further
The bottom section usually just follows the instructions
passed to it from the top section, but there are times when
it can't follow these instructions. For example, if the
bottom section gets an order to move forward when the front
bumper sensor shows that way to be blocked, this condition
is recognized and the bottom section instead follows
instructions specific to this condition.
In any case, the bottom section generates a status message
which it sends to the top unit, again via bluetooth. This
status message not only lets the top know what's going on in
the other unit, it also serves as a timing signal; the top
will sit and wait for this message before thinking about its
The NXT-G language seems rather limited, but the custom
blocks allow the creation of simple behavior "chunks" which
can then be assembled into much more complex behaviors. The
graphical interface allows one to make visual sense of the
interactions, which makes development go much faster. Yes, I
will be going to a more powerful language one day, but NXT-G
is perfect for this stage of my project.
Adopting coding standards, even at this early stage, is
crucial. Top and Bottom sections may run different code, but
they both use the same variables for the same functions.
Custom blocks used only by the top section all start with
the letter "T" and those used by the bottom start with "B".
The icons used also display a consistent pattern. These
"small" details will pay big dividends as the project gets
The control scheme, based on "orders" and "reports" is
simple and effective, and allows co-operation between the
sections. The top section decides what to do, but the bottom
section is allowed some flexibility in how to carry out the
orders. I am starting with a very simple set of possible
actions, but once I get the system itself working properly,
I expect to develop much more complex responses. I think the
basic control scheme will scale up well.
Latest blog entries Older blog entries