Building the ExoMy Rover

After building my first robot I decided that, for my next robot, I wanted to build something more complex, but I wanted to focus on the software and AI part of it. That’s why I decided to build an already existing one that was open sourced and experiment with it. From the many different robots that I’ve found online, the final decision was to build the ExoMy, an open source rover designed by the European Space Agency, fully 3D printed and relatively cheap. In this post, I will explain the process, changes and modifications that I’ve made while building the robot and I will brielfy explain the code for controlling the robot.

Costs and parts modifications

Roughly, the full list of parts and expenses is (with the modifications that I’ve made):

• Two spools of filament: 20€ each
• All hardware and electronics: 250€
• Raspberry Pi - Had a 3B+ already bought, although it may be not enough if I decide to add many more ROS nodes. Will upgrade if needed.
• LIPO Battery: 24€, depends on which one you buy.
• PiCamera - Bought a cheaper one for 10€, official one was 40. Will upgrade if this one is really bad, but for now it is good enough.
• Controller – Optional, did not buy one as I had an XBOX controller and I’m planning on using mainly the web browser for driving when needed.
• Others:
  • Had to buy LIPO charger and storage - 60€ total.
  • Bought an adapter for the LIPO connector because I thought that the LIPO battery was an XT60 connector but turned out to be a Dean connector - 3€.

I had some of the parts, like the raspberry pi and some bolts, already bought from other projects, but had to buy a LIPO charger and some other parts. The total cost for me has been 327€, with 60€ for the LIPO charger and battery storage bag. You can think of this as an estimate if you plan to build yours.

Time spent

The main two time factors are, without doubt, the time spent printing all the parts and the time waiting for all the parts to be delivered. If you decide to build, I strongly recommend start printing as soon as posible.

• Buying and waiting for the pieces, depends on manufacturers. I bought some of the parts on Aliexpress, waiting for some of them for around 2.5-3 weeks.
• Printing time. I have an Ender 3 Pro, and probably not the best settings, since I have a lot of problems on the first layer. I spent around 3 weeks printing all the parts, but this was not very optimized. I think that, with better planning this can be reduced to 2 weeks.
• Building the robot: around 10-15 hours. Some connectors and cables were custom made to create a better fit, which introduced some extra work.

Building difficulties and details

The process is pretty straightforward and very well explained and detailed on the Github repository. It was a pleasure to see everything very well detailed, with a lot of pictures of the process. I will like to add some things, however:

• On boogie bearings: be careful about the support/brim if you use, in order to remove all excess from the part. Check the 3D model to verify what you need to remove and what has to stay.
• For the Power switch, I had to search for a similar one, and I found and bought one that I though was identical. When it arrived, I then realized that the switch was quite smaller that the one that was supposed to be used. I made a custom 3D printer adapter and used those in the same way as the bigger one (although didn’t quite look as cool being this tiny). This switch, having only 2 connectors, also made a change on the wiring needed.
• It is better to test the camera before the installation of the Raspberry Pi and servo shield, in order to reduce the amount of testing and disassembling once it’s fully built. You can do it following this tutorial tutorial.
• As addressed on the ExoMy wiki, LiPO batteries need some care and proper usage to be safe. This guide, also linked on the ExoMy wiki, is a great resource if you have not used them before, as it was my case.

Some images and of the process:

You can see the Exomy moving on the following video (also, you can see my cats feeling attacked by our little robot):

You can see two things on this video: that my first driving skills are, at least, improvable, and that the lack of tires on the wheels makes the movement on flat terrain more shakey. On a straight line, the shakiness of the movement translates into some side to side small movements. I haven’t tried to print flexible materials on my Ender 3 Pro, so I decided to try an advice that I saw on an Exomy talk about using rubber bands:

And voilà! It’s not perfect but moves better than without them.

How does the ExoMy work internally

The software that runs on the Exomy can be found on the software repository. On the wiki, also, we have the following schema:

Nodes and interfaces schema. Source

Orange nodes represent already existing packages on ROS. Blue nodes are what has been implemented to control the Exomy. We have two messages implemented to drive the Exomy, the rover_command:

bool connected
bool motors_enabled
int64 locomotion_mode
int64 vel
int64 steering

And the motor_commands:

int64[] motor_speeds
int64[] motor_angles

The joystick parser node receives joy messages from either the node controlling the gamepad or the node that controls the web interface. From this joy message, creates a rover_command message that is sent to tell how the rover has to move, received by the robot node and then transformed into a motor_commands for specifying all motors, using the code in rover.py. This is received by the motor node which sends the corresponding signals to the PWM board, using the code on motors.py. We have, with all of this, the low level control of the motors already implemented. If we want to make our Exomy autonomous, as I plan to do, what we need to do is to create the ROS nodes responsible for the autonomy, which will send the proper rover_commands to drive our little robot.

Future plans and changes

The main change/improvement that I want to accomplish is to program the ExoMy to be autonomous for some kind of task. This will probably have included some Computer Vision, as the camera is the main sensor that the robot has and this will serve as a refresher for all the Computer Vision programming and techniques that I’ve studied on my degree, but applied on a real robot. I may try to add more sensors to the ExoMy on the future, but I want to focus first on making it autonomous.

I hope that you enjoyed this post as much as I’ve enjoyed this project, and If you have plans on building the ExoMy I strongly recommend you to join the Discord server. Of course, feel free to contact me if you have some doubts or you need more information.

See you soon!

References

Exomy Website: https://esa-prl.github.io/ExoMy/

ExoMy repository: https://github.com/esa-prl/ExoMy