A long while back there was a need at my company for a custom Linux distribution to run on an a high-end embedded platform. At the time there were few tools to consolidate the various components required for building a custom distribution. There was the Linux From Scratch project, which described the process of building a custom distribution. And then there were Dan Kegel’s crosstool scripts. But there wasn’t anything the explained exactly what you needed to pull together to bring up a piece of hardware with a custom Linux distribution. I wanted to know all the pieces required to build a complete system for the variety of new hardware I was starting to work on.
After much exploration I finally found the ingredients needed for any project. It reduces to the following.
- A cross toolchain to compile software on a host to run on target hardware.
- One or more bootloaders that configure hardware so it can run an operating system.
- A Linux Kernel.
- A root file system containing boot processing, libraries and applications core to the platform.
- Custom applications that turn all of this into a purpose-driven system.
Much work has gone into building a new generation of tools to make this process easier to manage. Dan’s scripts have evolved into Yan Morin’s excellent Crosstool-NG package that provides a menu based configuration to build a cross toolchain. The Busybox and Buildroot teams have forged a collection of utilities needed in a core platform to provide facilities for custom application development. And of course the Linux Kernel has grown to support a wide variety of hardware platforms.
While these tools evolved there were metabuild systems evolving around them. The most popular has been openembedded which started as a project for hand held devices. A metabuild is a “build of builds”, a wrapper around lots of other software with the intent of creating a complete system. The openembedded platform, along with yocto and a few others, was based on a cross OS design that utilizes python (via a tool called bitbake) to manage system builds. But those system just didn’t fit my needs. So I created my own: PiBox. PiBox wraps the core tools (toolchain, bootloader, kernel and root file system) making it easier to use upstream utilities to build a custom platform. It’s based on GNU Make so ramp up is easy (no custom python programming to learn). And it’s easily extendable to any hardware platform (I’ve run it on at least 5 different systems).
More important was the evolution of the philosophy of PiBox: the structure of the metabuild should be consistent so it easily translates to any project. And that philosophy carried over to the PiBox Media Center custom application development.
So PiBox is a tool for creating embedded distributions for the IoT world. And it’s a philosophy for how to build software for integration into those distributions.
But PiBox isn’t for everyone. PiBox is not multi-OS: it’s designed for Linux and Unix systems. It isn’t for people wanting point-and-click systems. It isn’t web based. It’s a build system and more. And it does require one important human aspect: motivation. Because in the end, PiBox is a learning tool. To understand PiBox is to understand embedded development.