Paper abstracts


A paper copy of the workshop proceedings can be ordered from FRANK Linux Systems.


Industrial and experimental applications

  • Real-Time Linux for Flight Testing Uninhabited Aerial Vehicles and GA Aircraft
    Charles E. Hall
  • Space Robotics: an Experimental Set-up based on RTAI-Linux
    Alessandro Macchelli, C. Melchiorri, R. Carloni and M. Guidetti
  • Flash Storage in Linux-Based Residential Gateways
    Zachi Friedman
  • Real-time Linux in Chemical Process Control: Some Application Results
    Andrey Romanenko, Lino O. Santos and Paulo A.F.N.A. Afonso
  • A Digital PID Controller Using RTAI
    Rodrigo da Silva Guerra, Hermes Jose Goncalves and Walter Fetter Lages
  • Graphic Supervisor of Lung Ventilator
    River Quispe Tacas, Alejandro Palomino Amaro, Adolfo Ascanio Rafael and Carlos Albino Rivera

    • Contributions and architectures

  • A Sample Data Acquisition and Control Application Using RTLab
    Calin Culianu and David Christini
  • Generic Real-Time Infrastructure for Signal Acquisition, Generation and Processing
    Herman Bruyninckx and Peter Soetens
  • RealBOX, A Novel Approach to MiniRTL Implementation for Instrumentation And Control Applications
    Nurpinar Akdeniz and Tekin Aydin
  • Graphical Programming of Realtime Applications with LabVIEW for Linux RTAI
    Thomas Leibner and Gerd Schmitz
  • Pretty Pictures in Hard Real-Time
    P. N. Daly, C.F. Claver, D. Dryden, R. Gomez and B. Abareshi
  • Driver Architecture in a Linux World
    John W. Linville

    • General issues and concepts

  • Teaching Real-Time Control Using Free Systems Software
    Kenneth H. Jacker
  • Loosely Coupled Tool Integration Architecture for Embedded Linux
    Seung Woo Son, Hyung Taek Lim, Chae Deok Lim and Heung Nam Kim
  • GNU Bayonne: Telephony Services for Freely Licensed Operating Systems
    David Sugar
  • Shielded Processors: Guaranteeing Sub-millisecond Response in Standard Linux
    Steve Brosky and Steve Rotolo
  • Improving the Responsiveness of Linux Applications in RTAI
    Luca Marzario, Luca Abeni and Giuseppe Lipari
  • Implementing Resource Reservations in Linux
    Luca Abeni and Giuseppe Lipari
  • Predictability in Embedded Linux and Commercial Requirements
    Masatoshi Iwasaki and Tatsuo Nakajima
  • A Quality-of-Service Enhanced Socket API in GNU/Linux
    Hasan Abbasi, Christian Poellabauer, Karsten Schwan, Gregory Losik and Richard West
  • An Assessment of Real-Time Robot Control over IP Networks
    Gustavo Hommerding Alt and Walter Fetter Lages
  • RTLinux POSIX API for IO on Real-time FIFOs and Shared Memory
    Cort Dougan and Matt Sherer
  • Bandwidth Allocation in RT-Linux
    Vladimir Pajkovski
  • Using Linux Kernel Facilities from RT-threads
    Nicholas McGuire
  • FSMLabs RTLinux PSDD: Hard real-time with memory protection
    Victor Yodaiken, Michael Barabanov, Cort Dougan

    • Papers the author of which was unable to attend

  • Optimal Pulse Patterns Modulator Using Real Time Linux
    David Antonio Ulloa Guzman
  • A Simulation Framework for Device Driver Development
    Yan ShouMeng and Zhou XingShe

    • Abstracts fro which no paper was provided

  • POSIX Application Defined Scheduling on RTLinux
    Josep Vidal, F. Gonzálvez and I. Ripoll
  • A Remote Surveillance and Control System Prototype with RTLinux and RTNET
    Yan Shoumeng and Zhou Xingshe
  • Simulating a Vehicle with RTLinux for the Testing of Transmission Control Units
    Karl Rentsch
  • Calling Plain Linux Device Drivers Functions from Hard Real Time Tasks
    Walter Fetter Lages
  • Yet Another RTAI Interface
    Francesco Mandracci
  • Realtime Dynamic Systems Implementation with DSLib
    Ivan Martinez, Jim Luther and Elbert Hendricks




    • Real-Time Linux for Flight Testing Uninhabited Aerial Vehicles and GA Aircraft
    Charles E. Hall
    Charles E. Hall

    Flight testing of small UAV's requires a small, lightweight computer system on board the aircraft. To obtain quality data and correctly implement control systems the system must have a hard real time operating system.Real Time Linux has been installed on a PC104 system and interfaced to the UAV's tranducers, actuators and radio control system. The system has been used to implement a full set of attitude controllers and a navigator for autonomous flight tests of a UAV. The system has also been used to collect data during flight tests of a general aviation aircraft. The paper will discuss the use of Real Time Linux in the flight critical system.


    Space Robotics: an Experimental Set-up based on RTAI-Linux
    Alessandro Macchelli, C. Melchiorri, R. Carloni and M. Guidetti
    Alessandro Macchelli

    Thanks to a constant research and development activity in the field of robotics and, more in general, of automation, reliable and relatively low-cost machines that can substitute or assist human operators in repetitive or dangerous tasks are now available. In robotics, this is particularly true for applications in structured environment, i.e. when the workspace in which the robot operates is known with great accuracy and precisions. On the other hand, it is obviously of interest the development of applications in ustructured or unknown environments. In this case, control algorithms that can give a sort of human behavior to the machines are needed: in other words, the machines should be characterized by a functional autonomy, i.e. they should be able to modify their behavior on the basis of information acquired in real-time from the environment. In space application, it is of great interest the development of autonomous or semi-autonomous robotic devices that can substitute the astronauts in routine operations in order to free them from repetitive tasks and reduce mission costs. In this work, an experimental setup based on a 6 degrees of freedom (dof) manipulator with a 3 dof gripper designed for a possible application within PaT, the Payload Tutor proposed by ASI (Italian Space Agency), is presented. This system consists of a robotic arm, a vision system, and a gripper. Since the gripper has to interact with free-floating and irregular objects, the vision subsystem provides all the information needed for grasping unknown objects in an optimal way. The robotic arm is a Comau SMART 3-S robot, a standard industrial 6 dof anthropomorphic manipulator with a non-spherical wrist, equipped with the standard controller C3G-9000. Each joint is actuated by a DC-brushless motor, and its angular position is measured by a resolver. In our setup, the controller is only used as an interface between the resolvers and drives on t he robot and a PC running RTAI-Linux. In each sampling period generated by the controller, the real-time control system running on the PC must acquire the data from the encoders, compute the new control input for the actuators and send their values to the C3G-9000. On the robot wrist, both the video-camera and the gripper are installed. The vision system is used to provide visual information about the environment and, in particular, about objects within the workspace of the robot. These information are needed to track a moving object in the workspace with the robot, to move the robot in a desired position in order to grasp an object with the gripper and to automatically calculate the optimal grasping configuration. At the moment, the vision system consists of a monocular camera, connected to a frame-grabber board installed on the same PC that implements the robot control algorithms. By properly moving the robot arm and, at the same time, acquiring images of the object from different points of view, the vision algorithms can give a good estimate of the distance of the object from the robot wrist. This information is essential to correctly move the robot in order to grasp the object with the gripper. Moreover, by means of the vision system, the shape of the object is recognized in order to calculate the better grasping points (target points). The object is caught on these points and the contact forces are properly controlled. Generally, the target points are selected on the basis of a kinematic analysis of a first order model: the resulting points do not depend on the shape of the object and on the geometric characteristics of the gripper. In our case, the target points are calculated by means of a kinematic analysis of a second order model that takes into account also the shape of the object and of the gripper's finger: in this manner, the resulting grasping configuration is more stable. The third component of our setup is the A.S.I. Gripper. It has three degrees of freedom, and is particularly suited for no-gravity manipulation tasks (i.e. in space applications), since it can interact with free-floating and irregularly shaped objects. Its control algorithms are executed on a custom DSP board (based on the TMS320C32 chip). For this board, a loader and a DSP-monitor have been developed under Linux, together with some drivers for the DSP board. Once the object distance and the target points are calculated, the gripper is correctly positioned in the workspace with respect to the object. Then, the fingers are closed and the object is grasped on the target points. At this point, the DSP board executes the control algorithm in order to assure proper contact forces. In the final version of the paper, a detailed description of all the subsystems will be presented, together with some experimental results.


    Flash Storage in Linux-Based Residential Gateways
    Zachi Friedman
    Zachi Friedman

    The availability of new in-home interconnection technologies, combined with the explosion of non PC-based devices, is driving the demand for a single device to connect in-home appliances to the public Internet. The residential gateway, as its name implies, is a central entry and control point at the home for all voice, video and data services, as well as the cornerstone for future services. It is the true enabler of the Age of Information. Embedded Linux distributions play a leading role in this brave new gateway world, surpassing veteran operating systems. What are the do's and don?ts of working with Linux on an embedded gateway design where storage is concerned? How do you address the concern of some 38% of the respondents to a poll that said: ?My main concern about using Linux in embedded applications is insufficient driver support from chip vendors?? What are the pros and cons of NOR versus NAND-based flash storage devices, and how do you choose the right technology for your system? What are the special considerations when choosing a flash file system for a Linux gateway design? How can you avoid data and code corruption and premature flash block expiration? This presentation will discuss the above items, and also focus on the crucial tools needed for a successful, long-lasting Linux-based gateway design as perceived by M-Systems, based on the company's experience with leading OEMs.


    Real-time Linux in Chemical Process Control: Some Application Results
    Andrey Romanenko, Lino O. Santos and Paulo A.F.N.A. Afonso
    Andrey Romanenko

    Many chemical processes require real-time control and supervision in order to operate them safely and profitably, while satisfying quality and environmental standards. As a means to comply with these requirements, it is common practice to use control software based on a proprietary operating system such as QNX, WxWorks, or MS Windows with real-time extensions. To our knowledge, the idea of using Real-Time Linux has not been embraced widely by research and industrial institutions in the area of Chemical Engineering. Nevertheless, recent application reports from other industrial fields indicate that several variants of the Linux operating system, that enable it to be real-time, are an attractive and inexpensive alternative to the commercial software. In fact, several implementations of open source data acquisition and control software, and real-time simulation environment have been developed recently. Moreover, the apparent trend for the number of such applications is to increase. We describe our experience at the Department of Chemical Engineering of the University of Coimbra, with two pilot plants that are under control of a system based on real-time Linux. One of them is a completed project and the other is under development. The experimental set-ups closely resemble industrial equipment and function in similar operating conditions. We hope that this successful application will encourage further deployment of real-time Linux in the Chemical Engineering research and industry.


    A Digital PID Controller Using RTAI
    Rodrigo da Silva Guerra, Hermes Jose Goncalves and Walter Fetter Lages
    Rodrigo da Silva Guerra

    This work presents an implementation of a digital PID (Proportional+ Integral+Differential) controller in a PC machine running RTAI. PID controllers are well known and have a wide range of applications in the control of analog systems such as servomotors. In order to achieve the desired performance the system output (axis position) is feed-back to the PID controller which generates the system input (motor voltage), in a closed loop. The controller computes the error between the desired system output (reference) and the actual system output. Then, the system input, which is the PID controller output, is generated as weighted sum of the error, its integral and its differential. The weighting coefficients are known as controller gains and referred as Kp, Ki, and Kd. The values of the controller gains determines the performance of the closed loop system and even its stability. The design of PID controllers is outside the scope of this paper, however it should be said that its values are very dependent on the sampling rate at which system output is read and the new value for system input generated. Therefore it is highly desirable to have an accurate sampling rate. For typical mechanical systems, the adequate sampling rate is in the range of milliseconds. Thus, well implemented PID controllers are usually hard real time systems. The PID controller described in this work uses the PC parallel port as an analog I/O interface. Just two bits are used. One to read the system output and the other to generate the system input. As the system input and output are analog variables, a technique called Pulse Width Modulation (PWM) is used to generate (and read) analog values using digital signals. This technique is based on varying the duty cycle of a rectangular wave accordingly to the analog value to be represented. By using PWM, an analog interface can be built without the use of conventional A/D and D/A converters. However, the switching rate of the PWM signal should be fast enough to be filtered by the system under control. For typical mechanical systems that means a few hundreds of microseconds. The implemented system can be characterized by four main tasks: Two PWM tasks which generate the input and output signals, a PID task responsible for the controller in a proper sense and a user interface task. Except for the user interface task, each one of the main tasks has its own time requirements which must be accurately met. The user interface was implemented as a plain Linux process using the NCurses library. Real time tasks were provided by threads under LXRT hard real time mode. The implementation of PWM under RTAI using the timing functions provided by RTAI are presented and the convenience of using these functions for actual real time control is discussed. In Particular, the semantics of rt_sleep() is analyzed in details and it is shown that the current semantics can lead to an confusing interpretation of what a periodic task is and what a task period is. Furthermore the current semantics of rt_sleep() is incompatible with the the semantics of rt_busy_sleep(), which can lead to even more confusion. A new semantics for rt_sleep() is suggested and the corresponding implementation presented.


    Graphic Supervisor of Lung Ventilator
    River Quispe Tacas, Alejandro Palomino Amaro, Adolfo Ascanio Rafael and Carlos Albino Rivera
    River Quispe Tacas

    The Units Intensive Cares (UIC) of the Hospitals in Peru, they need of a centralized system that it integrates in a net, the different marks of Lung Ventilator to supervise from oneself place the process of ventilation mechanics, to be a process of high risk; they also need of a graphic monitor of local supervision for the Lung Ventilator that lack this system. The denominated developed system Graphic Supervisor of Lung Ventilator it consists of a sensor of developed gassy flow, a module of acquisition of data to acquire the signs of the process of the ventilation mechanics, software for the graphic user interface monitoreo developed in Linux and Real Time Linux with a net of local area to integrate the Lungs Ventilator. The signs that they supervises are: pressure proximal, breathing flow, relative humidity and temperature of breathing flow. The Graphic Supervisor of Lung Ventilator, allows the professionals of the health to observe the breathing signs of all the patients in a centralized way, this way it can improve the quality of attention to the patients in UIC and to reduce the operative costs for the attention of the patients in the hospitals


    A Sample Data Acquisition and Control Application Using RTLab
    Calin Culianu and David Christini
    Calin Culianu

    RTLab is a software project which provides a cross-variant (RTAI and RTLinux) conceptual framework for biomedical experiment interface. The intent is to provide abstract services on top of RTAI/RTLinux and COMEDI for the rapid development of a certain class of control and measurement applications typical in the biomedical field. Applications that follow a periodic acquire-analyze-control pattern can be quickly written using a plugin-style architecture. A simple control application, complete with code, will be illustrated in this paper.


    Generic Real-Time Infrastructure for Signal Acquisition, Generation and Processing
    Herman Bruyninckx and Peter Soetens
    Herman Bruyninckx

    This paper presents the design for the real-time core of a generic real-time signal acquisition, processing and generation system. The design is generic in the sense that it can be used in a wide variation of application domains, from the PLC logic of MatPLC, over medical signal processing in the RT-Lab project, to the robot motion control of the Orocos project. It's exactly the functional overlap between these projects that has stimulated the presented design, in the hope of gaining more critical mass for the real-time signal processing core of these, and other, projects. The paper only presents the design of an application-independent real-time signal processing infrastructure, and its implementation on a Linux RTOS, but not the protocols and plug-ins to be provided by the applications, on top of this infrastructure.


    RealBOX, A Novel Approach to MiniRTL Implementation for Instrumentation And Control Applications
    Nurpinar Akdeniz and Tekin Aydin
    Nurpinar Akdeniz

    RealBOX is a PC104 form factor computer based on a 486DX2 processor with 8MB RAM and 8MB Disk-On-Chip Millenium. MiniRTL operating system boots from Disk-On-Chip and expands itself to RAM when the power is applied to the box. Our initial aim and the motivation behind our work was to have an embedded system with the following critical requirements which were fullfiled ; -real-time scheduler -operation without HardDisk. -small foot-print (so a solid state memory preferably the Disk-on-Chip) -no file system checks when power goes off and come again We are using the realBOX in our data acquisition and control applications and planning to utilize it for airborne control projects. We are late a little bit to submit this abstract but we strongly hopeful that you will pay attention to our work.


    Graphical Programming of Realtime Applications with LabVIEW for Linux RTAI
    Thomas Leibner and Gerd Schmitz
    Thomas Leibner

    The programming of real-time applications nowadays involves multitasking using timing demands with microsecond resolution, inter task messaging including semaphores for synchronization of multiple running tasks. For solving this task efficiently a programmer likes to use graphical visualization methods for program flow, messaging and priority dependencies. Instead of using graphical methods only for debugging and schematic overviews of analysis problems typical for real-time and multitasking, the graphical programming environment LabVIEW(tm) by National Instruments provides state-of-the-art tools for solving programming tasks by just doing graphical formulation of algorithms and data flow. One major disadvantage of LabVIEW, not being able to be used as programming environment for hard real-time in kernel space, could be eliminated using the user space API 'LXRT' of the RTAI 'Real Time Application Interface' for Linux. It is shown, that by implementing a generalized call interface to the 'LXRT' , the user space API of RTAI could be integrated into LabVIEW for Linux. By this extension it is now possible to perform with hard real-time using graphical user space programming. The visual data flow programming of LabVIEW easily visualizes timing and synchronization dependencies. Although the full LXRT API hasn't been implemented yet, a basic set of timing and data acquisition functions for hard real-time are shown to be working. A jitter as low as five microseconds on a Pentium III/500MHz makes it possible to have 20 kHz loops with sophisticated computing, e.g. PID closed loop control and audio filtering, by just doing graphical programming. This is another example of the power of the LXRT user space API of the Real Time Application Interface for Linux, giving us the possibility to do hard real-time from user space.


    Pretty Pictures in Hard Real-Time
    P. N. Daly, C.F. Claver, D. Dryden, R. Gomez and B. Abareshi
    P. N. Daly

    The WIYN Tip-Tilt Module (WTTM) was developed as an adaptive optics solution to image degradation due to atmospheric instability and dynamics. The WTTM was successfully commissioned onto the WIYN 3.5m telescope in February 2002 and it currently undergoing shared risks commissioning. In this paper we review the hardware and software design of the WTTM and present some spectacular results from the commissioning data.


    Driver Architecture in a Linux World
    John W. Linville
    John W. Linville

    Vendors of modern networking hardware realize that the devices they provide require a great deal of software in order to function effectively. As a result, many hardware vendors provide large amounts of software for use with their devices. However, the prevalent use of the VxWorks® operating system has allowed hardware vendors to become careless with the architecture of the driver software they provide. Often the driver software provided by hardware vendors is difficult to use in a protected environment like Linux®. This paper begins by discussing strategies for making use of such drivers in a Linux environment, and continues by discussing how hardware vendors might architect Linux-friendly driver software. Finally, the paper discusses how vendors can provide first-class Linux support for their hardware and why it is in their best interest to do so. This paper is a must read both for system integrators new to Linux and for driver software architects unfamiliar with the Linux environment.


    Teaching Real-Time Control Using Free Systems Software
    Kenneth H. Jacker
    Kenneth H. Jacker

    The paper begins with a short description of the Department's real-time course and its required group projects. This is followed by an overview of the hardware and systems software used in a specific real-time control laboratory assignment. After a discussion of the analysis, design, and implementation of the project, the paper concludes with a brief look at future work.


    Loosely Coupled Tool Integration Architecture for Embedded Linux
    Seung Woo Son, Hyung Taek Lim, Chae Deok Lim and Heung Nam Kim
    Seung Woo Son

    When developing applications under embedded Linux, there is a range of software tools to assist the development process. However, they are so tightly integrated that it is not only difficult to integrate into IDE but hard to add an additional tool. They are communicating with each other through their own protocols so that there is much communication overhead between host and target machine. In this paper, we propose loosely coupled tool integration architecture based on lightweight RPC mechanism. The proposed architecture is mainly composed of two agents running on host and target side respectively. To integrate various tools in a seamless way, we suggest well-defined host-to-target protocol and inter-tool protocol. Host agent mediates request from several host tools and interacts with the target agent. The host agent set out a set of common APIs needed for host-resident tool integration. The target agent, the counterpart of the host agent, is a kind of debug demon which serves request from the host agent. As designed for embedded software development, the size of target side agent is about 100KB and consumes less than 5% of CPU time. With the proposed architecture, we easily integrate various host tools using open APIs with low overhead target agent.


    GNU Bayonne: Telephony Services for Freely Licensed Operating Systems
    David Sugar
    David Sugar

    In this paper I will talk about the needs and requirements to successfully implement telecommunication services under GNU/Linux, particularly in terms of media processing, both for traditional telephone networks and IP based ones, as well as discussing the GNU projects recent efforts in these areas, particularly in the development of stable high performance and scalable RTP transport (GNU ccRTP) and in the development of GNU Bayonne (the telephony server of the GNU project), and how realtime kernel services impact this area of development.


    Shielded Processors: Guaranteeing Sub-millisecond Response in Standard Linux
    Steve Brosky and Steve Rotolo
    Steve Brosky

    Shielded Processors: Guaranteeing Sub-millisecond Response in Standard Linux By Steve Brosky Chief Scientist Concurrent Computer Systems There has been much good work in making standard Linux into a more responsive system for real-time applications. The low latency patches and the preemption patches have allowed guarantees on worst case interrupt response time at slightly above a millisecond. These guarantees today are only met when there is no networking or graphics activity in the system. The shielded processor concept dedicates selected processors in a symmetric multiprocessing system for the real-time components of an application. This paper will describe the implementation of shielded processors in RedHawk Linux and the benefits of shielded processors. It will also present the results of benchmarks for both interrupt response and program execution determinism. Interrupt response time guarantees are significantly below one millisecond and can be guaranteed even in the presence of networking and graphics activity.


    Improving the Responsiveness of Linux Applications in RTAI
    Luca Marzario, Luca Abeni and Giuseppe Lipari
    Luca Marzario

    RTAI is a real-time kernel that permits to execute, on the same physical machine, both hard real-time applications and the Linux Operating System. RTAI is particularly useful when dealing with real-time processes that needs a guaranteed low response-time to interrupts. By using a fixed priority scheduler provided with RTAI, it is also possible to schedule periodic hard real-time, and to guarantee the schedulability of the system. In this framework, Linux is assigned the lowest possible priority, and it is scheduled in background, i.e. when no other real-time task requires execution. This is the simplest way to guarantee that the behaviour of the real-time tasks is not compromised by the behaviour of Linux applications. However, in certain cases, under high real-time load, this method can be too restrictive for Linux applications. In certain cases, it is useful to mix hard real-time and soft real tasks activities in the same system. Hard real-time tasks represent critical activities that must finish before their assigned deadline, otherwise the system correctness is compromised. Soft real-time system represent non critical real-time activities: they are required to finish before their deadline, but occasional deadline misses do not compromise the correctness of the system. The most popular example of soft real-time application is a multi-media player: if some video frame is not displayed on time, or if it is skipped, nothing catastrophic happens. The ratio of deadline misses over a given interval of time can be taken as a measure of the Quality of Service (QoS) experienced by the final user: the lower the dealine miss ratio, the better the QoS. Soft real-time multimedia applications are usually executed on Linux mainly because many drivers, libraries and tools for video and sound systems are already available on Linux. When soft and hard real-time applications share the same physical machine, one possibility is to schedule hard real-time tasks as RTAI tasks, so guaranteeing a bounded response time; and soft real-time tasks as Linux processes. However, since Linux is assigned the background priority, the amount of execution time assigned to Linux processes over a given time interval depends on the requirements of the RTAI tasks and can vary a lot from interval to interval. Therefore, the amount of execution time that multimedia streams will receive is quite irregular, and it is difficult to guarantee a-priori a certain level of QoS. In this paper, we propose to apply a well-established technique in the real-time system literature, called Resource Reservation, to RTAI. In particular, we changed the RTAI scheduler to implement the Earliest Deadline First (EDF) scheduling policy and the Constant Bandwidth Server (CBS). With CBS, every task is assigned a capacity Q and a Period P, with the meaning that a task is allowed to execute at least Q unites of time every P units of time. A hard real-time task is assigned a capacity Q greater or equal to its worst case computation time and a period P equal to the task's period. Linux is assigned a capacity and a period as well, that depend on the QoS requirement of the soft real-time applications that execute on Linux. The system is schedulable if $sum_i{frac{Q_i}{P_i}}$. At run-time, every task has a remaining capacity q and an absolute deadline d. According to EDF, the task with the earliest deadline is scheduled to execute. At run-time, Linux is treated exactly as any other hard real-time task: initially, it is assigned an absolute deadline $d = P$ and a remaining capacity $q = Q$. When the capacity of Linux is finished, its priority is decreased by postponing its absolute deadline to $d = d + P$, and its capacity is recharged to $q = Q$. In this way, Linux cannot jeopardize the behaviour of the hard real-time tasks, but it is guaranteed a minimum execution time of Q every period P. This mechanims has very little overhead at run-time. Moreover, it has another advantage in the debug phase. During the development of a hard real-time task, it can happen that the task goes into an infinite cycle. For example the task might actively wait for a condition that does never happen. With a pure fixed priority scheduler, it is quite difficult to see what happens, because Linux is scheduled in background and will never execute again. Instead, with our scheduler, Linux is guaranteed a minimum execution time every period: therefore, the programmer can still record the trace and see the logs indicating the situation. In this paper, we implemented the proposed scheduler under RTAI. It is worth to point out that the proposed mechanism is very general, and it can be implemented with little effort in RT-Linux as well. Then, we run a series of experiments that show the advantages of using our mechanism over a pure fixed priority scheduler with Linux in background. We run some simple hard real-time application consisting of 5-10 tasks with different loads, and a mpeg-player under Linux that receives the multimedia stream from a remote host through ethernet. We measured the jitter experienced by the mpeg player: by using methodology, the ``regularity'' of the player is much higher than using the plain fixed priority scheduler. The paper is organized as follows: after a brief descrpition of the Constant banwidth Server (CBS), we describe our implementation in RTAI and discuss the overhead. Then, we describe the experimental setup and we report the results. Finally, we draw the conclusion and discuss future improvements.


    Implementing Resource Reservations in Linux
    Luca Abeni and Giuseppe Lipari
    Luca Abeni

    With the recent development of kernel patches for implementing kernel preemptability and high-resolution timers (and the acceptance of the first patch in the 2.5 development kernels), supporting real-time applications in Linux user-space is no more a dream. However, real-time applications must be run using the POSIX fixed priority scheduler, and we believe that this solution presents a number of problems: for example, either a non-root user is not enabled to run real-time applications (hence, real-time support is useless for most users), or it has the power to starve all the other users' processes (even the daemons, and the root's processes). It is our opinion that to safely support real-time applications a multi-user OS such as Linux should provide Resource Reservations to enable users to access the real-time facilities without being able to starve the system. Resource Reservations are not a new concept, and they have been implemented in some Linux variants (the most notable is Linux/RK). In this work, we propose a new implementation, that fundamentally differs from the previous ones in some important points: 1) Our implementation is non-intrusive, i.e, the whole reservation scheduler is a kernel module that can be loaded at run time, and requires only few changes to the kernel; 2) Since the modifications to the Linux kernel are very limited, we can easily upgrade to new kernel versions, or take advantage of new features implemented in Linux, such as kernel preemptability and high-resolution timers; 3) The scheduling infrastructure that we use is very general, and can be used to implement other loadable schedulers; 4) Compatibility with standard Linux is maintained; 5) Thanks to the algorithm that we implemented (the Constant Bandwidth Server - CBS) and to the careful design of the scheduler infrastructure, our scheduler can cope with aperiodic task arrivals (and with tasks that block and unblock), that cause problems in other reservation-based systems. In this paper, we present the design of our scheduler (showing also how to implement different schedulers based on the scheduling infrastructure that we propose), we compare it with some previous works, and we present a preliminary performance and overhead evaluation. Finally, we describe how a user-level or kernel-level QoS manager can be implemented based on our scheduler, and can be used to enforce a CPU allocation policy, to avoid that a single user can reserve too much CPU to its real-time applications.


    Predictability in Embedded Linux and Commercial Requirements
    Masatoshi Iwasaki and Tatsuo Nakajima
    Masatoshi Iwasaki

    In Japan, many campanies who are building complex embedded systems such as cellular phones and degital televisions are considering to adopt embedded Linux for their products. Most of these companies have been adopted the ITRON real-time operating system as their operating systems, but the functionalities are not enough to build complex embedded systems because ITRON does not provide memory protection, and file systems and network systems are provides as additional middleware components. Many future embedded systems need to access various services on the Internet, and Linux already provide a lot of middleware to reduce the development cost dramatically. Japan Embedded Linux Consortium consists of over 100 companies in Japan is now dicussing on how to migrate from ITRON-based embedded systems to Linux-based embedded systems. Especially, many campanies are interested in whether embedded Linux can satisfy timing constraints for their products or not. Our paper describes requirements on timing constraints that should be satisfied in their products. We have been discussing the requirements in Real-Time Working Group of Japan Embedded Linux Consortim, and we like to show whether current Linux can satisfy the requirements.


    A Quality-of-Service Enhanced Socket API in GNU/Linux
    Hasan Abbasi, Christian Poellabauer, Karsten Schwan, Gregory Losik and Richard West
    Hasan Abbasi

    With the increase in available network bandwidth and reduction in network latency, more emphasis has been placed on End-Host QoS to provide quality of service guarantees for distributed real-time applications, such as video streaming servers, video conferencing applications, and VoIP applications. End-host QoS requires support from the underlying operating system (OS) in the form of network schedulers and traffic controllers. GNU/Linux supports a variety of network schedulers for the provision of end-host QoS, but no easy-to-use API is provided between applications and system-level traffic controllers. Moreover, existing APIs lack the ability to link QoS attributes with stream or datagram sockets and to associate QoS information with individual packets allowing sophisticated network schedulers to make scheduling decisions based on such information or to link different streams such that their QoS management is coordinated. We propose an extension to the standard Berkeley socket interface that enables applications to easily create and manage connections with QoS requirements. This new API -- called Q-Sockets -- includes per-socket traffic classification that allows the application developer to link a socket connection with a scheduler so that all data going out on this socket is scheduled accordingly. We further allow an application to pass packet-specific parameters to the scheduler for fine-grained scheduler control. Finally, we provide functionality to allow developers to link multiple sockets for the coordinated scheduling of packets on these sockets. We evaluate our approach with a multimedia application using Q-Sockets and a real-time packet scheduler.


    An Assessment of Real-Time Robot Control over IP Networks
    Gustavo Hommerding Alt and Walter Fetter Lages
    Gustavo Hommerding Alt

    This paper presents an assessment of the performance of a real time controller using an IP network to link the controller, the sensor and the actuator. This control system is part of a anthropomorphic robot manipulator with two arms and a pan-and-tilt stereo vision head, totalizing 19 joints. Each joint has an actuator, an incremental encoder, an electromagnetic break and an inductive contact sensor. There are also two six-axis force sensors. In order to cope with all devices an distributed control system was implemented. The devices are all connected to an IP network and the real time control loops are configured by software and run over the IP network. The real time requirements of the control loops, which must run at 100Hz rate, are enforced by using RTAI in LXRT hard real time mode. RTAI is also used for monitoring the time behavior of the network packets, in order to deal with the best-effort of assumption of the IP network. Indeed, an IP network assures that it will do its best effort to deliver each data packet, but there is no guarantee that the packet will be delivered. However, a real time control loop must run at an accurate rate or the system performance or stability will be impacted. Therefore, sensor data must be feed to the controller at the same rate, or it will not be able to compute the control action. Hence, the ability of the IP network to deliver the packets with reliability and rate accuracy is very important. Of course, IP networks were not designed with such applications in mind, but it is very difficult to neglect the low-costs due to mass-production. The time behavior and the performance of a controller implemented over an IP network is characterized and compared with those obtained with a local controller. A method to deal with lost packages is also proposed. The key to this method is to note that a control network does not carry digital data in the same sense a generic computer network. A control network carries control signals in a digital format, hence the corruption of the digital data can be tolerated as long as the control signal can be recovered. This paper proposes a method to recover the control signal even in the presence of lost or late packets.


    RTLinux POSIX API for IO on Real-time FIFOs and Shared Memory
    Cort Dougan and Matt Sherer
    Cort Dougan

    The primary means of communication between RTLinux tasks and Linux tasks are realtime FIFOs. They were limited by the fact that there was a static number of them and their names were limited to /dev/rtf0 through /dev/rtfXX. Starting with RTLinux/Pro 1.2, we have added a means for creating real-time FIFOs with arbitrary names and locations that can be created and operated on just as with ordinary UNIX FIFOs.


    Bandwidth Allocation in RT-Linux
    Vladimir Pajkovski
    Vladimir Pajkovski

    In systems intended for handling continuous media (both video and audio), standard Linux does not provide suitable scheduling of the system resources regarding the complexity of the tasks. Where such a system consist of mixed applications, conventional computing is executed at the same time with hard real-time tasks, single scheduling policy is not able to satisfy the demands of the real-time application. If proportional resource allocation is applied, each task can recive a fair share of a resource. Different sheduling policies are appropriate for diffent applications. In that matter, few Fair-sheduling algorithms are tried out. Fair-sheduling algorithms make sure that each resource gets proportional share of the CPU while executing the task. For implementing the algorithms and testing behaviour of the application, RT Linux is used.


    Using Linux Kernel Facilities from RT-threads
    Nicholas McGuire
    Nicholas McGuire

    RTLinux has been focused on developing a POSIX compliant RTOS layer that operates below Linux - within this development communication between RT-threads and kernel as well as user-space have been quite limited, in part due to the inherent restrictions of a RTOS and in part due to the restrictions imposed by POSIX, or rather the combination of these two sets of restrictions. As RT-threads are operating in the same address-space as the Linux kernel itself it seems natural to investigate what capabilities within the Linux kernel could be made available to RT-threads as to enhance communication paths too and from user-space and non-rt kernel-space. In this paper a few of these, very non-portable, absolutely non-POSIX, paths are described. The main resources of interest to RT-threads being: Tasklets, Kernel Threads, Software interrupts, Global Variables. Accessing Non-RT facilities in kernel space Presenting a few simple examples the mechanisms and problems with utilizing these capabilities of the Linux kernel from within RT-context are discussed.


    FSMLabs RTLinux PSDD: Hard real-time with memory protection
    Victor Yodaiken, Michael Barabanov, Cort Dougan
    Victor Yodaiken

    This paper describes the process space (user mode) real-time facility on RTLinuxPro. The Process Space Development Domain (PSDD) is available on PowerPC and X86, supports SMP, and has extensive support for developing simulations including a secondary frame or slot scheduler. The API is a subset of the standard RTLinux POSIX Threads API and, in fact, process space threads can be recompiled to run as kernel space threads with no program-ming changes. The standard debuggers work with process space threads. One useful feature of PSDD is that process space threads share memory with the host UNIX process and are able to, for example, dynamically update variables shared between real-time I/O threads and a non-real-time simulation. PSDD supports use of Fortran and C++ as well as C. The paper covers: Real-time and memory protection; Overview of Process Space Real-Time and examples; The Frame Scheduler and examples; Technical Overview and API; Credits and History.


    Optimal Pulse Patterns Modulator Using Real Time Linux
    David Antonio Ulloa Guzman
    David Antonio Ulloa Guzman

    Since that microcontrollers and DSP's stated to be used in power electronics many ideas could be realized and the Optimal Pulse Pattern Modulator was developed together with the Trajectory Controller in order to correct its problem. Working in this kind of research one need a stable and comfortable system which must be flexible to make almost any change. According to that a combination between a Hitachi SH2 core and a personal computer under Real Time Linux was implemented. This paper describes some aspects about the theory of this modulator, how that was implemented and shows results obtained with this system.


    A Simulation Framework for Device Driver Development
    Yan ShouMeng and Zhou XingShe
    Yan ShouMeng

    Proprietary I/O devices are often involved in many computer application systems,especially in embedded systems. In such scenarios, Developers have to develop drivers for these devices to utilize them under some embedded operating system. Traditionally, development of device driver can undertake only after hardware design finishes, for the writing and debugging process involve many interactions with real hardware. However, with the increasing competition among corporations, shorter time to market is important for a successful production. To shorten the development cycle of device driver, this paper propose that using a simulation device as the target of driver's operation. Previous works on device simulation focus on how to support development of application level software. VxSim[1], a component in Vxworks Tornado environment for platform simulation, only support application software which requiring very simple interactions with hardware, but is not suitable for software with extensive device accesses, especially device drivers. A simulation development method for device drive is proposed in paper[2], which simulate all system routines in a application and compile and link the driver source code with the application together. This method can only make some testing work on device driver, but cannot support the simulation of the running of the entire application system that based on the device driver. This paper presents a device simulation mechanism based on an abstraction model of I/O devices. Then a simulation framework for device driver development is discussed. This framework can effectively support writing and debugging of device driver without the need of hardware existence. For the running of application software is relying on the underlying device driver, it is natural that this framework also supports the development of the entire system without requiring hardware involvement.


    POSIX Application Defined Scheduling on RTLinux
    Josep Vidal, F. Gonzálvez and I. Ripoll
    Josep Vidal

    Although in the last years many scheduling algorithms has been proposed, just few of them has been truly implemented in real RTOS. In most cases, the availability of RTOS source code or the complexity and risks involved in introducing new politics in kernel, causes that major part of nowadays RTOS only implements fixed priorities politics. To solve this, M. González (Universidad de Cantabria) is proposing a new POSIX standard called application-defined scheduling, that allows to introduce new scheduling politics without having to modify O.S. kernel's. This paper describes our experiences in the implementation of application-defined scheduling in RTLINUX. With this feature, several application-defined schedulers, implemented as special threads, can coexist in the system in a predictable way.

    A Remote Surveillance and Control System Prototype with RTLinux and RTNET
    Yan Shoumeng and Zhou Xingshe
    Yan Shoumeng

    An embedded real-time system prototype for remote surveillance and control is presented. The system consists of an embedded single-board and a few simulators for devices of which status is monitored and behavior is controlled. These components are connected through a fast switch via which the status information of devices is sent to the single-board computer periodically. And then the single-board computer will publish the status information to Internet or Intranet through an embedded web server called GoAhead. The operators can browse the status of devices and issue device control command via any standard browser (e.g. IE or Netscape) without additional client side software installation bother. To guarantee the timely data collection of the single-board computer, RTLinux was employed. But considering RTLinux cannot access network on the RT side, we employed the RTNET, which implemented a IP stack on RT side. The data is collected by a real-time task and then fed to a user space process via FIFO and share memory. The application code for client side was a JAVA applet and would be downloaded upon the operator¡¯s browse request. The applet runs on the client side and provides the graphical presentation of data and the operating interface for operator. This prototype system will have broad application scenarios, such as Device Remote Surveillance system especially the remote monitoring of device that located in the distant mountain and hazardous scenario.

    Simulating a Vehicle with RTLinux for the Testing of Transmission Control Units
    Karl Rentsch
    Karl Rentsch

    As part of the software development cycle engineers regularly need a systematic method of testing a product prior to release. In the automotive industry this testing is critical to the safety of the users. Complex embedded control units must be tested under precise conditions representative of an automobile. This paper looks at the signals and system requirements necessary to simulate a vehicle environment in hard real-time, the development of an automated test facility for an embedded transmission control unit and the RTL tricks and techniques used along the way. Many of the complexities in developing a vehicle simulation lie in the diverse range of signals required. In the past vehicle manufacturers have relied on wiring looms to share signals between sensors and electronic modules. Today, in-vehicle networks are replacing the need for looms and simplifying the sharing of information between electronic modules. Any vehicle simulation must be able to synchronize packet data with digital and analogue signals and be highly configurable. Extended simulations require an efficient method of describing a sequence of time critical events. These sequences must combine all data types, be repeatable with sub-millisecond precision and provide a true representative of in-vehicle signals. This paper describes the use of language tools, operating from user-space, cleverly controlling real-time signal sequences One of the best methods to verify the simulation is by recording I/O signals in-vehicle for direct comparison. By developing a miniRTL based “black box” we created an in-vehicle data recorder backward compatible with the test facility. This not only allows vehicle signals to be logged but also replayed as a real-time simulation at will. This paper describes methods of data synchronization, the development of language tools for writing real-time signal sequences, the incorporation of a miniRTL based system in the recording and playback of vehicle signals and automated processes for benchmarking the controllers behavior.

    Calling Plain Linux Device Drivers Functions from Hard Real Time Tasks
    Walter Fetter Lages
    Walter Fetter Lages

    Processes running under plain Linux usually access I/O devices through device drivers implemented monolithically in the kernel or as loadable kernel modules. This has the advantage of exposing standard interfaces for all I/O devices and enables processes running without root privileges to access I/O. Unfortunately, hard real time tasks can not use the standard kernel interfaces to I/O devices, since that would force an execution of kernel code, which does not comply with the hard real time requirements. This problem has been dealt with by implementing special device drivers to be used by real time tasks. Nonetheless, those special device drivers adhere more to the concept of a library than to the concept of a device driver. Each special device driver exposes his own set of functions that can be called by real time tasks, but there is not a common set of functions among all special device drivers. In other words, the concept of uniformity is not implemented. Obviously, it is highly desirable to use the same device driver for programs running under plain Linux or under real time. If soft real time is enough for the application, LXRT can be used. LXRT tasks runs in user space but under control of the real time linux scheduler. By running under user space, LXRT tasks can use standard C library calls to access I/O through standard device drivers. However, to access the device driver a portion of the plain Linux kernel code is executed on behalf of the LXRT task. Since the temporal behavior of the kernel code is not deterministic, the real time scheduler is force to switch the LXRT task to soft real time mode while it is executing kernel code. This paper addresses that problem and shows that under some assumptions it is possible to avoid the switch to soft real time mode while accessing device drivers and therefore the hard real time properties of the task are retained. By using the method proposed in this paper, the very same device driver can be used by plain Linux processes, by hard real time tasks running in kernel space, by LXRT tasks running in soft real time mode and by LXRT tasks running in hard real time mode. The effectiveness of the method is demostrated by the implementation of a device driver for a robot controller. Test programs written in C++ as plain Linux programs, as real time kernel modules, as LXRT soft real time tasks and as LXRT hard real time task, all accessing the controller through the device driver have their temporal behavior discussed.

    Yet Another RTAI Interface
    Francesco Mandracci
    Francesco Mandracci

    The described library is a software level that enables modules to run either in user-space (POSIX threads) or real-time (RTAI tasks), without filling up the code of ifdef and forcing a well-defined code structure. It is different from LXRT: here we twice compile the same source code in order to obtain a user space executable and a kernel module. The library provides a software abstraction for: threads, semaphores, memory allocation, timing, fifo-byte-queues (memory ring buffers, named pipes, rtai fifos and tcp/ip sockets). Moreover threads/tasks needs to be structured in a strict way: each thread/task must provide five callbacks, init(), start(), step(), stop() and destroy(). Each callback must return, no infinite loops allowed. The timing source in user space is the operating system clock. In real time you can choose among the RTAI timing, one interrupt (say IRQ 7), one PCI timing source. 1) What you loose You won't be able to use the full POSIX and RTAI interfaces. And in user space you won't be able to write your main() function. 2) What you gain You gain a known-to-work structure to start from. You gain the ability to run the same source code in user space and in real time. You can less painfully debug an algorithm in user space and then try it in real time. 3) Past to present The library was developed for a numerical control for a laser cutting machine, with timings of 30 ms in user space and 0.1 ms in real time. The timing source is the same PCI servo board used to control the motors. 4) Future The process of releasing it with GNU General Public License is in progress.

    Realtime Dynamic Systems Implementation with DSLib
    Ivan Martinez, Jim Luther and Elbert Hendricks
    Ivan Martinez

    The Dynamic Systems Library (DSLib) is a newly developed interface tool for use between block-diagram modelling and realtime programing. DSLib is a set of C++ classes representing components of block-diagram modelling: blocks (functions, integrators, summing points...), inputs, outputs, schedulers, etc. Such classes can be used in standard C++ code to define simply a dynamic system from a block-diagram approach. Once the system is properly defined, DSlib classes generate the implementation of the dynamic system for a specific realtime operating system (DSLib and RTAI, at the moment). DSLib has the following advantages with respect to ease of implementation: - It is an easy tool for users familiar with dynamic systems modelling. There is a direct equivalence between a block diagram and its DSLib definition. - It encapsulates the target operating system, so standard C and C++ is the only required programming knowledge. DSLib will generate the specific functions for realtime threads definition and interaction, memory managing, etc. For interaction of the dynamic system with the external world, DSLib also provides classes to easily define realtime fifos, shared memory, and even hardware inputs and outputs by using the Comedi library. From the point of view of the software developer, DSLib can be the kernel of any dynamic system modelling application. For example, a Matlab-like application can be obtained by just adding a user interface. For more info, please visit http://dslib.sourceforge.net/