Who Says Linux Is Not (in) Rocket Science?

Open source components

Currently, to build and launch the rocket requires the combined efforts of several teams with their respective specialisation in airframes, avionics, communications, ground control, the payload, propulsion, software and uncertainty. As you can see, this is a mixture of software and hardware teams—and they all play important roles.

The airframe team is responsible for designing the LV rockets—how to construct an aluminium module, where to place motor casing, nozzles and coupler bulkhead, as well as the aeroshell construction and parachute recovery module, which hides inside a rocket and is used on its return to the ground.

The avionics team produces all the software [6] and deals with hardware modules (like the flight computer, discussed below). This team is responsible for reliable software interconnections during flight and after-flight analysis (via the syslog Linux-subsystem). For example, the team is deeply connected with the ground team in terms of radio-exchange and communication, because all radio links from a rocket to the ground (amateur TV, Wi-Fi connections) are managed by the ground team. Pre-flight and flight videos [7, 8, 9, 10] are recorded by software made by these teams.

Another amazing group is the propulsion team that conducts research on different chemicals like what propellant ought to be used for rocket engines—LOX/Paraffin (liquid oxygen, plus a kind of wax), GOX/Paraffin (gaseous oxygen), or a very standard fuel like ammonium perchlorate [11] oxidiser with hydroxyl-terminated polybutadiene (HTPB) fuel.

Those from different teams very often form a new team for closer cooperation, as is the case with the payload team. Its members are from the avionics and airframe teams.

However, the most interesting perhaps is the Uncertainty Team! Its task is to achieve things that are unpredictable and very challenging. This team does research and implementation of probabilistic algorithms, and in particular, all sorts of Kalman filtering (a mathematical technique widely used in control systems and avionics to extract a signal from a series of incomplete and noisy measurements): Kalman unscented, Kalman extended, sigma point Kalman, particle filters and others. These are useful in estimating the position and orientation of a rocket given a diverse array of sensor inputs, all of which are incorrect in their own way. Without such estimation and the eventual feed back of this information to the whole system, controlling a rocket’s trajectory can be extremely difficult.

Discussing all these details is out of the scope of this article; however, we’re certainly concerned about the open source software parts. So let’s take a closer look at the operating system used by the avionics team.

Figure 4: The avionics and flight control system is based on Linux

The current flight computer for the team’s rocket is a PowerPC-based single-board computer that was specifically chosen because of a “Linux on Power” grant the students managed to win from IBM. It’s a 400 MHz Freescale MPC5200 PowerPC single-board computer (SBC) from TQ Components. The following are its specs:

CPU: 400 MHz Freescale with a 603e core

RAM: 64 MB SDRAM/32 MB Flash

Peripherals: USB 1.1, CAN, UARTS, PCI, ATA/IDE, SPI, etc

Size: 80 x 60 mm

Figure 5: The small, yet very powerful PowerPC flight computer

This flight computer uses U-Boot as the kernel boot-loader, a kernel image itself, then a device tree blob with an initramfs disk image that is stored in Flash. When the flight computer boots, the bootloader loads everything into the RAM and then boots from it. This means that all changes to the filesystem will be wiped out on the next power cycle. That’s why the system design has the following features: a) all software you ever want to use during a flight is installed in Flash; and b) rocket logs are stored on a compact Flash card to avoid being lost by an in-flight power cycle.

The kernel used for this PowerPC board, is stored at Denx’s site (developer and maker of TQM5200 board) and can be easily grabbed with git:

$ git clone git://git.denx.de/linux-2.6-denx.git

All other operations required for the flight computer are: Linux kernel compilation and U-Boot loader with a cross-compilation suite found in the Debian package repository, building user-space programs and drivers (including CAN and USB), making the initramfs image, and combining it all together to fit on a 32-MB Flash card.

Other major components used during the launch and flight are the telemetry unit, the GPS and recovery unit, as well as the inertial measurement unit, the power system unit and the amateur TV unit. All of these are based on the LPC2148 board with an ARM processor:

CPU: NXP’s ARM7TDMI LPC2148 with integrated USB 2.0 device

RAM: 512 KB Flash / 32+8 KB SDRAM

Clock frequency: 12.0000 MHz (equals 60 MHz CPU clock)

Size: 59 x 39.5 mm

The operating system used in this tiny board is eCos [12]—a real-time operating system intended for embedded applications. Rocket developers have a dedicated git-tree, because of a lpc2148-patch:

$ git-clone http://psas.pdx.edu/~sarah/ecos.git/

Cross-compilation and building for the LPC2148 board is similar to the process used for the flight computer.

Once all the software components are built and written to the Flash card, it is time for the hardware teams to put it all together.

But for now, let’s look at how to create a PCB. There has been some debate on what CAD software ought to be used: KiCAD, gEDA or Eagle. “We look forward to using open source CAD tools for electrical and mechanical design, but we don’t think any of them are quite there yet. Some are very, very close, and we hope to help them out in the near future, but for now we’re using closed source electronic and mechanical CAD tools,” says Greenberg. So, it was decided that Eagle is much better for the design. Though it isn’t an open source tool, it is free for non-commercial/academic applications and pretty much multi-platform.

Next step? A control software that is left on the ground—RocketView runs on a laptop, and is operated by the launching staff. This telemetry display software was originally written with GTK+ for visualising those events that come from the rocket via the radio link. Later, it was rewritten as a Java application with the same functionality, plus launch control functions. You can now safely push a button and a rocket will fly into the sky.

Figure 6: RocketView is the main application that doesn't leave the ground

The author has specialised in Linux and FOSS technologies for more than a decade. His professional spheres of interest include, but are not limited to, robotics, embedded systems, statistics and algorithmic methods.