1999 - 2000 - 2001 - 2002 - 2003 - 2004 - 2005 - 2006 - 2007 - 2008 - 2009 - 2010 - 2011 - 2012 - 2013 - 2014 - 2015

Announcement - Agenda - Paper Presentations - Participants

There is an ever-increasing demand from the Industry for a flexible, modular and a cost-effective CNC machine servo controller. The primary aim of this research is to develop a real-time PC-based servomotor control system. Such a machine controller is not only required to perform control functions but also do other functions like database maintenance, tool path planning and optimization, and operator interface among many other useful functions. In realizing this objective, the environment is not only designed keeping in view the Open Architecture Controller (OAC) specifications but also to launch a platform for total factory automation. Good fault-tolerance, factory floor networking and flexibility in terms of software are considered in designing the system.

RT-Linux has been chosen as the suitable real-time platform with Windows NT as the front-end for the system. RT-Linux is very reliable and gives a good performance with a worst case scheduling latency of 12(sec and a worst case interrupt latency of 10(sec on a 650MHz Pentium III processor. The rationale behind choosing various other components of the system that makes it possible to meet the OAC specifications and the functional requirements is elaborated in this paper. In addition, system working environment and some of its good features will be discussed. This open source based CNC servo control platform is a promising technology for the future of factory automation.

This paper presents an architecture and design methods for rapid development of real-time control systems such as CNC or robot controllers. PICARD (Port-Interface Component Architecture for Real-time system Design) is a software architecure and environment which is aimed to reduce development time and cost of real-time control system. With PICARD, a control engineer can construct a control system software by assemblying pre-built software components using interactive graphical development environment. Picard has been used to implement a prototype PC based CNC controller sucessfully. PICARD consists of PVM(Picard Virtual Machine), a component library, and PICE(PIcard Configuration Editor). PVM is a real-time engine of the PICARD system which runs control tasks on a real-time operating system. The component library is composed of components which are called task blocks. PICE is a visual editor which can configure control tasks by creating data-flow diagrams of task blocks or ladder diagrams for sequential logics. PICARD has been implemented on several operating system including QNX, WindowsNT (non-real-time), Linux (non-real-time), INtime, and RT-Linux. Compared to other operating systems, there are some differences on RT-Linux implementation in which real-time tasks should be written as wkernel modules. For the communication between PVM on a target system and PICE on a host computer, a simple protocol was devised because RPC or CORBA cannot be used in RT-Linux. By using discription of communication functions in Python language, function stubs are automatically generated. Experiences on using C++ language in kernel modules are also discussed.

This paper discusses the different benchmarking tools used to evaluate the performance of Linux and their suitablilty for evaluating Real Time system Performance. The importance of using Statistical Methods as well as defining absolute hard limits is presented. The author will then present an Open Source Test and Evaluation Suite toolkit which rapidly allows system performance to be monitored and calibrated in a manner to allow a user to define the relative merits of each proposed system. The toolkit can easily be adapted to different operating systems and different environments but still allow results to be compared against each other. Users are encouraged to make use of the toolkit to test their own configurations. Extensions and additions to the toolkit will be discussed. The paper will present results obtained from a number of different Operating Systems on a number of different hardware platforms.

Finally the other requiremetns that make up a useful Real Time Operating System will be presented. These include reliability, ease of programming and robustness. A number of different approaches to A number of possible ways for measuing. The methods to evaluate the Real time performance of a system are quite different to teh tools used to monitor the absolute performance of the system. The requirements for a test and evaluation package are presented. The special needs of Real Time applications are discussed.

The author has developed a set of tools to rapidly evaluate different configurations under different operating conditions.

We present a temporal debugger, capable of examining temporal behaviour of operating systems. The debugger is based on a simulator modelling an entire workstation at the instruction level. Unlike traditional debuggers, which need to interfere with program execution, a simulation-based debugger can operate without disturbing time flow of the simulated system. This allows non-intrusive and reproducible debugging of general-purpose operating systems, such as Linux.

We demonstrate the utility of the temporal debugger by analysing two time sensitive parts of Linux, scheduling and interrupt handling. We show how our tool allows a user to identify and isolate temporally unsatisfactory behaviour, and examine short sequences in detail.

Keywords: Soft Real Time Systems, Temporal Debugging, Operating Systems, Linux, Simics, Complete System Simulation

This paper describes a testing stage based on real time linux for characterizing rotating micro mechanical devices in terms of their peformance, quality and power consumption. In order to accomlish this, a kernel module employs several real time threads. One thread is used to control the speed of a master rotating up to 40000rpm by means of an incremental coder and a PCI counter board with the corresponding interrupt service routine. Another thread controls the slave motor to be tested, synchronized to the coder impulses using voltage functions saved in shared memory. The measurment thread is then responsible to acquire date synchronously to the rotor angle and stuffs data on voltages, currents, torque and speed into different FIFOs. Finally, a watchdog thread supervises timing and wakes up a users space program if data have been put in the FIFO. This GTK+ based graphical users space application prepares control information like voltage functions, processes data picked up from the FIFOs and displays results in figures.

Analyzing and understanding the behavior of real-time embedded systems is a complex task. Often, developers resort to ad-hoc methods in order to understand the behavior of their systems and isolate bugs. Answering this need, some commercial RTOS vendors have made available different types of tools to understand their product's behavior. The effectiveness of such tools vary, but they are usually quite expensive, which proves to be a barier to entry when wanting to design any system using an RTOS.

The RTAI extensions to the Linux Trace Toolkit presented here take these barriers away and provide developers with an open-source set of tools to analyze and understand the behavior of any RTAI-based real-time system. This analysis involves presenting RTAI's behavior in a control-graph form and presenting statistics regarding the overall system behavior including all the real-time tasks that ran. Furthermore, tracing such a system involves an overhead of, at most, 1 micro-second per event, which is very acceptable behavior for most real-time systems.

This paper demonstrates the possibility of executing wide band hard real time application in user space under Linux. Such a possibility is demonstrated through examples of its implementation at DIAPM of three digital active control systems, that require relatively high (up to 12 KHz) control frequencies: an active noise control of an acoustic duct using feedforward techniques, an application of active vibration suppression of a plate with piezoelectric materials, and an active noise reduction system used to control combustion instabilities in a Rijke tube.

A brief introduction of the basic ideas on which hard real time control in user space is based, its most recent developments, and a complete description of the software architecture adopted in each application are included.

Telemetry requires only soft realtime, i.e. receiving data at a fixed high rate without loss . These data must be processed in time and delivered to several different applications. The requirement for being real time is weak, as seen by human eye. Therefore standard LINUX is used with a special driver. The driver uses a SBS-4422 decommutation board and delivers data blocks in real time into user-space using cyclic buffer and DMA. The associated application is forced into RT-scheduling (SCHED_FIFO) and uses a standard read to synchronize and to get the buffer pointer. Measurements show that at actual data rates the rt-jitter stays in the range of 1 ms, with some exceptions, which are covered by the ring buffer. At the actual data rates (512 words every 2 ms) no data are lost, even if the remaining system is heavily loaded.

In this paper a remote data acquisition system for Mössbauer Spectroscopy based on RT-Linux is presented. More precisely, a kernel module is in charge of collecting the data from the data acquisition card which is self-made based on ISA, sharing the data with the normal Linux process through the module of mbuff, carrying out the remote control and returning the results to the client by building a simple and effectual communication model. It's a good sample to deal with the communication between the real time process and the normal process. This user application can access to this system by the browser, or Java program to implement the real time observation and control.

GPS, or Global Positioning System, is a key technology for both the civilian and scientific research markets. GPS provides users with precise geodetic positioning and time determination. Most GPS receivers require specialized hardware and complex software to operate. One receiver, known as GPSBuilder-2 originally designed by GEC Plessy, takes a novel approach. This receiver uses a minimal amount of hardware, thus its operation relies extensively upon software. The software runs on a Pentium class machine under DOS and interfaces an ISA card. In an effort to modernize this receiver, we migrated the code to RTLinux. The major aspects of the migrated code are an Interrupt Service Routine, multiple threads, and TCP connectivity. Following the migration we noticed that not only did receiver stability increase dramatically, but also errors in positioning decreased significantly. To provide insight into code migration from DOS to RTLinux, we will focus on the specific difficulties, discoveries, and enlightenments encountered.

Robot control software is a typical application applying real-time Linux as a hard real-time operating system. The author's software was originally running under MS-DOS. Problems of adapting it for real-time Linux are presented. This paper describes internal structure of the software as it had to be divided into a hard real-time part (a kernel module) and a standard Linux process part.

This paper presents the design decisions made and architecture used in developing a real time system to control a two-axis positioning gimbal. This system is interesting in that it includes several real-time to non-real-time interfaces for user interaction and network communications. The development process is described from the initial stages and selection of an operating system trough the development of code. Of particular interest to the real-time beginner is that each critical design decision is described with supporting information which may be useful to others making such decisions. The overall architecture of the system is described along with a basic functional description of each module, with particular attention to the interfaces. The system makes use of Tcl/Tk to provide a user interface and some novel approaches for the interface between RTLinux and Tcl/Tk are presented.

Techniques allowing kernel tasks and user space processes to share large blocks of memory are presented. In particular, "mbuff\/" device driver is introduced. Simple examples of synchronizing producer and consumer threads using only shared memory are given.

Comedi is a collection of drivers, common core, and high-level programming interface for data acquisition hardware, including A/D converters, D/A converters, digial I/O, and timer/counters. Comedi is somewhat unique among Linux drivers in that it equally supports real-time and non-real-time applications. A brief introduction to using Comedi will presented, followed by an outline of the present and future directions of Comedi.

The rt_com module provides a standard serial port driver for Real-Time Linux. It defines a API to access the generic PC-architecture serial ports from Real-Time space. rt_com works with NMT RT-Linux as well as RTAI. This talk gives an outline of the programming interface as well as of the internal structure of the driver. Additionally some application examples are given.

SimuLinuxRT is a a realtime interface to the SIMULINK package that allows one to run realtime code right from the SIMULINK diagram. It runs under RTLinux developed by FSM Labs. Simply draw a Simulink diagram and click Build . Click Run - the process will run in realtime at a specified rate up to 50 kHz. You can open any Simulink scope and you can see the data in realtime as well as save any Simulink scope data to Workspace or File. You can run other processes without interrupting the realtime process and use all Simulink features on a realtime process.

Modern automatic control systems need 1) logically complex and computationally expensive controller algorithms and I/O; 2) real time data storage of plant information such as states, inputs, and outputs; 3) real time plotting capabilities; 4) real time controller parameter updates (both scalar parameters and matrices); and 5) real time access to reference signals; 6) remote monitoring for safety purposes. Control systems based upon embedded Digital Signal Processors (DSP) boards often require specialized programming and development tools, may lack flexibility when computational or timing requirements change, and may not directly address the aforementioned needs. Even worse, newer and faster DSPs may not be fully pin compatible with their predecessors, thus requiring total redesign of the embedded electronics for a given project. A novel controller implementation system -- the Real Time Controls Laboratory (RTiC-Lab) -- has been developed explicitly to address these problems. It relies on both commodity personal computers and Real Time Linux to guarantee satisfying hard real time constraints in light of maintaining soft real time requirements (such as plant monitoring and parameter updates). RTiC-Lab is Open Source and is thus intended to serve as a communal effort among both controls engineers and the Real Time community. Discussion is presented on the design of RTiC-Lab's software architecture, the controller API, and the IPC-API which allows other software packages to communicate with RTiC-Lab. An example application is presented.

Hard real-time Linux variants, RTLinux and RTAI, both use fifos and shared memory to communicate with user applications. In this work, we describe a new package, lvrtl, which allows LabVIEW VIs to use these mechanisms in a completely generic way. For the get operations, the incoming data is collected into a dynamically resized array thus handling scalar and array data for several different data types. There are symmetric put operations and a complete suite of VIs with which to build LabVIEW applications. The package also includes extensive test code under RTLinux 2.2 and RTAI 1.3.

This contribution describes a possibility to build critical real-time applications using RT Linux 2.3 and LabVIEW 5.1 for Linux. Therefore a software interface has been added to LabVIEW, which gives control over real-time processes running on RT Linux. Unlike LabVIEW-RT, the real-time processes are programmed as linux kernel modules using "C" and do not need additional devices for hard real-time features, instead they run on the industry's standard PC architecture. All known Linux DAQ-card drivers can be used for data acquisition and control of external devices, as far as they are able to run on RT Linux. The real-time programming examples being presented are written in "C" and "G" and refer to a low-cost and modular data acquisition and control system, which is connected to the PC's printer port. A real-time control system has been developed which manages a biophysical experiment, using a PC with a Pentium 133Mhz and 32MB ram. It covers: 1. control of stepper drives, valves and power heating using pulse-width-modulation, thereby achieving near analog operation with precise synchronisity; 2. multi channel data acquisition (digital and analog, rate 1Hz..10kHz, resolution 8..18 bits); 3. multiple simultaneously and independently running feedback control loops for position and temperature. 4. online graphical visualization of measured data and user interface to control of the experiment; 5. real-time scripting and macro language for easy programming of repetitive automation tasks; 6. graphically controlled post processing of the obtained data. Finally, this fully functional real-time DAQ and control system was build up using only a fraction of the usually needed expenses. The use of open standards and modularity make this solution highly flexible and easy to adopt to future applications.

Development of embedded systems is moving away from single-task/single-user applications running on specialized target platform towards a reduced general purpose OS running on PC-like hardware. This move is well represented by Linux based projects for embedded platforms and specialized minimum distributions. As a sample system and as a basis for development of hard-realtime embedde systems miniRTL was designed. A system that is centered around three major tenets: hard-realtime capabilities, based on FSMLabs' current RTLinux, up-to-date Linux Kernels fully supporting all x86 platforms, maximum compatibility to a "standard" desktop development system. In this paper strategies to reach these goals will be described and the successful application to a running 1.44MB system demonstrated.

The development team has perfected and added much functionality to RTAI over the course of the last year. The presentation will review this progress and focus on the following areas:

• Improvements in the source tree, installation procedure and manual upgrade.
• Dynamic CPU frequency and bus frequency calibration.
• Port to Linux 2.4: 24.1.x releases and the PPC architecture.
• New Fifos: dynamic creation of named fifos, signal and semaphore interfaces.
• POSIX 1003.1c thread module with mutexes and condition variables.
• RT_MEM_MGR module: Dynamic memory management and C++ support.
• LXRT: soft and hard real time modes in user space with symmetrical API.
• Trap handling and memory protection while in plain RT and LXRT modes.
• LXRT-INFORMED: integration of RTAI, trap handlers and Linux at termination.
• RT_LXRT_COM and RT_LXRT_RNET modules: the concept of an extendable LXRT.
• MINI_LXRT: timers and tasklets running in user space.
• Integration of QNX IPC primitives, proxy messages and qBlk's to LXRT module.
• LIBLXRT: efforts to simplify the API for GUI and C++ programmers.
• LINUX_SERVER: access to Linux I/O while in LXRT hard real time mode.
• Linux Trace Tool Kit: support for RTAI including LXRT.

The LXRT module with its fully symmetrical API provides a safe and flexible tool to quickly implement hard real time programs in user space. Once the program is debugged, it can be easily migrated to the kernel for optimal performance if the application demands it. With CPU clocked near the 1 GHz mark the necessity to execute code in the kernel becomes questionable. Thus, LXRT provides the trust direction of RTAI's future developments.

FSMLabs RTLinux V3 should be released Fall 2000. RTLinux V3 basically completes the lightweight POSIX threads/signal handlers API for hard realtime programming, includes ports to Alpha and PowerPC, and adds a user mode hard realtime signal handler facility. Coming up next is some optimizations, more ports, extensive work on a low memory footprint Linux, and extensions for new applications. In this talk, I will give a brief overview of the project, look at some application areas and discuss future directions.

An open system allows independently developed hard real-time applications to run together with non-real-time applications and supports their reconfiguration at run-time. The open system always accepts non-real-time applications, but it never accepts a real-time application that may not be schedulable in the system. Once a real-time application is accepted, its schedulability is guaranteed regardless of the behaviors of other applications that execute concurrently in the system.

The paper describes the design and implementation of an open system in Linux and evaluates its performance. The implementation consists of three key components: a two-level kernel scheduler, a common system service provider, and real-time application programming interface (RTAPI). In Open real-time Linux, real-time applications can use existing Linux system resources and services, and there is no need to suspend the kernel in order to switch between real-time and non-real-time mode. The performance evaluation of Open Real-time Linux shows that its overhead of context switching outperforms any other available real-time linux system.

Real-time Linux variants are being considered for use in safety-critical applications in medicine, aviation, and other areas. The open-source philosophy has much to offer in these applications, but certification concerns impose additional requirements on the verification processes applied to these applications.

Some recent discussions in the Linux circle are on the low latency patch posted by Ingo Molnar. There are pros and cons on the usage of preemption points (or "schedule points" in Ingo's terminology). The preemption point approach is to solve the problem that the Linux kernel is non-reentrant. In this paper, we present the justification for inserting preemption points and also study their distribution and risk levels.

The Resource Kernel (RK) is an OS-independent kernel abstraction that provides guaranteed, timely and enforced access to system resources including CPU cycles, disk bandwidth and network bandwidth. RK, developed and distributed by the Real-Time and Multimedia Systems Laboratory at Carnegie Mellon University, has been incorporated into the Linux kernel to create a real-time version of the Linux kernel called Linux/RK. This paper will describe the recent enhancements to Linux/RK and discuss several performance evaluations, application porting experience, QoS guarantees and tools support. Future challenges in terms of end-to-end reservations and shared memory multiprocessors will also be discussed.

This paper describes a set of open source, integrated tools for developing embedded real-time applications, especially targeted to the automotive industry. The set of tools comprises a schedulability analyzer, a kernel library and a kernel configurator. The goal is to achieve portability of the application over different hardware platforms without sacrificing performance. With our tools, the programmer only need to write the application tasks using standard kernel primitives; then the optimization phase is carried out with the help of the kConfigurator tool, which automatically configures the kernel library to obtain maximum performance. So far, the tools have been provided for ST10/C166 microprocessor based boards, we are currently working on a version for ARM 7TDMI based boards.

ELinux is an extensible version of the Linux operating system capable of runtime extensions with functions that effectively manage the information flows and associated computations across distributed embedded execution platforms.