Paper abstracts

The developed project is an prototype to calculate, show and evaluate the main parameters of Forced Spirometry, on a PC using the operating system Linux and RTLinux.

To calculate these parameters is necessary to know the respiratory flow; therefore a hardware acquires and digitizes the flow and the respiratory pressure; a RTLinux task obtains these digitized signals, and by means of fifos it send them to the Graphical Interphase (application developed with Xforms library), to be shown graphically.

In the Graphical Interphase, we write the data of the patient, the program calculates the theoretical FVC and FEV1 that must have the patient; then the flow is acquired and shown on PC, besides the respiratory volume is obtained by the integration of the flow; then the parameters of Forced Spirometry (FVC, FEV1, FEV1/FVC, FEF25%-75%, PEF, MEF25, MEF50, MEF75, and TTOT) are calculated, these parameters are compared with the theoretical FVC and FEV1 to know if the patient has syndrome of obstruction or restrictive syndrome. The respiratory pressure will be used in later calculations of the respiratory work.

This prototype was developed to help to the prevention of the respiratory diseases in Peru, because these are the second cause of mortality in this country.

Nowadays almost all commercial fatigue test rigs are realised using digital control systems, with the likely exception of signal conditioning and power units. Such systems are often costly and proprietary and the user is allowed little flexibility of usage. So research activities requiring high flexibility in programming arbitrarily complex coordinated multi load histories and a high operational and specimen installation flexibility can be better tackled by in home-developed testing systems. In such a view a competitive fatigue test system has been developed at Dipartimento di Ingegneria Aerospaziale del Politecnico di Milano (DIAPM ) using RTAI. It integrates motion control, force control being nothing but a high resolution, high precision, high bandwidth position control, and user interface into a single general purpose PC with two off-the-shelf DAQ PCI boards. Such a solution leads to a low cost and easily upgradable system, having all the capabilities of its commercial counterparts at the fraction of its cost. It can control many load channels simultaneously, adapt to a wide range of actuators and transducers and implement any kind of control policy (force, displacement, hybrid). The control PC does it all: arbitrary load signals generation, test results logging, display and recording, optimisation of test conditions and controllers parameters. The latest version of software code is split in three parts, a real time module, a communication module and a graphical user interface (GUI), according to the basic principle to separate what has hard timing constraints from what is not time critical. The hard part is implemented in a LXRT module that creates five real-time threads. The graphical user interface is developed with GTK+-1.2; it runs in soft real time mode and can be executed both locally and remotely by using the services made available by the RTAI middleware layer net-rpc.

This diploma theses is integrated in the project MSR2000I at the European Aeronautic Defence and Space Company (EADS). MSR2000I is a secondary radar system to identify and track air traffic. Aircraft are scanned in different modes and incoming answers are analysed. The digital hardware of MSR2000I-system mainly uses Field Programmable Gate Arrays (FPGA) and handles time-critical tasks like signalling and filtering. An embedded Linux version with kernel 2.2.14 is used as the operating system for the software of MSR2000I. It manages the input of user-data and the output of prepared system-data such as flight-histories. The software runs on four industrial PC modules in PC104-standard.

New demands on the MSR2000I-system require faster and deterministic behaviour of Linux. Among several options, RTAI (Real Time Application Interface) extension was chosen to be used with Linux. Its tracing tool LTT (Linux Trace Toolkit) can monitor and analyse non real time and real time processes and threads. The compilation of a new Linux-kernel is required. Cross-dependencies of patches and adaptation to MSR2000I-hardware have to be considered. Advantages of a 2.4-series Linux-kernel are pointed out for future kernel-upgrades. Several examples based on the newly built Linux-kernel simulate the MSR2000I-system using different real time data exchange methods. Converting some critical parts of the application software is finally done in cooperation with software engineers at EADS.

Several computer and Linux-environments are used for development. A test-system with a single PC104-module and the real environment of MSR2000I is also used.

This paper presents libTRAIN, which is a generic library to control train scale models from a RT-Linux/Linux box. It hides the complexity of the model hardware and provides a high level program interface to applications in both RT-Linux and Linux. libTRAIN is the first piece of software in a project aimed to develop complex real-time applications for controlling train scale models. In this project, the final objective is to have a complete, although academic, testbed for our research lines related to RT-Linux and Real-Time Artificial Intelligence.

In this paper we present the real-time control of an industrial manipulator with RTAI-Linux which has been developed at the Mechatronics laboratory of the University of Modena and Reggio Emilia. The robot is an AXTRON and it is produced by the RRRobotica in Reggio Emilia (Italy). The manipulator is a SCARA-like robot with three degrees of freedom; it has two actuated rotational joints and a manual prismatic joint. The robot is mainly used for micro percussion marking, engraving and glue dispensing. Each rotational joint is actuated by a stepper motor with a resolution of 0.024 mm and the actuated axes are provided with range-delimiters.

The paper presents the interface of an existing open source multibody/multidisciplinary simulation framework, MBDyn, to RTAI/NEWLXRT for hardware/software-in-the-loop simulations of flexible space manipulators.

The adaptation of the multibody software to the needs of real-time simulation required a minimal effort, basically focused on specializing existing input/output facilities to the use of RTAI/NEWLXRT mailboxes and on eliminating or wrapping few system calls.

Preliminary applications to a simulation similar to that of the space robots control are presented, with different levels of sophistication and of integration into real-time control and visualization environments such as Matlab/Simulink Real-Time Workshop through the use of RTAILab.

In this work, a control system developed under RT-Linux is presented. The system consist of an experimental platform for time-response analysis and control of a teleoperated system with one degree of freedom, controlled under different strategies and connected by means a computer network. This platform can be used for testing new strategies for remote control on teleoperated systems. The implementation core is an RT-linux module that uses the COMEDI library to execute the feedback control tasks interacting with the data acquisition board. Communication tasks between the RT-Linux controller and the client graphical user interface (GUI), are based on Java2 and JNI technologies.

This paper presents an assessment of the performance of a real-time controller using an IP network to connect sensors and actuators of a robot. The temporal behavior of network packets and controller performance are characterized and compared against those obtained using a local controller. A method is proposed to compensate network delays and recover the performance of the networked controller. The networked control system is basically composed of two nodes: the robot interface and the controller. The functionalities implemented on both nodes are based on RTAI LXRT hard real-time tasks. In order to test the proposed delay compensation method under various network load conditions, a traffic emulator was developed. The traffic emulator imposes delays to selected packets. These delays are generated accordingly to a statistical model of the network load resembling real network traffic. The traffic emulator is a program based on LXRT that processes network packets queued by Netfilter. A scheduler/dispatcher architecture is used to cope with the statistical nature of delays imposed to packets. Details of the application protocol are discussed and the paper concludes by presenting results comparing control system performance with and without delay compensation for some representative network load conditions.

The MatPLC is an open-source control application, consisting of a core, a collection of modules and tools for creating custom modules (including an IEC 61131-3 IL and ST compiler). Since many control and monitoring systems are required to be hard-realtime, a feature not supported by the present implementation that relies on the standard Linux kernel and scheduler, the provision of MatPLC with hard-realtime capabilities is of great importance.

We outline the MatPLC architecture, consider a number of real-time operating systems, and discuss the design changes required to add hard-realtime capabilities to the MatPLC framework. We also make a preliminary evaluation of the effort required to port the existing code base to the extended framework.

We conclude that some parts of MatPLC will pose no porting problems while others will require significant work. We also pinpoint some inter-process synchronisation features used by the MatPLC that are currently missing in the existing RTOS, and propose ways to overcome this difficulty.

In the present paper we show the guidelines of a project to run a PLC (Programmable Logic Controller) under RTLinux. The first version we present, called boolean PLC, includes a translator for the instructions list PLC programming language, following a subset of the IEC 61131-3 standard. The user gives information about the hardware configuration (such as I/O cards), the software configuration (number of memory bits, and functional blocks) and the task characteristics (period, instruction list related programs). Each task (as defined in IEC 61131-3) is mapped to a thread and they can have access to common objects (I/O images, memory bits, functional block parameters) by means of shared memory. For the whole project, we have adapted the Spiral Model describing development as an iterative six-phase process. The system is being developed according to the ideals of Quality, in agreement with applicable standards (IEC 61131, ISO 9001, ISO/IEC 12207, ISO/IEC9126 and ISO/IEC14598), and adapting them to our small university R&D&I group.

Along the last decade has gone an increasing interest towards the utilization of open hardware and software platforms as support of industrial control applications. Some of the most important works was done withing the frame of the European project named OSACA, in Japan within the OCEC project, and in the U.S. within the OMAC project. Those efforts are goning on the definition of an open architecture for the control of manufacturing systems. The utilization of a PC (personal computer) as the control platform facilitates the conectivity, standardization and availability of components, and the cost reduction. There exists, nevertheless, an aspect that has been slightly analized: the application of these concepts on equipments designed with a propietary control structure.

As the first stage to analize its viability and to evaluate difficulties and limitations, there has developed an open control system for an SCARA industrial robot YAMAHA YK7000. The controller follows the philosophy defined by the OMAC architecture (Open Modular Architecture for Controllers). Control functions have been implanted on a dual platform (two PCs). One of them supports the critical functions (RtLinux) executing the paths planning and axes control tasks connected outside with commercial I/O cards. The second PC supports the interface with the user and other non critical applications. Both computers are connected by a TCP/IP link.

This article deals with implementation of virtual CAN API, CANopen slave device and CAN/CANopen monitor. This open source code, written under OCERA project, is destined for Linux and RT Linux. The virtual CAN API is the interface used to connect the application threads either with the CAN hardware card or with other software layers substituting CAN bus. The application thread can live either in the Hard RT space (RT Linux) or in the Soft RT space (Linux). In the other words we can say that VCA is a layer between the CAN driver and the application threads. CANopen device is a software solution based on CANopen FSM (Finite State Machine) threads, EDS (Electronic Data Sheet) file and HDS (Handler Definition Sheet) file. The device can be CANopen master or CANopen slave. CAN monitor is a component used to scan a CAN bus. It can receive, send and log messages. If CAN device EDS (Electronic Data Sheet) is available CanMonitor offers also basic SDO functionality. Written in Java the CAN monitor is a multi-platform application.

Resource reservation has an increasing interest, specially in systems with limited resources. The aim of this feature is to guarantee a certain resource share for an entity, usually a thread or group of threads. The operating system has to account for resource usage, in order to guarantee on run-time the availability of the reservation. The resource allowance allows applications to commit providing the output with a stable quality or Quality of Service (QoS).

The purpose of this paper is to describe an implementation of a resource management component and its integration in a Linux kernel. In this way it is possible to guarantee CPU reserves or budgets to threads. Linux provides some of the POSIX real-time extensions, which are used to ensure that threads with available reserves execute with higher priority than the rest of the threads. In order to implement the accounting and enforcing facilities with sufficient precision, it has been needed to implement special high resolution timers.

This paper is concerned with free software components dedicated to embedded real-time systems. We are providing a set of components including dynamic schedulers based on the Earliest Deadline algorithm and Fault-tolerance mechanisms based on time redundancy. All these components are designed to be integrated in the open source real-time operating system, Linux/RTAI.

In this paper, we present the integration of the Preemption Patch in RTLinux. This work has been carried out in the context of the OCERA project, which is financially supported by the IST research programme of the European Commission. In the OCERA project, one of the objectives is to provide hard real-time guarantees to RTLinux tasks and soft real-time execution to Linux processes. To this end, it is necessary to obtain low latencies in the Linux kernel. Two different approaches have been proposed in the Linux community: the Low Latency patch and the Preemption Patch. We decided to use the latter for it is less invasive. However, the preemption patch conflicts with the RTLinux patch, becasue both patches modify the interrupt handling routines. We provide a method for let both patches coexist with minimal overhead. Then we show the effectiveness of our approach by reporting extensive performance measurements.

The paper examines the effects of increasing the frequence of the timer interrupt in the Linux kernel from 2.4 to 2.6, by measuring periodical jobs scheduled at different periods with regard to the realtime capabilities of Linux. Linux 2.4 shows timing delays for periodical jobs in between 0 and 20 ms, these delays can be divided by 10 for Linux 2.6. We don't consider busy waits as they block the processor. The HZ macro determines the period of the timer interrupt in the standard Linux kernel. Measurements of the overhead caused by increasing HZ are presented. Formulas for the timing delays that the standard Linux 2.4 and 2.6 timing system cause are given and the timing resolution is compared to that of the High Resolution Timer Patch {2} and other kernel patches originating from the UTIME kernel patch of the University of Kansas {14}. These patches only show timing delays in between tens up to some hundreds of microseconds, because of reprogramming the timer interrupt to the next forseeable timing event.

Of course to work reliable the patches used need to be combined with a Linux kernel which can be preempted at any time. The Preemptible kernel patch that is now part of the Linux 2.6 standard kernel is a good step into this direction, despite of its remaining critical sections.

For several years, the CEA-LIST has studied a new generation of real-time systems development tools. This work resulted in the completion of the ACCORD/UML toolkit which helps users specify, design and implement real-time systems. This CASE tool provides high level facilities for building real-time applications. Starting from a design modeling based on the concept of real-time object, it enables to produce executable code that can run on top of Linux (relying on POSIX threads). Thanks to this approach, application coding can be achieved using generic features offered by the ACCORD middleware package to insure real-time behavior of the application. In this context, Linux is considered as a provider of basic operating system mechanisms. The ACCORD/UML methodology and its toolkit has been tested on various applications from Automotive and Telecom industry in the context of the European project AIT-WOODDES. Moreover, the integration of some OCERA results are currently under analysis in order to introduce fault tolerance mechanisms in the approach. In this paper, we briefly describe ACCORD/UML modeling approach. Then we present its core "real-time object" model and show how real-time constraints are specified. Next, we show the links between the ACCORD middleware and Linux and how they support users in implementing real-time systems on top of Linux.

This paper presents Stand-Alone RTLinux (SA-RTL) which is a porting of the RTLinux-GPL executive to a bare machine. Stand-Alone RTLinux provides the same API than the standard RTLinux-GPL but it do not need Linux to operate. On one hand SA-RTL lacks all the functionalities provided by Linux: lots of drivers, filesystem, graphic user interface, etc; but on the other hand SA-RTL is a faster, smaller, more robust RTOS. SA-RTL enables the use of RTLinux in very small hardware systems with reduced resources. It can be ported to systems with no MMU.

Besides the porting of the RTLinux API we also added two memory protection methods using the MMU (when available).

Operating systems and programming languages offer rich APIs (Application Programmers Interfaces) for programs to interact with time. We study a single function waitperiod, which takes a scalar argument: the period to wait before continuing execution, and returns a scalar: the time since some epoch. By making configuration external to the program, identical source code has been used for implementing a real-time robot controller running on newlxrtrtai and a simulator of the same robot controller running on cygwin.

The problem of reducing energy consumption is becoming very important in the design of embedded real-time systems. Many of these systems, in fact, are powered by rechargeable batteries, and the goal is to extend, as much as it is possible, the autonomy of the system. To reduce energy consumption, one possible approach is to selectively slow down the processor frequency.

In this paper we propose a modification of the Linux kernel to schedule aperiodic tasks in a soft real-time environment. The proposed solution consists in a new scheduling strategy based on the Resource Reservation Framework {Raj98}, which introduces very little modification to the Linux API. Our scheduler is based on Algorithm GRUB (Greedy Reclamation of Unused Bandwidth), presented by Baruah and Lipari {Lip00}.

After presenting the algorithm, we describe its implementation on a Intrinsyc CerfCube 250, which uses a Intel PXA250 processor. We show with an example of multimedia application that, by using our approach, we save up to 38% of energy with respect to an unmodified Linux.

Research in scheduling theory has been one of the most active and fertile areas in real-time. The result of this intensive research was a large number of scheduling algorithms. Most of the times, this policies come to live due to the great variety of applications of real-time and the inherent peculiarities to each one. For example, in multimedia applications CPU reservation was initially implemented using a fixed priority scheduler, but now it has successively been adapted to dynamic priorities, to obtain better CPU utilization and easy reclaiming of the unused CPU time. In control applications, however, it is mandatory to remove or, at least, minimize the delay of control tasks. Fixed priority schedulers do not accomplish this requirement, and several proposals of new scheduling algorithms achieve a better control performance of the system.

Nevertheless, major part of this results had never been implemented in commercial RTOS, which usually only provide a fixed priority scheduler. It is not an easy task to implement new algorithms, since it implies to modify the kernel of the real-time operating system. Users choose the scheduler provided by the commercial RTOS, loosing performance, or they build its own RTOS according to their needs. The last solution is a hard work and can take a long time. Moreover, the great variety of scheduling algorithms difficult its inclusion in the POSIX standard and in real-time operating systems.

Recently, M. Aldea and M. González addressed this problem, and proposed the POSIX-Compatible Application-defined scheduling (ADS) which allows to implement the scheduling policy at the user level. Their proposal has been designed to be included in the POSIX standard.

The aim of this paper is to explain the implementation of the ADS in RTLinux. This will allow to implement new scheduling algorithms that can be ported immediately to other POSIX compliant RTOS.

Task Planning within a real-time system is fundamental for safety purposes. Moreover, on-line reconfiguration for a distributed system is feasible in order to keep efficiency without any system disruption. The modification of Planning Algorithm for on-line reconfiguration is the scope of this work. This is based upon a neural network and a proper quasi-dynamic planning algorithm. The neural network used in this work is named as ART2 network. It has been selected based upon its non-supervised characteristics. Besides, planning scheduler algorithm is used as scheduler algorithm. Integration of both algorithms is achieved by off-line learning of the neural network with those valid and invalid plans. Plan validation is based on system efficiency. Having defined a group of patterns as valid and invalid, the use of the neural network is performed on-line when a new plan tends to be applied to the distributed system in order to be reconfigured. This neural network allows plan distribution to the distributed system during specific time window.

Conventional Unix/Linux systems are based on time-sharing schedulers that do not adequately support applications with QoS requirements, such as multimedia applications. In this project, we built a loadable Variable-Rate Execution scheduler to provide QoS to applications. The scheduler is implemented as a Linux loadable module, which can be dynamically loaded into the kernel to change the Linux scheduler. With the new soft real-time scheduler, users can assign a specified execution rate to any application, which is more precise than either the best-effort time-sharing algorithms or the all-or-nothing POSIX real-time priorities. In addition, users can dynamically adjust the execution rate during runtime.

Since different applications may have different execution rates, it is infeasible to predict the execution rate in general. Instead, we provide an interface for users to associate each variable rate task with a rate controller that automatically adjusts the task's execution rate. We also provide a default rate controller for legacy applications. The default rate controller assumes that the application can suspend itself when it is allocated a higher execution rate than its need. If the suspension time is greater than a upper threshold, the rate controller slows down the execution rate; if the suspension time is less than a lower threshold, it speeds up the execution.

This paper describes our work towards a rapid prototyping system for hard real-time systems focusing on scheduling algorithms and scheduler implementations. The framework aims to speed up the decision making process of a suitable scheduling algorithm for a real-time application. The framework supports various kinds of real-time scheduling algorithms, which can be simulated for evaluation purposes. Furthermore, implementations of these algorithms can be tested in a real-time operating system (RTOS) with real or synthetic workloads. The scheduler algorithms are implemented either as software routines, which are part of the operating system (OS), or are realized in a coprocessor to free the operating system kernel from time consuming scheduling operations. The target operating system of our framework is mainly RT-Linux, even though development for those systems is possible under Linux and Windows as well. The framework proposed in this paper is new in that it supports the selection of the best suitable scheduler based on real-time scheduling analysis.

The complexity of build real-time systems has driven the search of methodologies which help the developers to broach this task. In order to use these methodologies several commercial CASE tools based on them has been designed. These tools support the modelling and the automatic code generation of the systems over a set of platforms, but usually they are very expensive and do not work with every real time operating systems. On the contrary, EdROOM is a free tool for modelling and automatic C++ code generation of real-time systems easily adaptable to work with any RTOS. This paper explains how EdROOM has been adapted for developing real time systems running under RTAI {web3}. The fundaments of the adaptation work are presented and an educational motor control system is also presented as a simple example of use it.

``Simulink Target for RT-Linux''(STRTL) is an application developed to provide a cost-effective alternative to the expensive real-time applications that require specialized software and hardware. The application allows performing a number of laboratory scale hard real-time control experiments, which can be remotely monitored and tuned at run-time from a second computer using a TCP/IP connection. The software packages Matlab, Simulink and Real-Time Workshop (RTW), widely used among educational institutions, are used as a controller algorithm development tool. A performance comparison with the commercial Windows based version Real-Time Windows Target (RTWT) has also been discussed.

STRTL guarantees hard real-time performance, and provides on-line parameter tuning and real-time data plotting that can be exported to MATLAB for post-control analysis. Using STRTL, control engineers and researchers in academics and industry can design control algorithms as block diagrams and implement them in real time. The user-friendly graphical interface based on Simulink dramatically reduces the learning curve.

The purpose of this paper is to introduce STRTL among RT-Linux addicts so that they can explore it further for their future projects.

In today's embedded PC market the use of open source free software is becoming more important everyday. Because of specific requirements it is a challenge to use open source free software for real-time tasks. Problem of efficient hard real-time system development and use of free software as a base for high availability solution is the subject of this paper. In this paper, we are focused to show how open source real-time extension to Linux (RTAI) can be used for specific hard real-time tasks. We have used RTAI Linux extension as a base for real-time device driver for PC/104 synchronous serial adapter. Hard real-time requirements of synchronous serial communication demand a special kind of software design. For meeting hard real-time requirements we have used a standard object oriented notation - UML (Unified Modeling Language). As standard UML is not made for real-time systems, we have adopted and applied UML notation for real-time device driver design. Using UML and free software for solving specific problem we are able to develop a solution that is better than commercial solutions available on the market. The results presented in this paper clearly show that the use UML is one of the best ways for designing hard real-time systems. Also, results achieved in this work are a proof that free software is capable of satisfying most demanding hard real-time requirements.

This paper describes a tool named RTAI-Lab, which provides a common structured framework to design, build, run and monitor any suite of RTAI-based single/multitasking controllers and real time simulators, either specifically coded in a high level procedural language, typically C/C++, or automatically generated by proprietary MATLAB / Simulink/Real-Time-Workshop, and/or fully free open source SCILAB/Scicos/CodeGeneration.

Embedded systems usually can be modeled as finite state machines fed by events, formally known as reactive systems. The dFSM project aims to improve the development of systems that can be implemented with an automata set. The project starts from classical automatas, Moore and Mealy, Harel[1] hierarchical statecharts and Samek[2] Quantum Framework. A framework has been designed to allow to execute every automata as an independent user process that exchanges events using a mechanism based on publication / subscription. The final user has a simple C++ interface that makes the codification process more systematic so he can concentrate completely on modeling phase. The dFSM project is designed in the open source world over GNU/Linux, it has been released under LGPL license and is managed in http://www.sourceforge.net/projects/dfsm

A pooled, shared C++ allocator developed for use with the Standard Template Library (STL) is described. The allocator facilitates communication and control between multiple processes using data organized in STL container classes. The open source system has been compiled and tested on the Linux operating system.

I performed porting to H8/300 architecture of Renesas as very small GNU/Linux system environment. uClinux-2.4.20 runs with advanced mode of H8/300H and H8S CPU. And H8/300 architecture support is done merge of with linux-2.5.68, and development progresses currently. This thesis describes a part peculiar to in H8/300 support. And examination of method to perform real-time processing with CPU which is low-speed and problem to occur in a small system.

uClinux is the alternative of the Linux operating systems for processors without MMU support. Since its introduction, a great deal of MMU-less processors and microcontrollers have broaden their functional capabilities by adopting the services and the API of open-source, POSIX compliant, uClinux operating system. uClinux maintains almost the same services and API with regular Linux and provides embedded systems developers with a complete distribution and a rich pool of ready-to-run applications. The paper provides a solid methodology for porting uClinux 2.4, assuming that the appropriate GNU compiler/linker/binutils toolchain is available. It describes the subsystems of the operating system that require porting and suggests a sequence of steps the embedded systems developers should follow in order to have a functional kernel. Since the kernel is almost useless for application development without a kernel compatible library, the paper additionally makes a brief description of the main parts of the {uClibc} library that also requires porting. We particularly focus on uClibc since it provides the same API with glibc, but is much more lightweight, highly targeting small footprint embedded systems.

In this paper we will describe the work involved in porting a variant of the Linux kernel for MMU-less CPUs (uCLinux) to the ERC-32 platform. ERC-32 is an ESA approved radiation-tolerant SPARC V7 processor developed for space applications, and its interest lies in the open nature of its design and specification in order to increase the availability of development tools, operating systems and application software, and therefore reduce cost of space missions. Making and open operating system like Linux available to this platform makes it even easier to develop embedded applications for ERC-32. This paper includes a description of the work involved in the realization of this Linux port, the customization possibilities of the final product and a description of the provided end-user development environment consisting of GNU tools. Finally, the paper will describe performance testing results and talk about future enhancements.

This paper describes how to port Linux Ethernet drivers to RTLinux-GPL (hereafter RTLinux). It presents an architecture that will let Linux and RTLinux to share the same driver while accessing an Ethernet card. This architecture will let real-time applications to access the network as a character device (i.e. using the standard open(), read(), close(), write() and ioctl() calls) and also would let Linux to use the driver as it always did (ifconfig, route, etc.). This paper also discusses some scheduling policies that will give to RTLinux the highest priority while accessing the Ethernet card.

The amount of software in automatic control and mechatronic systems has been continuously growing in the last years. Within this domain, it is also getting more and more important to have software architectures and frameworks which allow efficient application development. On the other hand, size and computational overhead plays an important role on embedded controllers. For this reason, we have developed a compact software framework for distributed real-time computing which supports a component based system design. For all components, a small number of required common methods is defined. The framework provides uniform communication between the components based on package mailboxes. These mailboxes allow inter-component communication between components on the same system, real-time communication between distributed systems, and also communication between heterogeneous real-time and non real-time operating systems. The current implementation is used for control of autonomous service robots which are equipped with one or two Linux RTAI embedded PCs and a Windows laptop with a Java user interface. The communication and synchronisation between the two embedded PCs is done via real-time Ethernet using RTnet. The non real-time communication is managed by a TCP/IP router. This paper describes the concepts of the framework, the integration of RTnet, and the experiences we have with our robotics application.

This paper presents a software framework called SCOOT-R that was developed in our laboratory to design and implement real-time distributed applications. This architecture allows the exchange of objects between processes running on interconnected computers. It is based on client/server model with real-time extensions. At first, we describe the requirements that led to the development of this system and then we present the features of SCOOT-R that make it a good framework for prototyping multi-sensor automotive applications. The paper describes also the possibilities of our approach to allow the integration of independently designed modules in a coherent real-time system. Finally, we present a typical automotive application involving our system: real-time accurate vehicle positioning on a digital map.