Simplifying Embedded Linux Development with Graphical Tools
Jun 15, 2004 — by LinuxDevices Staff — from the LinuxDevices Archive — 2 viewsForeword: This whitepaper from esteemed Linux author and TimeSys Product Manager William von Hagen discusses the productivity advantages that graphical development tools can bring to embedded Linux development. It uses TimeSys's Eclipse-based TimeStorm tools by way of example, but the material presented is largely vendor-neutral. Enjoy! . . .
Recent embedded computing industry studies show that Linux is the operating system of choice for most new embedded development projects. Linux began as a solution for students looking for a free, powerful development platform, but has matured into a stable, powerful, and respected operating system that is used across the entire spectrum of modern computing. Today, Linux powers systems ranging from process control systems, PDAs, and consumer electronics devices to desktop systems, high-end network servers, and the world's most powerful computing clusters and multi-processor systems. The features that make Linux attractive in all of these scenarios are especially important in embedded systems, which are often produced and deployed in large quantities.
The cost, power, and flexibility advantages of Linux over proprietary embedded operating systems are obvious-as the old saying goes, “Imitation is the sincerest form of flattery.” For example, Linux has no royalties. Consequently, several proprietary embedded operating system vendors have dropped royalties for their operating systems. Similarly, the complete source code for Linux is always available. Therefore, several proprietary embedded operating system vendors have released the source code for their operating systems to their customers.
However, the fact that most new embedded projects will be deployed on Linux systems does not necessarily mean that they need be developed on Linux systems. Cross-development, where applications destined for one platform are developed and compiled on another, is a common approach to embedded development. Desktop systems typically have more power and resources than the embedded board for which you're developing. Also, until the arrival of Linux as the embedded operating system of choice, most embedded developers could only do cross-development, because their target operating systems only ran on the target hardware.
The availability and adoption of Linux on both desktop and embedded systems provides new opportunities for software that simplifies embedded application development, debugging, and testing. This white paper is the first in a series of white papers on using graphical tools for embedded development. The remaining white papers in this series are illustrated by examples of using TimeSys's TimeStorm tool suite to expedite embedded development and maximize developer and quality assurance productivity.
Managing Complexity Through Graphical Tools
Many of today's embedded software projects are complex, for a number of different reasons:
- an application may be inherently complicated due to the algorithms it uses, the design of the application (for example, sophisticated client/server applications), or both.
- the interaction between your application, other applications, and the operating system may introduce substantial overhead that requires constant monitoring.
- system and resource constraints may require iterative rewriting or optimization so that your application can deal with limited memory, small or non-existent long-term storage, or other classic embedded system constraints.
- standard system libraries and associated programming techniques may not be available for specific architectures or processors, forcing alternatives to be selected or developed.
- debugging and interacting with an application on a remote system with limited capabilities can be complex to set up and maintain.
These problems can easily be solved by anyone with sufficient experience in embedded application development, operating systems, and so on, but often requires that each project include a resident expert. A better approach is to use software that makes it easy to develop, monitor, and debug embedded software in the same way that an expert would.
No one would argue that the graphical user interface (GUI) has been computing's great enabler, moving the personal computer from a specialized tool to an office and home appliance. An operating system provides the underlying functionality required for application development, but a usable graphical environment and powerful tools that work within that environment are the true enablers of that operating system. This is especially true in a powerful, sophisticated environment such as Linux.
TimeSys's TimeStorm tool suite leverages the power of two of the most stable and widely-used graphical environments for Linux today: the X Window system, which has been the basis of almost all Unix and Linux graphical development; and the Eclipse framework, an easily expanded framework for creating and distributing development-oriented applications that are designed to coexist and interoperate.
Graphical tools for Linux eliminate much of the complexity of embedded applications and satisfy the need for easy-to-use graphical tools that simplify every stage of embedded application development, testing, and deployment.
Key Issues for Modern Development Tools
Proprietary OS and RTOS vendors have kept themselves in business for years by providing tools that expedite development within the confines of their proprietary environments. Though often powerful, tools that are tailored for a proprietary OS are inherently limited to working within that environment. As most of the embedded world turns to Linux for new embedded deployments and projects, the availability of powerful, easy-to-use embedded development tools that work with Linux becomes a critical issue.
Proprietary embedded OS vendors who have not yet adopted Linux are quick to point out that the Linux market seems fragmented. Many different Linux distributions are available, each customized for a particular market or set of services. Rather than illustrating a problem, the existence of multiple versions of Linux highlights the power of Linux and the degree to which it can be customized to meet a wide range of needs. However, the flexibility of Linux highlights the need for graphical tools that focus on the core aspects of Linux which are common to all distributions. Such tools will therefore work with any Linux distribution.
The key components of any Linux distribution are the following:
- Linux kernel, the core operating system, accompanied by optional loadable kernel modules that provide on-demand device drivers, bus and protocol support, and so on.
- Root Filesystem, the repository for system applications, system startup and configuration scripts, and user applications.
- Toolchains, which enable you to compile the kernel, loadable kernel modules, and applications that can be executed by programs in the root filesystem or other filesystems to which the distribution has access.
All Linux implementations use versions of the same kernel, configured differently. All Linux implementations use versions of the same core toolchain (GNU GCC), configured differently. The root filesystems for all Linux distributions have their roots in some subset of the core packages provided by the Open Source community, but differ in the packages that are selected and the subsets of these that are deployed.
Handling different versions of the Linux kernel, toolchains, and filesystem packages, and making it easy for developers to customize and work with them, is the true challenge of tools for embedded Linux development.
Some proprietary embedded OS and tools vendors argue that they have been unable to succeed in the Linux market because it does not exist. This is an odd and untimely observation given that traditional embedded operating system and tools vendors such as Wind River and QNX have recently made major announcements of Linux and Linux tools support. In general, Linux tools sales continue to climb, with new products and vendors entering the market on a fairly regular basis.
Focus Areas for Embedded Development Tools
Embedded system and application development requires a much wider spectrum of skills than most other types of development. Desktop and server application developers can count on a stable hardware platform with powerful software that provides a rich set of services. Embedded system and application developers must consider each of the following at some point:
- board initialization and bring-up for new or custom hardware, often by using a low-level hardware interface such as JTAG.
- bootloader selection, installation, and on-board configuration for new or custom hardware.
- operating system development that may require kernel customization and driver development.
- system-level debugging, with a remote access capability so that system problems can be accurately diagnosed and debugged.
- root filesystem (RFS) development, ranging from the in-memory or network-hosted filesystems used during development, to the permanent filesystems that must be created and maintained in FLASH or on other local storage.
- application development, once the system itself is up, running, and stable.
- application-level debugging using a remote connection. This should simplify transferring the updated applications to the embedded system and make it easy to remotely execute and analyze.
- testing and verification of release candidates. This should enable you to apply and reapply standard sets of tests against any combination of a deployed system and application.
The variety of tasks that may be necessary when bringing up an embedded board or when developing embedded software can be daunting. Each of these tasks requires a different set of skills, and is often addressed by a separate application designed for that task. Providing graphical tools that encapsulate the knowledge needed for each of these steps and reduce complex tasks to a few mouse clicks is the key to empowering the entire spectrum of embedded developers. For example, a graphical tool such as TimeSys's TimeStorm Linux Development Suite (LDS) enables you to create Linux filesystems of different types by simply selecting the filesystem type and size from a menu. The complex set of Linux system procedures necessary to create, format, and provide access to the new filesystem are totally invisible to the user.
Historically, proprietary RTOS and other OS vendors have unified all of the tasks necessary to bring up an embedded system by providing a similarly proprietary framework in which many of these tasks can be performed. This is convenient, but limits the user to the specific set of tools provided by a single vendor, reduces the chance of compatibility between tools from different vendors, and puts the user at the mercy of the vision of a single tools vendor.
A much better solution, and the one used in the embedded Linux tools market today, is to build tools using a single, freely available, Open Source framework. This framework is available to all tools vendors, provides consistent graphical presentation and behavior, and views all tools within the framework as mix-and-match plugins. This framework is known as the Eclipse framework.
Eclipse – A Single Framework for Solving Multiple Problems
Eclipse is an open source software development project (www.eclipse.org) dedicated to providing a robust, full-featured, industry platform for the development of highly integrated tools. Written in Java for maximum portability, Eclipse has been adopted as the framework for all future tools development efforts by well-known embedded tools vendors such as TimeSys, Wind River, RTI, and MontaVista.
Eclipse provides a basic framework that can be leveraged by various applications, known as plugins, which can then interoperate within an instance of the framework. This enables cooperative application development because tools vendors can focus on their core competencies and be assured that their plugins will integrate seamlessly with other well-designed plugins.
For example, the TimeStorm IDE (Integrated Development Environment) is a set of Eclipse plugins from TimeSys that provides a powerful environment for embedded application development, debugging, and testing. TimeStorm IDE does not need any special features in order to be integrated with the source code control systems (SCCS) that are commonly used to archive application code. Instead, Eclipse plugins that provide access to version control systems such as CVS, Perforce, Rational ClearCase, and Subversion are already available and can be instantly integrated with TimeStorm. A subset of the Eclipse plugins that are currently available or under development is available online.
The vision of Eclipse as an industry platform will only be realized if users can mix and match Eclipse plugins from different tool builders to satisfy each users' unique requirements, perhaps in ways that the tool builders never even imagined. The openness and flexibility of the Eclipse framework demonstrates a fundamental strength of the Open Source movement by giving all vendors a level playing field of shared source code and facilitating interoperability through openness. This minimizes duplication of effort, ensures maximum code sharing, encourages code sharing through the creation of common components, and promotes seamless interoperability between diverse types of tools.
Eclipse is the perfect foundation for modern tools development because it simplifies combining software from multiple vendors and running it side-by-side, within a single framework. This enables companies to focus on their specific areas of expertise, as TimeSys has done with its TimeStorm Integrated Development Environment (IDE), TimeStorm Linux Verification Suite (LVS), and TimeStorm LDS plugins for embedded application, system, and filesystem development and repeatable, deterministic testing.
Summary
This white paper began with an overview of the ways in which graphical tools can expedite and simplify embedded development. Subsequent sections discussed key areas of focus for Linux tools for embedded development, and highlighted the ways in which the open source community has satisfied those requirements through the open source Eclipse framework.
Software development tools for developing, deploying, and testing embedded systems are a reality and are available today. The inherent power and flexibility of Linux makes it the preferred choice for new embedded projects. Continuous improvements in performance, platform coverage, and hardware support only reinforce this choice. However, getting robust products to market quickly requires more than a free, powerful operating system-it requires sophisticated tools that simplify embedded development, deployment and testing, and provide “expert-in-a-box” solutions for complex problems.
The flexible tools environment provided by open source software such as the Eclipse framework facilitates the development and popularization of this sort of software. Software such as TimeSys's TimeStorm IDE, TimeStorm LDS, and TimeStorm LVS Eclipse-based suites provides off-the-shelf solutions that work with any Linux distribution.
William von Hagen is a Senior Product Manager at TimeSys Corp., has been a Unix devotee for over twenty years, and has been a Linux fanatic since the early 1990s. He has worked as a system administrator, writer, developer, systems programmer, drummer, and product and content manager. Bill is the author of Linux Filesystems, Hacking the TiVo, SGML for Dummies, Installing Red Hat Linux 7, and is the coauthor of The Definitive Guide to GCC (with Kurt Wall) and The Mac OS X Power Users Guide (with Brian Profitt). Linux Filesystems is available in English, Spanish, Polish, and traditional Chinese. Bill has also written for publications including Linux Magazine, Mac Tech, Linux Format, and online sites such as Linux Planet and Linux Today. An avid computer collector specializing in workstations, he owns more than 200 computer systems.
The next whitepapers in this series will highlight specific tasks in the embedded system and application development cycles, and discuss ways in which tools from Linux software vendors such as TimeSys provide powerful, flexible solutions to general problems.
TimeSys will also hold Webinars corresponding to von Hagen's whitepapers on embedded Linux development tools.
This article was originally published on LinuxDevices.com and has been donated to the open source community by QuinStreet Inc. Please visit LinuxToday.com for up-to-date news and articles about Linux and open source.