kramann.info
© Guido Kramann

Erste Schritte mit RTAIlab: Echtzeit-Sinusverlauf erzeugen (Real-time sinewave: step by step,Tutorial S. 15..20)

Übersicht

Mit der folgenden Anleitung, die auf dem Tutorial S.15..20 beruht, wird zunächst mit Hilfe von Scicos-Blockdiagrammen eine Anwendung erstellt, die eine Sinuswelle in Echtzeit erzeugen kann.
Hierfür steht ein spezieller Block mit der Bezeichnung "Sine" in der RTAI-Lab-Palette zur Verfügung.
Damit ein Echtzeitprogramm entsteht, wird aus dem Blockschaltplan C-Code generiert und compiliert.
Darüber hinaus existiert ergänzend zu Scilab/Scicos die Anwendung xrtailab.
Diese Anwendung erlaubt es, auf laufende Echtzeit-Prozesse, die mit Scicos erstellt, compiliert und gestartet wurden "zu schauen" und auch deren Parameter zu verändern.
Diese Anwendung muß dabei nicht auf dem gleichen PC laufen, wie der Echtzeitprozeß. Vielmehr ist es möglich, auch auf die laufenden Echtzeitprozesse auf anderen Rechnern zu schauen.
Das aus dem Scicos-Blockschaltbild generierte und compilierte Programm und xrtailab können also auf unterschiedlichen Rechnern laufen, auch wenn in dem Beispiel davon zunächst kein Gebrauch gemacht wird.
Soll dies aber geschehen, muß bei dem Verbindungsvorgang mit "connect" in xrtailab die IP-Adresse des Zielrechners angepaßt werden.
Der Defaultwert ist hier 127.0.0.1, was der Localhost-Adresse entspricht, also immer als Adresse desjenigen Rechners verwendet werden kann, auf dem xrtailab gerade läuft.
Damit in xrtailab auch die Echtzeit-Sinuswelle grafisch dargestellt werden kann, wird in dem Scicos-Blockschaltbild ein spezieller Scope-Baustein an den Ausgang des Sinusblocks angeschlossen.
Dieser Scope-Block dient also nicht dazu, eine grafische Oberfläche bei dem Echtzeitprogramm zu erzeugen, sondern ermöglicht den Datentransfer der Sinuswelle nach xrtailab, um die resultierende Kurve dort darstellen zu können.

Erstellen eines Ordners

Um die nachfolgend erstellten Files an einem bekannten Platz zu speichern, wird ein Ordner erstellt:

Bild 0-1: Erstellen eines Ordners, um die im folgenden entsehenden Dateien zu speichern.

Deaktivieren der automatischen Tastenwiederholung

Wenn der Computer mit dem Live-USB-Stick gestartet ist, läuft das Echtzeitlinux noch nicht.
Dies ist erst nach Laden der Linux-Echtzeit-Module der Fall.
Dann aber treten Schwierigkeiten auf, noch etwas in einer Konsole zu tippen: Aufgrund der Zeitscheiben, die regelmäßig vom Echtzeitprozeß beansprucht werden, wird die Dauer zu lang berechnet, wie lange eine Taste gedrückt wird und ständig Wiederholungen der gedrückten Buchstaben ausgegeben.
Um dies zu vermeiden, muß über das Kontrollzentrum die Tastenwiederholung ganz abgschaltet werden:
Kontrollzentrum->Angeschlossene Geräte->Tastatur: Kästchen bei "Tastenwiederholung aktivieren" deaktivieren:

Bild 0-2: Deaktivierung der Tastenwiederholung

Laden der RTAI-Module, um RTAI-Linux starten zu können

Um RTAI-Linux zu starten müssen die RTAI-Module geladen werden.
Dies geschieht am einfachsten durch die Verwendung eines Skriptes
Wir gehen davon aus, dass dieses Skript als Textdatei "startrtai.txt" unter /mnt/sda1_removable/MEINEDATEN/RTAIlab liegt.
Mit Strg-c läßt sich der im Filebrowser markierte Pfad kopieren und "rechte Maustaste - Einfügen" in die Konsole kopieren.
Auf diese Weise spart man viel Tipparbeit.
Durch chmod +x wird die Datei startrtai.txt ausführbar gemacht und schließlich durch ./startrtai.txt ausgeführt.
Die Befehlsabfolge in der Konsole lautet dann:

cd /mnt/sda1_removable/MEINEDATEN/RTAIlab
chmod +x startrtai.txt
./startrtai.txt

Code 0-1: Konsolenbefehle zur Abarbeitung des Shell-Skriptes "startrtai.txt"

insmod /usr/realtime/modules/rtai_hal.ko
insmod /usr/realtime/modules/rtai_up.ko
insmod /usr/realtime/modules/rtai_fifos.ko
insmod /usr/realtime/modules/rtai_sem.ko
insmod /usr/realtime/modules/rtai_mbx.ko
insmod /usr/realtime/modules/rtai_msg.ko
insmod /usr/realtime/modules/rtai_netrpc.ko ThisNode="127.0.0.1"
insmod /usr/realtime/modules/rtai_shm.ko
insmod /usr/realtime/modules/rtai_signal.ko
insmod /usr/realtime/modules/rtai_tasklets.ko
modprobe comedi
modprobe kcomedilib
modprobe comedi_fc
modprobe 8255 # acq. card hardware-specific
modprobe ni_mio_cs # acq. card hardware-specific
insmod /usr/realtime/modules/rtai_comedi.ko

Code 0-2: startrtai.txt - Ausführbare Datei zum Laden der RTAI-Module (booten von Realtime-Linux).

Starten von Scicos

Gehen Sie mit dem Konsolenbefehl "cd /mnt/sda1_removable/MEINEDATEN/sinus" in den vorbereiteten Ordner.
Durch Eingabe von "scilab" in eine Konsole, wird Scilab gestartet.
Durch Eingabe von "scicos" in die Scilab-Konsole, wird Scicos gestartet.

Bild 0-3: Starten von Scilab und Scicos

Das noch leere Scicos-Diagramm kann man schon einmal in dem vorbereiteten Ordner und dem Namen "sinus.cos" speichern:

Bild 0-4: Speichern des Scicosfiles sinus.cos

Blockdiagramm erstellen

Zunächst muß die Palette mit den verfügbaren Blöcken geöffnet werden:

Bild 0-5: Palettenauswahl

Die drei benötigten Elemente befinden sich an folgenden Stellen:

Clock-Block (Rote Uhr): Palette Sources
Sine-Block (Spezieller Echtzeit-Block zum Erzeugen einer Sinuswelle in Echtzeit): Palette RTAI-Lib
Scope-Block (Spezieller Echtzeit-Block, um entstehende Zeitverläufe so aufzubereiten, dass sie später in einem Grafikfenster von xrtailab angeschaut werden können): Palette RTAI-Lib

Bild 0-6: Auswahl des Clock-Blocks

Bild 0-7: Spezielle RTAI-Lab-Blöcke in der Palette "RTAI-Lib".

Um die Abzweigung einer vorhandenen Leitung zu erzeugen, wird an die Abzweigstelle doppelt geklickt (hier für die rote Clock-Leitung notwendig).
Sollte einmal die Verbindung von Blöcken nicht mehr möglich sein, sollte man einfach das Diagramm auffrischen: Diagramm->Replot

Durchrechnen aller Blöcke (Evaluate)

Bild 0-8: Notwendiger Aufruf von "Evaluate"

Bilden eines Superblocks

Die automatische C-Codegenerierung mit dem anschließenden Kompilierungsvorgang, wird auf einen Scicos-Superblock ausgeführt.
Deshalb muß zunächst ein solcher Superblock über alle Elemente, außer dem Clock-Block gebildet werden.
Nach Anwahl von Diagram->Region to Superblock, kann über die zusammenzufassenden Blöcke ein Rechteck gezogen werden.
:

Bild 0-9: Superblock-Bereich festlegen

Bild 0-10: Entstandener Superblock

C-Codegenerierung und Kompilierung zur Erstellung der Echtzeitanwendung

Nun muß für den Kompilier festgelegt werden, welcher Superblock in eine Echtzeitanwendung umgesetzt werden soll.
Dies geschieht mit RTAI->Set Target und einem anschließenden einfachen Klick auf den zu benutzenden Superblock.
Außerdem wird die Integrationsmethode und die Anzahl der Integrationsschritte zwischen zwei gesendeten Zuständen angegeben.

Bild 0-11: RTAI->Set Target

Als Vorbereitung für die Erzeugung der Echtzeitanwendung muß nun einiges spezifiziert werden:
Unter RTAI->RTAI CodeGen wird festgelegt, für welches Betriebssystem der Kompilevorgang durchgeführt wird, hier natürlich RTAI: Target: rtai
Ansonsten kann noch ein Name für die zu erzeugende Echtzeitanwendung vergeben werden und der Zielpfad für die entstehenden Dateien angegeben werden.
Schließlich kann noch die Samplingrate für den Prozeß angegeben werden. Dieser korrespondiert mit dem Wert in dem Clock-Block, d.h. Änderungen werden wechselseitig übernommen.
Damit das Konfigurationsfenster erscheint muß nach der Menüanwahl einmal auf den Superblock geklickt werden.
Im Anschluß daran, werden der C-Quellcode gebildet und die Kompilierung durchgeführt.
Den Erfolg dieses Vorgangs kann man in der Scilab-Konsole ablesen.

Bild 0-12: RTAI->RTAI CodeGen

Bild 0-13: Ausgabe auf der Scilab-Konsole beim Erzeugen der Echtzeitanwendung

Start der Echtzeitanwendung

Die Echtzeitanwendung kann nun in dem Verzeichnis gestartet werden, wo sie generiert wurde.
Voraussetzung ist aber, dass die RTAI-Module zuvor bereits geladen wurden (s.o.)

Zunächst können Startoptionen für die Anwendung ausgegeben werden.
Hierzu ist folgendes in der Konsole einzugeben:

cd /mnt/sda1_removable/MEINEDATEN/sinus/

Code 0-3: ./welle -u

OPTIONS:
  -u, --usage
      print usage
  -v, --verbose
      verbose output
  -V, --version
      print rtmain version
  -s, --soft
      run RT-model in soft real time (default hard RT)
  -w, --wait
      wait to start
  -p <priority>, --priority <priority>
      set the priority at which the RT-model's highest priority task will run (default 0)
  -f <finaltime>, --finaltime <finaltime>
      set the final time (default infinite)
  -n <ifname>, --name <ifname>
      set the name of the host interface task (default IFTASK)
  -i <scopeid>, --idscope <scopeid>
      set the scope mailboxes identifier (default RTS)
  -l <logid>, --idlog <logid>
      set the log mailboxes identifier (default RTL)
  -t <meterid>, --idmeter <meterid>
      set the meter mailboxes identifier (default RTM)
  -d <ledid>, --idled <ledid>
      set the led mailboxes identifier (default RTE)
  -y <synchid>, --idsynch <synchid>
      set the synchronoscope mailboxes identifier (default RTY)
  -c <cpumap>, --cpumap <cpumap>
      (1 << cpunum) on which the RT-model runs (default: let RTAI choose)
  -e, --external
      RT-model timed by an external resume (default internal)
  -o, --oneshot
      the hard timer will run in oneshot mode (default periodic)
  -m <stack>, --stack <stack>
      set a guaranteed stack size extension (default 30000)

Code 0-4: Optionen für die ausführbare Datei.

Nun wird die Echtzeitanwendung gestartet:

./welle -v

Code 0-5: Konsolenbefehl zum Start der Echtzeitanwendung "welle"

Es wird bei erfolgreichem Start folgende Kontrollausgabe von der Konsole zurückgegeben:

Target settings:
  Real-time : HARD;
  Internal Clock is OneShot;
  Priority : 0;
  RUN FOR EVER.
TARGET STARTS.
Model : WELLE .
Executes on CPU map : f.
Sampling time : 1.000000e-01 (s).
Target is running.

Code 0-6: Kontrollausgabe der Konsole

xrtailab

Nun kann mit Hilfe der Anwendung xrtailab auf die nun laufende Echtzeitanwendung "geschaut" werden.
Dazu ist eine zweite Konsole zu öffnen, die auch an einem anderen PC sein kann, sofern dieser über das Netzwerk mit dem Echtzeitrechner verbunden ist.
Die Startoptionen dieser Anwendung erhält man über xrtailab -h
Gestartet wird das Programm einfach durch Eingabe von xrtailab.

Über den Menüpunkt File->Connect kann eine Verbindung zu dem Echtzeitprozeß hergestellt werden.

Bild 0-14: Verbinden mit dem Echtzeitprozeß

Öffnen des Scopes / Ändern der Parameter - vergleiche Tutorial.

Aufgabe

Vollziehen Sie die obige Beschreibung praktisch nach.
Führen Sie dann einige Experimente aus:

Öffnen Sie xrtailab auf einem anderen Rechner, als der zu beobachtende Echtzeitprozeß läuft.
Ändern Sie die Parameter des Echtzeitprozesses von xrtai aus (vergl. Tutorial).
Variieren Sie die Anwendung durch Verwendung anderer Quellen und Senken aus der RTAI-Palette (z.B. Square, extdata, Meter, LED).
Studieren Sie die nachfolgenden Beispiele im Tutorial (FIFO, Semaphores) und versuchen auch diese umzusetzen.