Roverbot is a robust robot body that is easily adapted for just about any simple indoor mobile application you can think of.
When I got my Lego kit, the first application I wanted to try was to give Sandwich some competition in the line following arena.
This page tells a bit about the Roverbot base, the software program I wrote, and a
head-to-head comparison with Sandwich in both sensor design and line following performance.
Roverbot Base
The Lego Mindstorms Robotic Invention System (RIS) 2.0 comes with instructions for building the Roverbot base. It is a compact design
that's pretty sturdy. The mount point for the sensors is modular so you can easily swap a variety of touch sensors and light sensors.
Similarly, the drive train is modular, making it simple to use wheels, walking legs, or tank-like treads.
 |
 |
Video Footage: (if you listen real close, you can hear Ollie chomping in the background :-)
Roverbot going Clockwise - .wmv (2.06 MB)
Roverbot going the other way - .wmv (2.27 MB)
|
For my line following robot, I chose to use the wheels for the drivetrain, and the light sensor positioned in the front of the bot.
The assembly took about 1 hour, following the instructions provided with the kit. It could have taken less time, but I was like a kid
in a candy store and sat there admiring each piece of Lego. That, plus the fact that my kit arrived in the mail the day before I was
leaving for a vacation, so I also had to pack.
Line-Following Software
Once I finished assembling the Roverbot base, the first thing I did was to play around with the programming language
that comes with the Lego kit. It is so easy to use, you really don't need any prior programming experience. So I started out with
some simple behaviors like drive forward, simple turns, some dancing. So to challenge myself I figured I'd write a program for
line following. Here's a screen shot of my program.
Algorithm
My Roverbot uses a single light sensor for line following, so I had to come up with a technique that could overcome that
limitation. I call the algorithm "Line Addict". The basic idea is that my bot is "addicted" to the color of the line.
If he can see the line, then his addiction is satisfied, so he just drives forward. If he can't see the line, then he gets
the jitters, slowly at first, and then increases his jitter until he can see the line. And that's basically it, although I did add
in a slight optimization to remember what direction the most recent jitter ended on, and use that as the starting move for the next time he jitters.
This works well in turns (especially on an oval where all turns are in the same direction), but on straight-aways you can see in the video
what the effect is.
Roverbot vs. Sandwich
Do you want to see the difference between how Roverbot and Sandwich see their lines? click here
In Conclusion
In conclusion, I'm overly happy with my Lego RIS 2.0 kit. The Roverbot base is easy to build and seems robust enough
for use in some more sophisticated applications. The programming environment was easy enough for me to get started quickly.
I do want to try out some other programming options like NQC or Java, but that can wait until I find something I can't do with
the standard language.
My line-following Roverbot is only mediocre as a line-follower. In the current version of the software, it's limited to following
the black line that's on the race track that comes with the Lego kit, so a future upgrade would be to enhance the initialization
sequence to figure out what color line to follow. Also, once the bot looses the line and starts to jitter, if the jitter keeps
going long enough that he's swinging 90 degrees to either side, then he's lost the line. An enhancement would be to have him try
some maneuvers to find the line that's out of "swivel range".
