Fosdem Linux Magazine 
 [ Home ] [ Developers room ] Free and Open Source Software Developers' Meeting 


 This Year

Developers Room


 Practical Info


 Press Room

-- ABOUT US --
 Support FOSDEM

 Promotional material

 The FOSDEM Team

 Our Sponsors

 The Story

 Contact FOSDEM




 Become a member

 Why register?

Fosdem title


Embedded softwares room

Saturday Feb 8th 2003
13h50 -> 14h00 Introduction
Peter Vandenabeele
14h00 -> 14h45 Keynote: - Free Hardware Development
Richard Herveille
14h45 -> 15h30 Adapting Debian for Embedded Use
Martin Michlmayr
15h30 -> 16h00 Break / Demo: "Matrix" Playback on FPGA
Richard Herveille
16h00 -> 16h45 Portable Programming on Complex Systems
Peter De Schrijver
16h45 -> 17h30 Wonka - a JVM for Embedded Systems
Chris Gray
17h30 -> 18h15 Using C++ for Real-time Extensions to the Linux Kernel
Peter Soetens
Sunday Feb 9th 2003
10h00 -> 11h00 Breakfast / BoF's
11h00 -> 11h45 Cross-compiling Open Source
Eero Tamminen
11h45 -> 12h30 eCos - Embedded Configurable Operating System
Nick Garnett
12h30 -> 14h00 Lunch / Open eCos-maintainers Meeting
Jonathan Larmour
14h00 -> 14h45 RTAI - Real-time Application Interface
Philippe Gerum
14h45 -> 15h30 GNU Bayonne and Real-time Issues in Freely Licensed Telephony Software
David Sugar
15h30 -> 16h15 SPARE SLOT (suggestions welcome until Sat 8 pm)

More details:
Embedded and realtime systems are among the fastest growing fields of R&D where Free Software solutions become important. Operating System development has always been a very important topic in Free Software. As embedded and realtime systems typically have special OS requirements, we organise this Free Embedded and OS development track at the FOSDEM.

This track at FOSDEM provides a remarkable opportunity to present the ongoing work in these areas, and we invite developers to present their current projects.

The Program Committee evaluated the received abstracts and consists of:

- Peter De Schrijver, CTO Mind, Linux/eCos developer
- Herman Bruyninckx, Professor at K.U.Leuven, robotics development
- Michael Vogt, Debian project, Debian developer
- Gary Thomas, eCos maintainer, Linux developer
- Neal H. Walfield, GNU project, Hurd Developer

Peter Vandenabeele, acts as organiser for this track and non-voting secretary of the Program Committee. All communication should be addressed to

List of abstracts for embedded and kernel development track at fosdem 2003 Sat 8th and Sun 9th Feb 2003, Brussels.

[Version of 28 Jan 2003, changes in the program are still possible]

Saturday Feb 8th 2003:

Richard Herveille

OpenCores is a repository of open source freely available Intellectual Property (IP) cores. It is the hardware counterpart of the free software movement. Currently OpenCores hosts 185 projects, maintained by 657 developers. Many projects are still in the development stage and some will never reach maturity. But 65 projects are currently mature enough to be used in designs.

In order to start development access to tools is required. For software development the GNU toolchain provides a solid foundation. For hardware development freely available tools are either not (yet) available, or simply not mature enough. Testing is an even bigger problem. Software can be tested on the same system it is being developed, by simply running the program. Hardware can be tested by running simulations, but testing IP cores in real hardware always requires some form of programmable logic. Fortunately FPGA vendors provide an array of test and development boards for their devices. Also the major FPGA vendors are releasing 'lite' versions of their synthesis and Place&Route tools. This proved to be a major boost for open source hardware projects.

IP cores need to be interconnected via a common bus. OpenCores adopted the 'WISHBONE System-on-Chip (SoC) Interconnect Architecture for Portable IP Cores', or WISHBONE bus for short. WISHBONE provides a common, logical interface between IP cores. This improves portability and reliability of the system, and results in faster time to market. Especially when combining a multitude of cores from different designers from different backgrounds. Currently OpenCores maintains stewardship over the WISHBONE standard.

To prove the concept of OpenCores and the quality of the cores available from OpenCores we created a System-on-Chip (SoC). All IP cores needed to build the SoC are available from OpenCores. The used cores include a 32bit RISC (OpenRISC), JTAG Test Access Port for the OpenRISC, memory controller, UART, 10/100 Ethernet MAC, VGA controller, PS/2 keyboard controller, and an AC97 audio controller.

The 32bit OpenRISC 1200 forms the heart of the SoC. It is the first available implementation of the OpenRISC 1000 architecture. The OpenRISC 1000 architecture is available under the GNU LGPL license.

The OR1200 main features are:
* Open and free architecture
* Linear 32bit logical address space
* Harvard architecture, separate data and instruction busses
* Simple and uniform length instruction set, 32bits opcode, 32/64bits data
* 32 entries general purpose register file
* 1 Branch delay slot
* 8 KByte 1-way direct mapped instruction cache
* 8 KByte 1-way direct mapped data cache
* 64 entry hash based 1-way direct mapped TLB Instruction Memory Management unit (IMMU)
* 64 entry hash based 1-way direct mapped TLB Data Memory Management unit (DMMU)
* Power management module
* JTAG Test Access Port debug module
* Tick timer module
* Programmable interrupt controller

Software development for the OpenRISC 1000 Architecture is supported by a genuine GNU Toolchain Port and an advanced Architectural Simulator. A uCLinux port is also available, RTEMS and Linux ports are under development.

To conclude the presentation a demo will be shown using the working System-on-Chip.

Martin Michlmayr

Traditionally, it has been common to develop a home grown operation system for embedded use. However, according to a study carried out by Evans Data Corporation, there is a shift towards adopting standard systems, in particular such based on embedded Linux. This is partly due to the fact that embedded systems are nowadays as powerful as desktop systems were not too long ago. While embedded systems still have unique requirements, they are now more comparable to desktop systems than ever. This suggests the possibility that a standard operating system and its applications can be taken and adapted for embedded usage. The focus will be on the changes required in Debian to be better suited for embedded use. In particular, crucial changes to Debian's powerful package management system, dpkg, will be discussed. For example, embedded systems must avoid installing files which occupy storage but do not provide required functionality. This includes documentation and translation files. The iPKG package manager, closely related to dpkg, but developed specifically to meet the needs to embedded systems, will be presented. Additionally, for embedded use, large applications have to be replaced by smaller programs with similar functionality. BusyBox, which combines tiny versions of many common UNIX utilities into a single small executable, is important in this regard. Also, it will be discussed what is needed to replace bash with dash, a POSIX compliant shell much smaller than bash. Alternatives to the powerful but big libc6 library, such as dietlibc, will be presented.

Peter De Schrijver

Portable programming is an important requirement for system level programming, especially in embedded systems. However, as CPU and system architectures have become more complex over the years, this is a growing challenge. System programmers have to cope with such things as noncoherent I/O, out of order memory accesses, various busses and address tranlations next to things like endianess mismatches and alignment issues. We will discuss these issues and give ideas on how to build a device driver framework to allow for portable system programming.

Chris Gray

Wonka is a clean-room implementation of the Virtual Machine and class library specifications for Java, developed by Belgian company Acunia. It was developed specifically to meet Acunia's needs for Java in embedded and mobile systems. Wonka is Java2 compliant, and supports the CDC/FC profile plus some additional packages. A selective JIT compiler is currently under test.

Wonka is available under a BSD licence. In this presentation we will discuss some of the challenges involved in implementing a high level of Java functionality in an embedded context, and outline some current areas of development and research.

Peter Soetens

The Linux kernel is well known for its portability and extendability. One of the recent extensions is bringing realtime operating systems under the kernel hood so that realtime software can run on the same platform as the user(-space) programs. Examples are RTAI ( and RTLinux ( Since realtime programs introduce a complexity far beyond device drivers, better programming methodologies become a must to control the realtime softwares complexity. The C++ programming language facilitates object oriented development and design, which can be used to manage complex programs. There are reports of realtime operating systems being written entirely in C++ (e.g. eCos).

I will introduce how the Linux kernel can be extended to support C++ to the extent that all C++ programs can be brought in the kernel, except for exceptions. A second logical step is to bring the standard C++ library into the kernel, which will also be explained.

Sunday 9 Feb 2003:

Eero Tamminen

What are the problems with cross-compiling programs that use GNU Autotools to configure themselves?

How these problems can be solved?

Autotools is used mostly by Linux desktop software (KDE, Gnome) which are normally compiled natively. Why one would want to have all that software on an embedded device? What are the requirements for embedded desktop system software and how they match to what Open Source can currently offer?

Nick Garnett

eCos is a highly configurable, portable, open source, royalty free Operating System for real time embedded applications. This presentation provides a brief, mainly technical, overview of eCos: its history, implementation, configuration system and future directions.

One of the key technological innovations in eCos is a highly sophisticated configuration system. The configuration system allows the application writer to impose their requirements on the run-time components, both in terms of their functionality and implementation. eCos provides both a graphical configuration tool that runs on both Windows and Linux, and a command line tool that can be used to automate the configuration process.

eCos is designed to be portable to a wide range of target architectures and target platforms including 16, 32, and 64 bit architectures, MPUs, MCUs and DSPs. The eCos kernel, libraries and runtime components are layered on the Hardware Abstraction Layer (HAL), and thus will run on any target once the HAL and relevant device drivers have been ported to the target's processor architecture and board. Currently eCos supports a large range of different target architectures (ARM, Intel StrongARM and XScale, Hitachi SH3/4, Intel x86, MIPS, Matsushita AM3x, NEC V850, Motorola PowerPC, SPARC and several others), including many of the popular variants of these architectures and evaluation boards.

eCos has been designed to support applications with real-time requirements, providing features such as full preemptability, minimal interrupt latencies, and all the necessary synchronization primitives, scheduling policies, and interrupt handling mechanisms needed for these type of applications. eCos also provides all the functionality required for general embedded application support including device drivers, memory management, exception handling, networking, file systems, standard C and math libraries, POSIX and uITRON compatibility etc.

To permit proprietary application code to be linked with eCos without itself being forced to be released under the GPL, eCos is distributed under the GPL license with an exception. It is also royalty and buyout free, making it an attractive alternative to license inhibited, closed source or commercial real-time operating systems.

Philippe Gerum

RTAI is a GNU/Linux-based real-time interface for applications with strict timing constraints which has recently been ported over Adeos, a flexible environment for sharing hardware resources among concurrent operating systems.

We will discuss the process of migrating the RTAI core over the Adeos nanokernel, describing the pipelining scheme Adeos implements in order to dispatch hardware and system events to RTAI, so that real-time tasks have absolute priority over regular Linux activities.

We will conclude by considering the new paths this migration opens for extending RTAI while still keeping a high degree of determinism.

David Sugar

In understanding the needs of building current and next generation telephony services we have to consider that in the past such services were often built from proprietary realtime operating systems. Changes in the last 20 years in the power and capabilities of commercial off the shelf commercial platforms and free oper- ating systems have largely replaced the need for specialized proprietary realtime systems, but not the realtime requirements that still exist today. This paper is meant to provide an overview and introduction of the challenges and needs in providing realtime Linux services to support current and next generation telephone networks, but is not meant to be a rigorous analysis on the topic.

Spare slot...

The spare slot leaves us the opportunity to add an ad-hoc talk on a topic related to Embedded & Kernel Development. We will welcome suggestions for this slot until Saturday 8 pm.

Updates to the program will be posted on the paper program in H1302.

  Special announcement

will take place
on February 8 - 9 2003
in Brussels...

  FOSDEM search

  Search this site :


  Best background:
best background

Create the coolest Fosdem background design and win cool stuffs... More info

  Sponsors corner


 [ Home ] [ Developers room ] © FOSDEM 2002 - powered by Argon7