Scilab/Scicos and Linux RTAI - A unified approach

Roberto Bucher and Silvano Balemi

Abstract— This paper presents a Rapid Controller Prototyp-ing environment completely based on open source software.GNU/Linux with the RTAI extension is used as a hard real-timeoperating system. The Scilab/Scicos suite permits performanceof all phases of the control system design. A modified Scicoscode generator directly generates the C-code for the LinuxRTAI environment. Finally, the generated hard real-time taskruns as a user space application on a standard PC using theCOMEDI drivers to interface with the real plant. A GUIapplication facilitates the user to interact with the runningreal-time task (data visualization, data collection, parameterstuning) directly from any PC in the network.

All needed software is available on the web and can be freelydownloaded.

Some applications are presented to demonstrate the poten-tialities of the presented suite.

I. INTRODUCTION

Rapid Controller Prototyping (RCP) requires two compo-nents: a Computer Aided Control System Design (CACSD)software and a dedicated hardware with a hard real-time operating system. One of the most widespreadRCP environments is based on the commercial softwareMatlab/Simulink/Realtime-Workshop CACSD software ([1])which can be used to generate and compile codes fordifferent targets. The main disadvantage of this solution isthe cost of the needed software.

The software of the proposed solution can be freelydownloaded from the web. It is based on Scilab/Scicos andLinux RTAI, a hard real-time extension of the GNU/LinuxOperating System developed at the Dipartimento di Ingeg-neria Aerospaziale del Politecnico di Milano (DIAPM) ([2]).A modified version of the Scicos code generator has beenimplemented in order to produce code which is compatiblewith Linux RTAI.

This environment allows to quickly create real-time con-trollers for real plants by generating and compiling the fullcontrol application directly from the Scicos scheme. A newScicos library contains all the blocks needed to interfacethe controller with the plant (COMEDI blocks) and withmonitoring applications such as xrtailab ([3]) or rtai-xml([4]). This library also provides a set of input signals.

The user can perform all phases of control system design(see Fig. 1) within a unique environment.

The generated application runs as a normal user spacehard real-time application on a standard x86 computer,using drivers provided by the COMEDI project ([5]) orimplemented by the user to interface with data acquisition

The authors are with the Department of InnovativeTechnologies, University of Applied Sciences of South-ern Switzerland, CH-6928 Lugano-Manno, Switzerland{roberto.bucher,silvano.balemi}@supsi.ch

specification

modellingidentification

controldesign

simulation

implementation

verification

Fig. 1. Control system design phases

boards. Then, the generated hard real-time task can be locallyor remotely monitored using an external GUI application.The tuning of the task parameters is also possible.

Section II gives an overview of the different tools andit explains how to obtain them. Section III gives a moredetailed description of the interface between Scilab/Scicosand Linux RTAI. An industrial example is presented insection IV. Finally, section V presents some conclusions andthe future issues related to this project.

II. THE TOOLS

A. Scilab/Scicos

Scilab ([6]) is a scientific software package for numericalcomputations providing a large set of functions for engi-neering and scientific applications. It has been developedsince 1990 by researchers from INRIA (Institut Nationalde Recherche on Informatique et on Automatique, [7]) andENPC (Ecole Nationale des Ponts et Chaussee, [8]) and it canbe freely downloaded from the Internet. Scilab is currentlyused in educational and industrial environments around theworld.

In June 2004 INRIA released Scilab 3.0 which containsseveral improvements.

Scilab now includes different toolboxes and the possi-bility to add programs written in various languages (C,Fortran, . . .). It contains high-level data structures includ-ing arrays, lists, polynomials, rational functions and linearsystems. The syntax is very similar to that of Matlab andthe porting of applications written for this environment isvery easy.

Scilab integrates different control design specific tool-boxes:

• General System and Control Toolbox

Proceedings of the2005 IEEE Conference on Control ApplicationsToronto, Canada, August 28-31, 2005

TC5.5

0-7803-9354-6/05/$20.00 ©2005 IEEE 1121

• Robust control toolbox• Arma modelling and simulation toolbox• Identification toolbox

Scilab contains a tool called ”Scicos” which allows theimplementations of block diagrams in a graphical mode.Simulation of the designed scheme can be performed di-rectly from the Scicos window. Since version 2.6, Scicoshas been completed with a code generator which translatesthe graphical scheme into C-code. This C-code generator(”CodeGeneration .sci”) produces two kinds of objects:

• A dynamic library used in the scicos scheme to substi-tute blocks with compiled code.

• A set of C files that can be used to produce a stand-alone executable code.

Scilab doesn’t deliver a ”main” file needed to producea stand-alone executable. Input and output signals have tobe integrated by hand in the code because the standard I/Oscicos blocks can’t be handled by the code generator.

B. Linux RTAI

Paolo Mantegazza from the Politecnico di Milano startedthe RTAI (Real Time Application Interface) project in theyear 1999. Since version 3.1, Linux RTAI is based onPhilippe Gerum’s Adeos (Adaptive Domain Environmentfor Operating Systems) nanokernel ([9]). Adeos providesa simple layer that is placed under a running OS (calleddomain) and thereafter provides the primitives and the mech-anisms to allow multiple operating systems to share thesame hardware environment. Adeos uses a pipe to propagateinterrupts through the different domains running on thehardware. One of this domain is the normal Linux OS. Whenthe real-time modules of RTAI are loaded, a new domainRTAI is registered and inserted in the pipe. A more detaileddescription of Adeos is given in [10].

The RTAI extension was created as an environment forimplementing low cost data acquisition and digital controllersystems ([11]). The software is distributed under the GNUGeneral Public License (GPL) for the kernel part and underthe GNU Lesser General Public License (LGPL) for the userpart (see [12]). The system has already reached maturity andhas been exploited in several areas ([13], [14], [15], [16]).At present, different research and commercial projects takeadvantage of the Linux RTAI environment ([17], [18], [19],[20]).

One of the most important features of Linux RTAI isthe capability to use hard real-time code in both ker-nel and user space, using a single RTAI scheduler. Soan application started in user space can open multiplekthreads/threads/processes in both soft and hard real-time.

C. RTAI-Lab

RTAI-Lab is an open source project aiming to pro-vide a common structured framework for the integra-tion of RTAI into CACSD environments ([3]). Thepresent implementation includes support for the commercialMATLAB/Simulink/RealTime-Workshop (RTW) suite and

RTAI

RTAI-Lab

Scilab/Scicos

Fig. 2. Integration of RTAI with Scilab/Scicos

and GUI application

PC with hard real−time task NETWORK

UDP/IP

PC withGUI application

net_rpc

net_rpc

Fig. 3. RTAI-Lab with remote monitoring of the hard real-time task

the open source SCILAB/Scicos suite. Its internal archi-tecture allows the easy porting to other CACSD software.Basically, RTAI-Lab relies completely on the CACSD soft-ware for the control system design and code generation. Itonly provides some specific blocks and building options. Thegenerated code is embedded in a RTAI framework and canbe executed in soft or hard real-time and monitored by anexternal application.

At present, two GUI applications exist. Both can be runlocally or remotely on the network.

1) xrtailab: The Linux RTAI environment provides thexrtailab application. This tool permits monitoring and tuningof real-time tasks from any PC in the LAN (see Fig. 3).

The GUI application xrtailab provides three types ofdisplay instruments: digital scopes, LEDs and meters. Eachinstrument is defined by a specific block in the Scicos library.

Fig. 4 shows the running GUI application.xrtailab has been implemented using OpenGL (Mesalib)

and the Extended Fast Light Toolkit (EFLTK).2) ARTIST: ”A Real-Time Interactive Simulink-based

Telelab” is a project born at the Dipartimento di Sistemie Informatica of the University of Florence ([4]). One ofthe limitations of the original xrtailab application is that thenet rpc protocol used between the hard real-time task and theGUI application requires that the Linux RTAI OS be installedon the client. ARTIST introduces an interface between thehard real-time task and the network in order to route allmessages from the net rpc to the xml-rpc and the socket

1122

Fig. 4. RTAI-Lab graphical user interface

WAN

RTAI-XML

RT-task Client AppHost

Fig. 5. RTAI-XML server

protocol. This solution allows creation of a client applicationunder any operating systems. Fig. 5 shows the architectureof the RTAI-XML server.

The RTAI-XML server has been implemented by startingfrom the original xrtailab code and by substituting all graph-ical parts with the network protocol router.

A Java applet called jrtailab is provided as an example fora client application. It can be started using a standard webbrowser (see Fig. 6).

D. COMEDI

The COMEDI project aims to develop open-source drivers,tools, and libraries for data acquisition. A collection ofdrivers for a variety of common data acquisition plug-inboards has been implemented. The drivers are implementedas a core Linux kernel module providing common function-ality and individual low-level driver modules.

Close to the low-level acquisition boards drivers,COMEDI provides two basic modules:

Comedilib: it is a user-space library which provides adeveloper-friendly interface to Comedi devices. Included inthe Comedilib distribution are documentation, configurationand calibration utilities, and demonstration programs.

Fig. 6. The jrtailab application

Kcomedilib: it is a Linux kernel module which providesthe same interface as Comedilib in kernel space, suitable forreal-time tasks.

E. Download

All above mentioned tools can be freely downloaded fromthe web (see table I).

III. THE INTERFACE SCICOS-RTAI

The RTAI project provides all the files needed to interfacewith the CACSD environment Scilab/Scicos.

A. The RTAICodegen .sci file

The RTAI environment has been extended with the newcode generator RTAICodegen .sci. This is a modified versionof the CodeGeneration sci file provided by Scicos. The mostimportant modifications are:

• Only the files for standalone execution are generated.The generation of the dynamic library for Scicos hasbeen eliminated in the new code generator.

• The generated Makefile has been adapted in order toproduce code for Linux RTAI.

• The functions make actuator and make sensors producea more detailed code for each input and output of thesuperblock to allow easy integration of custom code. In-put and output blocks should be normally implementedwithin the superblock.

• The function make static standalone creates an arraywith the names of the Scicos blocks found in thefield identification. These names are used to univocallyidentify the block parameters in the GUI applications.

• The RTAI stand-alone executable code is generated andcompiled directly from the Scicos environment.

B. The RTAI-Lib.cosf library

The directory .../macros/RTAI contains a new block libraryspecific for the RTAI environment. Fig. 7 shows the blockscontained in this library.

There are three kinds of blocks:

1123

TABLE I

SOURCES AVAILABILITY

RTAI (with RTAI-Lab) www.rtai.orgScicos www.scicos.orgARTIST artist.dsi.unifi .it/rtaixml/COMEDI www.comedi.orgMesalib www.mesa3d.orgEFLTK anonymous@cvs.sourceforge.net:/cvsroot/ede

test.datextdatatest.datextdata

SCOPEScopeSCOPEScope

METERMeterMETERMeter

LEDLEDLEDLED

FIFO−0FIFO−0

MBXMbx Send OvwMBXMbx Send Ovw

MBXMbx Rcv no blkMBXMbx Rcv no blk

MBXMbx rcv blkMBXMbx rcv blk

MBXMbx Send ifMBXMbx Send if

SEMSEM waitSEMSEM wait

SEMSEM signalSEMSEM signal

comedi0 CH−0COMEDI A/Dcomedi0 CH−0COMEDI A/D

comedi0 CH−0COMEDI D/Acomedi0 CH−0COMEDI D/A

comedi0 CH−0COMEDI DIcomedi0 CH−0COMEDI DI

comedi0 CH−0COMEDI DOcomedi0 CH−0COMEDI DO

SineSine

SquareSquare

StepStepBlockC RTAIBlockC RTAI

SENSSENSORSENSSENSOR

ACTACTUATORACTACTUATOR

Fig. 7. Scicos RTAI library

Input signals: Because of the impossibility to generatecode using the normal Scicos input blocks, this librarycontains a new version of the most commonly used inputsignals (sine, square, step and generic data from a file).

COMEDI blocks: The interface between the generatedcode and the controlled hardware uses the devices providedby the COMEDI project. This allows to interface the gener-ated code with numerous acquisition boards.

RTAI-Lab blocks: RTAI-Lab makes available to the userthree types of data representations: digital scopes, LEDs andmeters. For each of these instruments a Scicos block has beenimplemented. The MBX blocks can be used to communicatebetween real-time tasks and allow realization of complexdistributed controls.

The user can easily add other specific blocks (for examplefor data acquisition boards not yet covered by the COMEDIproject).

C. The libsciblk library

This library contains the code of the Scicos blocks whichneed specific RTAI resources. A utility helps to create askeleton for these library blocks.

D. The rtmain.c file

This file is the core of the SCICOS-RTAI interface. Itcontains the project main procedure which starts a threadcalled rt BaseRate. This thread performs the initializationof the generated code, switches to hard real-time and thentriggers the periodic task. This periodic task is synchro-nized with the help of the procedure WaitTimingEvent.The default code of this procedure is given by the RTAI

function rt task wait period for synchronous mode, but itcan be substituted by other functions in order to implementasynchronous tasks.

The periodic task calls the two procedures<model name> main1 and <model name> main2.When the hard real-time task is stopped, it switches to softreal-time again and the procedure <model name> endof the generated code is called. Below is part of the code ofthis procedure.

NAME(MODEL,_init_blk)();rt_make_hard_real_time();t0 = rt_get_cpu_time_ns();rt_task_make_periodic(rt_BaseRateTask,

rt_get_time()+ rt_BaseRateTick,rt_BaseRateTick);

while (!endBaseRate) {WaitTimingEvent(TimingEventArg);if (endBaseRate) break;

TIME = (rt_get_cpu_time_ns() - t0)*1.0E-9;set_nevprt(nevprt);NAME(MODEL,main1)(NAME(block_,MODEL),z, &TIME);NAME(MODEL,main2)(NAME(block_,MODEL),z, &TIME);

}rt_make_soft_real_time();NAME(MODEL,_end)(NAME(block_,MODEL),z, &TIME);

E. Generating, building and running executable code

In order to create a stand-alone executable code using theCACSD software Scilab/Scicos and Linux RTAI, the usermust execute three distinct steps.

1. Model definition: The designer creates an appropriateScicos model using blocks from the standard built-in librariesand additional interface blocks from a specific RTAI-Lablibrary. Typically, the Scicos scheme used to validate thecontroller can be modified substituting the plant model, theinputs and the scopes with the blocks provided by the RTAI-Lib.cosf library. In particular, the plant model is substitutedby specific I/O blocks.

2. Code generation: The second step involves the C-codegeneration. First, the scheme has to be integrated into asuperblock. Then, the executable code is obtained by simplyclicking on the new RTAI button in the Scicos window.

3. Code execution: Finally, the stand-alone executablecan be directly started or transferred to any target machinerunning the same version of RTAI used for compilation.

Fig. 8 shows the compilation process needed to obtain theRTAI stand-alone executable code.

IV. EXAMPLE

One of the main research domains at the SUPSI is thecontrol of high precision systems ([21]). In order to obtaina flexible solution, a PC-104 platform has been developed.

1124

Scicos model

Superblock

rtmain.c generated files libsciblk.a

realtimestandalone

RTAICodeGen_.sci

Compilation and Link

Fig. 8. Code generation and creation of the stand-alone executable

Fig. 9. PC104-based system for high precision applications

According to the application needs, the hardware can be con-figured by stacking the necessary number of (also identical)boards on top of each other. The system with interface boardsfor voice-coil motors and for sinusoidal encoders is shownin Fig. 9.

Two of the boards used in this system are• An FPGA-based sinusoidal encoder interpolation board• A Sensoray AD-DA boardThe Scicos and RTAI drivers for the two boards have been

implemented at the SUPSI.The choice of a PC104 system with a x86-based processor

board allows to exploit the possibilities offered by LinuxRTAI and by its interfaces with Scilab/Scicos. The systemto be controlled can be identified, based on measurement datauploaded to Scilab/Scicos (see Fig. 10). Then, the controllercan be designed and tested in simulation (see Fig. 11).

Finally, by substituting the simulation model with theblock for the interfaces, the executable code can be generatedand the real-time control started, while the measurement datacan be displayed or recorded for later analysis (see Fig. 12)

The PC104 platform contains a flash disk (32-96MB)

excitation

ext_dataext_data

U

DA outDA out

measurement

SINCOSSINCOS

Preprocessing

PreprocPreprocRTAI ScopeRTAI Scope

11

Fig. 10. Scicos superblock for the identifi cation

Sinus

RTAI sinusRTAI sinus F1F1

F2F2

Feed forward

Compensation

+

−

+

−

Controller

CCPlant

den(s)num(s)den(s)num(s)

Fig. 11. Scicos scheme for the simulation

where the Linux RTAI OS (9MB) is installed. The compi-lation of the real-time code can be performed on a standardPC with Linux RTAI connected to the network. Then, thereal-time task can be downloaded and executed on the PC-104. The xrtailab GUI can be started on the same PC usedto develop the application, in order to display and upload themeasured data.

The system will be used not only as a base for furtherresearch in nanopositioning and manipulation, but also incommercial low-volume products, thus demonstrating theutility of the Linux RTAI project.

Sinus

RTAI sinusRTAI sinus F1F1

F2F2

Feed forward

Compensation

+

−

+

−

Controller

CCU

DA outDA out

measurement

SINCOSSINCOS

11

Fig. 12. Scicos superblock for the real-time controller

1125

V. CONCLUSIONS AND FUTURE WORKS

A. Conclusions

The presented work demonstrates that Rapid ControllerPrototyping with free open source is possible. Complexcontrollers have been successfully implemented at the SUPSIlaboratory. The example shows that the same environmentcan be successfully used for industrial applications. The mostinteresting advantage of the proposed solution is that all thesoftware is available on the web and that it can be freelydownloaded. The investment is reduced to the hardware cost,which consists of a standard PC and an acquisition board.The free suite composed by GNU/Linux and the RTAI add-on, the Scilab CACSD software and the COMEDI drivers,represents a valid alternative to commercial systems.

B. Future Works

RTAI/Fusion: At present, RTAI/fusion is an experimentaldevelopment branch led by the RTAI project; it aims toprovide a universal, interface-agnostic, hard real-time supportto user-space applications by integrating the Adeos, Xenomaiand LXRT technologies into the Linux environment.

The basic idea of RTAI/fusion is to merge the originalRTAI interfaces and the Xenomai ([22]) technology in orderto build and run any kind of real-time interfaces over anucleus which exports a set of generic RTOS services.Various RTOS personalities called ”skins” can then be builton the nucleus, providing their own specific interface tothe applications. The original RTAI APIs are moved overthe Xenomai nucleus using the same technique which hasalready been successfully used to mimic traditional RTOSlike VxWorks, pSOS+ or VRTX.

New Scilab/Scicos release: The code generator for theLinux RTAI environment has been already ported to thenext Scilab/Scicos release. Some parts of the code shouldbe integrated into the future standard code generator ofScicos, thus allowing a smoother integration of the twoenvironments.

REFERENCES

[1] Mathworks. The MathWorks. [Online]. Available:http://www.mathworks.com

[2] RTAI. Real Time Application Interface. [Online]. Available:http://www.rtai.org

[3] R. Bucher and L. Dozio, “CACSD with Linux RTAI and RTAI-Lab,”in Real Time Linux Workshop, Valencia, 2003.

[4] M. Basso and G. Bagni, “ARTIST: A Real-Time Interactive Simulink-based Telelab,” in Proceeding of the 2004 IEEE Conference onComputer Aided Control System Design, Taipei, Taiwan, Sept. 2004,pp. 196–201.

[5] COMEDI. Linux Control and Measurement Device Interface.[Online]. Available: http://www.comedi.org

[6] Scilab. A Free Scientifi c Software Package. [Online]. Available:http://www.scilab.org

[7] Inria. Insitut National de Recherce on Informatique et on Automatique.[Online]. Available: http://www.inria.fr

[8] Enpc. Ecole nationale des ponts et chaussee. [Online]. Available:http://www.enpc.fr

[9] ADEOS. Adaptive Domain Environment for Operating Systems.[Online]. Available: http://home.gna.org/adeos/

[10] K. Yaghmour, “Adaptive Domain Environment for Operating Sys-tems.”

[11] D. Beal, E. Bianchi, L. Dozio, S. Hughes, P. Mantegazza, andS. Papacharalambous, “RTAI: real time applications interface,” LinuxJournal, April 2000.

[12] GNU. GNU Operating System - Free Software Foundation. [Online].Available: http://www.gnu.org

[13] E. Bianchi, L. Dozio, P. Mantegazza, and G. L. Ghiringhelli, “Complexcontrol system, application of DIAPM-RTAI at DIAPM,” in Real TimeLinux Workshop, Vienna, 1999.

[14] E. Bianchi, L. Dozio, D. Martini, and P. Mantegazza, “Applicationsof a hard real-time support in digital control of complex aerospacesystems,” in AIDAA Congress, Torino, Italy, 1999.

[15] E. Bianchi and L. Dozio, “Some experience in fast hard real-timecontrol in user space with RTAI-LXRT,”in Real Time Linux Workshop,Orlando, 2000.

[16] L. Dozio and P. Mantegazza, “Linux Real Time Application Interface(RTAI) in low cost high performance motion control,” in MotionControl 2003, ANIPLA, Milano, Italy, 2003.

[17] PLATINO. Platino High Speed. [Online]. Available:http://www.primaindustrie.com/pr platino.html

[18] ALMA. Atacama Large Millimeter Array. [Online]. Available:http://www.alma.nrao.edu

[19] OROCOS. Open Robot Control Software Open Realtime ControlServices. [Online]. Available: http://www.orocos.org

[20] RT-MBDYN. MultiBody Dynamics Analysis Software onReal Time Distributed Systems. [Online]. Available:http://www.aero.polimi.it/˜mbdyn/mbdyn-rt

[21] S. Balemi, J. Moerschell, J.-M. Breguet, D. Braendlin, S. Bottinelli,and I. Beltrami, “Surface Inspection System for Industrial Applica-tions,” in Conf. on Robotics and Mechatronics, Aachen, Germany,Sept. 2004, pp. 1597–1602.

[22] P. Gerum. (2004) The Xenomai project. [Online]. Available:http://www.xenomai.org

1126