How small can you go? I’m fascinated
with the idea of swarms of small robots
acting together to accomplish a task. To do
some experiments with swarms requires a
small microcontroller. The one I selected for
this robotic test bed was the PICAXE-08M.
The challenge that remained was having
some I/O and processing power left after
driving the wheels. Here’s my solution and
an introduction to the cutest robot I’ve ever
created.

wall. It takes four I/O pins to operate two motors with
H-bridges. The PICAXE-08M only has five I/O pins and using
four of them to operate the motors would leave the robot
with only one I/O pin left. The one remaining I/O wouldn’t
be a true I/O pin as it could only input data. To leave an
additional I/O pin free for sensor controls, I used one I/O
pin as an input to both H-bridges. Using three inputs to
control two H-bridges created the following truth table.

P0 P1 P2 Motor 1 Motor 2

Robot

Pivots

I first used the PICAXE-08M microcontroller to create
a datalogger small enough to fit inside a ping-pong ball.
However, since then, I haven’t made much more out of this
little and inexpensive gem of a microcontroller. Since it’s
perfect for tiny tasks that don’t need much memory and
I/O, you normally won’t find a PICAXE-08M controlling a
robot. For readers not familiar with this micro, it has five
I/O (only three are bi-directional) and 256 bytes of memory.
However, even if it has limited memory and I/O, a swarm
of PICAXE-08M-based robots should be capable of working
collectively on a task.

An effective robot controller must be able to run a
robot forwards and backwards, as well as turn it clockwise
and counter-clockwise. I didn’t want to add a steering
mechanism to the robot because of the complexity.
Therefore, the controller operates two robot motors in
skid-steer mode. Rather than using modified servo PWM
motors — which take time away from operating sensors
— the robot controller operates its two motors with two
Toshiba TA800K H-bridges. Now the robot can drive
while it performs other tasks, like not crashing into the

You’ll notice that there’s no way to rotate one motor
clockwise and the other counter-clockwise at the same
time. So, rather than spinning with a zero turn radius (ZTR),
the robot pivots around its stationary wheel. The way to
achieve a pseudo-ZTR then is to pulse the wheels so they
take turns pivoting the robot. You’ll see this in the sample
code that follows.

Now with the turning procedure figured out, I was
ready to design the new robot controller. Since the