Paper abstracts

A vast need of current production industry is a significant increase of manufacturing precision and quality. A major step towards accomplishing these needs is MESACTIF (Modular Embedded System for ACTive Intelligent Fixtures), a fixture mounted underneath conventional part fixtures of milling machines. The goal is to significantly enhance the machine's accuracy and to enable the innovative manufacturing of complex shapes. A special requirement is modularity at all design levels to ensure high adaptability for a wide range of possible future applications. The result is a mechatronic system based on a RTLinux distributed embedded system.

In order to provide autonomous mobility, a robotic wheelchair,requires various tasks such as sensing, localization, obstacle detection, and motor control, which is a very complex control system. In this paper, we present a real-time control system design for robotic wheelchairs based on RTAI. We developed a multiprocessor-based robotic wheelchair platform for the disabled. Based on discussions on real-time requirements of robotic wheelchairs, we designed an efficient software architecture for autonomous real-time control of robotic wheelchairs. The performance is revealed by experimental results carried out at the Intelligent Sweet Home in KAIST.

Hardware-In-Loop-Simulator (HILS) is an important step in system design & development. In the present work a systematic approach has been adopted in creating the HILS for autonomous navigation of a Mini Aerial Vehicle (MAV). The issues addressed in this paper are 1. real time simulation of flight dynamics, 2. modeling of sensors, 3. integration of ADC and DAC interfaces under RTLinux, 4. GPS data simulator. An on-board computer and the actuators are the actual hardware in the simulation loop. The HILS is generic in nature and it can easily be adapted for any other on-board computer. This simulator will help in 1. design of navigation, guidance and control law, 2. testing the NGC laws in real time, 3. design and development of various interfaces e.g. GPS interface, filters etc. 4. identifying various faults in the system. Using the present HILS, on-board computer can be directly ported to MAV, without any modification in hardware and software.

Real Time Linux is rapidly finding application in several embedded systems because it is scalable, customizable and has a good development environment. However, problems arise on systems with low memory, and on systems that require to be booted fast. Linux is not optimized to boot fast, and requires at least 4MBytes of RAM.

This paper presents an embedded application: a Remote Terminal Unit (RTU), used in a Supervisory Control and Data Acquisition System (SCADA) to monitor and control critical process control plants. The RTU is based on Intels' 80486 microprocessor and has 2 MBytes of SRAM and 2MBytes of Flash memory. Besides this, the application requires the system to be booted in under one second.

FSMLabs' RTLinux was tuned to run on this system. This paper discusses two aspects of the tuning. First, the embedding of RTLinux on this low memory system. Second, the modifications made to reduce the boot time of the system.

Hard Real-Time Control (HRTC) is to be intended in terms of the relative time scales of the electromechanical components of the mechatronic system to be controlled. MicroElectroMechanical Structures (MEMS) or Drive-by-Wire (DbW) applications are good examples of hard real-time controls.

The combination of algorithmic and logic processing power by means of micro and/or Digital Signal Processor (uP, DSP) and Programmable Logic Devices (PLD) or Field Programmable Gate Arrays (FPGA) results in a powerful Algorithmic and Logic Core (ALC) to be used in many different and demanding mechatronic applications.

The digital platform here proposed is an industrial PC equipped with a FPGA board whose firmware Intellectual Properties (IP) can be accessed by the different software Service Routines (SR). Firmware is memory mapped into the PC memory space and the interrupt management is handled by a combined structure of software scheduler and firmware interrupt manager.

The FPGA board is also used to implement a hard real-time bus to connect such a digital platform to a number of DSP/FPGA based Actuator Control Units (ACU) dedicated to current and torque fine drive and control.

The FPGA board driver is developed within the proprietary hard real time RTAI API's and the development tool chain can be fully handled within the Simulink environment: simulation, software and firmware code generation use the very same model.

Embedding Linux in a carrier-grade application, like a Microwave Point-to-Point Radio Link, has many interesting concerns. These concerns range from technical issues, cost calculation issues to even political or licensing issues. However, when compared to an existing proprietry-only product which binds a company to long development cycles, it has many relatively obvious advantages. This report aims to address the concerns that have been raised in the process of embedding Linux in a microwave Point-to-Point radio application.

This paper describes an implementation of the Linux kernel and applications on a unique commercial-off-the-shelf component based space borne computer system. This system, called the parallel processing unit has been developed for the X-Sat micro-satellite mission. Interfaces using the kernel device driver model are utilised to allow seamless application interaction with the system hub. Software implemented universal error detection and correction (EDAC) processes protect user space applications in the harsh radiation environment of space. The primary advantage of such a Linux based space system is the high degree of similarity to ground based personal computing systems. This allows the user to utilise readily available software tools and shift the burden of development to the more powerful and user friendly desktop computing environment. However, this lends credence to the interesting concept of uploadable software payloads, discussed as part of the paper.

This work-in-progress report describes a distributed hybrid architecture that imparts autonomous intelligence capabilities of "perception-decision-action" to an ALV (Autonomous Landing Vehicle) control unit. The system is shown to degenerate to a remote thread execution mechanism of a real-time operating Linux system where the kernel instantiation is control strategy dependent.

There is a strong tendency towards using modern Personal Computers for various tasks they are not designed for. This also includes audio and video processing. Audio and Video data is real-time data. It needs to be dispatched within predefined and fixed time windows to avoid perceivable lags and dropouts. Neglecting this very fact, today's software solutions are built on General Purpose Operating Systems that do not guarantee any timing behaviour.

Target of this project is creating an open-source versatile real-time capable data aquisition, routing and manipulation framework. The "Audio" part in the name refers to the concepts' suitability for audio recording.

The goal of the software design is to maximize reliability. No sample must be lost during data aquisition or manipulation. Of course, one can't eliminate the possibility of too slow hardware, disk failure, network packet or connection loss and similar events. In these cases, the software must report an error immediately.

This paper describes a way to use a hard real-time operating system for the tricky task of reliably recording and reproducing audio samples and video frames. It relies on a working implementation. This implementation uses the Linux operating system, extended with real-time capabilities by RTLinux/Free. It is directed towards software developers with Linux knowledge. The concept described relies on Linux kernel mechanisms, real-time specific programming and hardware management.

RTLinux does not support direct access to any kind of permanent massive storage system, and in particular IDE hard disks. When a RTLinux thread has to store data on the hard disk, it has to use the Linux services. The usual way of doing the transfer is by means of RTFifos: a rtl-task sends the data to Linux through an RTfifo, and then, a Linux process writes this data on the hard disk.

This indirect method is slow, unpredictable and inneficient, since it is executed by Linux (background). Moreover, in some applications, like continuous media applications, it is required a certain degree of predictability. Therefore, for multimedia applications is more convenient that rtl-tasks have access to the hard drive, allowing higher determinism. To achieve this goal is necessary: 1) To port the IDE driver to RTLinux, 2) implement a real-time filesystem, and 3) implement a real-time disk scheduler.

The goal is to provide with a full "block layer" to RTLinux making the design scalable to allow future storage devices drivers implementations and offering a known interface to work with.

This paper describes a fixed-point arithmetic implementation of linear time-invariant digital filters in the C programming language, targeted for the use in real-time applications. FIR and IIR filters are presented in different configurations and representations, such as direct and transposed forms, as well as wave, state-space and normal forms. All these forms provide a first, second and $N^{th}$ order tick or update function, and they may also be arranged in cascades. Scaling of parameters and input values is adressed as well as quantization of filtered output values with optional noise shaping. The implementation is independent of filter types (low pass, high pass, etc.) and filter families (Butterworth, Bessel, etc.). All filters are implemented in a dynamic linkable library, both real-time safe for the GNU/Linux user space and the Linux kernel.

Scilab/Scicos is an open source project developed at the INRIA (Insitut National de Recherce on Informatique et on Automatique) in France which can be used to successfully replace other commercial and expensive software in solving mathematical and control problems. This software integrates a code generator for Scicos which has been modified and completed to automatically generate a code for the RTAI-Lab environment. The result is a full open source rapid prototyping system based on Linux RTAI, RTAI-Lab and Scilab/Scicos which has been successfully used to quickly implement real-time controllers and data acquisition systems.

Users can work within a unique environment during all phases of control system design (analysis, controller design, simulation, implementation). After these first steps, a Scicos scheme can be designed in order to implement the derived control algorithm. This scheme can be completed with blocks from a new specific Scicos library which provides all the modules needed to interface the Scicos model to data acquisition cards, input signals and RTAI-Lab. Some I/O blocks allow distributed control in a real-time network or in a local machine and can be used to mix Scilab/Scicos with Matlab/Simulink/RTW generated codes.

Some applications are presented to demonstrate the capabilities and the performances of the environment.

Real Time applications involve time-critical tasks, which are to be run in a high precision scheduling environment always meeting the timing constraints. Applications which run on RT Linux uses a hard real-time kernel for tasks which needs real-time processing and the Linux OS for other non real-time tasks. These include tasks like networking and display. It uses the display system present in desktop Linux operating system for part of the application involving display. At high throughput rate this leads to synchronization problems between real-time acquisition and display modules as in the case of real-time tracking applications. The Linux scheduler will not handle the data sent at the rate of a real-time task causing buffer overflow and system crash. In this paper a method to synchronize, the display task to the output data rate of the real-time task, using IO watches for the buffered Input/Output channel is discussed.

Applications that require a combination of high-performance computing capabilities and real-time behavior, although pervasive (simulation, medicine, training, multimedia communications), often rely on specific hardware and software components that make them high performance but expensive, and quite difficult to develop, validate and moreover upgrade. The increasing performance of COTS and the volume of software developed for these applications lead to the consideration of incremental development schemes in addition to sole performance. In the ITEA Hyades project, industrial companies, research centres and academic departments, propose a complete set of software technologies aimed at adding real-time capabilities to multi-processor systems, with a strong commitment to standards. In this paper we present the application requirements with respect to real-time, the architectural model proposed, as well as the reasons for using the Linux operating system. Then, we introduce software components that have been selected to provide real-time needs, among which are Adeos and ARTiS, and their expected contribution to global performance. Finally we provide performance measurements for these elements.

Runtime reconfigurable embedded systems target an architecture consisting of a reconfigurable system-on-chip (RCSoC), which has hardcore or softcore general-purpose processor (GPP) and field programmable gate arrays (FPGAs). The architecture provides common execution semantics for software and hardware tasks. The partial reconfiguration abilities of the newest FPGAs are fully exploited in order to improve performance, cost, energy-efficiency, and time-to-market

In this paper, we describe the research issues and technology approaches for the development of a hardware operating system for runtime reconfigurable platform of embedded devices. We propose a specialized operating system, that will manage hardware/software task management, to allow run-time partitioning and allocation of reconfigurable FPGA area, efficient communication techniques and well-organized task scheduling methodology.

In focusing the efficacy of reconfigurable computing, one of the important dimensions is the partitioning of the Field Programmable Gate Arrays [FPGAs]. As the amount of reconfigurable resources in a single-chip FPGA is increased tremendously, it allows the change of hardware tasks at run-time. The efficient area utilization of FPGA requires an efficient partitioning algorithm. A reconfigurable operating system is needed in run-time reconfigurable environment to manage the system resources effectively in a multitasking manner.

This paper addresses our work toward an efficient initial and run-time partitioning algorithm for block partitioning of FPGA reconfigurable resources and a new methodology for the real-time scheduling of hardware tasks in block-partitioned FPGA. The partitioned blocks in the FPGA are one-dimensional static blocks with different widths. A novel partitioning and scheduling algorithm for reconfigurable embedded devices is presented together with simulation results.

As embedded systems evolve, there is greater dependency on the real-time operating system (RTOS) to abstract the complex hardware. In return for the services provided, the RTOS consumes CPU cycles, thereby imposing a processing overhead on the CPU. In this paper, we review some of the techniques that have been proposed in literature for reducing the CPU utilisation by the RTOS primitives, including our work on two specific platforms -- a multi-core processor and a soft-core processor. We clearly demonstrate that the benefits of adopting a suitable RTOS acceleration strategy are significant. We also look at some of the challenges that face the RTOS industry if they are to adopt these mechanisms. It is our belief that the self-maintaining nature of open source software makes it a very viable candidate for benefiting from these approaches.

The LibeRTOS project focuses on producing a stable, robust, and highly configurable Linux platform for industrial automation and other real-time applications. This paper provides an overview of LibeRTOS and discusses its most important capabilities which include: (1) high resolution time keeping, (2) extremely flexible and fine grain performance data collection support, (3) highly configurable scheduling policies, and (4) integration of OS computational components, including interrupt handlers, into the system scheduling model. The combination of these capabilities provides a single-OS platform appropriate for a wide range of industrial automation and other real-time applications. This paper provides an overview of the most significant and innovative aspects of the LibeRTOS system implementation and discusses recent experimental results comparing its performance to RTAI, a popular dual-OS real-time system, for both kernel based and user space computations.

ARTiS is a real-time extension of GNU/Linux dedicated to SMP systems (Symmetric Multi-Processors). ARTiS divides the CPUs of an SMP system into two sets: real-time CPUs and non real-time CPUs. Real-time CPUs execute preemptible code only, thus tasks running on these processors perform predictably. If a task wants to enter into a non-preemptible section of code on a real-time processor, ARTiS will automatically migrate this task to a non real-time processor. Furthermore, dedicated load-balancing strategies allow all the system's CPUs to be fully exploited.

The purpose of this paper is to describe the basic API that has been specified to deploy real-time applications, and to present the current implementation of the ARTiS model, which was achieved through modifications of the 2.6 Linux kernel. The implementation is build around an automatic migration of tasks between real-time and non real-time processors and the use of a load-balancer. The basic function of those mechanisms is to move a task structure from one processor to another. A strong constraint of the implementation is the impossibility for the code running on an RT processor to share a lock or to wait after another processor.

Cleopatre is an open source and flexible real-time operating system, that supports many components, features and optional dynamics aspects. The Cleopatre components are classified in four groups: the scheduling components (including static and dynamic schedulers), the synchronization components (including priority inheritance and ceiling protocols), the aperiodic tasks servicing components (including Earliest Deadline Late and Total Bandwidth Servers) and the fault tolerance components (with Deadline Mechanism and Imprecise Computation).

This paper presents the experimental study of the performance of Real-Time Linux based on the x86 architecture. Holding the hardware constant and using different measurement methodologies, we measured a list of performance (ten kinds of test), including the overheads incurred during operating systems context switching test, conditional variable test, rt-fifo read/write test, mbuff read/write test, etc. Our experiments and analysis show that Real-Time linux provides good raw performance and it is suitable as an operating system platform for developing and running soft and hard real-time applications.

Scheduling theory has shown an impressive evolution due to the intensive research done in this area. As a result, a lot of scheduling algorithms has been proposed to support a large amount of applications. RTLinux uses a fixed-priority scheduler and although fixed-priority scheduling is suited for a large number of real-time applications, it has some drawbacks. Nevertheless, adding new scheduling policies is a complex and time-consuming task since the kernel's internal structure must be modified. In recent years, an Application Program Interface (API) to create Application-Defined Schedulers in a way compatible with POSIX has been proposed. This model allows the implementation of different scheduling policies in a portable way, without modifying the internal structure of the real-time operating system. In this document, the implementation of a new Application-Defined Scheduling model in RTLinux is presented. The Application-Defined schedulers are not implemented as special threads but as a set of primitive operations that are executed inside the kernel, avoiding unnecessary and costly context switches. Also in this paper, a new library of Application-Defined Schedulers and its API is presented. This library offers a wide range of scheduling policies. Using this library, the implementation of Real-Time systems can be done in an easy, efficient and consistent way. The use of the library makes possible the creation of systems with multiple schedulers working concurrently, every one at a different priority level.

There has been increasing interest in the real-time community for Quality of Service (QoS) based systems, such as multimedia and telecommunication systems. In this paper, we deal with scheduling components integrating new QoS functionalities under Linux/RTAI (Real-Time Application Interface) [Rta04]. The work relies on a periodic task model which allows occasional deadline violations, together with soft aperiodic tasks. This model discards selected task instances in such a way that the overall performance of the real-time system remains acceptable even in case of overload. The key objective is to exploit the skips in order to minimize the response time of soft aperiodic requests, using the EDL (Earliest Deadline as Late as possible) server, which is a dynamic slack stealing algorithm. The level of QoS, i.e. the skip factor, is fixed by the application programmer. Simulation results show the performance of two algorithms, namely EDL-RTO and EDL-BWP. Both the mean reponse time of aperiodic requests and the ratio of periodic tasks completions are considered. We also provide results to estimate the preemption cost induced by these algorithms. Finally, integration of these QoS scheduling strategies has been done in the open-source library of CLEOPATRE, a patch to Linux/RTAI.

A deterministic response time is the most important and necessary feature in Hard Real-Time Systems. This is the main reason why some years ago it was unthinkable to implement Hard Real-Time Systems with the Java language, an object-oriented, interpreted language, mainly because Java uses garbage collection to implicitly deallocate dynamic memory; This is widely known as``the garbage collection problem'' in the Real-Time Systems community, due to its temporal unpredictability. Nevertheless, few years ago a new standard, known as RTJava, has been specified to transform the Java language into a Real-Time compliant one, making it possible to implement Real-Time applications in Java. This new Real-Time standard tries to benefit from the experience gained in the design of other Real-Time languages, taking advantage of their real-time properties like scheduling control. On the other hand, RTLinux is a Hard Real-Time Operating System which allows to implement Hard Real-Time applications while preserving all of the Linux functionalities available for the Soft Real-Time part of the application. This paper will describe how we have ported the JamVM, a free Java Virtual Machine implementation to run Java bytecode directly on RTLinux, which allows to benefit from both the capabilities of the Java language and the RTLinux OS. This work represents our first milestone in the more ambitious goal to provide an Real-Time RTJava platform based on RTLinux.