ROSCon 2015 recap and videos – part 2
ROSCon is an annual conference focused on ROS, the Robot Operating System. Every year, hundreds of ROS developers of all skill levels and backgrounds, from industry to academia, come together to teach, learn, and show off their latest projects. ROSCon 2015 was held in Hamburg, Germany.
Here is the next set of posts from the OSRF blog, along with videos.
ROS android_ndk: What? Why? How?, with Gary Servín (Ekumen)
What’s ROS android_ndk? Why should you care? How does it work? Gary Servín is with Ekumen, an engineering and software consulting company based in Buenos Aires, Argentina that specializes in ROS, web and Android development. With the backing of Qualcomm and OSRF, Ekumen has been trying to make it both possible and easy to run ROS applications on small Android devices like tablets and cellphones using Android’s native language development kit.
As Gary explains, the increasing performance, decreasing cost, and overall ubiquity of Android devices make them ideal brains for robots. The tricky part is getting ROS packages to play nice with Android, which is where ROS android_ndk comes in: it’s a set of scripts that Ekumen is working on to make the process much easier. Unlike rosjava, ROS android_ndk gives you access to 181 packages from the desktop variant of ROS, with the ability to run native ROS nodes directly.
Ekumen is actively working on this project, with plans to incorporate wrappers for rosjava, actionlib implementation, and support for ROS 2. In the meantime, there’s already a set of tutorials on ROS.org that should help you get started.
ROS on Dronecode Systems, with Roman Bapst (ETH Zurich and PX4)
PX4 is a flight control software stack for autonomous aerial robots that describes itself as “rocket science straight from the best labs, powering anything from racing to cargo drones.” One of these labs is at ETH Zurich, where Roman Bapst serves on the faculty. Bapst works on computer vision and actively contributes to the PX4 autopilot platform.
Bapst starts out by describing some of the great things about the PX4 autopilot: it’s open source, open hardware, and supported by the Linux Foundation’s Dronecode Project, which provides a framework under which developers can contribute to an open source standard platform for drones. PX4 runs on 3DRobotics’ Pixhawk hardware, and once you hook up some sensors and servos, it will autonomously pilot nearly anything that flies – from conventional winged aircraft to multicopters to hybrids.
One of PX4’s unique features is its modularity, which is fundamentally very similar in structure to ROS. This means that you can run PX4 modules as ROS nodes, while taking advantage of other ROS packages under PX4 to do things like vision based navigation and control. Additionally, it lets you easily simulate PX4-based drones within Gazebo, which, unlike real life, has a free reset button that you can push after a crash.
The PX4 team is currently getting their software modules running as ROS nodes on Qualcomm’s Snapdragon Flight drone development platform, which would be a very capable and (affordable) way of getting started with a custom autonomous drone.
ROS 2 on “Small” Embedded Systems, with Morgan Quigley (OSRF)
Morgan Quigley is first author of the authoritative 2009 workshop paper on the Robot Operating System. He’s been Chief Architect at OSRF since 2012, and in 2013, MIT Tech Review awarded Quigley a prestigious TR35 award. In addition to software development, Quigley knows a thing or two about hardware: he helped Sandia National Labs design high-efficiency bipeds for DARPA, and he also gave Sandia a hand with the development of their sensor-rich, high-DOF robotic hand.
Quigley’s ROSCon talk is focused on small (but not tiny) microcontrollers: 32-bit MCUs running at a few hundred megahertz or so, with USB and Ethernet connections. While these types of processors can’t power smartphones or run Linux, they are found in many popular embedded systems, such as the Pixhawk PX4 autopilot. Microcontrollers like these would be much easier to integrate if they all operated under a standardized communication protocol, but there are enough inconvenient hoops that have to be jumped through to run ROS on them that it’s usually not worth the hassle.
ROS 2, which doesn’t rely on a master node and has native UDP message passing, promises to work much better than ROS on distributed embedded systems. To make ROS 2 fit on a small microcontroller, Quigley demonstrates a few applications of FreeRTPS, a portable, embedded-friendly implementation of the network protocol underlying ROS 2.
After showing the impressive results of some torture tests on a Discovery board, Quigley talks about what’s coming next, including a focus on even smaller microcontrollers (like Arduino boards that communicate over USB rather than Ethernet). Eventually, Quigley suggests that ROS 2 will be small and light enough to run on the microcontrollers inside sensors and actuators themselves, simplifying real-time control.
ROS + Docker: Enabling Repeatable, Reproducible, and Deployable Robotic Software Via Linux Containers, with Ruffin White (Georgia Tech)
Every day, roboticists write code that helps their robots do amazing new things. And every day, this code remains virtually useless to anyone else, because outside distribution is such a hassle. This isn’t a problem that’s unique to robotics: distributing software in general is tricky to do reliably and well, since you’re never sure what kind of system your end user has. Robotics magnifies this challenge because of the unpredictably exotic mix of hardware and software that makes up a given robot doing a given thing at a given time, combined with the extraordinarily rapid pace of advancement. Given all of this complexity, how do you make code that’s portable and robust and useful to as many people as possible?
Ruffin White, a graduate research assistant at the Institute for Robotics and Intelligent Machines at Georgia Tech (and ex-OSRF intern), discusses how Linux containers can help manage some of these issues. A Linux container is a software package that lives somewhere in between a complete virtual machine and bare code. Using a service called Docker, you can wrap up code, distros, libraries, drivers, and all the other dependencies necessary for your code to function into portable containers that still use the underlying kernel on whatever they end up getting installed on. This allows the container to be very lightweight, while also providing adaptability to local infrastructure.
White gives three different demonstrations of how Docker containers can come in handy for robots in a ROS environment. In the first, he shows how in an educational context, you can use containers to provide a preset environment that can be safely experimented in without any risk. Second, for researchers, containers can allow you to easily test different algorithms, provides a way to publish code in a repeatable and reproducible way, and makes collaborative research much simpler. And finally, industry can take advantage of containers to deploy multiple nodes on different cloud services, or to manage entire swarms of robots at once.