Building Andino — Open Source ROS2 Robot — Part 1 Base Install & Simulation
Last year I came across a ROSNews article that showed Andino robot and I thought it would be a perfect robot to build later as I seem to have all the parts or at least I can cannibalize from my older robots. Well the time to build Andino arrived in Jan 2024 and I have been hard at work since last few weeks to build this new robot and document steps along the way. Spoiler alert, its a really neat little robot and I have enjoyed working on building it. As you would expect, here is my blog entry for this build.
The basic hardware and software setup is all documented on the Andino github repository. However, while going through the build I realized that either I had to change a few things based on the parts I have OR in some cases there is not enough detail in the instructions provided on the github repo. My observation was that software part of instructions they have done an awesome job but the hardware part of the build is pretty minimal and requires one to either try things out or take best guess. I will try to point out where things may be different or add more details that others may find more useful so its easier.
Interesting thing about this particular robot is that it does not use IMU so you don’t have to fuse the odometry from encoders and IMU to get to final one which simplifies things a bit.
Thoughts on Bill Of Materials and Adjustments/Alternatives
The Bill of Materials is very well documented. IMO, all the parts together should not cost more than $250-300, RPi and Lidar being the biggest portion of that budget. This is a bit more expensive than the ESP32 robot build I had described in the past as that one eliminates the need for RPi using micro-ROS but still very affordable.
You’ll be able to see that the basic components are as follows:
- Raspberry Pi — I used RPi4 with 4 Gb RAM [same as recommended]
- Arduino Uno — I used an existing Uno I had and it worked fine [same as recommended]
- L298N — I also had a bunch of L298Ns lying around as these are very cheap to get and very versatile [same as recommended]
- DC Motors — for this I already had two of the L-shaped DFRobot FIT0458 [NOT same as recommended] that I had purchased a while ago and waiting to be used in a project. The main reason for using proper DC motor with encoder integrated is that I don’t have to fuddle around with the unreliable encoders. I have tried to use those cheap optical encoder disks mounted on motor shaft but that thing never worked right for me, that’s just my experience. These motors are not that expensive, you can get even cheaper versions of these on DigiKey or AliExpress that not L-Shaped and easy to mount.
- Lidar — I used same Lidar as they recommend an RPLidar [same as recommended]
- Camera — I used RPi Camera V2 that I already had [same as recommended]. You can probably use V3 as well. There was quite a bit of pain to get this to work with Ubuntu Server as I’ll describe later but it works fine at the end.
- Power Bank/Battery — They recommend just single 5V power bank for power. But this is not very practical as this can result in RPi having power brown out if motors are pulling a lot more current and cannot supply enough power to RPi and Arduino. So instead of doing this I used two battery packs — 1. phone/tablet power bank to power RPi & Arduino as Arduino gets power from USB port of RPi. 2. A separate 4*AA battery holder to power the DC Motors as DC motors I’m using require 3–7.5V for operating voltage. [NOT same as recommended]
- Base plates and wheels — Because I used different motors, I had to design and 3D print my own base plate and motor mounting plates, I can share the FreeCad models in my fork of the original Andino repository. I basically printed two copies of same base plate and had the different components mounted on two tiers. This is another area that is not very well documented in the Andino repo for assembling the hardware together. I’ll provide more details and photos along the way so it may help. For wheels I used the standard robot kit wheels that are typically supplied with TTMotor robot kits. Also, for the wheel castor I had one that was from an old kit that I reused from another old robot project. I’ll provide the links to all the parts at the end so if you need to find those or equivalent it will be easier. [NOT same as recommended for plates but same for Wheels]
- Operating system — They recommend Ubuntumate as operating system, but I have done some basic comparison and there is not a big difference in functional aspects of Ubuntumate and Ubuntu and since I’m very used to Ubuntu I stayed with Ubuntu Server without GUI. RPI Imager allows you to create an Ubuntu Server 22.04 Jammy 64-bit version SD Card from their RPI Imager app directly that you can install on Ubuntu or any other OS laptop/computer you have to make the SD card. I went with a 64 Gb SD card. [NOT same as recommended]. You can find additional instructions for installing some more tools after Ubuntu server is up and running on the Andino repo.
Another advantage of going with RPI Imager is that it allows you to enter wifi settings, customize Ubuntu username and password and computer name in the settings area of the app so when you plug the SD Card into your RPi it will connect to your wifi network right away and you can ssh into it and start working instead of trying to find mouse/keyboard/screen to connect to RPi and then manually configure all those things, its just a waste of time to do it that way unless you insist on having a GUI to RPi.
Preparing the Operating System and Software
After you have got your basic Ubuntu Server up and running on RPi and you are able to login, there are some more steps you are going to have to perform. Main things include
- Installing ROS2 Humble and dev tools
- Installing dependencies for Arduino, Camera, RPLidar
- Setting up correct names and permissions for USB ports for hardware devices like Arduino, RPLidar etc
- Building Andino ROS2 workspace so we can run Andino in simulation mode.
- Setting up Joystick [optional if you are going to use gamepad]
Installing ROS2 [on both laptop and RPi]
Before doing anything else on your brand new Ubuntu Server installation do the following steps:
sudo apt udpate && sudo apt upgrade
sudo apt install git net-tools software-properties-common build-essential -yThis is the easiest step, I always recommend everyone to follow linorobot/ros2me repository as it makes it dumb simple to install ROS2 Humble with exactly right packages for either laptop or RPi, it will detect the hardware architecture and install desktop/GUI packages on laptop but on RPi it will install base setup. It’s pretty slick. Here are the commands you need to execute to install it on both your laptop/computer and RPi/robot computer.
git clone https://github.com/linorobot/ros2me.git
./installInstalling dependencies for Arduino, Camera and RPLidar [Only perform this on RPi]
For Arduino follow the steps here — https://github.com/Ekumen-OS/andino/tree/humble/andino_hardware#arduino
For Camera follow the steps here — https://github.com/Ekumen-OS/andino/tree/humble/andino_hardware#arduino
For RPLidar follow the steps here — https://github.com/Ekumen-OS/andino/tree/humble/andino_hardware#arduino
Setting up correct names and permissions for USB ports [Only perform this on RPi]
Make sure to follow all the steps described in USB Port name configuration section here — https://github.com/Ekumen-OS/andino/tree/humble/andino_hardware#usb-port-name-configuration
USB Port name configuration is extremely important because Andino ROS2 workspace code looks for these exact names for the USB ports in various launch file and URDF files and if you don’t follow that you’ll have to search and find where all those things are located and modify them. Please don’t do that it will be a lot easier if you just fix the USB port names first. I learned it the hard way.
At the end you should be able to confirm everything looks good by running this command:
ls -l /dev/ttyUSB*
# you should see something like this in output notice the last two items
crw-rw---- 1 root dialout 188, 0 Sep 2 15:09 /dev/ttyUSB0
crw-rw---- 1 root dialout 188, 1 Sep 2 15:09 /dev/ttyUSB1
lrwxrwxrwx 1 root root 7 Sep 2 15:09 /dev/ttyUSB_ARDUINO -> ttyUSB0
lrwxrwxrwx 1 root root 7 Sep 2 15:09 /dev/ttyUSB_LIDAR -> ttyUSB1Building Andino ROS2 workspace [on both laptop and RPi]
Follow steps to build the Andino workspace on both laptop and RPi as described here — https://github.com/Ekumen-OS/andino/tree/humble/andino_hardware#create-robot-workspace
Tip —While running rosdep command see this note — “Note that option
-rhas been added. For ARM based processors, there are missing packages, e.g. those related to simulation. We would not try to run the simulation in the compute platform of andino, however for convenience it is added here.”What this means and how rosdep functions, if you don’t supply -r switch, the rosdep will stop at very first step where it encounters error installing packages e.g. there is no gazebo package for Ubuntu 22.04 server for aarm64 architecture for RPi and you’ll be stuck there. The -r option tells rosdep to continue despite the errors so even though you’ll see those errors generated for the three simulation folders — andino_gz_classic, andino_navigation, andino_slam, it will still install all the necessary ROS dependencies for the robot to work.
You’ll not face these errors when you run the same rosdep command on your laptop as the gazebo and other packages would already exist there or it will be able to install if not.
You can also follow steps listed in Extra Recommendations & Tools section that will make the process of troubleshooting and getting robot up smoother -https://github.com/Ekumen-OS/andino/tree/humble/andino_hardware#extra-recommendations--tools
I would highly recommend that you setup the ROS_DOMAIN_ID environment variable correctly on both laptop and RPi.
At this point we are ready to build the Andino workspace and run simulation on laptop/host computer [not on RPi/robot computer yet].
Follow the steps here to git clone code to your host machine and build the workspace — https://github.com/Ekumen-OS/andino?tab=readme-ov-file#colcon-workspace
Follow these steps to build and launch simulation to test everything works well in simulation mode.
Note: If you are going to use gamepad as controller follow the steps in section below named “Setting up Joystick” before launching the simulation in terminal windows.
# on host computer
# after building the workspace as described above
# launch three different launch files in three separate terminal windows
# terminal window - 1
# make sure to source your workspace
source install/setup.bash
ros2 launch andino_gz_classic andino_one_robot.launch.py use_gazebo_ros_control:=true
# terminal window - 2
# make sure to source your workspace
source install/setup.bash
ros2 launch andino_bringup andino_robot.launch.py
# terminal window - 3
# make sure to source your workspace
source install/setup.bash
ros2 launch andino_bringup teleop_joystick.launch.py
# at this point, while joystick is connected to laptop,
# hold down the LB/RB and move the joysticks,
# the robot should move in both gazebo classic and rviz2The first terminal will launch the RViz simulator and Gazebo Classic, the second window will launch all the necessary nodes to publish robot description and interact with gazebo plugins and third one will launch the joystick teleop node that will listen for your joystick controller. You’ll be able to see the robot in both Rviz and Gazebo Classic and control the movements of the robot in the simulators.
It should look something like this:
Setting up Joystick
The last step of setting up joystick is optional, I would recommend that you follow the steps to setup the joystick using this blog article from Articulated robotics using the gamepad section and initially plug in the USB key for your gamepad controller [if you are going to use that for robot control] in your laptop and test it out to make yourself familiar with which keys are the ones that are expected to be pressed for robot movement. Once you are familiar with that, you can unplug the USB key from laptop and plug it into your RPi. It will work just fine even if you left it in laptop, it is not required to have it plugged into RPi. That’s the beauty of ROS2 framework that all the ROS joystick messages are available to all subscribers on same network and ROS_DOMAIN_ID.
That’s it, if you followed along this far, you should have Andino robot working in simulation mode. And you should already have a solid base within your RPi for working on getting the real robot working in next article where we will dive deep into hardware assembly and getting robot to move while it is propped up on the stand where we can move the wheels, do some basic tests to make sure we are able to control the wheels via Joystick on real robot.
Have fun building, this is a really fun robot project that can be affordable to everyone and I appreciate all the efforts of open source community contributors to Andino repository and and Ekumen team. This will have a real impact on all the self-learners out there who do not have huge budgets to purchase expensive equipment but they can still learn the same concepts with a much affordable setup on their own.
