RoboMagellan Robot

A lot has happened since I last posted here, and I’ll be switching the focus of this blog to be more robotics stuff, although I will probably add in a few other bits and pieces as things go along.

Ever since I saw they were running RoboMagellan competitions back in the early 2000’s, I’ve wanted to build a robot to compete. I did build an outdoor navigation robot while I was working on a robotics contract for a University in the US back in 2008, but I didn’t know anything about outdoor robots at the time, and ended up choosing a poor chassis to start with. I also didn’t spend nearly enough time on the software, the robot was too large and heavy, and couldn’t figure out how to deal with the (rather noisy) LIDAR data I was getting. 

Video of that robot running in my back yard

I spent a couple years during the pandemic getting into RC Rock Crawlers, and built what I consider to be a rock-solid, extremely capable rock crawler vehicle.

Here’s a video of it in action:

Video of my RC Rock Crawler, in the wild

I recently got back into Robotics after a roughly five year hiatus.

I decided after a month or so of playing around with a couple walking robots that I really wanted to build a RoboMagellan robot, and I was going to use my yellow Baja Bug rock crawler as a base.

One of the safety requirements of a RoboMagellan robot is having some kind of remote failsafe, which will stop the robot if you let go. We run these robots in public parks and areas like that, with lots of people around. Being able to stop the robot instantly is a good thing, both for the health of bystanders and the robot itself.

I worked on the failsafe remote as a “getting started” project. I wanted something reasonably ergonomic, since I would be paying more attention to the robot than where the failsafe button is. I wanted something where I could see what it is doing, that would allow me to change from autonomous robot mode to remote control, and that also let me know how much battery is left, so I don’t run out of battery and die half way through a run.

So I needed the following parts to make up this failsafe handheld remote:

• 3D printed case
• Trigger button
• Mode button
• Some kind of display
• Microcontroller with an RF transceiver
• Battery (single cell lipo)
• Step up/step down voltage regulator to get a constant 3.3 volts
• Power switch

I needed some way to charge the battery, since I planned on using a single cell Lipo battery. The microcontroller had to be capable of running MicroPython or CircuitPython, since that is my language of choice for embedded programming now.

I did some research, and Adafruit had an excellent option that took care of almost everything. Adafruit Feather RP2040 RFM69 Packet Radio checks all the boxes and then some – it runs Circuit Python, it has a nice 915 MHz transceiver onboard, and it can run off a single cell lipo, and charge that lipo from USB power.

I ordered two from Digikey (Digikey carries a lot of Adafruit’s stuff, and has much better shipping to Canada than almost anywhere). I had a 620 mAh lipo battery on my work bench from an earlier experiment, and I also had a couple of those neat little 0.91” OLED LCD panels that are controlled using I2C. You can get them almost anywhere, I think I ordered them off Amazon although I think they are much cheaper from other sources like Ali Express.

I did some bench testing to make sure that the RP2040 could talk to both the LCD panel and the radio, and then started CAD modeling the case. I ended up with this:

After 3D printing the case in ABS, and making a few adjustments, I got this:

The grey cable is a USB-C extension cable I got off Amazon, and allows me to charge the battery, which is in a box under the microcontroller. The on/off switch is also on the bottom, next to the USB port.

The ugly looking resistors near the top of the microcontroller board form a voltage divider, so I can measure the battery voltage (which is almost always more than the 3.3v the analog to digital converters on the RP2040 can handle).

In RC mode, it looks like this:

Switching to autonomous mode looks like this:

Pressing the trigger while in autonomous mode looks like this:

Easy to use, easy to hold on to, does everything I need. I call that a successful project.

The Robot

Here are a couple of pictures showing the robot’s current state:

In the second picture I’ve added the GPS mount. I may have to relocate that onto some kind of mast, along with the IMU, but we’ll have to see how it does in actual testing.

The robot will be run from a Raspberry pi 4, running an autonomous controller written in Squeak Smalltalk. I’ll talk a lot more about my plans for the autonomous controller in a later post.

On the embedded side of things, the main microcontroller will be a WeAct STM32F405 Core Mini Board running MicroPython. There is a GPS, an IMU, and a small 1.47” LCD panel visible through the side window. It will have a small close range ToF LIDAR sensor in the front bumper (for final cone approach), and a set of 3 ToF LIDAR sensors in the back to help avoid backing into things. I’ve already installed an encoder onto the front of the motor, before it gets to the transmission, for helping with odometry.

You can see the small brass pin I machined in the above image, with a small magnet disc attached to the end. The quadrature encoder PCB is mounted to the back of the battery case, and will feed into the main STM32F405 microcontroller to keep track of how far the robot moves.

The main obstacle-avoidance and cone-finding sensor is a Luxonis Oak-D Lite (I backed their kickstarter). You can (according to the documentation) do simultaneous depth mapping and object detection (using a custom model you train), with zero CPU usage on the raspberry pi. I’m planning on training a model to do cone detection.

The RC Receiver (visible in the first robot image above, just behind the front left tire) will have the throttle and steering signals routed into the main microcontroller, and said microcontroller will produce the PWM signals for the steering servo and the motor control.

Finally, the failsafe, which is a duplicate of the Adafruit board inside the handheld remote, will talk to the main microcontroller and tell it what mode it is in, and thus how to control the motor and steering.

The Raspberry pi 4 will also talk to the main microcontroller over a serial port, and send control commands and receive sensor feedback as needed.

I think I’ll wrap it up here for now, but much more to come…