Funktionen
| Site: | QSC |
| Course: | Q-SYS Control 101 Training (German) |
| Book: | Funktionen |
| Printed by: | Guest user |
| Date: | Saturday, 23 November 2024, 12:20 AM |
Description
Übungsbeschreibung
Erstelle wiederholbare Funktionen und führe diese Funktionen dann mit verschiedenen Parametern in Lua und im Block Controller aus.
Video Transkript
0:08
Im Scripting ist eine Funktion eine Aktion oder Reihe von Aktionen, die durch einen bestimmten
0:13
Impuls ausgelöst wird. In anderen Programmiersprachen heißt dies vielleicht „Vorgang“ oder
0:19
„Subroutine“. Bis jetzt ist alles, was wir mit Skriptsprache geschrieben haben, automatisch passiert,
0:25
wenn wir das Skript laufen ließen, doch eine Funktion ist eine Aktion, die du im Skript definierst, und
0:31
danach kannst du diese ausführen wann und wie immer du willst.
0:36
Eine Funktion besteht in Lua aus fünf Einzelteilen. Zuerst gibst du das Wort „function“ ein, dann
0:43
kannst du, wenn du willst, der Funktion einen Namen geben. Wenn du deine Funktion benannt hast,
0:48
kannst du denselben Ablauf von verschiedenen Stellen aus immer wieder aufrufen, ohne ihn jedes
0:52
Mal neu schreiben zu müssen.
0:55
Als nächstes fügst du in Klammern deine gewünschten Funktionsargumente ein. Du kannst ein
1:00
Funktionsargument als lokale Variable ansehen – etwas, das innerhalb der Funktion zum Einsatz kommt.
1:07
Dann schreiben wir den Hauptteil („body“) der Funktion, also die Liste der Aktionen, die von ihr
1:12
ausgeführt werden sollen. Zum Schluss beendest du die Funktion mit dem Wort „end“.
1:18
Hier haben wir eine sehr einfache Funktion namens „f“ mit zwei Argumenten – x und y. Im Hauptteil
1:25
dieser Funktion setzen wir das Ergebnis aus x plus y. Das Wort „end“ schließt die Funktion ab. Wir
1:33
können diese Funktion nun starten, indem wir einfach ihren Namen eingeben, und die
1:37
Funktionsargumente, die wir integrieren wollen, in die Klammer setzen.
1:41
Wenn ich z. B. „f(1,2)“ eingebe, wird das Ergebnis „3“ ausgegeben. Bitte beachtet, dass die Funktion
1:51
hier zwei Argumente erwartet. Wenn ich sie ohne alle erforderlichen Informationen aufrufe,
1:56
antwortet sie mit einer Fehlermeldung. Oder wenn ich hier eine drittes Argument einfüge, passiert
2:01
mit dieser Information rein gar nichts, weil diese Funktion für ein drittes Argument keinerlei
2:06
Anweisung hat.
2:09
Falls euch das bekannt vorkommt, liegt es daran, dass Ihr schon eine benannte Funktion verwendet …
2:14
nämlich „print“. Der Befehl „print“ ist eine Funktion, und was auch immer ihr als sein einziges
2:20
Argument einfügt, ist die Information, die diese Funktion an das Debug-Fenster sendet.
2:26
Wenn ihr zu den fortgeschritteneren Funktionen kommt, wisst ihr manchmal vielleicht nicht, wie
2:30
viele Argumente ihr einfügen sollt. In diesem Fall könnt ihr anstelle der Argumente „…“ eingeben.
2:37
Dann stellt sich die Funktion auf so viele Argumente ein, wie angegeben werden.
2:42
Wenn die Funktion hingegen keinerlei Argumente erfordert, muss die Konstruktion trotzdem noch
2:47
mit Klammer auf und Klammer zu vervollständigt werden. Dazwischen steht aber nichts. Schauen wir
2:52
uns als Beispiel ein paar andere einfache Funktionen an.
2:56
Das ist eine Funktion namens „goblue“, ganz ohne Argumente. Der Hauptteil der Funktion ändert
3:02
einfach nur den .Color-Parameter eines bestimmten Steuerungselements in „blau“ und endet dann.
3:08
Weil diese Funktion nur eine einzige Sache tut und ohne Variablen auskommt, brauchen wir keine
3:13
Informationen in unserer Argumente-Klammer.
3:17
Hier erstellen wir eine einfache mathematische Funktion namens „plus5“. Sie enthält ein Argument,
3:23
A. Mit dieser Funktion fügen wir dem Wert eines Steuerungselements 5 hinzu. Der Hauptteile der
3:31
Funktion sieht dann so aus: Wir nehmen den eingehenden Wert, A.Value, und definieren ihn neu als
3:39
sein aktueller Zustand plus 5.
3:42
Zusätzlich geben wir den neuen A.Value aus, bevor wir die Funktion schließen. Jetzt können wir die
3:49
Funktion ausführen und als Argument ein Steuerungselement eingeben, zu dessen Wert dann 5
3:54
hinzugerechnet wird.
3:56
Du könntest dem Hauptteil deiner Funktion auch einen Antwortbefehl hinzufügen, der dann die
4:01
Information ausgibt, die du am Ende der Funktion definiert hast. Nehmen wir beispielsweise noch
4:07
einmal unsere erste Funktion – anstatt eine „print“-Angabe zu integrieren, definiere ich die lokale
4:13
Variable „m“ als unser „x+y“. Nur kann ich „m“ nicht anzeigen, weil dies eine lokale Variable ist, auf
4:22
die mein Druckbefehl keinen Zugriff hat.
4:26
Wenn ich aber die Formulierung „return m“ ans Ende setze, weiß unsere Funktion, dass sie diese
4:31
Antwort wieder ausspucken soll. So kann ich also die Funktion („print (f(1,2)“) anzeigen lassen und sie
4:40
erscheint in meinem Debug-Fenster.
4:43
Noch eine letzte Sache, wo wir gerade hier bei Lua sind: Vielleicht ist dir dieses kleine Symbol links
4:47
neben deiner Funktion aufgefallen. Wenn du es anklickst, wird der ganze Funktionsaufbau zu einer
4:53
einzelnen Code-Zeile zusammengeklappt. Du kannst ihn zum Bearbeiten jederzeit wieder
4:58
aufklappen, oder wieder zuklappen, damit das Lesen etwas leichter fällt.
5:03
Im Block Controller kannst du eine Funktion definieren, indem du auf „Variables & Functions“ gehst.
5:10
Hier siehst du zwei Blöcke namens „define function“, von denen nur einer eine „return“-Option hat.
5:17
Wenn du also Rückinformationen von dieser Funktion möchtest, kannst du hier diese Variable
5:21
hinzufügen, während es bei dieser Funktion kein zurück gibt. WITZIG!
5:27
Gut, geben wir unserer Funktion einen Namen. Und wenn du Funktionsargumente integrieren willst,
5:32
klickst du auf das Zahnrad und fügst „inputs“ in den Hauptteil dieses Blocks ein. Hier baue ich zwei
5:38
Argumente ein, und wenn ich möchte, dass diese Funktion deren Summe ausgibt, hole ich mir aus
5:43
dem Bereich „System“ einen „debug print“-Befehl, dann aus dem Bereich „Operators“ einen Additionsblock.
5:52
Ich kann die Argumente direkt oben aus diesem Funktionsblock herausziehen, um sie in seinem
5:57
„body“ einzufügen. Halte einfach die Maus über das Argument, und die dazugehörigen Blöcke
6:04
werden angezeigt. Ich ziehe „x“ und „x1“ in meinen Rechenblock. Wenn ich diese Funktion jetzt
6:11
starten will, finde ich sie als Funktion unter „Variable & Functions“.
6:16
Ich muss nur die beiden Argumente mit Information bestücken, wenn dann mein Block-Controller-
6:21
Skript läuft, wird die Funktion ausgeführt. Wie immer lege ich euch ans Herz, den von diesen Blocks
6:27
erzeugten Lua-Code anzuschauen, um euer Verständnis der Skriptsprache zu vertiefen. Ihr seht, dass
6:33
die Funktion genau nach dem gerade gelernten Muster aufgebaut ist. Ausgeführt wird sie dann auf
6:39
Basis der beiden Werte, die wir als Argumente eingegeben haben.
6:43
Im nächsten Abschnitt geht es um die Erstellung der Bedingungen zum Ausführen einer solchen
6:48
Funktion. Davor gibt es im Control Worksheet aber noch ein paar Funktionen für euch zum
6:53
Ausführen. Wenn das geschafft ist, auf zum nächsten Video!