Saturday, 28 August 2021

Running Robot Code on Start-up with systemd

Following the excellent blog post by Brian Starkey @usedbytes to set up my robot programs to launch on start-up on a Raspberry Pi, I found several things which didn't work with my particular programs. This article aims to extend the information from Brian's post.

First a quick recap on why use systemd services instead of rc.local or autostart desktop files. For me the main advantages of this method are:

  • The automatic start up of the robot code on boot can be turned on and off, which really helps when developing code and you don't want the robot program to launch each time you boot up.
  • You can configure the code to be restarted if it stops for any reason. Great for if an unexpected bug crashes your robot code in the middle of a demo or competition. No need to wait for a reboot to get the code running again.
So what went wrong when I tried to implement the services as described in Brian's blog? First I want to point out that nothing in Brian's blog was wrong. I just needed some additional configuration for my programs. The first problem I ran into was that I had only installed the python packages my program needed as the pi user, but found that the service was running as root. This can be fixed by installing all the packages as root, but I found an alternative option. You can specify the user to run the service as by putting User=pi in the service definition file.

The second problem I ran into was that my service ran in a headless mode, even though my Raspberry Pi was running a full desktop OS. This works fine for a python program which does not use the display, but my robot programs are usually built on top of pygame and use this to display information and sometimes control menus in a GUI. Running my programs as a service caused pygame to exit with 'pygame.error: Unable to open a console terminal'. So I had to learn how to run a service with access to the display device. This required a couple of lines to be added to the [Service] section:

Environment="DISPLAY=:0"
Environment="XAUTHORITY=/home/pi/.Xauthority"

I also needed to change the [Install] section WantedBy value:

[Install]
WantedBy=graphical.target

 

I am not going to repeat all the information from Brian's blog article here. You should read that first if you are not familiar with how to set up and configure services to run on boot. Once I had everything working this is what my runrobot.service file looked like.

[Unit]
Description=Robot Runner

[Service]
Type=exec
ExecStart=/usr/bin/python3 /home/pi/pygame-controller/examples/SentinelBoard/Turbo4WD.py
User=pi
Environment="DISPLAY=:0"
Environment="XAUTHORITY=/home/pi/.Xauthority"
Restart=always
RestartSec=5s

[Install]
WantedBy=graphical.target

Command Quick Reference

The service file needs to be copied into /etc/systemd/system in order to work:
sudo cp runrobot.service /etc/systemd/system

As long as the filename ends '.service' you do not need to specify the full filename in all the commands. You can just use the service name (runrobot in this case).

If you change the .service file then the changes will not be picked up until the next reboot, or after you run this command:
sudo systemctl daemon-reload

To enable service (make it run on boot):
sudo systemctl enable runrobot

Disable service (stop it running on boot):
sudo systemctl disable runrobot

Start service (run the robot program without doing a reboot):
sudo systemctl start runrobot

Stop service (stop it running):
sudo systemctl stop runrobot

View output from the service/program since last boot:
sudo journalctl -b0 --unit=runrobot


Tuesday, 29 June 2021

Dr Footleg on YouTube

My video content can be found at Dr Footleg on YouTube for my own channel. For much of my content recorded for other organisations I post links to it all on my Ko-Fi page so this is the place to find my talks on home robotics and PCB design.

Wednesday, 23 September 2020

Arduino Development using VSCode

The Arduino IDE provides a means to write code for microcontrollers, with library management, compilation and uploading of your code. But the code development environment is lacking many of the features of a modern IDE. Enter VSCode to the rescue! Providing syntax checking, auto-indentation (with clean up), and code completion via the IntelliSense feature. VSCode is free and provides a capable development environment which supports multiple languages, remote code development over SSH and many other capabilities via a comprehensive library of extensions. In this article, we will be looking at options to use it to develop code for Arduino (and Arduino supported boards).

Before starting with VSCode, you need to install the Arduino Desktop IDE (at time of writing this was v1.8.13). You can download it from www.arduino.cc/en/main/software. The VSCode extensions use the Arduino IDE under the hood, so you need this to be working with your boards.  Check that example sketches can be compiled and deployed onto your board using  the Arduino IDE. 

Now we can set up VSCode. You can download the editor from code.visualstudio.com/


We will be writing C/C++ code for Arduino, so we need to install the extension to add support for this language. 

Down the lefthand side of the VSCode window is a vertical toolbar. Click on the Extensions button to open the extensions manager. 



Find and install the C/C++ extension:


There are two options to add support for Arduino development. The more obvious looking one is the Arduino extension. I was able to get this working with some configuration required, but a number of features did not work for me. I could not open the Serial Monitor, Teensy boards were not supported and I found the IntelliSense feature reported problems in my code which were not problems for the Arduino compiler. I did learn a few tricks to make things workable and I have detailed these at the end of this article if you want to use this extension. But I found things worked better for me using the alternative option, the PlatformIO IDE extension. You probably don't want to install both as the IntelliSense feature configurations of each are not compatible.

PlatformIO IDE

The PlatformIO IDE extension provides support for more boards (including the Teensy family), but it is not as tolerant of the non-standard C/C++ syntax which Arduino sketches allow. You will need to convert any .ino files into .cpp files in your projects to work with this extension. You will also find that functions have to be declared before they are used, and global variables and functions declared in one file in a project will not be in scope in other files. More details on this later, but aside from these code compatibility issues I found it very easy to set up and most of the configuration was automatic.


To get started with the PlatformIO IDE, I suggest you follow their quickstart guide. That is what I did, and there is little point in me repeating that information here. See https://docs.platformio.org/en/latest/integration/ide/vscode.html#quick-start 

Once I had built a basic blink sketch following the quickstart guide, I successfully imported an existing Arduino project from the extension home page, ticking the option to use the Arduino libraries already installed on my computer. This created a copy of the project under my <user>/Documents/PlatformIO/Projects directory, with the configuration set up to include libraries from the existing Arduino IDE installation on my computer. You select the board you want to compile for in the import dialog. I already had the Teensyduino packages installed, and found the Teensy boards listed in the board picker. The IDE warned me that I should change the .ino file to a .cpp file in order for IntelliSense to work. The project source was also put under a 'src' folder. Projects with both cpp and header files should be reorganised by moving the h files from the src folder into the include folder. I just renamed my single ino file through the VSCode explorer pane and I was able to compile and upload the project to my Teensy 3.2 board.

One additional configuration change I made was in the platformio.ini file under my project. I added a build_cache_dir line as follows in my ini file. You can point this to any folder you like outside your project. By doing this, libraries compiled as part of your sketch will not need recompiling every time you rebuild. So after the first build, subsequent builds will only need to recompile classes with code changes, which will be faster.

[platformio]
; Set a path to a cache folder
build_cache_dir = C:/temp/PlatformIO_buildcache

You can also add additional library paths in this file. I was working on a project which uses a library I am also developing on my computer. So I added a path to my library code in development after the path to the Arduino libraries (note the syntax ~ to refer to your user home directory):

[env:teensy31]
platform = teensy
board = teensy31
framework = arduino
lib_extra_dirs = 
    ~/Documents/Arduino/libraries
    ~/Documents/dev/Cpp/RGBMatrixAnimations

That was all I needed to do to get up and running with simple single file sketches. But to make multi-file projects compatible I needed to make some code changes. The Arduino IDE does some rewriting of your code before it compiles it. All .ino files in the project are essentially combined into one large code file, and any functions defined in them have declarations added to the code before they get called. You do not get any of this in PlatformIO. This does force you to write more standards compliant code though, so it is no bad thing. To get my more complex project to compile I had to do the following:

  1. All .ino files in a project need to be changed to the extension .cpp
  2. Functions defined in my main cpp file needed to either be defined before they are called, or have forward declarations added near the top of the file. (This article explains it in more detail: https://community.platformio.org/t/order-of-function-declaration/4546/2 ).
  3. To call any code in other .cpp files requires an include for that .cpp file adding to the file calling that code. This also means you need to add includes for any library header files to all the cpp files which use those libraries (rather than just once in the main project code file).
  4. Global variables declared in the main code file can no longer be accessed from code in other files. So you'll need to pass them to the code using them in other files (either via class constructors or as parameters to any methods).
I avoided declaring functions directly in secondary cpp files, instead using these files only for class declarations. You can then pass variables to these classes via their constructors, or setter member methods. This gives tighter scope control and makes for more robust code. Overall I found the PlatformIO extension worked better for me than the Arduino extension, but if you want a more Arduino like coding experience rather than standards compliant C++ then you may find the Arduino extension suits you better.

Arduino Extension

If you want to use the Arduino extension instead of PlatformIO (maybe you want to work on projects with .ino files for example), then install that extension instead.


This adds several Arduino commands to the command palette. With this installed, when you open an Arduino sketch (.ino) file in VSCode you should see a custom footer bar with clickable options to select the connected board, COM port and Programmer (if you are using one). Click on the <select board> item and the board manager should open (you can also open it via the Command Palette). I found the <select PORT> command was not working, so I had to set it manually in the arduino.json file. Open this file from the .vscode folder in your workspace, and add the COM port line as follows (setting the correct numbered COM port matching the one you used to program your board from the Arduino IDE).

"port""COM4",

You should now be able to verify sketches and upload them to your board using the Arduino commands.

Open Command Palette (Ctrl + Shift + P), and type 'Arduino' to filter the commands list in the command picker. You will see 'Arduino: Verify' and 'Arduino: Upload' commands. Note these also have keyboard shortcuts displayed. e.g. You can compile and Upload the open sketch using Ctrl + Alt + U.

The first time you do this for a project, you will be asked which .ino file is the main one (if you have more than one in the sketch). Once you select this it is added into the arduino.json configuration file (so you know where to go to change it if you change the main file later).

You may see a warning at the start of the compiler output, saying 'Output path is not specified. Unable to reuse previously compiled files. Upload could be slow. See README.'. This means that each time you make a code change and go to upload again, the compiler has the recompile the entire project including all libraries, which can take a long time. To allow it to reuse the output from a previous compile and only recompile the files which have been changed, you need to define and output folder in the arduino.json file. This folder should not be under the project folder. You can add the following line to set the output to a folder named ArduinoOutput located alongside your project. Alternatively give a full path to a folder, maybe in your temp directory.

    "output""../ArduinoOutput",

This should get you to the point where you can open, edit, compile and upload sketches to your boards. But you may notice the code IDE still shows lots of errors in the code because the VSCode IntelliSense feature does not know where all the Arduino libraries are located. We need to add these to the workspace include paths:

Using the command palette, run the command: C/C++: Edit Configurations (UI)

This will open the UI to edit your C/C++ configuration. You can edit your win32 configuration, or create a new one. I decided to create a new one named 'arduino'.

In the 'Include Path' field, make sure all 3 of these paths are added in addition to the workspaceFolder item:

${env:userprofile}/AppData/Local/Arduino15/packages/**
${env:userprofile}/Documents/Arduino/libraries/**
C:/Program Files (x86)/Arduino/hardware/arduino/avr/libraries/**

That last one assumes you installed the Arduino IDE into the default location under C:\Program Files (x86)\Arduino. If you installed to a different location then change it as appropriate. Note the use of the userprofile environment variable to make the configuration work on any computer. These configuration files can be checked into source control so that your projects can be checked out and run quickly on different computers regardless of the logged in username.


My complete arduino configuration section looked like this:

        {
            "name""arduino",
            "includePath": [
                "${workspaceFolder}/**",
                "${env:userprofile}/AppData/Local/Arduino15/packages/**",
                "${env:userprofile}/Documents/Arduino/libraries/**",
                "C:/Program Files (x86)/Arduino/hardware/arduino/avr/libraries/**"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "compilerPath""C:\\Program Files (x86)\\mingw-w64\\i686-8.1.0-posix-dwarf-rt_v6-rev0\\mingw32\\bin\\gcc.exe",
            "cStandard""gnu18",
            "cppStandard""gnu++14",
            "intelliSenseMode""gcc-x64"
        }

Finally, open the command palette again and run the command C/C++: Select a configuration, and select the 'arduino' configuration. This should clear most of the reported 'problems' in the code IDE, and IntelliSense code completion suggestions should now be working. There are some exceptions to this however.

The Arduino IDE appears to treat all .ino files in a project directory as being part of the main .ino file. So any code split across different .ino files will be compiled by the Arduino IDE as if that code was all in one big file. However the VSCode IntelliSense environment does not do this. One way to avoid this problem is to only have a single .ino file in your project, and use the extension .cpp for any other code files. You will then have to add #include statements as required to include these .cpp files in other files which reference them, and you will no longer be able to access globals defined in the main .ino file from code in the .cpp files. It will make you write better code, forcing references to be passed to objects rather than being accessible everywhere via globals. But you may find projects published by others do not work with the IntelliSense feature in VSCode.

In some cases, libraries will have been written to be compatible with both Arduino and Windows/Linux C/C++ programs. These can cause problems because the VSCode IntelliSense environment does not realise it is running in an Arduino environment. So it tries to check the code against windows libraries which will not be on your Arduino project path. You can make it behave like an Arduino environment by adding the following line to the start of your main sketch .ino file:

#define ARDUINO 100

But I suggest commenting out the line before compiling as the Arduino IDE will set it's own define, which may be different to this. Better to just live with these reported include errors since they will not apply when the Arduino IDE compiles the code.

Some data types in my project were flagged as not defined by default in standard C/C++. These included:

  • byte
  • boolean
  • uint8_t/uint16_t/uint_32_t
If you want to avoid these being flagged as errors by IntelliSense then you can use bool in place of boolean, uint8_t in place of byte. Then to make IntelliSense aware of the uint types, I added the following #if defines which I use in code designed to be compatible with both Arduino and non-Arduino environments:

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#elif defined(ARDUINO)
#include "WProgram.h"
#else
#include <stdint.h>
#include <stdio.h>
#endif

I am not sure how much of this was really needed, as the IntelliSense appeared somewhat temperamental about which errors it reported. Sometimes if would just be complaining that included libraries referenced header files it could not find, but then it would suddenly report most of my file contained errors.

I was unable to get the serial monitor working under the Arduino extension. When I clicked the icon in the footer toolbar to open it, I saw the following error: .vscode\extensions\vsciot-vscode.vscode-arduino-0.3.2\out\node_modules\usb-detection\build\Release\detection.node is not a valid Win32 application.

I uninstalled the Arduino extension after I discovered the PlatformIO IDE extension, which appears to be working much better for me. If you have more success then please share in the comments.

Thursday, 14 March 2019

A Complete Rebuild in Acrylic

It was always my plan to make my competition robot in transparent laser cut acrylic, so that the insides could be seen. Plus it just looks so nice! Having learned the art of designing and building a laser cut robot using 3 mm plywood I was now ready to re-cut the refined design in acrylic. The main modification I made was to shorten the legs by 15 mm. I had realised from driving my prototype that it really did not need such high ground clearance as the small wheels could not climb over anything but small obstacles. It was also a little unstable. I could get it to lift some of the wheels off the ground doing sharp turns at speed!

I added some engraving to various parts and also added holes for threading all the motor and servo wires through the legs. I had drilled these holes by hand on the wooden model. Now I knew where I wanted them I added them to the CAD model so these could be laser cut on the acrylic parts. I had already designed an acrylic mount for my main display and had this mounted on the wooden chassis.

With so many parts to cut I wanted to make optimum use of my acrylic sheet material. So I used an online SVG nesting tool to layout the parts. I prepared an SVG file of all the parts in Inkscape, including a containing rectangle required by the nesting tool to limit the area and shape to fit the parts into. I uploaded this to https://svgnest.com/ which generated a cutting layout for me to download.

An optimised parts layout for laser cutting

The complete set of laser cut acrylic parts ready to assemble

First I assembled the 4 steering legs. One snag I ran into is the inconsistency in thickness of acrylic sheets. A 3 mm sheet can vary in thickness between around 2.8 mm and 3.2 mm. This is due to the surface tension on the sheet when it is being cast, which results in a curved top surface dipping down towards the middle of the sheet. The sheet sizes you typically buy are cut from this larger cast sheet. Depending on which part of the cast sheet your piece was cut from you get different thicknesses across your piece. Some of my sheets exceeded 3 mm thickness towards one end, so some of my parts did not slot together as all my slots are cut at 3 mm wide. I had to re-cut a few parts with slightly wider slots. But I did not want to make all my slots wider by default, particularly the motor mounting plates which wobbled too much when the slots were not a tight fit. This an area which could do with some more refinement so that the rigidity of the motor mounts is not so dependent on tight tolerances. In the process of assembly I accidentally snapped one part in half and cracked another by over tightening the bolts holding the parts together. Acrylic is a much more brittle material than plywood and is easy to crack, especially around rectangular holes with sharp internal corners. I later modified some of my parts to increase the width of material around the outside edges of the slots from 3 mm to 4 mm to increase the strength of some parts. After re-cutting (plus a few spares) I had two completed Rocker Bogie arms.

The Rocker Bogie arms remade in acrylic with cable routing holes

As I assembled my robot using the new parts, I tried to extensively photo-document every step of the process. My plan is to write up a full build guide and possibly release a kit of parts for others to build their own rover from my design.

Some of the many photographs I took to document the assembly process

Another problem which came from switching to acrylic was that the plates did not grip each other like the plywood had. Some of my chassis body side plates were not staying together at the ends furthest from the bolts holding them in place. I had to add some additional T-slots and bolts to hold everything firmly together. I had designed a new front plate to mount a Pixy2 camera on, and this was not held on with anything more than the friction of the tabs in the slots. This would need more refinement for the competition as it was also going to be holding my Pi Noon attachment and I did not want that falling off mid-battle. For for now I could push it on and it looked good enough for me to shoot some photos. I set up my filming lights to provide some nice back lighting and took a few photos to try and capture the beauty of the acrylic design.

My final photo submitted for the Pi Wars 2019 program

Wednesday, 13 March 2019

Another Redesign: Electronics Cartridge

One problem I identified with my robot chassis design was that I could not access any of the electronics without taking the whole thing apart. It was not possible to remove the SD Card from the Raspberry Pi without unscrewing the Pi either. One option for the SD Card access which Brian Corteil suggested was to boot the Pi from a USB thumb drive instead. I had not realised this was possible, but some testing with various tiny sized USB memory sticks showed this worked very well (at least with the Pi 3b). But I was still concerned that if I had any wiring problems on competition day it would be difficult to access the internals to fix things.

The idea I had to solve this was to redesign my chassis so that all the electronics were mounted on a plug-in cartridge which could be pulled out of the chassis to easily access everything. This also allowed me to design a second tier to mount breakout boards on above the Raspberry Pi.

CAD model of my electronics cartridge

Having a 2 tier electronics tray posed some problems with how to route the ribbon cable which connects the touch screen display to the Pi. I went through a few iterations before building a prototype cartridge. If I routed the ribbon cable straight up through the upper tier then it limited the space to arrange the breakout boards on that tier. I ended up with a design where the ribbon cable was folded to change the orientation through 90 degrees from the Pi to the display. The fold was contained on the lower tier, which required the height of the lower tier to be higher than originally planned. Space was tight for the upper tier, and I did not take into account the height of the Du Pont connectors used to attach all the wires to the breakout boards. Another redesign of my entire chassis was required to allow another 5mm of head room. I modelled just one Du Pont connector with a wire bending over coming from it (you can see it in the CAD model above) to check I had the required headroom for the wiring.

Redesigned chassis with the electronics cartridge inserted

It all looked great in CAD, but when I came to assemble it I realised I needed a lot longer cables to provide enough slack to actually slide out the cartridge from the chassis. My ribbon cable was not long enough and 40 way ribbon cables seemed very expensive when I looked online at the usual electronics suppliers. Then I remembered somebody had pointed out that IDE hard disk cables in older PCs were just this type of cable. I checked my box of parts for modding PCs and found I had several. They all had 3 connectors, but I simply cut one off close to the middle connector to give a suitable length ribbon cable. All my other Du Pont connector leads I was making myself from a reel of ribbon cable, so I made these long enough to provide some slack.

The reality was that all this extra cable took up a lot of room, and the cartridge was very tightly packed when assembled. It was very hard to slide out due to the cables all catching on bolts, and in hindsight I could have done with another 10mm of head room in the chassis. But I can just about slide it out with a lot of cable wrangling if required to plug in a new lead. I later extended the i2c breakout to a second bus board near the front of the chassis so that I could easily plug and unplug additional ic2 devices mounted on the front of the robot without needing to remove the cartridge.

The assembled electronics cartridge with the multiple folds in the long ribbon cable. Most of the i2c device cables are missing here, apart from one connecting to the PWM breakout used to drive the servos and motor power. The 4 servo cables are also missing here.

Shown with the chassis front and front-side panels removed. The cables completely pack out the space in the cartridge.



Tuesday, 12 March 2019

Robot Software Design

I went for a modular design for my robot software. Python is very modular in structure, with each module importing the modules (or code libraries) it requires. I designed my robot software along the following lines.



Each module does a specific job, and is accessed through a few simple functions which describe the operation being performed. For example the Sensors module contains a function readDistance(sensor) which returns the distance measured by one of the TOF (time of flight) sensors. The parameter (sensor) specifies which sensor (by number) to read. The module also provides the required methods to configure and initialise the sensors, and the i2c multiplexer board they are connected to. So all the complexity of switching i2c buses, turning on sensors and reading them is wrapped up in a module with a very simple code interface.

Another advantage of a modular approach is that you can put all the code which is specific to a set of hardware (e.g. motor controllers) in a single module. The module then presents an interface with simple methods like setMotorSpeed(motor, speed). If you need to change the motor controllers used in your robot, or want to reuse the code on another robot with a similar arrangement of twin motors then you only need to replace this one module and the rest of the code can be reused without changes.

The hardware interface module is called from a module which represents the movement capabilities of the robot. In this case my robot has steerable wheels, and multiple motors wired up in two groups. So the movement control of the robot is wrapped up and controlled through a few simple functions:

  • setLeftMotorPower(speed)
  • setRightMotorPower(speed)
  • setSteering(angle)
  • setSpotTurn(angle)

The LED Matrices module handles setting up and connecting a pair of rgb 5x5 LED matrix breakouts, and displaying patterns on them. A series of patterns are stored in the module and can be called by name. There is also a frame buffer which allows series of patterns to be queued up to show on the LEDs one after the other. Methods can be added to queue up patterns by name. e.g. showBlueEyes() or eyesBlink(). Animations cycle through the frames in the buffer for each display when a nextFrame() method is called.

The main program module handles output onto the main display screen. It also contains all the event handler functions for controller input. A separate module handles detecting different game controllers and mapping their buttons, sticks, hats and triggers to the same named events. So a range of game controllers can be used on the robot and they will all call the same code when their 'triangle button' is pressed.

The main module also contains the code for reacting to touchscreen input to display and navigate through graphical menus, and the main program loop which takes actions based on the mode the robot is in. In this main loop, sensors reading calls can be made, there is the call to display the next frame on the LED matrices, and trigger calls to any event handlers for the connected game controller.

Developing all the code for menus, modes and linking controller input to the robot can be very time consuming when trying to test on the robot itself. But by having the modular structure we can create a virtual copy of our robot, or Digital Twin. By writing a mock copy of each module which interfaces to the actual hardware we can work on the code without the robot being present at all. I did a lot of the coding on a laptop using Raspbian x86 running in a VirtualBox VM. Coding anytime, anywhere. Only the laptop was needed to write, debug and test much of the code.



Just 3 modules (coloured blue above) needed mock versions to the written for the robot to be virtualised. Each of these mock modules has the same name and functions in it as the real version. But the code inside the functions captures the display object from pygame and renders a representation of itself onto the display.

Digital Twin: A virtual representation of the robot
(Background Mars image from Hubble Space Telescope. Credit: NASA)

The mock hardware interface module renders the shape of the robot, and shows the motor speeds and steering leg angles. The mock sensors module generates randomly varying distance readings and renders yellow triangles to indicate the sensor values. The rgb LED matrix mock module renders a representation of each LED matrix onto the screen. I also added an option to display numerical information to aid debugging and diagnosing problems. You can see the virtual robot running in this video clip I posted on Twitter:



The graphical representation of the digital twin of my robot and the sensor output was so useful for debugging issues that I moved it from the mock module into the main robot module. All the graphics slow down the main loop so that it does impair the responsiveness of the robot. So I made it possible to switch on and off via the controller. In normal running the display shows a static graphic of a solar panel, as you can see in this video clip.


(Post Pi Wars 2019 competition I published the full source code for my digital twin robot on github. You can play with my virtual robot using the code on the 'mock' branch. Full instructions and code here: https://github.com/Footleg/PiWars2019/tree/mock )

Monday, 11 March 2019

First Fully Drive-able Build of my Mars Rover

My first prototype body to mount my rocker bogie arms onto made me realise I needed to better balance the weight of my robot over the main pivot axis. I also needed better clearance between the body and the steering legs. Then there was the challenge of where to put the rest of the electronics and the battery. I decided the battery was the thing to provide the weight to counter balance the body, and being a heavier item should also be located closer to the ground to make the robot more stable. So I drafted a design where the rear of the body was tapered giving less width. Enough to accommodate the battery but narrow enough to give sufficient clearance for the rear steering legs.

Early redesign of main body with narrower rear end

In attempting to wire up all the motors, and with the steering servo cables also needing routing into the chassis body, my robot was suddenly looking rather messy. I had deliberately made my prototypes from 3mm ply so they could be modified easily to iterate on the design. I explored ways to route the motor wires by getting out the drill.

Iterative design: wire routing!

Somebody commented on one of my Twitter posts asking where I planned to mount the Pi Noon attachment required for two of the challenges. This was not something I had considered up to this point. The challenge rules stated the attachment point had to be on the front of the robot, in the middle. My robot design at this point had nothing but thin air in that position! I wondered about making some sort of brace which attached to the two front rocker arms to hold it. This would lock the rocker (but the event would have a flat surface so not a big issue). Then I realised it was also needed for the Spirit of Curiosity challenge and this was expected to have terrain of varying difficulty. This was the challenge my robot was built for, and my robot was based on the namesake Mars rover of this challenge. I needed another plan. Looking at pictures of the real Mars Curiosity rover I realised that the rocker arm linking bar was positioned forwards of the main pivot axis, rather than behind as on my rover. I swapped mine to the same (you can see this difference between the original animated CAD model and the actual plywood first prototype in my earlier post).

Redesigned chassis shape with battery compartment and room for breakout electronics

Looking at my remodelled chassis it suddenly struck me that the back looked awfully like a front now, and what I had always imagined as the front was looking much more like the back (complete with USB and ethernet 'exhaust' ports). This now gave me a front panel to attach the Pi Noon attachment to as well. I extended the new front end to bring it level with the end of the rocker arms, and so my final rover shape was decided.

The new completed chassis built and ready for some road testing

Checking the A4 footprint of my new design

Finally I had something I could road test. The closest thing I had to some martian terrain was a load of rocks and fossils collected on family trips to the Jurassic coast.


Overall I was very pleased with how well my robot handled. It was very easy to control. The grip on steeper slopes was not enough, but I think for the Pi Wars challenges it will be sufficient. It was a little top heavy and prone to toppling over on more challenging obstacles. Here are some of the out-takes.