A4: Octave

- 1 -

A4 Arbeiten mit Octave

Octave ist ein freies CAS (Computer Algebra System), dass unter der GNU-Lizenz verfügbar ist.

Außerdem gibt es Octave für eine Vielzahl von Betriebssystemen: Linux, Windows, FreeBSD, und OS

X. Mit Hilfe von Kommandos und Skripten können numerische Lösungen mathematischer Probleme

berechnet werden. Die grafische Ausgabe erfolgt über gnuplot oder fltk, die direkt mit installiert wird.

Octave erscheint bis zur Version 3.6.4 als Kommando-Fenster. Skripte werden mit Hilfe eines externen

Editors geschrieben. Ab der Version 4.0.0 ist eine komfortable grafische Benutzeroberfläche verfügbar.

A4.1 Installation

Im ersten Schritt ist die Octave-Umgebung zu installieren. Das Paket „Octave 4.0.0 for Windows“1

(OpenSource).

A4.2 Arbeiten mit Packages (Octave)

Für Octave gibt es eine Vielzahl von sogenannten Packages. Diese Erweiterungen müssen installiert und

geladen werden, bevor sie genutzt werden können. Für die Regelungstechnik wird das Package

„control“, das mächtige Funktionen zur Bearbeitung regelungstechnischer Aufgabenstellung beinhaltet,

benötigt.

Ob es installiert ist, kann mit dem Befehl

pkg list

nachgesehen werden. Der Befehl listet alle installierten und ggf. geladenen Packages auf.

Die Installation der letzten aktuellen Version kann entweder direkt online aus dem Internet

pkg install –forge control

erfolgen oder auch nach einem Download2 mit Verweis auf die Archiv-Datei des Package:

pkg install z:\tmp\ control-2.8.1.tar.gz

Laden des Packages erfolgt dann mit dem Befehl:

pkg load control

Wenn oft mit bestimmten Packages gearbeitet werden soll, dann kann das Laden automatisiert werden.

Hierfür ist die Datei

{Octave-home}\share\octave\4.x.x\m\startup\octaverc

zum Beispiel für die Regelungstechnik wie folgt zu erweitern:

1 Octave: https://www.gnu.org/software/octave/download.html

2 http://octave.sourceforge.net/packages.php

A4: Octave

- 2 -

pkg load control

fprintf("package control wurde geladen\n"); % Nachricht ausgeben

An dieser Stelle lassen sich weitere Voreinstellung dauerhaft einfügen, z.B. auch ein Standard-

Arbeitsverzeichnis.

Für die Ausführung der m-Files dieses Studienbuchs werden die Packages

control

symbolic (ab Version 2.0)

vorausgesetzt.

Wird mit Matlab gearbeitet, dann müssen die entsprechenden Toolboxen vorhanden sein.

A4.3 Kurzeinführung in Octave

Ab Version 4 verfügt Octave wie Matlab auch über eine grafische Benutzeroberfläche. Innerhalb dieser

gibt es ein Befehlsfenster, in dem Befehle eingegeben und ausgeführt werden können.

A4: Octave

- 3 -

Abb. A 4.1: benutzeroberfläche von Octave

In dem Befehlsfenster können nun beliebige Berechnungen durchgeführt werden.

Beispiel: >> a=12; >> b=5; >> c=a*b c = 60

Hinweis: der Abschluss einer Zeile mit einem Semikolon unterbindet die direkte Ausgabe der

Zuweisung.

Die Definition eines Vektors und seine Übergabe als Argument an eine Funktion generiert einen

Ergebnisvektor. Dieser kann dann z. B. einem Plot (Ausgabe in einem eigenen Fenster) übergeben

werden (Abb. A4.2).

A4: Octave

- 4 -

Abb. A4.2: Befehlseingabe mit Plot-Ausgabe

Der identische Code im Editor kann direkt ausgeführt werden (Abb. A4.3).

Abb. A4.3: Skript-Programmierung im internen Editor

Komplexe Aufgabenstellungen lassen sich gut mit eigenen Funktionen strukturieren. Somit werden

diese Funktionen in weiteren Projekten einsetzbar.

Beispiel:

Die in der Abb. A4.4 gezeigte Funktion berechnet eine parametrisierbare Sinus-Funktion.

Abb. A4.4: Definition einer eigenen Funktion sin2()

Es folgt der Aufruf der zuvor definierten Funktion sin2() (Abb. A4.4) im Skript s2.m (Abb. A4.5).

A4: Octave

- 5 -

Abb. A4.5: Aufruf der definierten Funktion sin2()

Sollen die grafischen Ausgaben zu Dokumentationszwecken verwendet werden, dann müssen sie in

einem im Textverarbeitungssystem weiterverwendbares Format gespeichert werden. Dies gelingt mit

der Druck-Funktion print(). Um einen Plot direkt in MS-Word einbinden zu können, empfiehlt sich

dessen Speicherung im „emf“-Format. Die Weiterverarbeitung im Adobe-Illustrator braucht die

Formate „eps“ oder „aifm“. Soll das CAD-System AutoCad (oder kompatible) eingesetzt werden, so

kann das Format „dxf“ genutzt werden.

Der Druck-Befehl kann entweder von der Konsole aus abgesetzt werden, wenn z.B. ein brauchbarer Plot

entstanden ist: >> s2; >> print -demf z:\p1\test.emf;

Alternativ kann die Befehlssequenz auch in dem Skript umgesetzt werden.

A4.4 Grafische Animation

Gerade bei der Berechnung von Gelenkgetrieben kann eine Bewegungssimulation hilfreich sein. Auch

diese Aufgabe kann relativ einfach mit einem m-File realisiert werden. Dazu sind die sich ändernden

Daten innerhalb einer Animationsschleife neu zu berechnen und dann mit einem oder mehreren

Plotbefehlen auszugeben. Die grafische Ausgabe ist gesondert zu steuern. Der Grundsätzliche Ablauf

gliedert sich in die folgenden Schritte:

1) Grafikfenster schließen (close all)

2) Neues Grafikfenster erzeugen (figure;)

3) Schleife öffnen (for k=…)

4) Zeichenfläche löschen (cla;)

5) Daten berechnen

6) Plotten (hold on; plot(…); plot(…); hold off;)

7) Ausgabe erzwingen (drawnow;)

8) Kurz Wartezeit für den Betrachter (pause(0.02);)

9) Zurück zu Schritt 4.

Ein einfaches Beispiel mit zwei Sinus-Funktionen zeigt die Abb. A4.6

A4: Octave

- 6 -

Abb. A4.6: Animation

A4.5 Kopplung mit externen Programmen

Die Kopplung von Octave mit anderen Simulationstools kann auf unterschiedliche Weise geschehen.

Die einfachste Lösung basiert auf einen Austausch von Daten über Dateien. Das folgende Beispiel soll

die Vorgehensweise demonstrieren.

1. Octave schreibt eine ASCII-Datei

2. BORIS liest diese Datei ein und simuliert den dynamischen Teil des Systems.

3. BORIS schreibt eine Ergebnisdatei der Simulation.

4. Octave visualisiert die Ergebnisse in einem einheitlichen Format.

Beispiel:

In Octave wird die Führungsgröße für eine zu untersuchende Regelung berechnet und in einer ASCII-

Datei gespeichert. Damit BORIS diese Datei verarbeiten kann, müssen die Zeitwerte und die

Führungsgröße in jeweils einer Spalte stehen. In Octave lassen sich Dateien sehr einfach mit dem Befehl

save() schreiben. In diesem Beispiel wird eine Sprungfunktion als Führungsgröße generiert (Abb.

A4.6).

A4: Octave

- 7 -

Abb. A4.6: Script zur Generierung von Daten in Octave

In BORIS wird die Datei eingelesen. Die Werte werden hier zur Demonstration auf ein PT1-Glied

aufgeschaltet, und das Ergebnis wird in einer Ergebnisdatei gespeichert (Abb. A4.7).

Abb. A4.7: Simulationskopplung über Dateien in BORIS

Liegen die Ergebnisse vor, dann kann nun mit einem weiteren Script in Octave das Ergebnis mit dem

Befehl load() geladen, ggf. bearbeitet und dann grafisch ausgegeben werden (Abb. A4.8).

Abb. A4.8: Octave-Script zum Einlesen der Ergebnisse der BORIS-Simulation

A4: Octave

- 8 -

A4.6 Regelungstechnik mit Control-Package / -Toolbox

In dem Package control sind eine Vielzahl von Funktionen für die Regelungstechnik realisiert. Hier

sollen die wichtigsten Funktionen kurz besprochen werden.

Die Laplace-Übertragungsfunktionen ( )F s im Bildbereich lassen sich sehr einfach mit Hilfe des

Zähler- und Nennerpolynoms erzeugen. Dazu wird die Funktion tf() (transfer function) benutzt. Sie

erwartet Zähler- und Nennerpolynom in Form von Vektoren mit Koeffizienten:

>> F = tf([0.8],[3 1])

Transfer function 'F' from input 'u1' to output ...

0.8

y1: -------

3 s + 1

Continuous-time model.

Die Darstellung als Übertragungsfunktion sys dient als Basis für alle weiteren Berechnungen und

Ausgaben.

Wichtig sind natürlich die Reaktionen eines dynamischen Systems auf eine Anregung. Die einfachste

Standardanregung mit der Sprungfunktion kann komfortabel mit Funktion step() berechnet werden:

>> step(F)

Dieser Aufruf erzeugt automatisch ein Plotfenster, dass die Sprungantwort auf einen Einheitssprung

berechnet. Die Zeitdauer dieser Simulation berechnet Octave automatisch (basierend auf den Polstellen

der Übertragungsfunktion).

Eine direkte Zuweisung auf eine Variable erzeugt einen Vektor mit der Sprungantwort. Nachfolgend

wird zusätzlich der Zeitvektors für die Berechnung der Sprungantwort vorgegeben.

>> t=linspace(0,15,100);

>> h=step(F,t);

>> plot(t,h,'linewidth',2,[t(1) t(1) t(100)],[0 4 4],'color','red');

Der Eingangssprung wird hier im plot-Aufruf als Vektor direkt mit ausgegeben.

A4: Octave

- 9 -

Soll eine Antwort auf ein beliebiges Eingangssignal berechnet werden, so kann die Funktion lsim ()

verwendet werden:

>> xe = 2.3 * sin(0.5*t);

>> xa = lsim(F,xe,t);

>> plot(t,xe,'r',t,xa,'linewidth',2,'b');

Die Berechnung von Übertragungsfunktionen aus mehreren Einzel-ÜFs kann in Anlehnung an das

Kapitel 9 durch konsequente Verwendung von Zähler- und Nennerpolynomen gut standardisiert werden.

Dies wird am Beispiel der Berechnung der Führungsübertragungsfunktion eines Regelkreises kurz

erläutert.

Regler- und Streckenübertragungsfunktion sind durch Angabe ihrer Zähler- und Nennerpolynomen

gegeben:

ÜF der Strecke: )(

)()(

sN

sZsF

S

SS

ÜF des Reglers: ( )

( )( )

RR

R

Z sF s

N s=

Dies kann wie folgt formuliert werden:

% PT1-Strecke --------------

KS=0.4 % Verstärkung

T1=10 % Verzögerungszeit

ZS = [KS];

NS = [T1 1];

% PI-Regler ---------------

KP=3 % P-Anteil

TN=T1 % Nachstellzeit

ZR = [KP*TN KP];

NR = [TN 0];

A4: Octave

- 10 -

Die Führungsübertragungsfunktion berechnet sich so:

( ) ( ) ( ) ( ) ( )( )

1 ( ) ( ) ( ) ( ) (

( )

( () ) ) ( ) ( )R S R S RS

WR S R S R S RS RS

F s

w s

F s Z s Z s Z sF s

F s F s N s N s Z s Z s N s s

x s

Z

⋅ ⋅= = = =

+ ⋅ ⋅ + ⋅ +

Die Multiplikation zweier Polynom-Funktionen kann mit der Funktion conv() erfolgen:

ZW=ZRS=conv(ZR,ZS); % Zählerpoly. Führung

NRS=conv(NR,NS);

Für die Addition der Produkte im Nenner der Führungs-ÜF ist allerdings die Addition zweier Polynome

erforderlich. Dazu steht die externe Funktion addp() zur Verfügung, die die Addition auch bei

unterschiedlichem Grad der zu addierenden Polynome leistet. Damit ergibt sich der Nenner zu

NW=addp(NRS,ZW); % Nennerpoly. Führung

und die Führungs-ÜF kann dann bestimmt werden:

FW=tf(ZW,NW)

Diese Form wird durchgängig genutzt, da sie die allgemeine Lösung zur Untersuchung von Führungs-,

Versorgungsstörungs- und Laststörungsverhalten ermöglicht.

Alternativ kann mit der Funktion series() für die Reihenschaltung von Regler und Strecke und der

Funktion feedback() die Rückkopplungsschleife zum geschlossenen Regelkreis berechnet werden:

FR = tf(ZR,NR);

FS = tf(ZS,NS);

FW = feedback(series(FR,FS));

Bodediagramm

Für die Berechnung eines Bodediagramms steht die Funktion bode() im Package control zur

Verfügung. Es lassen sich mehrere Übertragungsfunktionen verarbeiten. Ohne eine Zuweisung wird ein

Plot-Fenster mit dem Bodediagramm erzeugt.

Fs1 = tf(10,[2 1]); Fs2 = tf(10,[4 2 1]);

bode(Fs1,Fs2,Fs1*Fs2);

A4: Octave

- 11 -

A4.7 Symbolik mit Matlab und Octave

Die meisten Analyseaufgaben im Studienbuch nutzen ausschließlich numerische Funktionen von

Matlab und Octave und dem Control-Package. In einigen Fällen kann das Symbolic-Package eingesetzt

werden. Bzgl. Octave basiert die aktuelle Version des Symbolic-Package ab der Version 2.0 auf dem

Projekt „SymPy3“. Die Syntax lehnt sich an die Symbolic-Toolbox von Mathlab an. Zurzeit werden

noch nicht alle Funktionen in dem Package unterstützt.

Die Vorgehensweise ist sehr einfach: mit dem Schlüsselwort syms werden symbolische Variablen

definiert. Mit diesen lassen sich dann Funktionen definieren:

>> syms x K

>> f(x)=K*x^2+3

f(x) = (symfun)

2

K*x + 3

>> f=K*x^2+3

f = (sym)

2

K*x + 3

Mit der Funktion diff() kann die Ableitung einer symbolischen Funktion erzeugt werden.

>> f1= diff(f,x)

f1 = (sym) 2*K*x

An dem Beispiel des Führungsverhaltens eines Regelkreises sollen die Anwendung der symbolischen

Funktionen aufgezeigt werden.

syms s % LaPlace-Bildvariable

syms Ks T1 T2

% Zähler und Nenner der Strecken-Uef

Zs = Ks;

Ns = (T1*s+1)*(T2*s+1);

syms Kr Tn

Zr = Kr*(Tn*s+1);

Nr = Tn*s;

% Ausgabe

disp('Strecke:');

Fs = simplify(Zs/Ns)

3 http://www.sympy.org

A4: Octave

- 12 -

disp('Regler:');

Fr = simplify(Zr/Nr)

disp('Führungs-ÜF');

Zw = Zr * Zs;

Nw = Nr*Ns + Zr*Zs;

Fw = Zw / Nw;

Fw = simplify(Fw)

% Numerische Auswertung

Pws = [Ks, T1, T2, Kr, Tn]; % Vektor der symbolischen Parameter

Pw = [0.5, 10, 2, 2.5, 10]; % numerische Parametervorgabe

% Generierung der numerischen Polynome der Strecken-UeF

ZwP = double( sym2poly(subs(Zw,Pws,Pw) ));

NwP = double( sym2poly(subs(Nw,Pws,Pw) ));

% TransferFunction / UeF der Führung

nFw = tf(ZwP,NwP)

step(nFw);

Auf der Konsole entstehen die nachfolgenden Ausgaben:

Strecke:

Fs = (sym)

Ks

---------------------

(T1*s + 1)*(T2*s + 1)

Regler:

Fr = (sym)

Kr

Kr + ----

Tn*s

Führungs-ÜF

Fw = (sym)

Kr*Ks*(Tn*s + 1)

---------------------------------------------

Kr*Ks*(Tn*s + 1) + Tn*s*(T1*s + 1)*(T2*s + 1)

A4: Octave

- 13 -

Transfer function 'nFw' from input 'u1' to output ...

12.5 s + 1.25

y1: ---------------------------------

200 s^3 + 120 s^2 + 22.5 s + 1.25

Weitere wichtige Möglichkeiten bestehen in der Erzeugung einer numerisch auswertbaren Matlab-

Funktion aus einer zuvor symbolisch definierten Funktion mit matlabFunction()

y(x) = 2 + 5*x + 50*x^2 + 90*sin(x*pi)

f = matlabFunction(y)

y1 = diff(y,x)

f1 = matlabFunction(y1)

A4.8 Aufbau der m-Files

Die zum Studienbuch gehörenden m-Files sind einheitlich strukturiert. Dies erleichtert das Verständnis

für die Skripte. Sie sind darauf ausgelegt, auf konkrete Aufgabenstellungen angepasst zu werden. Daher

werden die anpassbaren Parameter einer Stelle zusammengefasst und gekennzeichnet. Die m-Files

gliedern sich wie folgt:

Kopf Kommentarbereich mit Angaben zu

Ziel/Aufgabe des Skripts

Benötigte Packages/ Toolboxen

Datum der letzten Änderung

Initialisierung clear all; löscht den gesamten Variablenspeicher

close all; schließt alle offenen Plot-Fenster

Parameter-Block Hier werden die numerischen Variablenwerte oder

symbolische Definitionen vorgegeben

Berechnungen Generierung der Ergebnisse

Ausgabe der Ergebnisse Erzeugen eines oder mehrerer Plot-Fenster

Ausgabe von numerischen Werten auf die Konsole