Notice: We have migrated to GitLab launching 2024-05-01 see here:

Version 23 (modified by Chris Johns, on 11/22/14 at 05:22:16) (diff)


RTEMS Eclipse Information

RTEMS provides an Eclipse Plugin you can use to help integrate your work flow with RTEMS.

RTEMS Eclipse Plug-In Setup

There is a plug-in available for RTEMS development with Eclipse. It is based on CDT. See also the user guide.


RTEMS is a free real-time operating system that must compete against commercial closed source offerings that have very impressive looking GUI oriented Development Environments. The RTEMS Project has spent years honing RTEMS and tuning it to be a competitive run-time and it certainly has the technical capabilities to compete. But often RTEMS gets dinged for not having a "pretty face". Projects in this category address that deficiency.

Eclipse is an open source Integrated Development Environment (IDE) which has become very popular in the real-time embedded systems community. For RTEMS to continue to compare favorably against its commercial proprietary competition, Eclipse support is an important feature. Eclipse has a plug-in architecture and there are already multiple plug-ins and add-ons for embedded development.

This is a very open ended project which has a number of steps based upon sub-projects or plugins which need to be made available to RTEMS developers.

See Embedded and Device Development as a reference.

Since RTEMS has multiple targets, this project would focus on getting Eclipse working nicely with multiple targets. There are over half a dozen simulators which are capable of supporting a multithreaded RTEMS application and a few of those simulate target hardware with networking capabilities. There are existing RTEMS BSPs that run on simulators so the person(s) working on this project would not require special target hardware or anything that costs to verify that their implementation works with multiple hardware configurations.

GNU Debugger Integration

This can be accomplished using the Zylin Embedded CDT plugin. There may be other RTEMS specific items that could enhance the debugger interface in Eclipse. Perhaps when using CEXP and the RTEMS GDB stub, you can build a module and click a button to download it to the target?

CDT (C/C++ Development) also supports the GDB and provides a fully functional C and C++ Integrated Development Environment (IDE) for the Eclipse platform. Our focus is development on Linux for deployment on Linux, but we are interested in participation from others who would like to extend our work in other directions (e.g. a Windows client, targeting Unix(R) or embedded platforms, wizards for developing applications that use particular library or database or messaging APIs, or extension to other languages). We are looking for contributions from the open source community in the areas of testers, developers and general users who can help us ensure that the C/C++ tools work well on all the Eclipse platforms and compiler environments.

Interaction with the Target System

There are Eclipse plug-ins that provide serial terminal emulation, Telnet, and FTP connections to the remote target. Using these would provide a more integrated RTEMS development/debug environment. This functionality is currently provided by the Eclipse Remote Systems Explorer (RSE) plugin.

Integration Eclipse Device Software Development Platform

The Eclipse DSDP is an effort to use eclipse as a standard way of developing, debugging and otherwise interacting with embedded devices.

There are many sub-projects in there, but some of the interesting ones are: Sequoyah, Target management(RSE) and RTSC


''RSE'' Remote System Explorer (Target Management) can be used to create a SSH (Secure SHell) connection to the QEMU (Quick EMUlator) emulator. This can be done by connecting to the local host via SSH, since the SSH port of the host has been redirected to the SSH port of the emulator. Once this connection had been established a remote shell can be launched on the QEMU using the “Launch Shell” option under “SSH Shells”. This shell can be used to browse the emulator filesystem and run commands on the emulator.

One of the interesting aspects of this is how Wind River has adopted Eclipse as the platform for vxWorks and Embedded Linux development. It appears that they are putting significant effort into contributing code back to the DSDP platform and trying to help create open standards for this type of development environment. It would be nice if this work ends up meaning that an Eclipse platform could talk to a target server on either vxWorks, Linux or RTEMS.


''RTSC (Real-Time Software Components)'' provides foundational tools and low-level runtime content to enable component-based development using the C language targeting all embedded platforms. While other component technologies exist for embedded systems, RTSC is unique in that it scales down to highly resource constrained embedded systems including DSPs and 16-bit micro-controllers.


Embedded Rich Client Platform (eRCP). The intent of this project is to extend the Eclipse Rich Client Platform (RCP) to embedded devices. eRCP is largely a set of components which are subsets of RCP components. It basically enables the same application model used on desktop machines to be used on devices.


Mobile Tools for Java (MTJ) The scope of the Mobile Tools for the Java Platform (MTJ) project is to extend the Eclipse platform to enable developers to develop, debug, and deploy mobile Java applications to emulators and real devices. The project will develop frameworks that can be extended by tool vendors and tools that can be used by third-party developers.


Sequoyah project's purpose is to be focused on the needs of all mobile developers. Inheriting components from TmL, MTJ and Pulsar projects, Sequoyah intends to remove the artificial barriers of Linux and Java in order to provide a home for all Eclipse mobile developers.

FindBugs Eclipse Plugin

FindBugs is a defect detection tool for Java that uses static analysis to look for more than 200 bug patterns, such as null pointer dereferences, infinite recursive loops, bad uses of the Java libraries and deadlocks. FindBugs can identify hundreds of serious defects in large applications (typically about 1 defect per 1000-2000 lines of non-commenting source statements). FindBugs is open source, has been downloaded more than 230,000 times and is used by many major companies and financial institutions.

Using this plugin one can make his life easier doing Real-time Java Programming by detecting known bug patterns in software.

The GNU Java Compiler, currently doesn't work with RTEMS, see 1 but AERO­VM ­ Hard Real­Time Java Virtual Machine seems to work on boards with Leon processors.

(this plugin may be of use in the future when the GCC­ Java will work with RTEMS)

See also:

NDS Managed Builder

Provided that RTEMS can run on arm/nds (Nintendo DS) one can make use of NDS Managedbuilder, an Eclipse CDT plugin for C/C++ development for the Nintendo DS target system. It supports DevkitPro compiler/debugger.

  • easy to use managed build system based on the GNU toolchain
  • supports C and C++ projects, also ASM Programming
  • different project types
  • NDS ROM - ARM9 Sources + NDS Tool
  • NDS ARM7 Code - ARM7 Sources + ObjCopy
  • NDS ARM7 Library - generates a static link lib
  • NDS ARM9 Library - generates a static link lib
  • includes ObjCopy and NDS-Tool in the toolchain
  • integrate the ARM gdb debug server

EGit plugin

EGit is an Eclipse Team provider for the Git version control system. Git is a distributed SCM, which means every developer has a full copy of all history of every revision of the code, making queries against the history very fast and versatile

Using Git in conjunction with CVS would make some people happy regarding their choice of version control system, given that Git has now become quite popular and is considered to be quite fast. (see Best Practices for using Git with CVS )

Providing other means of doing version control will make RTEMS development more flexible.

There is a repository for Git exports of the various modules in the CVS repository which can be found at

For tools that aid in the transition from CVS to Git easier see: gitcvs-migration and git-cvsimport

Some people even use Git as a CVS client

LEON C/C++ IDE for Eclipse

LeonIDE in conjunction with CDT plugin makes it possible to cross- compile C and C++ application for LEON and ERC32 processors, and to debug them on either simulator and target hardware (TSIM or GRMON).

  • LEON IDE is a plug-in for the Eclipse C/C++ Development Tooling or CDT.
  • CDT is a C / C++ development environment for Eclipse.
  • LEON IDE extends the CDT environment to include support for development and debugging using the tools provided by Aeroflex Gaisler.

Supported toolchains:

  1. RTEMS 4.6.5 1.0.19
  2. RTEMS 1.0.4

Also see LEON/ERC32 RTEMS Cross Compilation System (RCC) a cross-compilation system for both ERC32 and LEON processors.

Embedded Linux Development Kit

Embedded Linux Development Kit (ELDK)includes the GNU cross development tools, such as the compilers, binutils, gdb, etc., and a number of pre-built target tools and libraries necessary to provide some functionality on the target system. It is provided for free with full source code, including all patches, extensions, programs and scripts used to build the tools.

Plug-in Development Environment

Plug-in Development Environment (PDE) provides tools to create, develop, test, debug, build and deploy Eclipse plug-ins, fragments, features, update sites and RCP products.

Using Eclipse PDE we can add more functionality to the current RTEMS Eclipse plugin or create a new plugin (maybe adapt some plugin from this wiki page or find another one) so that it is useful to the RTEMS community.

Like a Wizard/Editor? for Eclipse to configure RTEMS for a certain Application e.g. max number of tasks, semaphores ( or another project is to support RTEMS as a run-time in Argo UML (

RTEMS Eclipse Plug-in Project


The git:// project repository module contains the following submodules:

  • org.rtems.cdt: Plug-in for further development
  • org.rtems.feature: Deployable components
  • org.rtems.update: Update site
  • org.rtems.cdt.toolchain: Initial plug-in
  • org.rtems.cdt.toolchain2: Temporary development plug-in (obsolete)

Current Status

The plug-in is usable and tested on Cygwin, MinGW, MacOS X and UNIX. See also the user guide.


  • Extends the CDT GNU toolchain with the RTEMS tools (cross-compiler, linker, assembler, archiver)
  • No dependency on special environment variable settings (including PATH)
  • Automatic detection of tool options via the standard Makefile interface


  • Project types for libraries and loadable modules (CEXP)
  • Project templates
  • Automatic detection of default paths for platforms (Cygwin and MinGW) and RTEMS base installation and BSPs
  • RTEMS manager inclusion/exclusion via the Project Properties Pages (applies to executables only)
  • GDB and Qemu Launch Configurations: attach debugger or launch simulator/emulator with your project's product
  • Ability to disable the usage of the discovered compiler search path and/or options
  • More stable scanner configuration (this is more a CDT internal issue), scanner is currently not working for Cygwin
  • Per configuration platform and BSP paths (this simplifies migration)

Initial Implementation

The publish of initial implementation of RTEMS Eclipse Plug-in came with some accidents. It's Joel Sherrill who first discovered the appearance of such implementation. One night the initial implementer was uploading screen shots to the wiki site to document the usage of the plug-in, there were problems with uploading files, and later the wiki site became inaccessible. The implementer thought he might bring down the wiki site, so went to sleep. On the next morning, somehow these accidents alerted Joel. Except images of Eclipse with RTEMS awareness, he could not find the email address of the "culprit", thus he yelled out on the mailing list, and so came the plug-in implementation. Daron Chabot and Sebastian Huber immediately joined to further develop it.

The initial plug-in has most features of a full-fledged Eclipse/CDT IDE with ordinary GNU tool chain. After setup, except typing in project name and post build commands, with only mouse clicks, it can finish the whole process of:

  • Generate skeleton code
  • Compile
  • Link
  • Generate boot image and externally start up the system (in simulator)
  • Setup break points, and hook GDB to the remote target

The detail document for the initial implementation including its limitations can be found here?.

Revision History