Paper abstracts

Intelligent robots are capable of handling complex tasks that includes recognition of vocal commands, logical inference, autonomous navigation and manipulation, etc. To accomplish intelligent behaviors, researchers have proposed a number of control software architectures such as tripodal schematic control architecture (TSCA).

To achieve real-time performance for robot's navigation, we have implemented software components in the reactive layer of TSCA on RTAI (Real-Time Application Interface) for our intelligent robot. In this article, we present our structures of the reactive layer components. Real-time performance of the designed reactive control layer is demonstrated via experimental results.

Researchers, developers and system integrators require more openness in control systems in order to design, develop and rapidly integrate functionalities to fulfill new application requirements. Even if several robot control vendors provide their products with customized development tools, low cost and not proprietary solutions should be preferred to face the rapid market changes and to reduce control life cycle costs. In fact, most important success factors are the use of off-the-shelf hardware and open source and/or free software, as well as a design focused on reconfigurability and portability of the control software is crucial. In this paper a control architecture which complies with the above mentioned requirements is presented. Specifically a modular control portable on different platforms has been designed, implemented and then validated on two different platforms both based on real-time operating systems (RTOS). The porting activity between the two platforms and specifically between QNX 4.25 and RTAI Linux has been done using features compliant to the POSIX standard. As specific target, the proposed architecture has been exploited to control two robots with different kinematics architectures. The first one is a 4 d.o.f parallel robot prototyped at ITIA-CNR while the second one is an industrial 7-d.o.f robot manufactured by Mitsubishi which is based on a serial kinematic chain. The obtained results for the second application case are presented more in detail. Such a robot has an open architecture dedicated to Research & Development that allows the direct control of servo PLC controller through an upper level PC controller. To guarantee the real-time communication, the servo and upper level controller are linked by a dedicated fiber optic network based on Arcnet interface at 100 Mb/s. Procedures have been developed to move the robot in a safe and robust way.

Currently can combination of Linux and RTAI be run on various platforms. Yet the decision to choose one of them relies on many factors of which the stability of the microprocessor in various conditions is one but not the last of them, obviously. In this paper we want to present the development project where at start the combination Intel StrongARM/Linux/RTAI seemed very reliable and promising, at least by Google. However, as the project progresses towards the end of development cycle many unexpected and nearly unsolvable problems appear.

Snapshot is to create an instant image of a file system. Creating a snapshot image with little processing and space overheads is critical to provide the continuous data service during backup.

In Linux, there are two types of snapshot techniques available : volume-based approach like Logical Volume Manager(LVM) and file system-based approach like SnapFS. The volume-based LVM provides efficient space management capability, but requires some space to be exclusively reserved to store snapshot images and results in high snapshot processing overhead. The file system-based SnapFS performs better than LVM due to its less snapshot processing overhead. Moreover, the SnapFS does not have to reserve some space exclusively for snapshot images. Therefore, the file system-based SnapFS is considered a better solution in the desktop environment where large-scale space management capability is not that criticial. However, SnapFS is available only in Linux kernel 2.2.

In this paper, we develop a file system-based snapshot for the ext3 file system in Linux kernel 2.6. The main concept of the file system-based snapshot mainly come from old-version SnapFS. Experimental evaluation shows that our implementation is quite efficient and working correctly.

The `C-API Simulink Target for RT-Linux' (CAPI_STRTL) is an application developed to extend the functionality of the original `Simulink target for RT-Linux' (STRTL) by providing the user with full parameter tuning and signal access, of a real time application running in a RT-Linux kernel, independent of the Simulink/MATLAB interface.

In this manner, CAPI_STRTL extends the utility of the original STRTL from its conventional use in control applications to more exotic fields such as haptics/virtual reality and even augmented reality - not to mention the many other possible implementations users can realize by having signal access and parameter tuning at the disposal of their custom applications.

The CAPI_STRTL is an add-on feature to the STRTL and is not intended to replace it in anyway.

The purpose of this paper is to introduce the CAPI_STRTL and demonstrate how its functionality can extend the use of STRTL. This paper assumes some previous knowledge of the workings of STRTL.

Real-time embedded systems used to be hand tailored to fit requirements and constraints of applications. But the increasing complexity of applications and the rapid evolution of hardware make these practices unbearable to face nowadays industrial reality with very fast evolution of requirements. The development process of real-time embedded applications must be supported by specific tools to facilitate their reuse, evolution and maintainability. Initiatives based on UML-RT provide such tools to model applications and automatically generate code. In this paper we present one such approach providing a simple domain model for the design of Fault-Tolerant Real-Time applications. A first implementation has been achieved with the OCERA-Fault-Tolerant framework developed within the OCERA IST project as target. This framework is a specialized framework based on RTLinux.

As part of a Cambridge-Massachusetts Institute funded project a set of teaching resources is being developed around the ARM based Balloon Board microcomputer. The system is being designed to give students and academics a preinstalled system with support material and low cost hardware for control and data acquisition projects. Aspects of the hardware and teaching resource are discussed, together with experiences gained in configuring the system for use with a design and build autonomous robot project for second year undergraduates. Extensions to the current system are also presented including work extending the system using RTAI, additional low cost hardware and inclusion in the MDP Resource CD (Multidisciplinary Design Project) which is also being developed,(www-mdp.eng.cam.ac.uk)

The Real-Time Driver Model (RTDM) is an approach to unify the interfaces for developing device drivers and associated applications under real-time Linux. The device models supported by RTDM will be introduced in this paper. An overview of the low and high level APIs will be given and the concept of device profiles for defining generic device interfaces will be presented. Moreover, the integration of RTDM in Xenomai will be explained and a survey of already available applications of this concept will be provided.

This paper investigates the possibility of using standard, low-cost, widely used FireWire as a new generation fieldbus medium for real-time distributed control applications. A real-time software subsystem, RT-FireWire was designed that can, in combination with Linux-based real-time operating system, provide hard real-time communication over FireWire. In addition, a high-level module that can emulate Ethernet over RT-FireWire was implemented. This additional module enables existing IP-based real-time communication frameworks to work on top of FireWire. The real-time behavior of RT-FireWire was demonstrated with a simple control setup. Furthermore, an outlook of the future development on RT-FireWire is given.

WSN (Wireless Sensor Networks) are considered the sensing technology of the future. Many experimental systems have been designed to create a WSN to collect environment data and accessed via a web-interface. But almost WSN are build on the special technology including the software and hardware. In order to extend the application of WSN, we design a sensor platform based on PowerPC, on which the genral embedded Linux runs.Then the abundant free-software and open-source is introduced into WSN's study.We also present a prototype for data collecting and data publishing for this platform. Especially, we utilize the SVG to release the data dynamically.

As real-time capabilities are becoming relevant in main-stream desk-top Linux more and more, and new variants and ideas are popping up all over the Open-Source world, a notoriously incomplete, overview of the existing variants of soft-real time Linux is given in the article. Many of the variants are for special purposes, some are more general approaches that target every-day soft-rt demands, like audio/video streaming, finding your way through the many approaches and selecting the one that best fits your problem is not always easy, this article hopes to clarify a few basic terms and technological concepts, in the hope that it will simplify this selection process.

In October, 2004 the authors of this paper announced a Real-Time Linux Kernel prototype on the Linux Kernel mailing list. The Real-Time Linux prototype introduced preemptible locking into the Linux kernel, and allowed task preemption to occur while tasks were executing within critical sections, resulting in a dramatic improvement in the Real-Time response of the Linux kernel.

Ingo Molnar reviewed the preemptible locking prototype and quickly implemented a preemptible kernel on top of his existing Voluntary Preemption project. This effort gave rise to the Real-Time preemption patch, which is currently available for download:

http://people.redhat.com/~mingo/realtime-preempt

This paper examines the foundations of the Real-Time Linux kernel, focusing in detail on thread-context interrupt handling, replacement of non-preemptible locking with preemptible mutex-based locks, priority-inheritance, virtualization of interrupt-disable, integration of high-resolution timers, as well as current development on user-space extensions of the kernel real-time mutex.

POSIX is a set of international standards whose main goal is to support applications portability at the source code level. It defines an operating system interface and environment based on the UNIX operating system. A series of POSIX Real-Time standards have been defined to support real-time applications portability. However, portability is often sacrificed in Real-Time Operating Systems (RTOS) since they must provide predictability and low overhead. In this paper we discuss the POSIX Real-Time Signals Extension and we propose an approach to implement it into a RTOS in order to improve the performance of systems where the execution entities are threads instead of processes, making a compromise between standard conformance and efficiency. The notion of Signal Owner is presented to avoid ambiguity and assign signal priorities accordingly in priority-based systems and to minimize overhead. Also, we discuss the consequences of the defined default POSIX signal actions in real-time systems and the implementation of signal queueing in the Minimal Real-Time System Profile, and different approaches are presented to address these issues. The paper also describes briefly the implementation of the POSIX Real-Time Signals Extension in RTLinux.

A real-time virtual resource is an abstraction for resource sharing where the application task groups sharing a resource must meet timing constraints in the absence of knowledge of all the timing requirements of all the task groups, thus prohibiting a global schedulability analysis. RTVR addresses the issues of application isolation in the open system environment, as well as satisfying the timeliness requirements of all the task groups. Based on the theoretical framework in previous work, we present in this paper the first implementation of a real-time virtual resource for the CPU. We shall describe two real-time virtual resource (RTVR) prototypes that are based on the Linux 2.4.18.3 kernel. The first RTVR implementation uses a static resource level scheduler which can be applied to systems with predefined application task sets. The second implementation has a novel dynamic resource level scheduler under which task groups (temporal partitions) can join and leave dynamically. We shall report some experimental results on measuring system performance in various aspects such as the effect of the scheduling quantum size, interrupt request response time and scheduling overhead. The experiments demonstrate that RTVR can be efficiently implemented while satisfying its theoretical properties.

We present a methodology to perform fine-grained cycle-accurate timing measurements crossing the user-kernel boundary. Special attention is payed not to deteriorate the results by the measurement process itself. Next, we apply our methodology to obtain execution timing for the system entry and exit paths on x86-based Linux systems. We compare and evaluate three different mechanisms, namely interrupts, call gates and the sysenter/sysexit facility. The measurements are performed on different processor platforms ranging from simple Intel Pentium to Pentium 4 with Hyper Threading and an Intel Itanium system. Our results indicate that timing for kernel entry and exit varies in a non-trivial way. Of the tested architectures, the AMD Athlon exhibits the most efficient behavior.

The purpose of benchmarking systems is most commonly to alow judgment if a system configuration is suitable for a given RT-spec. Aside from the fact that these RT-specs are most often quite vague, the problem of benchmarking is not well resolved in the currently available hard real-time solutions for Linux.

As a guidance to many of the findings presented here we have adopted the following theme:

Celestial navigation is based on the premise that the Earth is the center of the universe. The premise is wrong, but the navigation works. An incorrect model can be a useful tool.

The issue thus is to validate the models on practical code and not drop to deeply into a theoretical view. In this article we summarize our experience with benchmarking RTLinux and with some partially paradox optimization strategies that we have derived from benchmark results.