Language reference
Sprachreferenzen

Projektarchitektur

Allen Sprachen gemeinsame Objekte

AS-Sprache

Flußdiagramm

FBS-Sprache

KOP-Sprache

ST-Sprache

AWL-Sprache

Standard-Operatoren, Funktionsbausteine und Funktionen


 Projektarchitektur

Ein ISaGRAF-Projekt besteht aus mehreren Programmiereinheiten, die Programme genannt werden. Diese Projektprogramme sind in einer hierarchischen Architektur angeordnet. Sie können in den Grafik- oder Textsprachen AS, FD (Flußdiagramm), FBS, KOP, ST oder AWL geschrieben werden.

Programme

Zyklische und sequentielle Operationen

AS- und FD-Sohnprogramme

Funktionen und Unterprogramme

Funktionsbausteine

Programmiersprache

Ausführungsregeln


Programme

Ein Programm ist eine logische Programmiereinheit, die Operationen zwischen den Variablen eines Prozesses beschreibt. Dabei handelt es sich um sequentielle oder zyklische Operationen. Zyklische Programme werden automatisch bei jedem Zielsystemzyklus ausgeführt. Die sequentielle Programmausführung folgt den dynamischen Regeln der AS- oder FD-Sprache.

Die Programme sind in einer hierarchischen Baumstruktur angeordnet. Programme, die sich auf der höchsten Prioritätsebene befinden, werden vom System aktiviert. Die Unterprogramme (auf niedrigeren Prioritätsebenen) werden von ihren Vaterprogrammen gesteuert. Die Programmbeschreibungen erfolgen mit Hilfe der folgenden Grafik- oder Textsprachen :

- Ablaufsprache (AS) für die Programmierung hoher Prioritätsebenen

- Flußdiagramm (FD) für die Programmierung hoher Prioritätsebenen

- Funktionsbaustein-Sprache (FBS) für komplexe zyklische Operationen

- Kontaktplan (KOP) nur für boolesche Operationen

- Strukturierter Text (ST) für beliebige zyklische Operationen

- Anweisungsliste (AWL) für Operationen niedriger Ebenen

Für die Programmierung eines Programms können nicht mehrere Sprachen benutzt werden, mit Ausnahme von KOP und FBS, die in einem Diagramm miteinander kombiniert werden können.


Zyklische und sequentielle Operationen
Sequentielle und zyklische Abschnitte

Die Programmhierarchie besteht aus vier hauptsächlichen Abschnitten oder Gruppen :

ANFANG	Programme, die am Anfang eines jeden Zielsystemzyklus ausgeführt werden

SEQUENTIELL	Programme, die den dynamischen AS- oder FD-Regeln folgen

ENDE	Programme, die am Ende eines jeden Zielsystemzyklus ausgeführt werden

FUNKTIONEN	ein Satz nicht-dedizierter Unterprogramme

Die Programme der Abschnitte "Anfang" und "Ende" beschreiben zyklische Operationen und sind zeitunabhängig. Die Programme des Abschnitts "Sequentiell" beschreiben sequentielle Operationen, wobei die Basisoperationen expliziert von der Timer-Variablen synchronisiert werden. Die Hauptprogramme des Abschnitts "Anfang" werden systematisch am Anfang eines jeden Zyklus, die Hauptprogramme des Abschnitts "Ende" systematisch am Ende eines jeden Zyklus ausgeführt. Die Hauptprogramme des Abschnitts "Sequentiell" folgen den dynamischen AS- oder FD-Regeln.

Programme des Abschnitts "Funktionen" sind Unterprogramme, die von allen anderen Programmen des Projekts aufgerufen werden können. Ein Programm des Abschnitts "Funktionen" kann ein Unterprogramm dieses Abschnitts aufrufen.

Die Haupt- und Sohnprogramme des sequentiellen Abschnitts werden in der AS- oder FD-Sprache geschrieben, im Gegensatz zu den Programmen der zyklischen Abschnitte (Anfang und Ende), die nicht in der AS- oder FD-Sprache geschrieben werden können. Jedes Programm eines jeden Abschnitts kann ein oder mehrere Unterprogramme besitzen. Ein Programm des sequentiellen Abschnitts kann ein oder mehrere AS- oder FD-Sohnprogramme (deren Sprache seiner eigenen Programmiersprache entspricht) steuern. Unterprogramme können nicht in der AS- oder FD-Sprache geschrieben werden.

Die Programme des Abschnitts "Anfang" werden benutzt, um einleitende, auf den Eingangsvariablen ausgeführte Operationen zu beschreiben, um höhere gefilterte Variablen zu konstruieren. Solche Variablen werden häufig von den Programmen des Abschnitts "Sequentiell" verwendet. Die Programme des Abschnitts "Ende" werden benutzt, um Sicherheitsoperationen für Variablen zu beschreiben, die im Abschnitt "Sequentiell" benutzt werden, bevor die Werte zu den Ausgangseinrichtungen gesendet werden.


AS- und FD-Sohnprogramme

Ein beliebiges AS-Programm des sequentiellen Abschnitts kann andere AS-Programme, die AS-Sohnprogramme genannt werden, steuern. Ein AS-Sohnprogramm ist ein parallel ausgeführtes Programm, das von seinem Vaterprogramm gestartet, gestoppt, angehalten oder erneut gestartet werden kann. Das Vaterprogramm sowie sein Sohnprogramme werden beide in der AS-Sprache geschrieben. AS-Sohnprogramme können lokale Variablen und Definitionen besitzen.

Wenn ein Vaterprogramm ein AS-Sohnprogramm startet, setzt es eine AS-Zugriffsberechtigung (Aktivierung) in jeden seiner Initialisierungsschritte. Dieser Befehl wird mit der GSTART-Anweisung geschrieben. Wenn ein Vaterprogramm ein AS-Sohnprogramm stoppt, entfernt es alle vorhandenen Zugriffsberechtigungen aus seinen Schritten. Dieser Befehl wird mit der GKILL-Anweisung geschrieben.

Wenn ein Vaterprogramm ein AS-Sohnprogramm anhält, entfernt es alle vorhandenen Zugriffsberechtigungen aus seinen Schritten und speichert deren Position. Dieser Befehl wird mit der GFREEZE-Anweisung geschrieben. Wenn ein Vaterprogramm ein angehaltenes AS-Sohnprogramm erneut startet, ersetzt es alle beim Anhalten entfernten Zugriffsberechtigungen in den Schritten. Dieser Befehl wird mit der GRST-Anweisung geschrieben.

Ein beliebiges FD-Programm des sequentiellen Abschnitts kann andere FD-Unterprogramme steuern. Das FD-Vaterprogramm wird blockiert (wartet), bis die Ausführung des FD-Unterprogramms beendet ist. Es ist nicht möglich, gleichzeitige Operationen in einem FD-Vaterprogramm und einem seiner FD-Unterprogramme auszuführen.


Funktionen und Unterprogramme

Die Ausführung eines Unterprogramms oder einer Funktion wird von seinem Vaterprogramm gesteuert. Das Vaterprogramm wird solange unterbrochen, bis die Ausführung des Unterprogramms oder der Funktion vollendet ist :

Haupt.	Unterprogramme

Jedes Programm eines jeden Abschnitts kann ein oder mehrere Unterprogramme besitzen. Ein Unterprogramm kann nur von einem einzigen Vaterprogramm aktiviert werden. Unterprogramme können lokale Variablen und Definitionen besitzen. Für die Beschreibung eines Unterprogramms können alle Sprachen, mit Ausnahme der AS- und FD-Sprachen, verwendet werden. Die Programme des Abschnitts "Funktionen" sind Unterprogramme, die von beliebigen Programmen des Projekts aufgerufen werden können. Im Gegensatz zu anderen Unterprogrammen sind sie keinem Vaterprogramm dediziert. Ein Programm des Abschnitts "Funktionen" kann ein Unterprogramm dieses Abschnitts aufrufen.

Achtung: Das ISaGRAF-System unterstützt keine Rekursivität in den Funktionsaufrufen. Wenn ein Programm des Abschnitts "Funktionen" von sich selbst oder von einem seiner untergeordneten Programme aufgerufen wird, entsteht ein Ausführungsfehler.

Achtung: Eine Funktion oder ein Unterprogramm kann die lokalen Werte seiner lokalen Variablen nicht "speichern". Eine Funktion oder ein Unterprogramm ist nicht instanziiert, es kann also keine Funktionsbausteine aufrufen.

Die Schnittstelle eines Unterprogramms muß ausdrücklich definiert werden, mit einem Typ und einem einmaligen Namen für jeden seiner Aufrufparameter und den Returnparameter. Gemäß der Schreibkonventionen der ST-Sprache muß der Returnparameter eines Unterprogramms den gleichen Namen wie das Unterprogramm tragen.

Die folgende Tabelle zeigt, wie der Returnparameter im Rumpf eines Unterprogramms in den verschiedenen Sprachen forciert wird:

ST:	Unter Anwendung seines Namens (der gleiche Name wie das Unterprogramm) wird dem 	Returnparameter ein Wert zugewiesen.

unterprogramm_name:= <ausdruck>;

AWL:	Der Wert des aktuellen Ergebnisses (AWL-Verzeichnis) am Ende der Sequenz wird im 	Returnparameter gespeichert:

LD	10

ADD	20 	(* Wert des Returnparameters = 30 *)

FBS:	Zuordnung des Returnparameters unter Anwendung seines Namens:

unterprogramm_name

KOP:	Benutzen Sie ein Spulensymbol mit dem Namen des Unterprogramms:

unterprogramm_name


Funktionsbausteine

Funktionsbausteine können die Sprachen KOP, FBS, ST oder AWL benutzen. Funktionsbausteine sind instanziiert. Dies bedeutet, daß die lokalen Variablen eines Funktionsbausteins für jede Instance kopiert werden. Wenn ein Baustein in einem Programm aufgerufen wird, wird in Wirklichkeit die Instance des Baustein aufgerufen: es wird zwar der gleiche Code aufgerufen, aber die benutzten Daten sind die, welche der Instance zugeordnet wurden. Die Variablenwerte der Instance werden von einem Zyklus zum anderen gespeichert.

Achtung:

- Ein Funktionsbaustein, der in einer der IEC-Sprachen geschrieben wurde, kann keine anderen Funktionsbausteine aufrufen: Der Instanziierungsmechanismus verwaltet nur die lokalen Variablen des Bausteins selbst. Die folgenden Standardfunktionsbausteine können nicht in einem IEC-Funktionsbaustein benutzt werden:

SR, RS, R_Trig, F_Trig, SEMA, CTU, CTD, CTUD, TON, TOF, TP, CMP, StackInt, AVERAGE, HYSTER, LIM_ALRM, INTEGRAL, DERIVATE, BLINK, SIG_GEN

- Aus dem gleichen Grund können auch keine positiven oder negativen Kontakte und Spulen oder Setze- und Rücksetze-Spulen benutzt werden.

- Die Funktionen TSTART und TSTOP, die dazu dienen, Timer zu starten und zu stoppen, können nicht in Funktionsbausteinen für 3.0x Zielsysteme benutzt werden. Ihre Benutzung ist erst ab dem Zielsystem 3.20 möglich.

- Wenn eine Schleife in einem Funktionsbaustein benötigt wird, muß vor der Schleife eine lokale Variable eingesetzt werden. Es folgt ein Beispiel:

Diese Schleife funktioniert nicht:	So ist es richtig:


Programmiersprache

Ein Programm kann in einer der folgenden Grafik- oder Textsprachen geschrieben werden:

- Ablaufsprache (AS) für die Programmierung hoher Prioritätsebenen

- Flußdiagramm (FD) für die Programmierung hoher Prioritätsebenen

- Funktionsbaustein-Sprache (FBS) für komplexe zyklische Operationen

- Kontaktplan (KOP) nur für boolesche Operationen

- Strukturierter Text (ST) für beliebige zyklische Operationen

- Anweisungsliste (AWL) für Operationen niedriger Ebenen

Für die Programmierung eines Programms können nicht mehrere Sprachen benutzen werden, mit Ausnahme von KOP und FBS, die in einem Diagramm miteinander kombiniert werden können. Die Programmiersprache wird bei der Programmerstellung gewählt und kann später nicht mehr geändert werden


Ausführungsregeln

ISaGRAF ist ein synchrones System. Sämtliche Operationen sind zeitabhängig. Die Dauer einer Zeitspanne wird Zykluszeit genannt :

In einem Zielsystemzyklus erfolgen die folgenden Grundoperationen:

Dieses System garantiert :

- daß die Eingangsvariablen in einem Zyklus unverändert bleiben,

- daß die Ausgangseinrichtungen nicht öfter als einmal pro Zyklus aktualisiert werden,

- daß verschiedene Programme zuverlässig mit einer globalen Variablen arbeiten können,

- daß die Antwortzeit der gesamten Anwendung geschätzt und gesteuert werden kann.


 Allen Sprachen gemeinsame Objekte

Hier werden die hauptsächlichen Funktionalitäten und gemeinsamen Objekte der ISaGRAF-Programmierdatenbank vorgestellt. Diese Objekte können in allen AS-, FD-, FBS-, KOP-, ST- und AWL-Programmen benutzt werden.

Grundtypen

Konstante Ausdrücke

Variablen

Kommentare

Definitionen


Grundtypen

Alle konstanten Ausdrücke oder Variablen, die in einem Programm (einer beliebigen Sprache) benutzt werden, müssen mit einem Typ gekennzeichnet werden. Die Typenkonsistenz muß in den grafischen Operationen und in Textausdrücken befolgt werden. Die folgenden ISaGRAF-Grundtypen stehen für die Objektprogrammierung zur Verfügung :

BOOLESCH:	logischer Wert (true oder false)

ANALOG:	ganzzahliger oder realer (Fließkomma-) kontinuierlicher Wert

TIMER:	Zeitwert

ZEICHENKETTE:	Zeichenfolge

Hinweis : Timer enthalten Werte, die stets unter einem Tag liegen, und können nicht zum Speichern eines Datums benutzt werden.


Konstante Ausdrücke

Konstante Ausdrücke sind stets typenbezogen, d. h. daß dieselbe Notation nicht für konstante Ausdrücke unterschiedlichen Typs verwendet werden kann.

Konstante Ausdrücke vom Typ boolesch

Konstante Ausdrücke vom Typ ganzzahlig analog

Konstante Ausdrücke vom Typ real analog

Konstante Ausdrücke vom Typ Timer

Konstante Ausdrücke vom Typ Zeichenkette


Konstante Ausdrücke vom Typ boolesch

Es gibt lediglich zwei konstante Ausdrücke vom Typ boolesch :

TRUE	ist äquivalent zum ganzzahligen Wert 1

FALSE	ist äquivalent zum ganzzahligen Wert 0

Bei der Eingabe der Schlüsselwörter "True" und "False" wird zwischen Groß- und Kleinschreibung nicht unterschieden.


Konstante Ausdrücke vom Typ ganzzahlig analog

Ein konstanter Ausdruck vom Typ ganzzahlig ist ein vorzeichenbehafteter, langer, ganzzahliger (32 Bit) Wert zwischen -2147483647 und +2147483647.

Ein konstanter Ausdruck vom Typ ganzzahlig analog kann in einer der folgenden Grundgrößen ausgedrückt werden. Ganzzahlige konstante Ausdrücke müssen mit einem Vorzeichen beginnen, das deren Grundgröße kennzeichnet.

Grundgröße	Vorzeichen	Beispiel

DEZIMAL	(kein)	-908

HEXADEZIMAL	"16#"	16#1A2B3C4D

OKTAL	"8#"	8#1756402

BINÄR	"2#"	2#1101_0001_0101_1101

Das Unterstrichzeichen ('_') hat keine semantische Bedeutung und kann beliebig zum Trennen einzelner Zeichengruppen verwendet werden. Es steigert die Leserlichkeit längerer Ausdrücke.


Konstante Ausdrücke vom Typ real analog

Konstante Ausdrücke vom Typ real analog können dezimal oder wissenschaftlich dargestellt werden. Ein Dezimalpunkt ('.') trennt den dezimalen vom ganzen Zahlenteil. Dies ist absolut notwendig, um ganzzahlige Konstanten von den realen Konstanten unterscheiden zu können. In der wissenschaftlichen Darstellungsweise werden die Buchstaben 'E' oder 'F' benutzt, um die Mantisse vom Exponenten zu trennen. Der Exponent eines realen  wissenschaftlichen Ausdrucks ist eine vorzeichenbehaftete Ganzzahl zwischen -37 und +37. Hier einige Beispiele konstanter Ausdrücke vom Typ real analog:

3.14159	-1.0E+12

+1.0	1.0F-15

-789.56	+1.0E-37

Der Ausdruck "123" stellt keinen realen konstanten Wert dar. Die richtige Schreibweise ist "123.0".


Konstante Ausdrücke vom Typ Timer

Konstante Ausdrücke vom Typ Timer sind Zeitwerte zwischen 0 Sekunden und 23h59m59s99ms. Die kleinste zulässige Einheit ist eine Millisekunde. Die folgenden Standardzeiteinheiten werden in konstanten Ausdrücken vom Typ Timer benutzt:

Stunde:	Der Buchstabe "h" folgt auf die Anzahl der Stunden

Minute:	Der Buchstabe "m" folgt auf die Anzahl der Minuten

Sekunde:	Der Buchstabe "s" folgt auf die Anzahl der Sekunden

Millisekunde:	Die Buchstaben "ms" folgen auf die Anzahl der Millisekunden

Der Ausdruck muß mit dem Vorzeichen "T#" oder "TIME#" beginnen. Für die Vorzeichen oder Buchstaben sind Groß- und Kleinschreibung zulässig. Bestimmte Einheiten können weggelassen werden. Hier einige Beispiele für konstante Ausdücke vom Typ Timer :

T#1H450MS	1 Stunde und 450 Millisekunden

time#1H3M	1 Stunde und 3 Minuten

Der Ausdruck "0" ist kein Zeitwert, sondern ein analoger konstanter Ausdruck.


Konstante Ausdrücke vom Typ Zeichenkette

Konstante Ausdrücke vom Typ Zeichenkette sind Zeichenfolgen, die zwischen zwei Apostrophen geschrieben werden. Zum Beispiel :

'DIES IST EINE ZEICHENKETTE'

Achtung: Das Apostroph-Zeichen darf nicht innerhalb der Zeichenkette verwendet werden. Ein konstanter Ausdruck vom Typ Zeichenkette muß auf einer Zeile des Programmquellcodes geschrieben werden und darf 255 Zeichen (einschließlich Leerzeichen) nicht überschreiten.

Eine leere Zeichenkette wird durch zwei Apostroph-Zeichen gekennzeichnet, zwischen denen keine Leerzeichen oder Tabs erlaubt sind:

''   (* dies ist eine leere Zeichenkette *)

Das Spezialzeichen Dollar ('$'), gefolgt von anderen Spezialzeichen, kann benutzt werden, um nicht druckbare Zeichen in eine Zeichenkette einzufügen :

Sequenz	Bedeutung	Ascii	Beispiel

$$	'$'-Zeichen	16#24	'Der $$ steht...'

$'	Apostroph	16#27	'Geben Sie $'O$' für YES ein '

$L	folgende Zeile	16#0a	'folgende $L Zeile'

$R	Wagenrückgang	16#0d	'    Tag $R guten'

$N	neue Zeile	16#0d0a	'Dies ist eine Zeile$N'

$P	neue Seite	16#0c	'Seitenende $P Seitenanfang'

$T	Tabulation	16#09	'Name$TGröße$TDatum'

$hh   (*)	belieb. Zeichen	16#hh	'ABCD = $41$42$43$44'

(*) "hh" ist der hexadezimale Wert des Ascii-Codes für das Zeichen.


Variablen

Variablen können Programm-LOKAL oder GLOBAL sein. Lokale Variablen können nur von einem einzigen Programm benutzt werden, globale Variablen hingegen von allen Programmen eines Projekts.

Reservierte Schlüsselwörter

Direkt dargestellte Variablen

Boolesche Variablen

Analoge Variablen

Timer-Variablen

Zeichenketten-Variablen

Variablennamen müssen die folgenden Regeln beachten :

- Der Name darf nicht länger als 16 Zeichen sein,

- das erste Zeichen muß ein Buchstabe sein,

- darauffolgende Zeichen müssen Buchstaben, Zahlen oder Unterstrichzeichen sein.


Reservierte Schlüsselwörter

Es folgt eine Liste reservierter Schlüsselwörter. Solche Bezeichner können nicht als Namen für Programme, Variablen, "C"-Funktionen oder -Funktionsbausteine benutzt werden:

A	ANA, ABS, ACOS, ADD, ANA, AND, AND_MASK, ANDN, ARRAY, ASIN, AT, ATAN,

B	BCD_TO_BOOL, BCD_TO_INT, BCD_TO_REAL, BCD_TO_STRING, BCD_TO_TIME, BOO, BOOL, BOOL_TO_BCD, BOOL_TO_INT, BOOL_TO_REAL, BOOL_TO_STRING, BOOL_TO_TIME, BY, BYTE,

C	CAL, CALC, CALCN, CALN, CALNC, CASE, CONCAT, CONSTANT, COS,

D	DATE, DATE_AND_TIME, DELETE, DINT, DIV, DO, DT, DWORD,

E	ELSE, ELSIF, EN, END_CASE, END_FOR, END_FUNCTION, END_IF, END_PROGRAM, END_REPEAT, END_RESSOURCE, END_STRUCT, END_TYPE, END_VAR, END_WHILE, ENO, EQ, EXIT, EXP, EXPT,

F	FALSE, FEDGE, FIND, FOR, FUNCTION,

G	GE, GFREEZE, GKILL, GRST, GSTART, GSTATUS, GT,

I	IF, INSERT, INT, INT_TO_BCD, INT_TO_BOOL, INT_TO_REAL, INT_TO_STRING, INT_TO_TIME,

J	JMP, JMPC, JMPCN, JMPN, JMPNC,

L	LD, LDN, LE, LEFT, LEN, LIMIT, LINT, LN, LOG, LREAL, LT, LWORD,

M	MAX, MID, MIN, MOD, MOVE, MSG, MUL, MUX,

N	NE, NOT,

O	OF, ON, OPERATE, OR, OR_MASK, ORN,

P	PROGRAM

R	R, REDGE, READ_ONLY, READ_WRITE, REAL, REAL_TO_BCD, REAL_TO_BOOL, REAL_TO_INT, REAL_TO_STRING, REAL_TO_TIME, REDGE, REPEAT, REPLACE, RESSOURCE, RET, RETAIN, RETC, RETCN, RETN, RETNC, RETURN, RIGHT, ROL, ROR,

S	S, SEL, SHL, SHR, SIN, SINT, SQRT, ST, STN, STRING, STRING_TO_BCD, STRING_TO_BOOL, STRING_TO_INT, STRING_TO_REAL, STRING_TO_TIME, STRUCT, SUB, SYS_ERR_READ, SYS_ERR_TEST, SYS_INITALL, SYS_INITANA, SYS_INITBOO, SYS_INITTMR, SYS_RESTALL, SYS_RESTANA, SYS_RESTBOO, SYS_RESTTMR, SYS_SAVALL, SYS_SAVANA, SYS_SAVBOO, SYS_SAVTMR, SYS_TALLOWED, SYS_TCURRENT, SYS_TMAXIMUM, SYS_TOVERFLOW, SYS_TRESET, SYS_TWRITE, SYSTEM,

T	TAN, TASK, THEN, TIME, TIME_OF_DAY, TIME_TO_BCD, TIME_TO_BOOL, TIME_TO_INT, TIME_TO_REAL, TIME_TO_STRING, TMR, TO, TOD, TRUE, TSTART, TSTOP, TYPE,

U	UDINT, UINT, ULINT, UNTIL, USINT,

V	VAR, VAR_ACCESS, VAR_EXTERNAL, VAR_GLOBAL, VAR_IN_OUT, VAR_INPUT, ,VAR_OUTPUT,

W	WHILE, WITH, WORD,

X 	XOR, XOR_MASK, XORN

Alle Schlüsselwörter, die mit einem Unterstrichzeichen ('_') beginnen, sind interne Schlüsselwörter und dürfen nicht in Textanweisungen benutzt werden.


Direkt dargestellte Variablen

ISaGRAF ermöglicht die Verwendung von direkt dargestellten Variablen in den Quellcodes der Programme, um einen freien Kanal darzustellen. Unter freien Kanälen versteht man Kanäle, welche nicht mit einer deklarierten E/A-Variablen verknüpft sind. Der Bezeichner einer direkt dargestellten Variablen beginnt stets mit dem Zeichen "%".

Es folgen die Benennungskonventionen einer direkt dargestellten Variablen für den Kanal einer einzelnen Karte. "s" ist die Steckplatznummer der Karte. "c" ist die Nummer des Kanals.

%IXs.c	freier Kanal einer booleschen Eingangskarte

%IDs.c	freier Kanal einer ganzzahligen Eingangskarte

%ISs.c	freier Kanal einer Zeichenketten-Eingangskarte

%QXs.c	freier Kanal einer booleschen Ausgangskarte

%QDs.c	freier Kanal einer ganzzahligen Ausgangskarte

%QSs.c	freier Kanal einer Zeichenketten-Ausgangskarte

Es folgen die Benennungskonventionen einer direkt dargestellten Variablen für den Kanal einer Baugruppe. "s" ist die Steckplatznummer der Baugruppe. "b" ist der Index der einzelnen Karte innerhalb der Baugruppe. "c" ist die Nummer des Kanals.

%IXs.b.c	freier Kanal einer booleschen Eingangskarte

%IDs.b.c	freier Kanal einer ganzzahligen Eingangskarte

%ISs.b.c	freier Kanal einer Zeichenketten-Eingangskarte

%QXs.b.c	freier Kanal einer booleschen Ausgangskarte

%QDs.b.c	freier Kanal einer ganzzahligen Ausgangskarte

%QSs.b.c	freier Kanal einer Zeichenketten-Ausgangskarte

Hier zwei Beispiele:

%QX1.6	6ter Kanal der Karte #1 (boolescher Ausgang)

%ID2.1.7	7ter Kanal der Karte #1 in der Baugruppe #2 (ganzzahliger Eingang)

Eine direkt dargestellte Variable kann nicht den Datentyp "real" haben.


Boolesche Variablen

Boolesch ist gleichbedeutend mit logisch. Boolesche Variablen können ausschließlich die Werte TRUE oder FALSE annehmen und werden in booleschen Ausdrücken benutzt. Eine boolesche Variable kann eines der folgenden Attribute besitzen :

Intern:	vom Programm aktualisierte Speichervariable

Eingang:	an einen Sensor angeschlossene Variable (vom System aktualisiert)

Ausgang:	an einen Aktor angeschlossene Variable

Achtung: Bei der Deklaration einer booleschen Variablen können die Werte "true" und "false" durch Zeichenketten ersetzt werden, die jedoch ausschließlich für die Programmeinstellung (Debugging) bestimmt sind. Diese Zeichenketten dürfen nicht in den Programmen benutzt werden, außer sie werden als Definitionen für die Sprache eingegeben.


Analoge Variablen

Analog ist gleichbedeutend mit kontinuierlich. Diese Variablen nehmen vorzeichenbehaftete, ganzzahlige oder reale (Fließkomma-) Werte an. Folgende Formate sind verfügbar :

Ganzzahlig:	vorzeichenbehaftete Ganzzahl auf 32 Bits :

von -2147483647 bis +2147483647

Real:    	Fließkommawert auf 32 Bits - Standard IEEE

(einfache Präzision)

1 Vorzeichenbit + 23 Mantisse-Bits + 8 Exponenten-Bits

Der Exponent einer REALEN analogen Variablen muß zwischen einschließlich -37 und +37 liegen.

Analoge Variablen können eins der folgenden Attribute besitzen :

Intern:	vom Programm aktualisierte Speichervariable

Eingang:	an einen Sensor angeschlossene Variable (vom System aktualisiert)

Ausgang:	an einen Aktor angeschlossene Variable

Hinweis: Wenn eine reale Variable an eine E/A-Einrichtung angeschlossen ist, verarbeitet der entsprechende E/A-Treiber den äquivalenten ganzzahligen Wert.

Achtung: Ganzzahlige und reale analoge Variablen oder konstante Ausdrücke können nicht in einem analogen Ausdruck gemischt werden.


Timer-Variablen

Ein Timer ist ein Zähler. Timer-Variablen nehmen zeitbezogene Werte an und werden in Zeitausdrücken benutzt. Ein Zeitwert liegt zwischen 0s und 23h59m59s99 und kann nicht negativ sein. Timer-Variablen werden auf 32 Bits gespeichert. Ihre interne Darstellung ist eine positive Anzahl an Millisekunden.

Achtung: Timer-Variablen können keine EINGANGS- oder AUSGANGS-Attribute besitzen.

Timer-Variablen können vom ISaGRAF-System automatisch aktualisiert werden. Wenn ein Timer aktiv ist, wird sein Wert automatisch nach der Systemuhr inkrementiert. Die folgenden Anweisungen der ST-Sprache können benutzt werden, um einen Timer zu steuern :

TSTART:	startet die automatische Aktualisierung eines Timers

TSTOP:	stoppt die automatische Aktualisierung eines Timers


Zeichenketten-Variablen

Bei diesen Variablen handelt es sich um Variablen, die Zeichenketten enthalten. Die Länge der Kette hängt von den ausgeführten Operationen ab und beschränkt sich auf die maximale Länge, die bei ihrer Deklaration bestimmt wurde (maximal 255 Zeichen). Eine Zeichenketten-Variable kann die folgenden Attribute besitzen :

Intern:	vom Programm aktualisierte Speichervariable

Eingang:	an einen Sensor angeschlossene Variable (vom System aktualisiert)

Ausgang:	an einen Aktor angeschlossene Variable

Zeichenketten-Variablen können sämtliche Zeichen der Ascii-Tabelle enthalten (Codes 0 bis 255). Das Nullzeichen (Code 0) ist innerhalb der Kette erlaubt. Bestimmte "C"-Funktionen der ISaGRAF-Standardbibliothek können Zeichenketten, die Nullzeichen (0) enthalten, nicht richtig verarbeiten.


Kommentare

Im Quellcode der ST- und AWL-Textprogramme dürfen Kommentare frei eingefügt werden. Ein Kommentar beginnt mit den Zeichen "(*" und ended mit den Zeichen "*)". Kommentare können an beliebigen Stellen in einem ST-Programm eingesetzt werden und sich über mehrere Zeilen erstrecken.

Es folgen einige Beispiele :

counter := ivalue;   (* Zuweisung Hauptzähler *)

(* hier ein Kommentar

auf zwei Zeilen *)

c := counter (* Kommentare können an beliebigen Stellen eingefügt werden *) + base_value + 1;

Kommentare dürfen nicht verschachtelt werden. Die Zeichen "(*" sind innerhalb der Kommentare nicht zugelassen.

Achtung: In der AWL-Sprache werden Kommentare nur dann akzeptiert, wenn sie als letztes Element einer Anweisungszeile erscheinen.


Definitionen

Im ISaGRAF-System können konstante Ausdrücke, boolesche "true" und "false" Ausdrücke, Schlüsselwörter oder komplexe ST-Ausdrücke neu definiert werden. Zu diesem Zweck wird einem Ausdruck ein entsprechender Bezeichner zugewiesen. Zum Beispiel :

YES	bedeutet	TRUE

PI	bedeutet	3.14159

OK	bedeutet	(auto_modus AND NOT (alarm))

Wenn solch eine Äquivalenz definiert ist, kann ihr Bezeichner an einer beliebigen Stelle im ST-Programm benutzt werden, um den zugeordneten Ausdruck zu ersetzen. Im folgenden ST-Programm werden die oben definierten Äquivalenzen verwendet :

If OK Then

   angle := PI / 2.0;

   isdone := YES;

End_if;

Definitionen können programm- LOKAL, GLOBAL, oder ALLGEMEIN sein.

Lokale Definitionen können nur von einem Programm benutzt werden.

Globale Definitionen können von allen Programmen eines Projekts benutzt werden.

Allgemeine Definitionen können von allen Programmen aller Projekte benutzt werden.

Beachten Sie, daß allgemeine Definitionen mit dem Archivmanager separat gespeichert werden können.

Achtung: Wenn der gleiche Bezeichner zweimal mit unterschiedlichen ST-Äquivalenzen definiert wird, wird der zuletzt definierte Ausdruck benutzt. Zum Beispiel:

Definition:	OPEN	ist äquivalent zu	FALSE

OPEN	ist äquivalent zu	TRUE

bedeutet:	OPEN	ist äquivalent zu	TRUE

Bei der Benennung der Definitionen müssen die folgenden Regeln beachtet werden :

- Der Name darf nicht länger als 16 Zeichen sein,

- das erste Zeichen muß ein Buchstabe sein,

- darauffolgende Zeichen müssen Buchstaben, Zahlen, oder Unterstrichzeichen ('_') sein.

Achtung: Eine Definition kann keine andere Definition in ihrem Ausdruck benutzen. Das folgende Beispiel ist ungültig:

PI	ist	3.14159

PI2 	ist	PI*2

Schreiben Sie die vollständige Äquivalenz unter Verwendung von Konstanten oder Variablen und Operationen:

PI2 	ist	6.28318


 AWL-Sprache

Die AWL-Sprache (Anweisungsliste) ist eine Textsprache niedrigen Niveaus. Sie eignet sich besonders für kleinere Anwendungen oder um bestimmte Teile einer Anwendung zu optimieren. Die Anweisungen verarbeiten stets aktuelle Ergebnisse (oder AWL-Verzeichnisse). Der Operator zeigt an, welche Art von Operation zwischen dem aktuellen Ergebnis und dem Operand erfolgen soll. Das Ergebnis der Operation wird seinerseits im aktuellen Ergebnis gespeichert.

Syntax der AWL-Sprache

AWL- Operatoren


Syntax der AWL-Sprache

Ein AWL-Programm ist eine Liste von Anweisungen. Jede Anweisung wird auf einer neuen Zeile geschrieben und muß einen Operator enthalten, eventuell vervollständigt durch Ergänzungen und, wenn für die Operation erforderlich, einen oder mehrere Operanden, die durch Kommas (',') getrennt werden. Eine Marke, gefolgt von einem Doppelpunkt (':') kann der Anweisung vorangehen. Wenn der Anweisung ein Kommentar angehängt wird, muß er das letzte Element der Zeile sein. Ein Kommentar beginnt stets mit dem Zeichen '(*' und endet mit '*)'. Zwischen den Anweisungen können leere Zeilen eingefügt werden. Kommentare dürfen auch auf Zeilen ohne Anweisungen geschrieben werden.

Marken

Anweisungs-Ergänzungen

Verzögerte Operationen

Beispiele von Anweisungszeilen :

MARKE	OPERATOR	OPERAND	KOMMENTARE

Anfang:	LD	IX1	(* Druckknopf *)

ANDN	MX5	(* Befehl gültig *)

ST	QX2	(* startet Motor *)


Marken

Eine Marke, gefolgt von einem Doppelpunkt (':') kann der Anweisung vorangehen. Marken können auf Zeilen gesetzt werden, die keine Anweisungen enthalten. Von manchen Anweisungen, wie z.b. den Sprüngen, werden sie als Operanden benutzt. Bei der Benennung der Marken müssen die folgenden Regeln beachtet werden :

- Der Name darf höchstens 16 Zeichen enthalten

- Das erste Zeichen muß ein Buchstabe sein.

- Darauffolgende Zeichen können Buchstaben, Zahlen oder '_' sein.

Zwei Marken desselben AWL-Programms dürfen nicht den gleichen Namen tragen. Eine Marke darf den gleichen Namen wie eine Variable haben.


Anweisungs-Ergänzungen

Die folgende Liste enthält Ergänzungen, die für die Anweisungen in der AWL-Sprache zugelassen sind. Das Ergänzungszeichen wird dem Anweisungsnamen ohne Trennzeichen beigefügt.

N	boolesche Inversion des Operands

(	Verzögerungsoperation

C	bedingte Operation

Die Ergänzung 'N' bedeutet, daß der Operand nicht invertiert werden darf, bevor er von der Anweisung verwendet wird. Zum Beispiel wird die Anweisung ANDN IX12 auf folgende Weise interpretiert :

Ergebnis := Ergebnis AND NOT ( IX12 )

Die Ergänzung "Klammer auf" '(' bedeutet, daß die Anweisungsbewertung bis zur nächsten Anweisung verzögert werden muß "Klammer zu" ')'.

Die Ergänzung 'C' bedeutet, daß die Anweisung nur dann ausgeführt werden kann, wenn das aktuelle Ergebnis den booleschen Wert TRUE hat (oder ungleich 0 für einen nicht booleschen Wert). Die Ergänzung 'C' kann mit dem Operator 'N' kombiniert werden, um anzuzeigen, daß die Anweisung nur dann ausgeführt werden kann, wenn das aktuelle Ergebnis den Wert FALSE hat (oder 0 für eine nicht boolesche Anweisung).


Verzögerte Operationen

Da die AWL-Sprache nur ein einziges Verzeichnis verarbeitet (aktuelles Ergebnis), müssen manche Operationen verzögert werden, um die natürliche Ausführungsordnung der Anweisungen zu ändern. Für die Darstellung dieser Verzögerungen werden Klammern benutzt.

'('	ist eine Ergänzung	die Operation wird verzögert

')'	ist eine Anweisung	die verzögerte Operation wird ausgeführt

Die Ergänzung "Klammer auf" '(' bedeutet, daß die Anweisungsbewertung bis zur nächsten Anweisung verzögert werden muß "Klammer zu" ')'. Zum Beispiel wird die folgende Sequenz :

AND(	IX12

OR	IX35

)

so interpretiert :

Ergebnis := Ergebnis AND ( IX12 OR IX35 )


AWL- Operatoren

Die folgende Tabelle ist eine Zusammenfassung sämtlicher Operatoren der AWL-Sprache:

Operator	Ergänzung	Operand	Beschreibung

LD	N	Variable,Konst	Lädt den Operand

ST	N	Variable	Speichert aktuelles Ergebnis

S	BOO-Variable	Forcierung zu TRUE

R	BOO-Variable	Forcierung zu FALSE

AND (&)	N   (	BOO	logisches UND

OR	N   (	BOO	logisches ODER

XOR	N   (	BOO	exklusiv-ODER

ADD	(	ANA oder TMR	Addition

SUB	(	ANA oder TMR	Substraktion

MUL	(	ANA oder TMR	Multiplikation

DIV	(	ANA oder TMR	Division

GT	(	ANA oder TMR	Test >

GE	(	ANA oder TMR	Test >=

EQ	(	ANA oder TMR	Test =

LE	(	ANA oder TMR	Test <=

LT	(	ANA oder TMR	Test <

NE	(	ANA oder TMR	Test <>

JMP	C   N	Marke	Sprung zu einer Marke

RET	C   N	Rückgabe von Unterprogramm

 ) 	Ausführung verzögerter Anweisungen

Funktion	Aufruf eines Unterprogramms oder einer Funktion

CAL	C   N 	FB Instancen-Name	Aufruf eines Funktionsbausteins

Im folgenden Abschnitt werden ausschließlich Operatoren beschrieben, die spezifisch zur AWL-Sprache sind. Andere Standard-Operatoren werden im Abschnitt "Standard-Operatoren, Funktionsbausteine und Funktionen" erläutert.


"LD"-Operator

Operation	Lädt einen Wert in das aktuelle Ergebnis

Ergänzungen	N

Operand	Konstanter Ausdruck

Interne, Ein- oder Ausgangsvariable

Beispiel :

(* BEISPIELE VON LD-OPERATIONEN *)

LDex:	LD	false	(* Ergebnis := boolesche Konstante FALSE *)

LD	true	(* Ergebnis := boolesche Konstante TRUE *)

LD	123	(* Ergebnis := analoge Konstante *)

LD	123.4	(* Ergebnis := reale analoge Konstante *)

LD	t#3s	(* Ergebnis := Timer-Konstante *)

LD	boo_var1	(* Ergebnis := boolesche Variable *)

LD	ana_var1	(* Ergebnis := analoge Variable *)

LD	tmr_var1	(* Ergebnis := Timer-Variable *)

LDN	boo_var2	(* Ergebnis := NOT ( boolesche Variable ) *)


Operator "ST"

Operation	Speichert das aktuelle Ergebnis in einer Variablen

Das aktuelle Ergebnis wird von dieser Anweisung

nicht geändert

Ergänzungen	N

Operand	Interne oder Ausgangsvariable

Beispiel :

(* BEISPIELE VON ST-OPERATIONEN *)

STboo:	LD	false

ST	boo_var1	(* boo_var1 := FALSE *)

STN	boo_var2	(* boo_var2 := TRUE *)

STana:	LD	123

ST	ana_var1	(* ana_var1 := 123 *)

STtmr:	LD	t#12s

ST	tmr_var1	(* tmr_var1 := t#12s *)


"S"-Operator

Operation	Forciert eine boolesche Variable zu TRUE,

wenn das aktuelle Ergebnis TRUE ist. Keine Operation

erfolgt, wenn das aktuelle Ergebnis FALSE ist. Das aktuelle

Ergebnis wird von dieser Anweisung nicht geändert.

Ergänzungen	(keine)

Operand	Boolesche, interne oder Ausgangsvariable

Beispiel :

(* BEISPIELE VON S-OPERATIONEN*)

SETex:	LD	true	(* aktuelles Ergebnis := TRUE *)

S	boo_var1	(* boo_var1 := TRUE *)

(* unverändertes, aktuelles Ergebnis *)

LD	false	(* aktuelles Ergebnis := FALSE *)

S	boo_var1	(* keine Aktion - boo_var1 unverändert *)


"R"-Operator

Operation	Forciert eine boolesche Variable zu FALSE,

wenn das aktuelle Ergebnis TRUE ist. Keine Operation

erfolgt, wenn das aktuelle Ergebnis FALSE ist. Das aktuelle

Ergebnis wird von dieser Anweisung nicht geändert.

Ergänzungen	(keine)

Operand	Boolesche, interne oder Ausgangsvariable

Beispiel :

(* BEISPIELE VON R-OPERATIONEN *)

RESETex:	LD	true	(* aktuelles Ergebnis := TRUE *)

R	boo_var1	(* boo_var1 := FALSE *)

(* aktuelles Ergebnis unverändert *)

ST	boo_var2	(* boo_var2 := TRUE *)

LD	false	(* aktuelles Ergebnis := FALSE *)

R	boo_var1	(* keine Aktion - boo_var1 unverändert *)


"JMP"-Operator

Operation	Sprung zu einer durch eine Marke aufgefundene Anweisung

Ergänzungen	C   N

Operand	Marke in demselben AWL-Programm definiert

Beispiel :

(* Das folgende Beispiel testet den Wert eines analogen Selektors *)

(* (0 oder 1 oder 2) und forciert eine von drei booleschen Variablen. *)

(* Der Test "gleich 0" wird von der JMPC-Anweisung ausgeführt. *)

JMPex:	LD	selector	(* Selektor = 0 oder 1 oder 2 *)

BOO	(* Umrechnung zu boolesch *)

JMPC	test1	(* wenn Selector = 0 dann *)

LD	true

ST	bo0	(* bo0 := true *)

JMP	JMPend	(* Programmende *)

(* dekrementiert Selektor *)

test1:	LD 	selector

SUB	1	(* Selektor ist 0 oder 1 *)

BOO	(* Umrechnung zu boolesch *)

JMPC	test2	(* wenn Selektor = 0 dann *)

LD	true

ST	bo1	(* bo1 := true *)

JMP	JMPend	(* Programmende *)

(* letzte Möglichkeit *)

test2:	LD	true

ST	bo2	(* bo2 := true *)

JMPend:	(* Programmende *)


"RET"-Operator

Operation	Beendet die Programmausführung.

Wenn die AWL-Sequenz ein Unterprogramm ist,

wird das aktuelle Ergebnis des Werts zum aufrufenden

Programm zurückgegeben.

Ergänzungen	C   N

Operand	(keine)

Beispiel :

(* Das folgende Beispiel testet den Wert eines analogen Selektors *)

(* (0 oder 1 oder 2) und forciert eine von drei booleschen Variablen. *)

(* Der Test "gleich 0" wird von der JMPC-Anweisung ausgeführt. *)

RETex:	LD	selector	(* Selektor = 0 oder 1 oder 2 *)

BOO	(* Umrechnung zu boolesch *)

JMPC	test1	(* wenn Selektor = 0 dann *)

LD	true

ST	bo0	(* bo0 := true *)

RET	(* Ende - gibt 0 zurück *)

(* dekrementiert Selektor *)

test1:	LD	selector

SUB	1	(* Selektor = 0 oder 1 *)

BOO	(* Umrechnung zu boolesch *)

JMPC	test2	(* wenn Selektor = 0 dann *)

LD	true

ST	bo1	(* bo1 := true *)

LD	1	(* Wert des Selektors *)

RET	(* Ende - gibt 1zurück *)

(* letzte Möglichkeit *)

test2:	RETNC	(* Rückgabe, wenn Selektor einen *)

(* ungültigen Wert enthält *)

LD	true

ST	bo2	(* bo2 := true *)

LD	2	(* Wert des Selektors *)

  	RET	(* Ende - gibt 2 zurück *)


")"-Operator

Operation	Führt eine verzögerte Operation aus.

Die verzögerte Operation wurde durch "(" geändert.

Ergänzungen	(keine)

Operand	(keine)

Beispiel :

(* Beispiel von verschachtelten, verzögerten Operationen *)

(* res := a1 + (a2 * (a3 - a4) * a5) + a6; *)

Delayed:	LD	a1	(* Ergebnis:= a1; *)

ADD(	a2	(* verzögertes ADD - Ergebnis:= a2; *)

MUL(	a3	(* verzögertes MUL - Ergebnis:= a3; *)

SUB	a4	(* Ergebnis:= a3 - a4; *)

)	(* führt verz. MUL aus - Ergebnis:= a2*(a3-a4); *)

MUL	a5	(* Ergebnis:= a2 * (a3 - a4) * a5; *)

)	(* führt verzögertes ADD aus*)

(* Ergebnis:= a1 + (a2 * (a3 - a4) * a5); *)

ADD	a6	(* Ergebnis:= a1 + (a2 * (a3 - a4) * a5) + a6; *)

ST	res	(* res := aktuelles Ergebnis *)


Aufruf eines Unterprogramms oder einer Funktion

Ein Unterprogramm oder eine Funktion (in der AWL, ST, KOP, FBS oder "C"-Sprache geschrieben) wird von der AWL-Sprache aufgerufen, wobei ihr Name als Operator benutzt wird.

Operation	führt ein Unterprogramm oder eine Funktion aus - der vom Unterprogramm oder der Funktion zurückgegebene Wert wird im aktuellen AWL-Ergebnis gespeichert.

Ergänzungen	(keine)

Operand	Der erste Aufrufparameter muß vor dem Aufruf im aktuellen Ergebnis gespeichert werden. Die folgenden Aufrufparameter werden, durch Kommas getrennt, im Operandenfeld ausgedrückt.

Beispiel :

(* Aufruf eines Unterprogramms : Umrechnung analog > Timer *)

Main:	LD	bi0

SUBPRO	bi1,bi2	(* Unterprogramm-Aufruf *)

(* Ergebnis := vom Unterprogramm *)

(* zurückgegebener Wert *)

ST	result	(* Ergebnis := vom Unterprogramm zurückgegebener Wert *)

GT	vmax	(* Überschreitungstest *)

RETC	(* Rückgabe, wenn Überschreitung *)

LD	result

MUL	1000	(* Umrechnung in Millisekunden *)

ST	tmval	(* Speichern in einer Timer-Variablen *)

(* Unterprogramm mit Namen 'SUBPRO' : bewertet den analogen Wert *)

(* als binärer Wert auf drei booleschen Eingängen gegeben: in0, in1, in2 sind die drei booleschen Eingangsparameter des Unterprogramms *)

LD	in2

ANA	(* Ergebnis:= ana(in2); *)

MUL	2	(* Ergebnis:= 2*ana(in2); *)

ST	temporary	(* temporary := result *)

LD	in1

ANA

ADD	temporary	(* Ergebnis:= 2*ana(in2) + ana(in1); *)

MUL	2	(* Ergebnis:= 4*ana(bi2) + 2*ana(bi1); *)

ST	temporary	(* temporary := result *)

LD	in0

ANA

ADD	temporary	(* Ergebnis:= 4*ana(in2) + 2*ana(in1)+ana(in0); *)

ST	SUBPRO	(* gibt den Wert des aktuellen Ergebnisses zurück*)

(* an das aufrufende Programm *)


Aufruf eines Funktionsbausteins: CAL-Operator

Operation	ruft einen Funktionsbaustein auf

Ergänzungen	C   N

Operand	Name der Funktionsbaustein-Instance.

Vor dem Aufruf, der die LD/ST-Sequenz benutzt, müssen die Eingangsparameter des Bausteins zugewiesen werden.

Wenn Ausgangsparameter benutzt werden, sind diese bekannt.

Beispiel 1:

(* Aufruf des Funktionsbausteins SR : SR1 ist eine Instance von SR *)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command

(* FBS-Äquivalenz : *)

Beispiel 2

(*Es wird angenommen, daß R_TRIG1 eine Instance des Bausteins R_TRIG ist und CTU1 eine Instance des Bausteins CTU *)

LD	command

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTU1.cu

LDN	auto_mode

ST	CTU1.reset

LD	100

ST	CTU1.pv

CAL	CTU1

LD	CTU1.Q

ST	overflow

LD	CTU1.cv

ST	result

(* FBS-Äquivalenz: *)


 ST-Sprache

Die ST-Sprache (Strukturierter Text) ist eine hohe Textsprache für die Beschreibung von Automatisierungsprozessen. Sie wird hauptsächlich für die Implementierung komplexer Prozeduren benutzt, die in den grafischen Sprachen schwer darzustellen sind. Die ST-Sprache ist die Vorgabesprache für die Programmierung der Aktionen in den Schritten und der Bedingungen, die den Transitionen der AS-Sprache zugeordnet werden.

ST-Syntax

Ausdrücke und Klammern

Aufrufe von Funktionen und Funktionsbausteinen

Spezielle boolesche ST-Operatoren

ST-Anweisungen

ST-Erweiterungen


ST-Syntax

Ein ST-Programm besteht aus einer Folge von Anweisungen, die jeweils mit einem Semikolon enden (";"). Die im Quellcode benutzten Namen (Variablenbezeichner, Konstanten, Sprach-Schlüsselwörter...) werden durch passive Trennzeichen (Leerzeichen, Zeilenende oder Tabulationen) oder aktive Trennzeichen getrennt, die bestimmte Operationen darstellen. (Zum Beispiel steht das Zeichen ">" für einen "größer als" Vergleich). Kommentare können an beliebigen Stellen in den Text eingefügt werden. Ein Kommentar beginnt mit den Zeichen "(*" und endet mit den Zeichen "*)".  Jede Anweisung endet mit einem Semikolon (";"). In der ST-Sprache gibt es die folgenden Standardanweisungen :

- Zuweisungsanweisung (Variable := Ausdruck;)

- Aufruf eines Unterprogramms oder einer Funktion

- Aufruf eines Funktionsbausteins

- Selektionsanweisungen (IF, THEN, ELSE, CASE)

- Wiederholungsanweisungen (FOR, WHILE, REPEAT)

- Steueranweisungen (RETURN, EXIT)

- Spezialanweisungen für Verknüpfungen mit anderen Sprachen (z.B. AS-Sprache).

Passive Trennzeichen dürfen beliebig zwischen den aktiven Trennzeichen, konstanten Ausdrücken und Bezeichnern eingefügt werden. Passive Trennzeichen sind: Leerzeichen, Tabulationen und Zeilenende. Im Gegensatz zu zeilen-formatierten Sprachen, wie AWL, können Zeilenendzeichen überall im Programm verwendet werden. Bei der Benutzung von passiven Trennzeichen sollten die folgenden Regeln beachtet werden, um die Lesbarkeit des Quellcode zu verbessern :

- Schreiben Sie nur eine Anweisung pro Zeile.

- Benutzen Sie Tabulationen, um komplexe Anweisungen einzurücken.

- Fügen Sie Kommentare ein, um die Lesbarkeit von Zeilen oder Abschnitten zu verbessern.

Lesbarkeit des Quellcodes - Beispiel:

schlecht lesbar	gut lesbar
imax := max_ite; cond := X12; if not(cond (* alarm *) then return; end_if; for i (* index *) := 1 to max_ite do if i <> 2 then Spcall(); end_if; end_for; (* no effect if alarm *)	(* imax : number of iterations *) (* i: FOR statement index *) (* cond: process validity *) imax := max_ite; cond := X12; if not (cond) then     return; end_if; (* process loop *) for i := 1 to max_ite do     if i <> 2 then         Spcall ();     end_if; end_for;


Ausdrücke und Klammern

ST-Ausdrücke kombinieren ST-Operatoren mit variablen oder konstanten Operanden. In jedem einfachen Ausdruck (der Operanden mit einem ST-Operator kombiniert) müssen die Operanden vom gleichen Typ sein. Ein einfacher Ausdruck ist vom gleichen Typ wie seine Operanden und kann in einem komplizierteren Ausdruck verwendet werden. Zum Beispiel :

(boo_var1 AND boo_var2)	ist vom Typ BOOLESCH

not (boo_var1)	ist vom Typ BOOLESCH

(sin (3.14) + 0.72)	ist vom Typ analog REAL

(t#1s23 + 1.78)	ist ein ungültiger Ausdruck

Man benutzt Klammern, um die einzelnen Teile eines Ausdrucks zu trennen und die Priorität der Operationen expliziert darzustellen. Werden keine Klammern in einen komplexen Ausdruck eingefügt, so wird die Operationssequenz durch die Vorgabepriorität der ST-Operatoren bestimmt. Zum Beispiel :

 2 + 3 * 6 	gleich 2+18=20	weil die Multiplikation prioritär ist

(2+3) * 6	gleich 5*6=30	Priorität durch die Klammern

Achtung: Es können nicht mehr als 8 Klammerebenen in einem Ausdruck verschachtet werden.


Aufruf von Funktionen und Funktionsbausteinen

Standard-ST-Funktionsaufrufe können für alle folgenden Objekte benutzt werden:

- Unterprogramme

- in IEC-Sprachen geschriebene Bibliotheksfunktionen und -funktionsbausteine

- "C"-Funktionen und -Funktionsbausteine

- Typumrechnungsfunktionen

Aufruf von Unterprogrammen oder Funktionen

Aufruf von Funktionsbausteinen


Aufruf von Unterprogrammen oder Funktionen

Name:	Name des aufgerufenen Unterprogramms

oder der Bibliotheksfunktion (in den IEC-Sprachen oder in "C" geschrieben)

Funktion:	ruft ST-, AWL-, KOP- oder FBS-Unterprogramm oder -Funktion oder eine "C"-Funktion auf und bezieht ihren Rückgabewert

Syntax:	<var_ana> := <uprog> (<par1>, ... <parN> );

Operanden:	Der Typ des Rückgabewerts und die Aufrufparameter müssen

der für das Unterprogramm definierten Schnittstelle entsprechen

Rückgabe:	Der vom Unterprogramm zurückgegebene Wert

Unterprogrammaufrufe können in beliebigen Ausdrücken sowie in AS-Bedingungen benutzt werden.

Beispiel 1: Unterprogrammaufruf

(*ST-Hauptprogramm *)

(* bezieht einen analogen Wert und rechnet ihn in einen begrenzten Zeitwert um *)

ana_timeprog := SPlimit ( tprog_cmd );

appl_timer := tmr (ana_timeprog * 100);

(* Aufgerufenes FBS-Programm, genannt 'SPlimit' *)

Beispiel 2: Aufruf einer Funktion

(*In komplexen Ausdücken benutzte Funktionen: min, max, right, mlen und left sind Standard-"C"-Funktionen *)

limited_value := min (16, max (0, input_value) );

rol_msg := right (message, mlen (message) - 1) + left (message, 1);


Aufruf von Funktionsbausteinen

Name:	Name der Funktionsbaustein-Instance

Bedeutung:	Ruft einen Funktionsbaustein der ISaGRAF-Bibliothek oder der Benutzerbibliothek

auf und greift auf seine Returnparameter zu

Syntax:	(* Aufruf eines Funktionsbausteins *)

<name_bau> ( <pa1>, <pa2> ... );

(* greift auf die Returnparameter zu *)

<ergebnis> := <name_bau>. <param_ret_1>;

...

<ergebnis> := <name_bau>. <name_ret_N>;

Operanden:	Die Parameter sind Ausdrücke, die dem Typ der für den

Funktionsbaustein spezifizierten Parameter entsprechen

Rückgabewert:	Siehe Syntax, um die Returnparameter zu erhalten.

Siehe ISaGRAF-Bibliothek für die Bedeutung und den Typ eines jeden Funktionsbaustein-Parameters. Die Instance des Funktionsbausteins (Name der Kopie) muß im Datenverzeichnis deklariert werden.

Beispiel :

(* ST-Programm mit Aufruf eines Funktionsbausteins *)

(* Deklaration der Instance im Datenverzeichnis: *)

(* trigb1 : bloc R_TRIG - Erkennung einer steigenden Flanke *)

(* Aktivierung des Funktionsbausteins in ST  *)

trigb1 (b1);

(* Zugriff auf die Returnparameter *)

If (trigb1.Q) Then nb_fronts := nb_fronts + 1; End_if;


Spezielle boolesche ST-Operatoren

Die folgenden booleschen Operatoren sind spezifisch für die ST-Sprache:

REDGE	Erkennung einer steigenden Flanke

FEDGE	Erkennung einer fallenden Flanke

Andere boolesche Standardoperatoren, wie:

NOT	boolesche Negation

AND (&)	logisches UND

OR	logisches ODER

XOR	logisches Exklusiv-ODER

können benutzt werden. Sie werden im Abschnitt "Standardoperatoren, Funktionsbausteine und Funktionen' beschrieben.


REDGE-Operator

Name:	REDGE

Funktion:	bewertet die steigende Flanke eines komplexen booleschen Ausdrucks

Syntax:	<flanke> := REDGE ( <ausdruck_boo>, <variable_speich> );

Operanden:	Der erste Operand ist eine boolesche Variable oder ein komplexer boolescher Ausdruck.

Der zweite Operand ist eine boolesche interne Variable, die benutzt wird,

um den vorherigen Zustand des verarbeiteten Ausdrucks zu speichern.

Rückgabe:	TRUE, wenn der Zustand des Ausdrucks von FALSE auf TRUE übergeht

FALSE in allen anderen Fällen

Die steigende Flanke eines Ausdrucks kann nur ein einziges Mal mit dem REDGE-Operator im einem Ausführungszyklus erkannt werden.

Achtung: Die boolesche "Speichervariable", die benutzt wird, um den letzten Zustand des Ausdrucks zu speichern, kann nicht für die Flankenberechnungen anderer Ausdrücke verwendet werden.

Wenn der Ausdruck eine boolesche Variable namens "xxx" ist, deklariert man eine einmalige interne Variable namens "EDGE_xxx" und benutzt sie in den REDGE-Ausdrücken für diese Variable. Hierdurch wird vermieden, daß die Speichervariable bei anderen REDGE-Berechnungen überschrieben wird.

Beispiel :

(* ST-Programm, das einen REDGE-Operator benutzt *)

(*dieses Programm zählt die steigenden Flanken eines booleschen Eingangs*)

(* Bi120 ist eine boolesche Eingangsvariable *)

(* Edge_Bi120 ist die Variable für das Speichern des Zustands von Bi120 *)

If REDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Hinweis: Dieser Operator ist nicht Teil der IEC1131-3 Norm. Vielleicht bevorzugen Sie den Standardbaustein R_TRIG. Er wurde aus Kompatibilitätsgründen erhalten.


FEDGE-Operator

Name:	FEDGE

Funktion:	bewertet die fallende Flanke eines booleschen Ausdrucks

Syntax:	<flanke> := FEDGE ( <ausdruck_boo>, <variable_speich> );

Operanden:	Der erste Operand ist eine boolesche Variable oder ein komplexer boolescher Ausdruck.

Der zweite Operand ist eine boolesche interne Variable,

die benutzt wird, um den letzten Zustand des verarbeiteten Ausdrucks zu speichern.

Rückgabe:	TRUE, wenn der Zustand des Ausdrucks von TRUE auf FALSE übergeht

FALSE in allen anderen Fällen

Die fallende Flanke eines Ausdrucks kann nur ein einziges Mal mit der FEDGE-Funktion in einem Ausführungszyklus erkannt werden. Der Operator kann benutzt werden, um die Bedingung einer AS-Transition zu beschreiben.

Achtung: Die boolesche "Speichervariable", die benutzt wird, um den letzten Zustand des Ausdrucks zu speichern, kann nicht für die Flankenberechnungen anderer Ausdrücke verwendet werden.

Wenn der Ausdruck eine boolesche Variable namens "xxx" ist, deklariert man eine einmalige interne Variable namens "EDGE_xxx" und benutzt sie in den FEDGE-Ausdrücken für diese Variable. Hierdurch wird vermieden, daß die Speichervariable bei anderen FEDGE-Berechnungen überschrieben wird.

Beispiel :

(* ST-Programm, das einen FEDGE-Operator benutzt *)

(* dieses Programm zählt die fallenden Flanken eines booleschen Eingangs *)

(* Bi120 ist der Name der Eingangsvariablen *)

(* Edge_Bi120 ist die Variable für das Speichern des Zustands von Bi120 *)

If FEDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Hinweis: Dieser Operator ist nicht Teil der IEC1131-3 Norm. Vielleicht bevorzugen Sie den Standardbaustein F_TRIG. Er wurde aus Kompatibilitätsgründen erhalten.


Anweisungen der ST-Sprache

Die verschiedenen Anweisungstypen der ST-Sprache sind :

Zuweisung

RETURN-Anweisung

IF-THEN-ELSE-Struktur

CASE-Anweisung

WHILE-Anweisung

REPEAT-Anweisung

FOR-Anweisung

EXIT-Anweisung


Zuweisung

Name:	:=

Funktion:	weist einer Variablen einen Ausdruck zu

Syntax:	<variable> := <ausdruck> ;

Operanden:	die Variable muß eine interne oder Ausgangsvariable sein

die Variable und der Ausdruck müssen vom gleichen

Typ sein

Der Ausdruck kann ein Aufruf eines Unterprogramms oder einer Funktion der ISaGRAF-Bibliothek sein.

Beispiel :

(* ST-Programm mit Zuweisungen *)

(* Variable <<= Variable *)

bo23 := bo10;

(* Variable <<= Ausdruck *)

bo56 := bx34 OR alrm100 & (level >= over_value);

result := (100 * input_value) / scale;

(* mit Unterprogrammaufruf *)

rc := PSelect ( );

(* mit Aufruf einer Funktion  *)

limited_value := min (16, max (0, input_value) );


RETURN-Anweisung

Name:	RETURN

Funktion:	Beendet die Programmausführung

Syntax:	RETURN ;

Operanden:	(keine)

Wenn die RETURN-Anweisung in einem AS-Aktionsblock erscheint, betrifft die Beendigung nur diesen Aktionsblock.

Beispiel :

(* FBS-Spezifikation des Programms: programmierbarer Zähler *)

(* St-Implementierung des Programms, mit RETURN-Anweisung *)

If not (CU) then

Q := false;

CV := 0;

RETURN; (* beendet das Programm *)

end_if;

if R then

CV := 0;

else

if (CV < PV) then

CV := CV + 1;

end_if;

end_if;

Q := (CV >= PV);


IF-THEN-ELSE-Anweisung

Name:	IF ... THEN ... ELSIF ... THEN ... ELSE ... END_IF

Funktion:	Führt eine von zwei ST-Anweisunglisten aus.

Die Wahl erfolgt entsprechend des Werts eines booleschen Ausdrucks

Syntax:	IF <bool_ausdruck> THEN

   <anweisung> ;

   <anweisung> ;

   ...

ELSIF <bool_ausdruck> THEN

   <anweisung> ;

   <anweisung> ;

   ...

ELSE

   <anweisung> ;

   <anweisung> ;

   ...

END_IF;

Die ELSE- und ELSIF-Anweisungen sind optionell. Wird ELSE weggelassen, erfolgt keine Anweisung, wenn die Bedingung FALSE ist.

Beispiel :

(* ST-Programm mit IF-Anweisung *)

IF manual AND not (alarm) THEN

level := manual_level;

bx126 := bi12 OR bi45;

ELSIF over_mode THEN

level := max_level;

ELSE

level := (lv16 * 100) / scale;

END_IF;

(* Struktur IF ohne ELSE *)

If overflow THEN

alarm_level := true;

END_IF;


CASE-Anweisung

Name:	CASE ... OF ... ELSE ... END_CASE

Funktion:	Führt eine von mehreren ST-Anweisungslisten aus.

Die Wahl erfolgt entsprechend eines ganzzahligen Ausdrucks.

Syntax:	CASE <ganzzahliger_ausdruck> OF

<wert> : <anweisungen> ;

<wert> , < wert > : < anweisungen > ;

...

ELSE

< anweisungen> ;

END_CASE;

Die Selektionswerte müssen ganzzahlige konstante Ausdrücke sein. Mehrere, durch Kommas getrennte Werte können zu derselben Anweisungsliste führen. Die ELSE-Anweisung ist optionnell.

Beispiel:

(* ST-Programm mit CASE-Anweisung *)

CASE error_code OF

255:	err_msg := 'Divide by zero';

fatal_error := TRUE;

1:	err_msg := 'Overflow';

2, 3:	err_msg := 'Bad sign';

ELSE

err_msg := 'Unknown error';

END_CASE;


WHILE-Anweisung

Name:	WHILE ... DO ... END_WHILE

Funktion:	Wiederholungsstruktur für eine Gruppe von ST-Anweisungen.

Die "continue"-Bedingung wird VOR der Wiederholung bewertet.

Syntax:	WHILE <bool_ausdruck> DO

   <anweisung> ;

   <anweisung> ;

   ...

END_WHILE ;

Achtung: Da ISaGRAF ein synchrones System ist, werden die Eingangsvariablen während der Wiederholung einer WHILE-Schleife nicht aktualisiert. Die Zustandsveränderung einer Eingangsvariablen darf nicht benutzt werden, um die Bedingung einer WHILE-Anweisung zu beschreiben.

Beispiel :

(* ST-Programm mit WHILE-Anweisung *)

(* dieses Programm benutzt spezielle "C"-Funktionen, um die Zeichen *)

(* auf einer seriellen Kommunikationsschnittstelle zu lesen *)

string := ''; (* leere Kette *)

nbchar := 0;

WHILE ((nbchar < 16) & ComIsReady ( )) DO

string := string + ComGetChar ( );

nbchar := nbchar + 1;

END_WHILE;


REPEAT-Anweisung

Name:	REPEAT ... UNTIL ... END_REPEAT

Funktion:	Wiederholungsstruktur für eine Gruppe von ST-Anweisungen

Die "continue"-Bedingung wird NACH der Wiederholung bewertet.

Syntax:	REPEAT

   <anweisung> ;

   <anweisung> ;

  ...

UNTIL <bool-bedingung>

END_REPEAT ;

Achtung: Da ISaGRAF ein synchrones System ist, werden die Eingangsvariablen während der Wiederholungen einer REPEAT-Schleife nicht aktualisiert. Die Zustandsveränderung  einer Eingangsvariablen kann nicht benutzt werden, um die Beendigungsbedingung einer REPEAT-Anweisung zu beschreiben.

Beispiel :

(* ST-Programm mit REPEAT-Anweisung *)

(* dieses Programm benutzt spezielle "C"-Funktionen, um die Zeichen *)

(* auf einer seriellen Kommunikations-Schnittstelle zu lesen *)

string := ''; (* leere Kette *)

nbchar := 0;

IF ComIsReady ( ) THEN

REPEAT

string := string + ComGetChar ( );

nbchar := nbchar + 1;

UNTIL ( (nbchar >= 16) OR NOT (ComIsReady ( )) );

END_REPEAT;

END_IF;


FOR-Anweisung

Name:	FOR ... TO ... BY ... DO ... END_FOR

Funktion:	Führt eine begrenzte Anzahl von Wiederholungen aus,

unter Anwendung einer Indexvariablen vom Typ ganzzahlig analog

Syntax:	FOR <index> := <mini> TO <maxi> BY <schritt> DO

   <anweisung> ;

   <anweisung> ;

END_FOR;

Operanden:	index:	bei jeder Wiederholung inkrementierte interne analoge Variable

mini:	Initialwert der Indexvariablen (vor der ersten Schleife)

maxi:	zugelassener Maximalwert für den Index

schritt:	Index-Inkrementierung bei jeder Schleife

Die [ BY schritt ] Anweisung ist optionell. Wenn nicht spezifiert, wird 1 für den Inkrementierungsschritt vorgegeben.

Achtung: Da ISaGRAF ein synchrones System ist, werden die Eingangsvariablen während der Wiederholungen nicht aktualisiert.

Hier das "While"-Äquivalent einer FOR-Anweisung :

index := mini;

while (index <= maxi) do

<anweisung> ;

<anweisung> ;

index := index + schritt;

end_while;

Beispiel :

(* ST-Programm mit FOR-Anweisung *)

(* Dieses Programm entnimmt einer Kette die "Zahlen"-Zeichen *)

length := mlen (message);

target := ''; (* leere Kette *)

FOR index := 1 TO length BY 1 DO

code := ascii (message, index);

IF (code >= 48) & (code <= 57) THEN

target := target + char (code);

END_IF;

END_FOR;


EXIT-Anweisung

Name:	EXIT

Funktion:	verläßt eine Wiederholungsanweisung vom Typ FOR, WHILE oder REPEAT

Syntax:	EXIT;

Operanden:	(keine)

Die EXIT-Anweisung wird im allgemeinen in einer IF-Anweisung innerhalb eines FOR-, WHILE- oder REPEAT-Blocks benutzt.

Beispiel:

(* ST-Programm mit EXIT-Anweisung *)

(* dieses Programm sucht ein Zeichen in einer Kette *)

length := mlen (message);

found := NO;

FOR index := 1 TO length BY 1 DO

code := ascii (message, index);

IF (code  = searched_char) THEN

found := YES;

EXIT;

END_IF;

END_FOR;


ST-Erweiterungen

Die folgenden Funktionen sind Erweiterungen der ST-Sprache:

TSTART / TSTOP: Timer-Verwaltung

Die folgenden Anweisungen und Funktionen ermöglichen die Steuerung von AS-Sohnprogrammen.

Sie können in ACTION(): ... END_ACTION; Blöcken in AS-Schritten benutzt werden.

GSTART	startet ein AS-Programm

GKILL	stoppt ein AS-Programm

GFREEZE	hält ein AS-Programm an

GRST	startet ein angehaltenes AS-Programm erneut

GSTATUS	liefert den aktuellen Status eines AS-Programms

Achtung: Diese Funktionen sind nicht Teil der IEC 1131-3 Norm.

Ein Äquivalent für GSTART und GKILL wird mit der folgenden Syntax im AS-Schritt erreicht:

child_name(S); (* äquivalent zu GSTART(child_name); *)

child_name(R); (*äquivalent zu GKILL(child_name); *)

Die folgenden Felder können benutzt werden, um auf den Zustand eines AS-Schritts zuzugreifen:

GSnnn.x	ist ein boolescher Wert, der die Schrittaktivität darstellt

GSnnn.t	gibt an, wieviel Zeit seit der letzten Schrittaktivierung verstrichen ist

("nnn" ist die Referenznummer des AS-Schritts)

Unter Anwendung der folgenden Syntax ist es außerdem möglich, die Aktivität eines deklarierten Schritts in einem anderen AS-Programm zu testen:

GSnnn(nameprog).x

Achtung: Diese Syntax für die Referenzierung eines Schritts eines anderen Programms ist nicht Teil der IEC 1131-3 Norm. Innerhalb der IEC-Norm kann das gleiche erreicht werden, indem eine globale boolesche Variable im Datenverzeichnis deklariert wird, welche die zu testende Schrittaktivität darstellt (zum Beispiel ref_step_X). Dann fügen Sie die Variable mit dem N-Qualifizierer in den Schritt ein (ref_step_X(N);) und benutzen die Variable in dem Programm, welches die Schrittaktivität testen soll.

Prog program	das andere Programm, das die Schrittaktivität von Prog program benötigt


TSTART-Anweisung

Name:	TSTART

Funktion:	Startet das Zählen einer Timer-Variablen.

Der aktuelle Wert des Timers wird durch die TSTART-Anweisung nicht verändert

(Zählen beginnt beim aktuellen Wert des Timers).

Syntax:	TSTART ( <timer_variable> );

Operanden:	alle inaktiven Timer-Variablen

Rückgabe:	(keine)

Beispiel :

(* AS-Programm mit TSTART- und TSTOP-Anweisungen *)

Steuerungsdiagramm, wenn bi100 immer FALSE ist:

Der Timer behält einen Zyklus lang den gleichen Wert bei.


TSTOP-Anweisung

Name:	TSTOP

Funktion:	Stoppt die Aktualisierung einer Timer-Variablen.

Der Wert der Variablen wird durch TSTOP nicht verändert.

Syntax:	TSTOP ( <timer_variable> );

Operanden:	beliebige aktive Timer-Variable

Rückgabe:	(keine)

Beispiel : Siehe TSTART (die Funktion wird weiter oben beschrieben)


GSTART-Anweisung

Name:	GSTART

Funktion:	Startet ein AS-Sohnprogramm, wobei eine

Zugriffsberechtigung in jeden seiner Initialisierungsschritte plaziert wird

Syntax:	GSTART ( <sohn_programm> );

Operanden:	das spezifizierte AS-Programm muß der Sohn des

Programms sein, das die GSTART-Anweisung enthält.

Rückgabe:	(keine)

Die Söhne des durch GSTART gestarteten Programms werden nicht automatisch mit ihm gestartet.

Hinweis: Da GSTART nicht Teil der IEC 1131-3 Norm ist, sollte der S-Qualifizierer bevorzugt werden, mit der folgenden Syntax, um ein AS-Sohnprogramm zu starten:

Child_name(S);

Beispiel: Verwendung von GSTART und GKILL

(* Sequenz 'Sfather' *)	(* Sequenz 'Schild' *)


GKILL-Anweisung

Name:	GKILL

Funktion:	Stoppt ein AS-Programm, wobei alle Zugriffsberechtigungen

aus den Schritten entfernt werden

Syntax:	GKILL ( <sohn-programm> );

Operanden:	Das spezifizierte AS-Programm muß der Sohn des

Programms sein, das die GKILL-Anweisung enthält.

Rückgabe:	(keine)

Die Söhne des gestoppten Programms werden automatisch mit ihm gestoppt.

Hinweis: Da GKILL nicht Teil der IEC 1131-3 Norm ist, sollte der R-Qualifizierer bevorzugt werden, mit der folgenden Syntax, um ein AS-Sohnprogramm zu stoppen:

Child_name(R);

Beispiel: Verwendung von GSTART und GKILL

(* Sequenz 'Sfather' *)	(* Sequenz 'Schild' *)


GFREEZE-Anweisung

Name:	GFREEZE

Funktion:	Unterbricht die Ausführung eines AS-Sohnprogramms.

Das angehaltene Programm kann mit der GRST-Anweisung erneut gestartet werden.

Syntax:	GFREEZE ( <sohn_programm> );

Operanden:	Das spezifizierte AS-Programm muß der Sohn des

Programms sein, das die GFREEZE-Anweisung enthält.

Rückgabe:	(keine)

Söhne des Programms werden automatisch mit dem Programm angehalten.

Hinweis: GFREEZE ist nicht Teil der IEC 1131-3 Norm.

Beispiel :


GRST-Anweisung

Name:	GRST

Funktion:	Startet ein AS-Sohnprogramm erneut, das durch die

GFREEZE-Anweisung angehalten wurde.

Syntax:	GRST ( <sohn_programm> );

Operanden:	Das spezifizierte AS-Programm muß der Sohn des

Programms sein, das die GRST-Anweisung enthält.

Rückgabe:	(keine)

Die Söhne des Programms werden automatisch von der GRST-Anweisung mitgestartet.

Hinweis: GRST ist nicht Teil der IEC 1131-3 Norm.

Beispiel : Siehe weiter oben beschriebene Funktion GFREEZE.


GSTATUS-Funktion

Name:	GSTATUS

Funktion:	Liefert den aktuellen Zustand eines AS-Programms.

Syntax:	<var_ana> := GSTATUS ( <sohn_programm> );

Operanden:	Das spezifizierte AS-Programm muß der Sohn des

Programms sein, das die GSTATUS-Anweisung enthält.

Rückgabe:	0 = das Programm ist inaktiv (gestoppt)

1 = das Programm ist aktiv (gestartet)

2 = das Programm ist angehalten

Hinweis: GSTATUS ist nicht Teil der IEC 1131-3 Norm.

Beispiel:


 FBS-Sprache

Die FBS-Sprache (Funktionsbaustein-Sprache) ist eine graphische Sprache, mit der man komplexe Gleichungen unter Anwendung der elementaren Funktionen der ISaGRAF-Bibliotheken aufbauen kann.

Die 'RETURN'-Anweisung

Sprünge und Marken

Boolesche Inversion

Aufruf von Funktionen und Funktionsbausteinen von der FBS

Ein FBS-Diagramm beschreibt eine Funktion zwischen Eingangsvariablen und Ausgangsvariablen. Diese Funktion wird wie ein Netzwerk aus elementaren Funktionsbausteinen aufgebaut. Die Ein- und Ausgangsvariablen werden mit den Funktionsbausteinen durch Verbindungslinien verbunden. Der Ausgang eines Funktionsbausteins kann an den Eingang eines anderen Funktionsbausteins angeschlossen werden.

Eine durch ein FBS-Diagramm dargestellte, komplette Funktion wird mit Hilfe der elementaren Funktionsbausteine der ISaGRAF-Bibliothek konstruiert. Jeder elementare Funktionsbaustein besitzt eine vordefinierte Anzahl an Anschlußpunkten für seine Ein- und Ausgänge. Ein Funktionsbaustein wird durch ein Rechteck dargestellt. Seine Eingänge werden links am Rechteck, seine Ausgänge rechts am Rechteck angeschlossen. Ein elementarer Funktionsbaustein führt eine elementare Funktion zwischen seinen Ein- und Ausgängen aus. Der Name der ausgeführten Funktion erscheint im Rechteck des Bausteins. Die Ein- und Ausgänge des Bausteins sind jeweils von einem bestimmten Typ.

Die Eingangsvariablen eines FBS-Diagramms werden an die Eingänge der Funktionsbausteine angeschlossen. Der Typ einer jeden Variablen muß dem Typ des entsprechenden Funktionsbaustein-Eingangs entsprechen. Eingänge für ein FBS-Diagramm können konstante Ausdrücke oder beliebige interne, Ein- oder Ausgangsvariablen sein.

Die Ausgangsvariablen eines FBS-Diagramms werden an die Ausgänge der Funktionsbausteine angeschlossen. Der Typ einer jeden Variablen muß dem Typ des entsprechenden Funktionsbaustein-Ausgangs Rechnung tragen. Ausgänge für ein FBS-Diagramm kann eine beliebige interne oder Ausgangsvariable oder der Name des bearbeiteten Programms sein (nur für Unterprogramme). Wenn der Name des bearbeiteten Programms als Diagramm-Ausgang benutzt wird, stellt er eine Zuweisung des vom Unterprogramm zurückgegebenen Werts dar.

Die Ein- und Ausgangsvariablen und die Ein- und Ausgänge eines Funktionsbausteins werden durch Verbindungslinien miteinander verbunden. Sie dienen der Verbindung von zwei Diagrammpunkten :

- Eingangsvariable mit einem Bausteineingang

- Bausteinausgang mit dem Eingang eines anderen Bausteins

- Bausteinausgang mit einer Ausgangsvariablen

Diese Verbindungen sind orientiert : Sie transportieren eine Information von ihrem linken zu ihrem rechten Ende. Die linken und rechten Enden einer Verbindungen müssen mit Elementen des gleichen Typs verbunden werden.

Mehrfach-Verbindungslinien nach rechts werden benutzt, um eine Information vom linken Ende einer Verbindung zu mehreren Punkten nach rechts zu transportieren. Alle Enden der Verbindungslinie müssen vom gleichen Typ sein.


Die 'RETURN'-Anweisung

Das Schlüsselwort "<RETURN>" kann als Diagramm-Ausgang erscheinen. Es muß an den booleschen Ausgang eines Funktionsbausteins angeschlossen werden. Die RETURN-Anweisung stellt eine bedingte Beendung der Programmausführung dar : Wenn der mit ihr verbundene Ausgang den booleschen Zustand TRUE annimmt, wird das Ende des Diagramms nicht interpretiert. Es folgt das Beispiel einer RETURN-Anweisung :

(* ST-Äquivalenz: *)

If auto_mode OR alarm Then

Return;

End_if;

bo67 := (bi10 AND bi23) OR x_cmd;


Sprünge und Marken

Marken und bedingte Sprünge werden verwendet, um die Diagrammausführung zu steuern. Rechts vom Marken- oder Sprungsymbol kann keine Verbindung vorgenommen werden.

>>LAB	Sprung zu einer Marke (der Name der Marke ist "LAB")

LAB:	Definition einer Marke (genannt "LAB")

Wenn die Verbindung links vom Sprungsymbol den booleschen Zustand TRUE annimmt, wird die Programmausführung zur entsprechenden Marke umgeleitet. Das folgende Beispiel veranschaulicht die Anwendung der Sprünge und Marken:

(* AWL-Äquivalenz: *)

ld	manual

and	b1

jmpc	NOMODIF

ld	input1

or	input2

st	result

NOMODIF:	ld	result

or	valid

st	cmd10


Boolesche Inversion

Eine einfache Verbindungslinie, die an den booleschen Eingang eines Funktionsbausteins angeschlossen ist, kann in einer booleschen Inversion enden. Sie wird durch einen kleinen Kreis dargestellt. Wenn eine boolesche Inversion verwendet wird, müssen die linken und rechten Enden der entsprechenden Verbindunglinie vom Typ boolesch sein. Hier ein Beispiel:

(* ST-Äquivalenz: *)

output1 := input1 AND NOT (input2);


Aufruf von Funktionen und Funktionsbausteinen von der FBS

Die FBS-Sprache ermöglicht den Aufruf von Unterprogrammen , Funktionen oder Funktionsbausteinen. Unterprogramme, Funktionen oder Funktionsbausteine werden als ein Funktionskasten dargestellt. Der Name im Kasten ist der Name des Unterprogramms, der Funktion oder des Funktionsbausteins.

Bei Unterprogrammen und Funktionen ist der Rückgabewert der einzige Ausgang des Funktionskastens.

Funktionsbausteine können mehrere Ausgänge haben.

(* Beispiel eines FBS-Programms, das einen Baustein vom Typ UNTERPROGRAMM benutzt *)

(* ST-Äquivalenz: *)

net_weight := Weighing (mode, delta); (* Unterprogramm-Aufruf *)

If (net_weight = 0) Then Return; End_if;

weight := net_weight + tare_weight;


 AS-Sprache

Die AS-Sprache (Ablaufsprache) ist eine grafische Sprache, die für die Beschreibung sequentieller Operationen benutzt wird. Ein Prozeß besteht aus einer Reihe von bekannten Schritten (stabilen Zuständen), die durch Transitionen miteinander verbunden sind. Jeder Transition wird eine boolesche Bedingung zugeordnet. Die Aktionen in den Schritten werden in der ST-, AWL-, KOP- oder FBS-Sprache beschrieben.

Format des AS-Netzwerks

Grundkomponenten des AS-Netzwerks

Verzweigungen und Zusammenführungen

Makroschritte

Aktionen in den Schritten

Mit Transitionen verbundene Bedingungen

AS-Entwicklungsregeln

Hierarchie der AS-Programme


Format des AS-Netzwerks

Ein AS-Programm ist ein grafisches Netzwerk, bestehend aus Schritten und Transitionen, die durch orientierte Verbindungslinien miteinander verbunden sind. Verzweigungen und Zusammenführungen werden durch Mehrfachverbindungen dargestellt. Bestimmte Teile des Netzwerks können isoliert und im Hauptnetzwerk durch ein einziges Symbol, einen sogenannten Makroschritt, dargestellt werden. Die hauptsächlichen grafischen Regeln der AS-Sprache sind :

- Ein Schritt darf keinem anderen Schritt folgen.

- Eine Transition darf keiner anderen Transition folgen.


Grundkomponenten des AS-Netzwerks

Ein AS-Netzwerk besteht aus den folgenden Grundkomponenten (grafischen Symbolen) : Schritte und Initialisierungsschritte, Transitionen, orientierte Verbindungslinien und Sprungbefehle zu einem Schritt.

Schritte und Initialisierungsschritte

Transitionen

Orientierte Verbindungen

Sprungbefehl zu einem Schritt


Schritte und Initialisierungsschritte

Ein Schritt wird durch ein Quadrat symbolisiert. Jeder Schritt erhält eine Referenz-Nummer, die in den Rahmen des Quadrats geschrieben wird. Eine allgemeine Beschreibung des Schritts wird in ein mit dem Schrittsymbol verbundenes Rechteck geschrieben. Diese Beschreibung ist ein freier Kommentar (keine Programmiersprache). Diese Informationen bilden die Ebene 1 des Schritts :

Bei der Ausführung zeigt eine Zugriffsberechtigung an, ob der Schritt aktiv ist :

Aktiver Schritt:	Inaktiver Schritt:

Die initiale Situation eines AS-Programms wird durch seine Initialisierungsschritte dargestellt. Initialisierungsschritte werden durch ein Quadrat mit doppeltem Rahmen symbolisiert. Beim Programmstart wird jeder Initialisierungsschritt automatisch mit einer Zugriffsberechtigung versehen.

Initialisierungsschritt:

Ein AS-Programm hat mindestens einen Initialisierungsschritt.

Schritte besitzen die folgenden Attribute (Diese Felder können in allen anderen Sprachen benutzt werden) :

GSnnn.x	Schrittaktivität (boolescher Wert)

GSnnn.t	Dauer der Schrittaktivität (Zeitwert)

(nnn ist die Referenznummer des Schritts)


Transitionen

Eine Transition wird durch einen horizontalen Balken dargestellt, der eine Verbindungslinie durchkreuzt. Jede Transition besitzt eine Referenz-Nummer, die neben ihr Symbol geschrieben wird. Eine allgemeine Beschreibung der Transition wird rechts daneben eingegeben. Dies ist ein freier Kommentar (keine Programmiersprache). Diese Informationen bilden die Ebene 1 der Transition :


Orientierte Verbindungen

Orientierte Verbindungen werden durch einfache Linien zwischen den Schritten und Transitionen dargestellt. Wenn die Richtung (Orientierung) dieser Linien nicht ausdrücklich festgelegt wird, erfolgt die Verbindung von oben nach unten.


Sprungbefehl zu einem Schritt

Ein Sprungbefehlsymbol kann dazu benutzt werden, eine Transition mit einem Schritt zu verbinden, ohne daß eine Verbindungslinie gezogen werden muß. Das Sprungbefehlsymbol wird mit der Referenznummer des Zielschritts gekennzeichnet :

Sprungbefehlsymbole dürfen nicht für Sprünge zu Transitionen verwendet werden. Es folgt das Beispiel eines Sprungbefehls - die folgenden Netzwerke sind äquivalent :


Verzweigungen und Zusammenführungen

Verzweigungen sind Mehrfachverbindungen von einzelnen AS-Symbolen aus (Schritten oder Transitionen) zu mehreren, anderen AS-Symbolen hin. Zusammenführungen sind Mehrfachverbindungen, die von mehreren AS-Symbolen zu einem einzigen Symbol führen. Es gibt einfache oder doppelte Verzweigungen und Zusammenführungen :.

Einfache Verzweigungen

Doppelte Verzweigungen


Einfache Verzweigungen

Eine einfache Verzweigung ist eine Mehrfachverbindung von einem Schritt aus zu mehreren Transitionen hin. Sie ermöglicht der aktiven Zugriffsberechtigung, in einen der Zweige überzugehen. Eine einfache Zusammenführung ist eine Mehrfachverbindung von mehreren Transitionen aus zu einem Schritt hin. Einfache Zusammenführungen werden gewöhnlich benutzt, um die offenen Zweige einer einfachen Verzweigung zu schließen. Einfache Verzweigungen und Zusammenführungen werden durch einfache horizontale Linien dargestellt.

Achtung: Die Bedingungen, die mit den verschiedenen Transitionen am Anfang einer Verzweigung verbunden sind, sind nicht impliziert exklusiv. Die Exklusivität muß in jeder dieser Bedingungen expliziert detailliert werden, um sicher zu gehen, daß bei der Ausführung nur eine einzige Zugriffsberechtigung in einem der Zweige der Verzweigung erstellt wird. Hier ein Beispiel mit einfachen Verzweigungen und Zusammenführungen :


Doppelte Verzweigungen

Eine doppelte Verzweigung ist eine Mehrfachverbindung von einer Transition aus zu mehreren Schritten hin. Sie stellt parallele Operationen in der Prozeßausführung dar. Eine doppelte Zusammenführung ist eine Mehrfachverbindung von mehreren Schritten aus zu einer Transition hin. Eine doppelte Zusammenführung wird gewöhnlich benutzt, um die offenen AS-Zweige einer doppelten Verzweigung zusammenzuführen. Doppelte Verzweigungen und Zusammenführungen werden durch doppelte horizontale Linien dargestellt.

Hier ein Beispiel mit doppelten Verzweigungen und Zusammenführungen :


Makroschritte

Ein Makroschritt ist die einmalige Darstellung einer einmaligen Gruppe von Schritten und Transitionen. Der Rumpf des Makroschritts wird separat an einer anderen Stelle in seinem AS-Programm beschrieben. Er erscheint als ein einziges Symbol im AS-Hauptnetzwerk. Das folgende Symbol wird für die Darstellung eines Makroschritts benutzt :

Die Referenznummer, die im Symbol des Makroschritts erscheint, ist die Referenznummer des ersten Schritts im Rumpf des Makroschritts. Der Rumpf eines Makroschritts beginnt mit einem Anfangsschritt und ended mit einem Endschritt. Das Netzwerk muß in sich zusammenhängend sein. Ein Anfangsschritt darf keine Verbindungen nach oben (keine vorangehenden Transitionen), ein Endschritt keine Verbindungen nach unten (keine nachfolgenden Transitionen) haben. Der Rumpf eines Makroschritts kann weitere Makroschritte einschließen.

Achtung: Da jeder Makroschritt eine einmalige Gruppe von Schritten und Transitionen darstellt, darf der gleiche Makroschritt nicht mehrmals in einem AS-Programm auftreten.

Hier das Beispiel eines Makroschritts :

(* Hauptnetzwerk *)	(* Rumpf des Makroschritts *)


Aktionen in den Schritten

Die Ebene 2 eines AS-Schritts besteht aus einer ausführlichen Beschreibung der Aktionen, die ausgeführt werden, wenn der Schritt aktiv ist. Diese Beschreibung erfolgt unter Anwendung der AS-Textstruktur und anderen Sprachen, wie der ST-Sprache (Strukturierter Text). Hier die einzelnen Aktionstypen :

Boolesche Aktionen

Impuls-Aktionen

Nicht-gespeicherte Aktionen

AS-Aktionen

Es können mehrere Aktionen (gleichen oder unterschiedlichen Typs) in einem Schritt beschrieben werden. Die

speziellen Funktionalitäten, die den Gebrauch anderer Sprachen ermöglichen, sind:

Aufruf von Funktionen und Funktionsbausteinen in einer Aktion

AWL-Schreibkonventionen


Boolesche Aktionen

Eine boolesche Aktion weist einer booleschen Variablen das Aktivitätssignal eines Schritts (Schrittflagge) zu. Die boolesche Variable muß eine interne oder Ausgangsvariable sein. Sie wird jedesmal forciert, wenn das Schrittaktivitätssignal startet oder stoppt.

Hier die Syntax der grundlegenden booleschen Aktionen :

<boolesche_variable> (N);	Weist der Variablen das Schrittaktivitätssignal zu

<boolesche_variable> ;	gleicher Effekt (das Attribut N ist optionell)

/ <boolesche_variable> ;	Weist der Variablen die Inversion des Schrittaktivitätssignals zu

Andere Aktionen forcieren die Variable zu false oder true, wenn der Schritt aktiv wird. Hier die Syntax dieser Setze- und Rücksetze-Aktionen :

<boolesche_variable> (S) ;	forciert die Variable zu TRUE, wenn das Schrittaktivitätssignal TRUE 	wird

<boolesche_variable> (R) ;	forciert die Variable zu FALSE, wenn das Schrittaktivitätssignal TRUE 	wird

Die boolesche Variable muß eine INTERNE oder AUSGANGsvariable sein. Die folgende AS-Programmierung bewirkt das folgende Verhalten:

Beispiel mit booleschen Aktionen :

(* AS-Programm mit booleschen Aktionen *)


Impuls-Aktionen

Eine Impuls-Aktion ist eine ST- oder AWL-Anweisungsliste, die ein einziges Mal ausgeführt wird, wenn der Schritt aktiv wird. Die Anweisungen werden entsprechend der folgenden AS-Syntax geschrieben:

ACTION (P) :

(* ST-Anweisungen *)

END_ACTION ;

Hier das Steuerungsdiagramm einer Aktion vom Typ P :

Beispiel einer Impuls-Aktion :

(* AS-Programm mit Impuls-Aktionen *)


Nicht-gespeicherte Aktionen

Eine nicht-gespeicherte (normale) Aktion ist eine ST- oder AWL-Anweisungsliste, die bei jedem Zyklus ausgeführt wird, und zwar solange der Schritt aktiv ist. Die Anweisungen werden entsprechend der folgenden AS-Syntax geschrieben :

ACTION (N) :

(* ST-Anweisungen *)

END_ACTION ;

Hier das Steuerungsdiagramm einer Aktion vom Typ N :

Beispiel einer nicht-gespeicherten Aktion :

(* AS-Programm mit nicht-gespeicherten Aktionen *)


AS-Aktionen

Eine AS-Aktion ist eine AS-Tochtersequenz, die entsprechend der Entwicklung des Schrittaktivitätssignals gestartet oder gestoppt wird. Eine AS-Aktion kann mit den Aktionsqualifizierern N (Nicht-gespeichert), S (Set), oder R (Reset) geschrieben werden. Hier die Syntax der grundlegenden AS-Aktionen :

<sohn_programm> (N) ;	Startet die Tochtersequenz, wenn der Schritt aktiv wird und stoppt die 	Tochersequenz, wenn der Schritt inaktiv wird.

<sohn_programm> ;	Gleicher Effekt (das Attribut N ist optionell)

<sohn_programm> (S) ;	Startet die Tochtersequenz, wenn der Schritt aktiv wird.

Nichts geschieht, wenn der Schritt wieder inaktiv wird.

<sohn_programm> (R) ;	Stoppt die Tochtersequenz, wenn der Schritt aktiv wird.

Nichts geschieht, wenn der Schritt wieder inaktiv wird.

Die in der Aktion spezifizierte AS-Sequenz muß ein AS-Sohnprogramm des in Bearbeitung befindlichen Programms sein. Man sollte nicht vergessen, daß die Benutzung der Qualifizierer S (Set) oder R (Reset) für eine AS-Aktion das gleiche bewirkt, wie die Anweisungen GSTART und GKILL, die in einer ST-Impuls-Aktion programmiert werden.

Im folgenden Beispiel einer AS-Aktion wird das AS-Hauptprogramm "Vater" genannt. Es hat zwei AS-Sohnprogramme, die SeqMlx und SeqPomp heißen. Hier die AS-Programmierung des Vaterprogramms :

(* AS-Programm mit AS-Aktionen *)


Aufruf von Funktionen und Funktionsbausteinen in einer Aktion

Unterprogramme, Funktionen und Funktionsbausteine (in ST, AWL, KOP oder FBS geschrieben) oder "C"-Funktionen und "C"-Funktionsbausteine können direkt von einem AS-Aktionsblock aus aufgerufen werden, und zwar entsprechend der folgenden Syntax:

Für Unterprogramme, Funktionen und "C"-Funktionen:

ACTION (P) :

     <ergebnis> := <unter_programm> ( ) ;

END_ACTION;

oder

ACTION (N) :

     <ergebnis> := <unter_programm> ( ) ;

END_ACTION;

Für Funktionsbausteine in "C" oder in ST, AWL, KOP, FBS:

ACTION (P) :

Fbinst(in1, in2);

ergebnis1 := Fbinst.out1;

ergebnis2 := Fbinst.out2;

END_ACTION;

oder

ACTION (N) :

Fbinst(in1, in2);

ergebnis1 := Fbinst.out1;

ergebnis2 := Fbinst.out2;

END_ACTION;

Die Syntax wird im Abschnitt "ST-Sprache" ausführlich beschrieben.

Es folgt das Beispiel eines Unterprogramm-Aufrufs in einem Aktionsblock :

(* AS-Programm mit Aufruf eines Unterprogramms in einer Aktion *)


AWL-Schreibkonventionen

Die Programmierung in der AWL-Sprache (Anweisungsliste) kann direkt in einen AS-Aktionsblock eingesetzt werden, und zwar entsprechend der folgenden Syntax :

ACTION (P) :	(* oder N *)

#info=IL

     <Anweisung>

     <Anweisung>

     ....

#endinfo

END_ACTION;

Die Schlüsselwörter "#info=IL" und "#endinfo" müssen genau in dieser Form eingegeben werden (Groß- und Kleinschreibung beachten). Fügen Sie keine Leerzeichen oder Tabs vor, nach oder zwischen diesen Schlüsselwörtern ein. Hier das Beispiel eines AWL-Programms in einer Aktion :

(* AS-Programm mit AWL-Sequenz in einem Aktionsblock *)


Mit Transitionen verbundene Bedingungen

Mit jeder Transition ist ein boolescher Ausdruck verbunden, der das Überschreiten der Transition bedingt. Diese Bedingung, die Ebene 2 der Transition, wird gewöhnlich in der ST-Sprache oder im KOP (Schneller KOP-Editor) geschrieben. Andere Strukturen sind zugelassen :

ST-Schreibkonventionen

KOP-Schreibkonventionen

AWL-Schreibkonventionen

Aufruf eines Unterprogramms in einer Transition

Achtung: Wenn einer Transition kein Ausdruck zugeordnet wird, ist ihre Vorgabebedingung TRUE.


ST-Schreibkonventionen

Die ST-Sprache (Strukturierter Text) kann verwendet werden, um die Bedingung einer Transitionen zu beschreiben. Der vollständige Ausdruck muß vom Typ boolesch sein und mit einem Semikolon enden, entsprechend der folgenden Syntax :

< boolescher_ausdruck > ;

Ein Ausdruck kann ein konstanter Wert (TRUE oder FALSE), eine boolesche interne oder Eingangsvariable oder eine Kombination von Variablen sein, die einen booleschen Wert ergeben. Hier das Beispiel einer in der ST-Sprache programmierten Transition :

(* AS-Programm mit AS-Programmierung für Transitionen *)


KOP-Schreibkonventionen

Der Kontaktplan (KOP-Sprache) kann benutzt werden, um die mit einer Transition verbundene Bedingung zu beschreiben. Das Diagramm besteht aus nur einem Rung mit einer Spule. Der Wert der Spule stellt den Wert der Transition dar.

Es folgt ein Beispiel einer KOP-Programmierung für Transitionen:


AWL-Schreibkonventionen

Die AWL-Sprache (Anweisungsliste) kann unmittelbar für die Programmierung von Transitionsbedingungen verwendet werden, und zwar entsprechend der folgenden Syntax :

#info=IL

     <Anweisung>

     <Anweisung>

     ....

#endinfo

Der Wert, der am Ende der AWL-Sequenz im aktuellen Ergebnis (AWL-Verzeichnis) erscheint, ist das Ergebnis der mit der Transition verbundenen Bedingung :

Aktuelles Ergebnis = 0	Bedingung ist FALSE

Aktuelles Ergebnis <> 0	Bedingung ist TRUE

Die Schlüsselwörter "#info=IL" und "#endinfo" müssen genau in dieser Form eingegeben werden (Groß- und Kleinschreibung beachten). Setzen Sie keine Leerzeichen oder Tabs vor, nach oder zwischen diesen Schlüsselwörtern ein. Hier das Beispiel einer in der AWL-Sprache programmierten Bedingung :

(* AS-Programm mit AWL-Programmierung für Transitionen *)


Aufruf eines Unterprogramms in einer Transition

Unterprogramme oder Funktionen (in FBS, KOP, ST, oder AWL) oder "C"-Funktionen können aufgerufen werden, um die mit einer Transition verbundene Bedingung zu bewerten, und zwar entsprechend der folgenden Syntax:

< unter_programm > ( ) ;

Der vom Unterprogramm oder der Funktion zurückgegegebene Wert muß boolesch sein und liefert das Ergebnis:

Rückgabewert = 0             	Bedingung ist FALSE

Rückgabewert <>              	Bedingung ist TRUE

Es folgt das Beispiel eines Unterprogramm-Aufrufs in einer Transition :

(* AS-Programm mit Unterprogramm-Aufruf für Transitionen *)


AS-Entwicklungsregeln

Die folgenden fünf Entwicklungsregeln der AS-Sprache sind:

 Initiale Situation

Die initiale Situation wird durch Initialisierungsschritte dargestellt, die beim Anwendungstart aktiv sind. Ein AS-Programm besitzt mindestens einen Initialisierungsschritt.

 Überschreitung einer Transition

Eine Transition ist entweder gültig oder ungültig. Sie ist gültig, wenn alle unmittelbar vorangehenden Schritte aktiv sind, sonst ist sie ungültig.

Eine Transition kann nur dann überschritten werden, wenn :

   - sie gültig ist und

   - die mit ihr verbundene Bedingung true ist.

 Zustand der aktiven Schritte

Die Überschreitung einer Transition zieht gleichzeitig die Aktivierung aller unmittelbar darauffolgenden Schritte und die Deaktivierung aller unmittelbar vorangehenden Schritte nach sich.

 Gleichzeitige Überschreitung von Transitionen

Man kann doppelte Linien benutzen, um Transitionen darzustellen, die gleichzeitig überschritten werden sollen. Wenn diese Transitionen getrennt dargestellt werden, kann der Aktivitätszustand der vorangehenden Schritte (GSnnn.x) benutzt werden, um ihre Bedingungen darzustellen.

 Gleichzeitige Aktivierung und Deaktivierung eines Schritts

Wenn ein Schritt in einem Sequenzablauf gleichzeitig aktiviert und deaktiviert wird, ist die Aktivierung prioritär.


Hierarchie der AS-Programme

Mit dem ISaGRAF-System können AS-Programme in einer vertikalen Struktur geschrieben werden. Die AS-Programme werden in einer hierarchischen Baumstruktur angeordnet. Jedes Programm kann andere AS-Programme steuern (starten, stoppen...), die Sohn-Programme genannt werden. Die AS-Programme werden in einer hierarchischen Baumstruktur miteinander verknüpft und stehen in einer "Vater-Sohn"-Beziehungen zueinander.

Für diese Hierarchie gelten die folgenden Grundregeln :

- AS-Programme, die kein Vaterprogramm haben, heißen "Hauptprogramme".

- AS-Hauptprogramme werden vom System beim Anwendungsstart aktiviert.

- Ein Vaterprogramm kann mehrere Sohnprogramme besitzen.

- Ein Sohnprogramm darf nur ein einziges Vaterprogramm besitzen.

- Ein Sohnprogramm kann nur von seinem Vaterprogramm gesteuert werden.

- Ein Vaterprogramm kann nicht die Söhne seiner Sohnprogramme (seine Enkel) steuern.

AS-Vaterprogramme steuern ihre AS-Sohnprogramme mit den folgenden Aktionen :

Starten (GSTART) Startet das Sohnprogramm : aktiviert jeden seiner Initialisierungsschritte. Die Sohnprogramme dieses Programms werden nicht automatisch mit ihm gestartet.

Stoppen (GKILL) Stoppt das Sohnprogramm, indem alle aktiven Schritte deaktiviert werden. Alle seine Sohnprogramme werden ebenfalls gestoppt.

Anhalten (GFREEZE) Unterbricht die Programmausführung (deaktiviert alle aktiven Schritte des Sohnprogramms und unterbricht die Transitionsberechnung) und speichert den Zustand der Programmschritte, so daß das Programm wieder gestartet werden kann. Alle Sohnprogramme des angehaltenen Programms werden ebenfalls angehalten.

Erneut starten (GRST) Startet ein angehaltenes AS-Sohnprogramm erneut, indem alle Schritte wieder aktiviert werden, die beim Anhalten des Programms deaktiviert wurden. Die Sohnprogramme des Programms werden nicht automatisch wieder gestartet.

Testen (GSTATUS) Liefert den aktuellen Zustand (angehalten, aktiv, inaktiv) des Sohnprogramms.


 KOP-Sprache

Die KOP-Sprache (Kontaktplan) ist eine graphische Darstellung boolescher Gleichungen, in der Kontakte (als Eingänge) und Spulen (als Ausgänge) miteinander kombiniert werden.

Stromschienen

Mehrfach-Verbindungen

Kontakte und Spulen

RETURN-Anweisung

Sprünge und Marken

Funktionsbausteine im KOP

In der KOP-Sprache können boolesche Daten mit Hilfe von graphischen Symbolen, die in ein Diagramm eingesetzt werden, manipuliert werden. Die Symbole des KOP-Diagramms werden wie Elemente eines elektrischen Kontaktplans behandelt. KOP-Diagramme werden links und rechts durch Stromschienen begrenzt. Hier die graphischen Grundkomponenten eines KOP-Diagramms :

Linke Stromschiene (mit horizontaler Verbindung)

Rechte Stromschiene (mit horizontaler Verbindung)

Horizontale Verbindungslinie

Vertikale Verbindungslinie

Vertikale und horizontale Mehrfach-Verbindungen (alle verknüpft)

Mit einer Variablen verbundener Kontakt

Mit einem Ausgang oder einer internen Variablen verbundene Spule


Stromschienen

KOP-Diagramme werden links und rechts durch vertikale Linien, die sogenannten linken und rechten Stromschienen, begrenzt.

Die einzelnen Symbole eines KOP-Diagramms werden miteinander, sowie mit den Stromschienen durch Verbindungslinien verbunden. Verbindungen erfolgen entweder vertikal oder horizontal.

Jedes Verbindungssegment kann die booleschen Zustände FALSE oder TRUE annehmen. Der Zustand einer Verbindung propagiert sich in seine sämtlichen, rechten Enden. Horizontale Verbindungen, die an die linke Stromschiene angeschlossen sind, haben den booleschen Zustand TRUE.


Mehrfach-Verbindungen

Der boolesche Zustand einer horizontalen Verbindungslinie ist in ihren linken und rechten Enden der gleiche. Mit kombinierten, horizontalen und vertikalen Verbindungen können Mehrfach-Verbindungen konstruiert werden. Der Zustand der Enden in einer Mehrfach-Verbindung respektiert logische Regeln.

Eine Mehrfach-Verbindung nach links kombiniert mehrere horizontale Verbindungslinien, die links an eine vertikale Verbindungslinie angeschlossen werden, sowie eine einzige horizontale Verbindungslinie rechts. Der Zustand des rechten Endes ist das Ergebnis des LOGISCHEN ODER zwischen den Zuständen der linken Enden.

(* Beispiel einer Mehrfach-Verbindung nach links *)

(* Zustand des rechten Endes : (v1 OR v2 OR v3) *)

Eine Mehrfach-Verbindung nach rechts kombiniert eine einzige horizontale Verbindungslinie, die links an eine vertikale Verbindungslinie angeschlossen ist, sowie mehrere horizontale Verbindungslinien rechts. Der Zustand des linken Endes wird in sämtliche rechten Enden propagiert.

(* Beispiel einer Mehrfach-Verbindung nach rechts *)

(* ST-Äquivalenz *)

output1 := input1;

output2 := input1;

Eine Mehrfach-Verbindung links und rechts kombiniert mehrere horizontale Verbindungslinien links, die an eine vertikale Verbindungslinie angeschlossen werden, sowie mehrere horizontale Verbindungen rechts. Der Zustand sämtlicher rechten Enden ist das Ergebnis des LOGISCHEN ODER zwischen den Zuständen der linken Enden.

(* Beispiel einer Mehrfach-Verbindung links und rechts *)

(* ST-Äquivalenz *)

output1 := input1 ODER input2;

output2 := input1 ODER input2;

output3 := input1 ODER input2;


Kontakte und Spulen

Folgende Kontakt-Typen können in einem Kontaktplan verwendet werden :

Direkte Kontakte

Invertierte Kontakte

Kontakte mit Erkennung positiver Flanken

Kontakte mit Erkennung negativer Flanken

Folgende Spulen-Typen können in einem Kontaktplan verwendet werden :

Direkte Spulen

Invertierte Spulen

"SETZE"-Spulen

"RÜCKSETZE"-Spule

Spulen mit Erkennung steigender Flanken

Spulen mit Erkennung fallender Flanken

Der Name der zugeordneten Variablen wird über das Symbol geschrieben :


Direkte Kontakte

Ein direkter Kontakt stellt eine Operation zwischen dem Zustand einer Verbindungslinie und einer booleschen Variablen dar.

Der Zustand der Verbindung rechts ist das Ergebnis des LOGISCHEN UND zwischen dem Zustand der linken Verbindung und dem Wert der Variablen, die dem Kontakt zugeordnet ist.

(* Beispiel direkter Kontakte *)

(* ST-Äquivalenz *)

output1 := input1 AND input2;


Invertierte Kontakte

Ein invertierter Kontakt stellt eine Operation zwischen dem Zustand einer Verbindungslinie und der logischen Inversion einer booleschen Variablen dar.

Der Zustand der Verbindung rechts ist das Ergebnis des LOGISCHEN UND zwischen dem Zustand der linken Verbindung und der LOGISCHEN INVERSION des Werts der Variablen, die dem Kontakt zugeordnet ist.

(* Beispiel invertierter Kontakte *)

(* ST-Äquivalenz *)

output1 := NOT (input1) AND NOT (input2);


Kontakte mit Erkennung positiver Flanken

Diese Kontakte stellen eine Operation zwischen dem Zustand einer Verbindungslinie und dem Übergang einer booleschen Variablen zu dem Zustand TRUE dar.

Die Verbindung rechts nimmt den Zustand TRUE an, wenn der Zustand der Verbindung links TRUE ist und wenn der Zustand der zugeordneten Variablen von FALSE zu TRUE übergeht. In allen anderen Fällen nimmt sie den Zustand FALSE an.

(* Kontakt mit Erkennung einer positiven Flanke *)

(* ST-Äquivalenz *)

output1 := input1 AND (input2 AND NOT (input2prev));

(* input2prev ist der Wert von input2 im vorherigen Zyklus *)


Kontakte mit Erkennung negativer Flanken

Diese Kontakte stellen eine Operation zwischen dem Zustand einer Verbindungslinie und dem Übergang einer booleschen Variablen zu dem Zustand FALSE dar.

Die rechten Verbindung nimmt den Zustand TRUE an, wenn der Zustand der Verbindung links TRUE ist und wenn der Zustand der zugeordneten Variablen von TRUE zu FALSE übergeht. In allen anderen Fällen nimmt sie den Zustand FALSE an.

(* Kontakt mit Erkennung einer negativen Flanke *)

(* ST-Äquivalenz *)

output1 := input1 AND (NOT (input2) AND input2prev);

(* input2prev ist der Wert von input2 im vorherigen Zyklus *)


Direkte Spulen

Eine direkte Spule ermöglicht die Forcierung eines booleschen Ausgangs mit dem Zustand einer Verbindungslinie.

Die zugeordnete Variable wird zu dem Zustand der linken Verbindung forciert. Der Zustand der Verbindung links wird in die Verbindung rechts propagiert. Die rechte Verbindung kann an die rechte Stromschiene angeschlossen werden. Die zugeordnete, boolesche Variable muß eine AUSGANGS- oder INTERNE Variable sein. Der Name der zugeordneten Variablen kann der Name eines bearbeiteten Programms sein (nur für Unterprogramme). In diesem Fall stellt die Spule die Zuordnung des vom Unterprogramm zurückgegebenen Werts dar.

(* Beispiel einer direkten Spule *)

(* ST-Äquivalenz: *)

output1 := input1;

output2 := input1;


Invertierte Spulen

Eine invertierte Spule ermöglicht die Forcierung eines booleschen Ausgangs zu einer logischen Inversion des Zustands einer Verbindungslinie.

Die zugeordnete Variable wird zu einer logischen Inversion des Zustands der linken Verbindung forciert. Der Zustand der linken Verbindung wird in die rechte Verbindung propagiert. Die rechte Verbindung kann an die rechte Stromschiene angeschlossen werden. Die zugeordnete, boolesche Variable muß eine AUSGANGS- oder INTERNE Variable sein. Der Name der zugeordneten Variablen kann der Name eines bearbeiteten Programms sein (nur für Unterprogramme). In diesem Fall stellt die Spule die Zuordnung des vom Unterprogramm zurückgegebenen Werts dar.

(* Beispiel einer invertierten Spule *)

(* ST-Äquivalenz: *)

output1 := NOT (input1);

output2 := input1;


"SETZE"-Spulen

Eine Spule mit "Setze"-Aktion ermöglicht das Forcieren eines booleschen Ausgangs zu dem Zustand der Verbindungslinie.

Die zugeordnete Variable wird ZU TRUE FORCIERT, wenn die Verbindung links den Zustand TRUE annimmt. Die Variable behält diesen Wert, bis ein entgegengesetzter Befehl von einer Spule des Typs "RÜCKSETZE" gegeben wird. Der Zustand der linken Verbindung wird in die rechte Verbindung propagiert. Die rechte Verbindung kann an die rechte Stromschiene angeschlossen werden. Die zugeordnete, boolesche Variable muß eine AUSGANGS- oder INTERNE Variable sein.

(* Beispiel einer Spule mit SETZE- und RÜCKSETZE-Aktionen *)

(* ST-Äquivalenz: *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


"RÜCKSETZE"-Spule

Eine Spule mit "Rücksetze"-Aktion ermöglicht das Forcieren eines booleschen Ausgangs zu dem Zustand einer Verbindungslinie.

Die zugeordnete Variable wird ZU FALSE FORCIERT, wenn die Verbindung links den Zustand TRUE annimmt. Die Variable behält diesen Wert, bis ein entgegengesetzter Befehl von einer Spule des Typs "SETZE" gegeben wird. Der Zustand der linken Verbindung wird in die rechte Verbindung propagiert. Die rechte Verbindung kann an die rechte Stromschiene angeschlossen werden. Die zugeordnete, boolesche Variable muß eine AUSGANGS- oder INTERNE Variable sein.

(* Beispiel einer Spule mit SETZE- und RÜCKSETZE-Aktionen *)

(* ST-Äquivalenz: *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


Spulen mit Erkennung steigender Flanken

"Positive"Spulen ermöglichen den booleschen Ausgang des booleschen Zustands einer Verbindungslinie. Diese Art von Spule ist nur im Schnellen KOP-Editor verfügbar.

Die zugeordnete Variable wird zu TRUE forciert, wenn der boolesche Zustand der linken Verbindung von FALSE auf TRUE steigt. In allen anderen Fällen wird die Ausgangsvariable auf FALSE zurückgesetzt. Der Zustand der linken Verbindung wird in die rechte Verbindung propagiert. Rechte Verbindungen können an die rechte vertikale Stromschiene angeschlossen werden.

Die zugeordnete boolesche Variable muß eine AUSGANGs- oder INTERNE Variable sein.

(* Anwendungsbeispiel einer "positiven" Spule *)

(* ST-Äquivalenz: *)

IF (input1 and NOT(input1prev)) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(* input1prev ist der Wert von input1 im vorherigen Zyklus *)


Spulen mit Erkennung fallender Flanken

"Negative" Spulen ermöglicht den booleschen Ausgang des booleschen Zustands einer Verbindungslinie. Diese Art von Spule ist nur im Schnellen KOP-Editor verfügbar.

Die zugeordnete Variable wird zu TRUE forciert, wenn der boolesche Zustand der linken Verbindung von TRUE auf FALSE fällt. In allen anderen Fällen wird die Ausgangsvariable auf FALSE zurückgesetzt. Der Zustand der linken Verbindung wird in die rechte Verbindung propagiert. Rechte Verbindungen können an die rechte vertikale Stromschiene angeschlossen werden.

Die zugeordnete boolesche Variable muß eine AUSGANGs- oder INTERNE Variable sein.

(*Anwendungsbeispiel einer "positiven" Spule *)

(* ST-Äquivalenz: *)

IF (NOT(input1) and input1prev) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(* input1prev ist der Wert von input1 im vorherigen Zyklus *)


RETURN-Anweisung

Das RETURN-Symbol kann benutzt werden, um die bedingte Beendung einer Programmausführung darzustellen. Rechts vom RETURN-Symbol darf keine Verbindung angebracht werden.

Wenn der Zustand der linken Verbindung TRUE ist, wird das weitere KOP-Diagramm (darauffolgende Zeilen) nicht interpretiert.

Anmerkung: Wenn das KOP-Programm ein Unterprogramm ist, muß sein Name einer Ausgangsspule zugeordnet werden, um den Rückgabewert zu setzen (Rückgabe an das aufrufende Programm).

(* Anwendungsbeispiel des RETURN-Symbols *)

(* ST-Äquivalenz *)

If Not (manual_mode) Then RETURN; End_if;

result := (input1 OR input3) AND input2;


Sprünge und Marken

Marken und bedingte oder unbedingte Sprünge werden benutzt, um die Diagrammausführung zu steuern. Rechts von einem Marken- oder Sprungssymbol kann kein Anschluß vorgenommen werden.

Die folgenden Notationen werden benutzt:

>>LAB	Sprung zu Marke mit dem Namen "LAB"

LAB:	Definition der Marke mit dem Namen "LAB"

Wenn die Verbindung links vom Symbol den Zustand TRUE annimmt, wird die Programmausführung zur entsprechenden Marke umgeleitet.

(* Anwendungsbeispiel für Sprünge und Marken *)

(* AWL-Äquivalenz *)

ldn	manual_mode

jmpc	other

ld	input1

st	result

jmp	END

OTHER:	ld	input2

st	result

END:	(*Programmende *)


Funktionsbausteine im KOP

Im Schnellen KOP-Editor werden Funktionsbausteine mit booleschen Linien verbunden. Eine Funktion kann in Wirklichkeit ein Operator, ein Funktionsbaustein oder eine Funktion sein. Da alle Bausteine nicht immer einen booleschen Eingang oder Ausgang besitzen, bewirkt das Einfügen solcher Bausteine in ein KOP-Diagramm die Verwendung zusätzlicher EN- und ENO-Parameter in der Baustein-Schnittstelle. Im FBS/KOP-Editor werden die EN- und ENO-Parameter nicht benutzt, da die Variablen mit den erforderlichen Typen verbunden werden können.

Der "EN"-Eingang:

Bei manchen Operatoren, Funktionen und Funktionsbausteinen ist der erste Eingang nicht immer boolesch. Da der erste Eingang immer an das Rung angeschlossen werden muß, wird automatisch ein anderer Eingang mit dem Namen "EN" an der ersten Stelle eingefügt. Der Baustein wird nur ausgeführt, wenn der EN-Eingang TRUE ist. Das folgende Beispiel zeigt einen Vergleichs-Operatoren und den äquivalenten Code in ST:

	IF rung_state THEN    q := (value1 > value 2); ELSE    q := FALSE; END_IF; (*Rung mit q-Status fortführen*)

Der "ENO"-Ausgang:

Bei manchen Operatoren, Funktionen und Funktionsbausteinen ist der erste Ausgang nicht immer boolesch. Da der erste Ausgang immer an das Rung angeschlossen werden muß, wird automatisch ein anderer Ausgang mit dem Namen "ENO" an der ersten Stelle eingefügt. Der ENO-Ausgang nimmt immer den gleichen Zustand wie der erste Eingang des Bausteins an. Das folgende Beispiel zeigt einen AVERAGE-Funktionsbaustein und den äquivalenten Code in ST:

	AVERAGE(rung_state, Signal, 100); OutSignal := AVERAGE.XOUT; eno := rung_state; (* Rung mit eno-Status fortführen *)

Die "EN"- und "ENO"-Parameter:

In manchen Fällen sind EN und ENO erforderlich. Es folgt das Beispiel eines arithmetischen Operators und der äquivalente Code in ST:

	IF rung_state THEN    result := (value1 + value2); END_IF; eno := rung_state; (*Rung mit eno-Status fortführen *)


Standard-Operatoren,
Standard-Operatoren, Funktionsbausteine und Funktionen

Standard-Operatoren

Standard-Funktionsbausteine

Standard-Funktionen

Index


Standard-Operatoren

Es folgt eine Liste der verfügbaren Funktionsbausteine, die den in der ST-Sprache definierten Standard-Operatoren, -Funktionsbausteinen und -Funktionen entsprechen. Die folgende Typen-Abkürzungen wurden benutzt: BOO (boolesch), INT (ganzzahlig), REAL (real), TMR (Timer) und MSG (Zeichenkette) :

Datenmanipulation:

1 Gain	Zuweisung

Neg	Analoge Negation

Boolesche Operationen:

& (AND)	Logisches UND

>=1 (OR)	Logisches ODER

=1 (XOR)	Logisches exklusiv-ODER

Arithmetische Operationen:

 + 	Addition

 - 	Substraktion

 * 	Multiplikation

 / 	Division

Maskierungs-Operationen:

AND_MASK	Analoge Bit-zu-Bit UND-Maske

OR_MASK	Analoge Bit-zu-Bit ODER-Maske

XOR_MASK	Analoge Bit-zu-Bit exklusiv-ODER-Maske

NOT_MASK	Bit-zu-Bit Inversion

Vergleiche:

 < 	Kleiner als

 <= 	Kleiner oder gleich

 > 	Größer als

 >= 	Größer oder gleich

 = 	Gleich

 <> 	Ungleich

Datenumrechnungen:

BOO	Umrechnung zu boolesch

ANA	Umrechnung zu analog, ganzzahlig

REAL	Umrechnung zu analog, real

TMR	Umrechnung zu Timer

MSG	Umrechnung zu Zeichenkette

Weitere Operatoren:

CAT	Verkettung von Zeichenketten

SYSTEM	Zugriff auf die Systemparameter

OPERATE	E/A-Verarbeitung


1 gain

Argumente:

IN	alle Typen

Q	alle Typen

Beschreibung:

Zuweisung einer Variablen an eine andere Variable.

Dieser Baustein wird insbesondere dann benutzt, wenn ein Diagramm-Eingang direkt mit einem Diagramm-Ausgang verbunden werden soll. Er kann auch verwendet werden, um eine boolesche Inversion vor dem Anschluß einer Verbindungslinie an eine Diagramm-Ausgangsvariable einzufügen.

(* FBS-Programm mit "Zuweisung"-Baustein *)

(* ST-Äquivalenz: *)

ao23 := ai10;

bo100 := NOT (bi1 AND bi2);

(* AWL-Äquivalenz: *)

LD	ai10

ST 	ao23

LD	bi1

AND	bi2

STN	bo100


NEG

Argumente:

IN	INT- REAL	Ein- und Ausgang müssen das gleiche Format haben.

Q	INT - REAL

Beschreibung:

Zuweisung der Negation einer Variablen.

(*FBS-Programm mit Negations-Bausteinen *)

(* ST-Äquivalenz *)

ao23 := - (ai10);

ro100 := - (ri1 + ri2);

(* AWL-Äquivalenz: *)

LD	ai10

MUL	-1

ST 	ao23

LD	ri1

ADD	ri2

MUL	-1.0

ST	ro100


& AND

Anmerkung: Für diesen Operator kann die Anzahl der Eingänge zu mehr als zwei erweitert werden.

Argumente :

(inputs)	BOO

output	BOO	Logisches UND zwischen beiden Termen

Beschreibung:

Boolesches UND zwischen zwei oder mehr Termen.

(* FBS-Programm mit "UND"-Baustein *)

(* ST-Äquivalenz: *)

bo10 := bi101 AND NOT (bi102);

bo5 := (bi51 AND bi52) AND bi53;

(* AWL-Äquivalenz: *)

LD	bi101	(*Ergebnis := bi101 *)

ANDN	bi102	(*Ergebnis := bi101 AND not(bi102) *)

ST	bo10	(* bo10 := Ergebnis  *)

LD	bi51	(*Ergebnis := bi51;

&	bi52	(*Ergebnis := bi51 AND bi52 *)

&	bi53	(*Ergebnis := (bi51 AND bi52) AND bi53 *)

ST	bo5	(* bo5 := Ergebnis  *)


>=1 OR

Anmerkung: Für diesen Operator kann die Anzahl der Eingänge zu mehr als zwei erweitert werden.

Argumente :

(inputs)	BOO

output	BOO	Logisches ODER zwischen den beiden Termen

Beschreibung:

Boolesches ODER von zwei oder mehr Termen.

(* FBS-Programm mit "ODER"-Bausteinen *)

(* ST-Äquivalenz: *)

bo10 := bi101 OR NOT (bi102);

bo5 := (bi51 OR bi52) OR bi53;

(* AWL-Äquivalenz: *)

LD	bi101

ORN	bi102

ST	bo10

LD	bi51

OR	bi52

OR	bi53

ST	bo5


=1 XOR

Argumente:

IN1	BOO

IN2	BOO

Q	BOO	boolesches exklusiv-ODER der 2 Eingangstermen

Beschreibung:

Boolesches exklusiv-ODER zwischen zwei Termen.

(* FBS-Programm mit "Exklusiv ODER"-Bausteinen *)

(* ST-Äquivalenz: *)

bo10 := bi101 XOR NOT (bi102);

bo5 := (bi51 XOR bi52) XOR bi53;

(* AWL-Äquivalenz: *)

LD	bi101

XORN	bi102

ST	bo10

LD	bi51

XOR	bi52

XOR	bi53

ST	bo5


+

Anmerkung: Für diesen Operator kann die Anzahl der Eingänge zu mehr als zwei erweitert werden.

Argumente:

(inputs)	INT-REAL	kann GANZZAHLIG oder REAL sein

(alle Argumente müssen das gleiche Format haben)

output	INT -REAL	vorzeichenbehaftete Addition der beiden Termen

Beschreibung:

Addition von zwei oder mehr analogen Variablen.

(* FBS-Programm mit "Addition"-Baustein *)

(* ST-Äquivalenz: *)

ao10 := ai101 + ai102;

ao5 := (ai51 + ai52) + ai53;

(* AWL-Äquivalenz: *)

LD	ai101

ADD	ai102

ST	ao10

LD	ai51

ADD	ai52

ADD	ai53

ST	ao5


-

Argumente:

IN1	INT -REAL	kann GANZZAHLIG oder REAL sein

IN2	INT -REAL	(IN1 und IN2 müssen das gleiche Format haben)

Q	INT -REAL	Substraktion (erste - zweite)

Beschreibung:

Substraktion von zwei analogen Variablen (erste - zweite).

(* FBS-Programm mit "Substraktion"-Baustein *)

(* ST-Äquivalenz: *)

ao10 := ai101 - ai102;

ao5 := (ai51 - 1) - ai53;

(* AWL-Äquivalenz: *)

LD	ai101

SUB	ai102

ST	ao10

LD	ai51

SUB	1

SUB	ai53

ST	ao5


*

Anmerkung: Für diesen Operator kann die Anzahl der Eingänge zu mehr als zwei erweitert werden.

Argumente:

(inputs)	INT -REAL	kann GANZZAHLIG oder REAL sein

(alle Argumente müssen das gleiche Format haben)

output	INT -REAL	vorzeichenbehaftete Multiplikation der Eingangstermen

Beschreibung:

Multiplikation von zwei oder mehr analogen Variablen.

(* FBS-Programm mit "Multiplikation"-Baustein *)

(* ST-Äquivalenz: *)

ao10 := ai101 * ai102;

ao5 := (ai51 * ai52) * ai53;

(* ST-Äquivalenz: *)

LD	ai101

MUL	ai102

ST	ao10

LD	ai51

MUL	ai52

MUL	ai53

ST	ao5


/

Argumente:

IN1	INT -REAL	kann GANZZAHLIG oder REAL sein

IN2	INT-REAL	analoger Wert ungleich null (Divisor)

(IN1 und IN2 müssen das gleiche Format haben)

Q	INT-REAL	vorzeichenbehaftete ganzzahlige oder reale Division von IN1 durch IN2

Beschreibung:

Division von zwei analogen Variablen (die erste wird durch die zweite geteilt).

(* FBS-Programm mit "Division"-Baustein *)

(* ST-Äquivalenz: *)

ao10 := ai101 / ai102;

ao5 := (ai51 / 2) / ai53;

(* AWL-Äquivalenz: *)

LD	ai101

DIV	ai102

ST	ao10

LD	ai51

DIV	2

DIV	ai53

ST	ao5


AND_MASK

Argumente:

IN	INT	muß vom Format GANZZAHLIG sein

MSK	INT	muß vom Format GANZZAHLIG sein

Q	INT	Bit-zu-Bit logisches UND zwischen IN und MSK

Beschreibung:

Ganzzahlige analoge Bit-zu-Bit UND-Maske.

 (* FBS-Programm mit "UND-Maske"-Baustein *)

(* ST-Äquivalenz: *)

parity := AND_MASK (xvalue, 1); (* =1, wenn xvalue ungerade *)

result := AND_MASK (16#abc, 16#f0f); (* gleich 16#a0c *)

(* AWL-Äquivalenz: *)

LD	xvalue

AND_MASK	1

ST	parity

LD	16#abc

AND_MASK	16#f0f

ST	result


OR_MASK

Argumente:

IN	INT	muß vom Format GANZZAHLIG sein

MSK	INT	muß vom Format GANZZAHLIG sein

Q	INT	logisches Bit-zu-Bit ODER zwischen IN und MSK

Beschreibung:

Ganzzahlige analoge Bit-zu-Bit ODER-Maske.

 (* FBS-Programm mit "ODER-Maske"-Baustein *)

(* ST-Äquivalenz: *)

is_odd := OR_MASK (xvalue, 1); (* immer ungerade *)

result := OR_MASK (16#abc, 16#f0f); (* gleich 16#fbf *)

(* AWL-Äquivalenz: *)

LD	xvalue

OR_MASK	1

ST	is_odd

LD	16#abc

OR_MASK	16#f0f

ST	result


XOR_MASK

Argumente:

IN	INT	muß vom Format GANZZAHLIG sein

MSK	INT	muß vom Format GANZZAHLIG sein

Q	INT	Logisches Bit-zu-Bit exklusiv-ODER zwischen IN und MSK

Beschreibung:

Ganzzahlige analoge Bit-zu-Bit exklusiv-ODER-Maske

 (* FBS-Programm mit "Exklusiv ODER-Maske"-Baustein *)

(* ST-Äquivalenz: *)

crc32 := XOR_MASK (prevcrc, nextc);

result := XOR_MASK (16#012, 16#011); (*gleich 16#003 *)

(*AWL-Äquivalenz: *)

LD	prevcrc

XOR_MASK	nextc

ST	crc32

LD	16#012

XOR_MASK	16#011

ST	result


NOT_MASK

Argumente :

IN	INT	muß vom Format GANZZAHLIG sein

Q	INT	invertiert Bit zu Bit den IN auf 32 Bits

Beschreibung:

Ganzzahlige analoge Bit-zu-Bit Negation-Maske

 (*FBS-Programm mit "NOT_MASK"-Baustein *)

(* ST-Äquivalenz: *)

result := NOT_MASK (16#1234);

(* result ist 16#FFFF_EDCB *)

(* AWL-Äquivalenz: *)

LD	16#1234

NOT_MASK

ST	result


<

Argumente:

IN1	INT-REAL-

TMR-MSG

IN2	INT-REAL-

TMR-MSG	die beiden Eingänge müssen vom gleichen Typ sein

Q	BOO	TRUE wenn IN1 < IN2

Beschreibung:

Testet, ob eine Wert KLEINER ALS ein anderer Wert ist ( Analog, Timer oder Zeichenkette)

 (* FBS-Programm mit "Kleiner als"-Baustein *)

(* ST-Äquivalenz: *)

aresult := (10 < 25);     (* aresult = TRUE *)

mresult := ('z' < 'B');    (* mresult = FALSE *)

(* AWL-Äquivalenz: *)

LD	10

LT	25

ST	aresult

LD	'z'

LT	'B'

ST	mresult


<=

Argumente:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG	die beiden Eingänge müssen vom gleichen Typ sein

Q	BOO	TRUE wenn IN1 <= IN2

Beschreibung:

Testet, ob ein Wert KLEINER als ODER GLEICH einem anderen Wert ist (Analog oder Zeichenkette)

(* FBS-Programm mit "Kleiner oder gleich"-Baustein *)

(* ST-Äquivalenz: *)

aresult := (10 <= 25);     (* aresult = TRUE *)

mresult := ('ab' <= 'ab');    (* mresult = TRUE *)

(* AWL-Äquivalenz: *)

LD	10

LE	25

ST	aresult

LD	'ab'

LE	'ab'

ST	mresult


>

Argumente:

IN1	INT-REAL-

TMR-MSG

IN2	INT-REAL-

TMR-MSG	die beiden Eingänge müssen vom gleichen Typ sein

Q	BOO	TRUE wenn IN1 > IN2

Beschreibung:

Testet, ob ein Wert GRÖSSER ALS ein anderer Wert ist (Analog, Timer oder Zeichenkette)

 (* FBS-Programm mit "Größer als"-Baustein *)

(* ST-Äquivalenz: *)

aresult := (10 > 25);     (* aresult = FALSE *)

mresult := ('ab' > 'a');    (* mresult = TRUE *)

(* AWL-Äquivalenz: *)

LD	10

GT	25

ST	aresult

LD	'ab'

GT	'a'

ST	mresult


>=

Argumente:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG	die beiden Eingänge müssen vom gleichen Typ sein

Q	BOO	TRUE wenn IN1 >= IN2

Beschreibung:

Testet, ob ein Wert GRÖSSER als oder GLEICH einem anderen Wert ist (Analog oder Zeichenkette)

 (* FBS-Programm mit "Größer oder gleich"-Baustein *)

(* ST-Äquivalenz: *)

aresult := (10 >= 25);      (* aresult = FALSE *)

mresult := ('ab' >= 'ab'); (* mresult = TRUE *)

(* AWL-Äquivalenz: *)

LD	10

GE	25

ST	aresult

LD	'ab'

GE	'ab'

ST	mresult


=

Arguments:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG	die beiden Eingänge müssen vom gleichen Typ sein

Q	BOO	TRUE wenn IN1 = IN2

Beschreibung:

Testet, ob ein Wert GLEICH einem anderen Wert ist (Analog oder Zeichenkette)

 (* FBS-Programm mit "Ist gleich"-Baustein *)

(* ST-Äquivalenz: *)

aresult := (10 = 25);     (* aresult = FALSE *)

mresult := ('ab' = 'ab');    (* mresult = TRUE *)

(* AWL-Äquivalenz: *)

LD	10

EQ	25

ST	aresult

LD	'ab'

EQ	'ab'

ST	mresult


<>

Arguments:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG	die beiden Eingänge müssen vom gleichen Typ sein

Q	BOO	TRUE wenn erster <> zweiter

Beschreibung:

Testet, ob ein Wert UNGLEICH einem anderen Wert ist (Analog oder Zeichenkette)

 (* FBS-Programm mit "Ist ungleich"-Baustein *)

(* ST-Äquivalenz: *)

aresult := (10 <> 25);       (* aresult = TRUE *)

mresult := ('ab' <> 'ab');  (* mresult = FALSE *)

(* AWL-Äquivalenz: *)

LD	10

NE	25

ST	aresult

LD	'ab'

NE	'ab'

ST	mresult


BOO

Argumente:

IN	ALLE TYPEN	alle nicht booleschen Werte

Q	BOO	TRUE für einen analogen Wert ungleich null

FALSE für einen analogen Wert gleich null

TRUE für eine Zeichenkette 'TRUE'

FALSE für eine Zeichenkette 'FALSE'

Beschreibung:

Beliebige Variable in eine boolesche Variable umrechnen.

(* FBS-Programm mit Umrechnung zu boolesch *)

(* ST-Äquivalenz: *)

ares := BOO (10);          (* ares = TRUE *)

tres := BOO (T#0s);       (* tres  FALSE *)

mres := BOO ('false');    (* mres = FALSE *)

(* AWL-Äquivalenz: *)

LD	10

BOO

ST	ares

LD	t#0s

BOO

ST	tres

LD	'false'

BOO

ST	mres


ANA

Argumente:

IN	ALLE TYPEN	alle Werte, die nicht analog ganzzahlig sind

Q	INT	0 wenn IN ist FALSE / 1 wenn IN ist TRUE

Zahl in Millisekunden für einen Timer

ganzzahliger Teil für reale analoge Werte

Dezimalwert, durch eine Zeichenkette dargestellt

Beschreibung:

Beliebige Variable zu einer ganzzahligen Variablen umrechnen.

(* FBS-Programm mit Umrechnung zu Ganzzahlig *)

(* ST-Äquivalenz: *)

bres := ANA (true);          	(* bres = 1 *)

tres := ANA (t#1s46ms);     (* tres = 1046 *)

mres := ANA ('0198');      	(* mres = 198 *)

(* AWL-Äquivalenz: *)

LD	true

ANA

ST	bres

LD	t#1s46ms

ANA

ST	tres

LD	'0198'

ANA

ST	mres


REAL

Argumente:

IN	BOO-INT-

TMR	alle Werte, die nicht analog, real sind (keine Zeichenkette)

Q	REAL	0.0 wenn IN ist FALSE / 1.0 wenn IN ist TRUE

Zahl in Millisekunden für einen Timer

Zahl äquivalent zu einem analogen, ganzzahligen Wert

Beschreibung:

Beliebige Variable in eine reale Variable umrechnen

(* FBS-Programm mit Umrechnung zu Real *)

(* ST-Äquivalenz: *)

bres := REAL (true);         	 (* bres = 1.0 *)

tres := REAL (t#1s46ms);   (* tres = 146.0 *)

ares := REAL (198);           	(* ares = 198.0 *)

(* AWL-Äquivalenz: *)

LD	true

REAL

ST	bres

LD	t#1s46ms

REAL

ST	tres

LD	198

REAL

ST	ares


TMR

Argumente:

IN	INT-REAL	alle Werte außer Zeitwerten

IN (oder ganzzahliger Teil von IN , wenn real)

ist die Zahl in Millisekunden

Q	TIMER	Zeitwert, dargestellt durch IN

Beschreibung:

Beliebige Variable in eine Timer-Variable umrechnen.

(* FBS-Programm mit Umrechnung zu Timer *)

(* ST-Äquivalenz: *)

ares := TMR(1256);	(* ares = t#1s256ms *)

rres := TMR (1256.3);	(* rres = t#1s256ms *)

(* AWL-Äquivalenz: *)

LD	1256

TMR

ST	ares

LD	1256.3

TMR

ST	rres


MSG

Argumente:

IN	BOO-

INT-REA	alle Werte, außer Zeichenketten

Q	ZK	'false' oder 'true', wenn IN boolesch ist

dezimale Darstellung, wenn IN analog ist

Beschreibung:

Beliebige Variable in eine Zeichenketten-Variable umrechnen.

(* FBS-Programm mit Umrechnung zu Zeichenkette *)

(* ST-Äquivalenz: *)

bres := MSG (true);	(* bres = 'TRUE' *)

ares := MSG (125);	(* ares = '125' *)

(* AWL-Äquivalenz: *)

LD	true

MSG

ST	bres

LD	125

MSG

ST	ares


CAT

Anmerkung: Für diesen Operator kann die Anzahl der Eingänge zu mehr als zwei erweitert werden.

Argumente:

(inputs)	ZK	(die Summe der Längen der Zeichenketten darf die Kapazität des Ergebnisses nicht überschreiten )

output	ZK	Verkettung der Eingangs-Zeichenketten

Beschreibung:

Mehrere Zeichenketten zu einer Zeichenkette verketten

(* FBS-Programm mit "Verkettung"-Baustein *)

(* ST-Äquivalenz *)

meinname:= ('Herr' + ' ') + 'Meyer';

(* bedeutet: meinname := 'Herr Meyer' *)

(* AWL-Äquivalenz *)

LD	'Herr'

ADD	' '

ADD	'Meyer'

ST	meinname


SYSTEM

Argumente:

Mode	INT	identifiziert den Systemparameter und den Zugriff-Modus

Arg	INT -TMR	neuer Wert für einen "Schreib"-Zugriff

Param	INT	Wert des zugegriffenen Parameters

Beschreibung:

Zugriff auf die Systemparameter

Für die SYSTEM-Funktion sind folgende Befehle (vordefinierte Schlüsselwörter) verfügbar :

Befehl	Bedeutung

SYS_TALLOWED	Lesen der programmierten Zykluszeit

SYS_TCURRENT	Lesen der aktuellen Zykluszeit

SYS_TMAXIMUM	Lesen der maximalen Zykluszeit

SYS_TOVERFLOW	Lesen der Zykluszeit-Überschreitungen

SYS_TRESET	Einstellen des Zeitzählers auf null

SYS_TWRITE	Schreiben der Zykluszeit

SYS_ERR_TEST	Test der Ausführungsfehler

SYS_ERR_READ	Lesen des letzten Ausführungsfehlers

Hier die Liste der Argumente, die für die vordefinierten Befehle der SYSTEM-Funktion erforderlich sind :

Befehl	Argument

SYS_TALLOWED	0

SYS_TCURRENT	0

SYS_TMAXIMUM	0

SYS_TOVERFLOW	0

SYS_TRESET	0

SYS_TWRITE	neue zugelassene Zykluszeit

SYS_ERR_TEST	0

SYS_ERR_READ	0

Befehl	zurückgegebener Wert

SYS_TALLOWED	zugelassene Zykluszeit

SYS_TCURRENT	aktuelle Zykluszeit

SYS_TMAXIMUM	festgestellte max. Zykluszeit

SYS_TOVERFLOW	Anzahl der Überschreitungen

SYS_TRESET	0

SYS_TWRITE	geschriebener Wert

SYS_ERR_TEST	0, wenn keine Fehler gefunden wurden

SYS_ERR_READ	ältester Fehlercode

(* FBS-Programm mit "System"-Baustein *)

(* ST-Äquivalenz *)

alarm := (SYSTEM (SYS_TOVERFLOW, 0) <> 0);

If (alarm) Then

nb_err := nb_err + 1;

rc := SYSTEM (SYS_TRESET, 0);

End_If;


OPERATE

Argumente:

IO	(ALLE)	Ein- oder Ausgangsvariable

Funct	INT	auszuführende Aktion

Arg	INT	Argument für die ausgeführte Aktion

Q	INT	Rückgabe Ausführungsbericht

Beschreibung:

Zugriff auf einen E/A-Kanal

Die Bedeutung der Argumente von OPERATE hängen von der Implementierung der E/A-Schnittstelle ab. Siehe Handbuch der verwendeten Steuerung oder Datenblatt der entsprechnden E/A für weitere Informationen über die Funktion OPERATE.


Standard-Funktionsbausteine

Die folgenden Standard-Funktionsbausteine werden vom ISaGRAF-System unterstützt. Sie sind vordefiniert und brauchen nicht in der Bibliothek deklariert zu werden.

Boolesche Daten:

SR	Bistabil - Forcierung zu TRUE prioritär

RS	Bistabil - Forcierung zu FALSE prioritär

R_TRIG	Erkennung einer steigenden Flanke

F_TRIG	Erkennung einer fallenden Flanke

SEMA	Semaphor

Zählen:

CTU	Zähler

CTD	Zwischenzähler

CTUD	Zähler/ Zwischenzähler

Timer:

TON	Timer bei Einschaltung

TOF	Timer bei Ausschaltung

TP	Impuls-Timer

Ganzzahlige:

CMP	Komparator

STACKINT	Stapel analoger, ganzzahliger Werte

Reale:

AVERAGE	Aktueller Mittelwert auf N Samples

HYSTER	Bool. Hysterese ü.d. Differenz

LIM_ALRM	Grenzalarm mit Hystereseberechnung

INTEGRAL	Integration (Zeit)

DERIVATE	Abweichung (Zeit)

Signale:

BLINK	Blinklicht

SIG_GEN	Zeitbasis

Anmerkung: Neu entwickelte "C"-Funktionsbausteine werden für die FBS-Sprache verfügbar.


SR

Argumente:

SET1	BOO	wenn TRUE, forciert Q1 zu TRUE (dominant)

RESET	BOO	wenn TRUE, setzt Q1 auf FALSE zurück

Q1	BOO	boolescher Speicherstatus

Beschreibung:

Dominant bistabil forcieren: Siehe folgende True-Tabelle:

Set1 	Reset	Q1	Q1

0 	0	0	0

0	0	1	1

0	1	0	0

0	1	1	0

1	0	0	1

1	0	1	1

1	1	0	1

1	1	1	1

 (* FBS-Programm mit "SR"-Funktionsbaustein *)

(* ST-Äquivalenz: Es wird angenommen, daß SR1 eine Instance des Bausteins SR ist *)

SR1((auto_mode & start_cmd), stop_cmd);

command := SR1.Q1;

(* AWL-Äquivalenz: *)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command


RS

Argumente:

SET	BOO	wenn TRUE, forciert Q1 zu TRUE

RESET1	BOO	wenn TRUE, setzt Q1 auf FALSE zurück (dominant)

Q1	BOO	boolescher Speicherstatus

Beschreibung:

Dominant bistabil rücksetzen: Siehe folgende True-Tabelle:

Set 	Reset1	Q1	Q1

0 	0	0	0

0	0	1	1

0	1	0	0

0	1	1	0

1	0	0	1

1	0	1	1

1	1	0	0

1	1	1	0

(* FBS-Programm mit "RS"-Funktionsbaustein *)

(* ST-Äquivalenz: Es wird angenommen, daß RS1 eine Instance des Bausteins RS ist *)

RS1(start_cmd, (stop_cmd OR alarm));

command := RS1.Q1;

(* AWL-Äquivalenz: *)

LD	start_cmd

ST	RS1.set

LD	stop_cmd

OR	alarm

ST	RS1.reset1

CAL	RS1

LD	RS1.Q1

ST	command


R_TRIG

Argumente:

CLK	BOO	alle booleschen Variablen

Q	BOO	TRUE wenn CLK von FALSE zu TRUE übergeht

FALSE in allen anderen Fällen

Beschreibung:

Erkennung einer steigenden Flanke einer booleschen Variablen

(* FBS-Programm mit "R_TRIG"-Funktionsbaustein *)

(* ST-Äquivalenz: Es wird angenommen, daß R_TRIG1 eine Instance des Bausteins R_TRIG ist *)

R_TRIG1(cmd);

nb_edge := ANA(R_TRIG1.Q) + nb_edge;

(* AWL-Äquivalenz: *)

LD	cmd

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


F_TRIG

Argumente:

CLK	BOO	alle booleschen Variablen

Q	BOO	TRUE wenn CLK von TRUE auf FALSE übergeht

FALSE in allen anderen Fällen

Beschreibung:

Erkennung einer fallenden Flanke einer booleschen Variablen

(* FBS-Programm mit "F_TRIG"-Funktionsbaustein *)

(* ST-Äquivalenz: Es wird angenommen, daß F_TRIG1 eine Instance des Bausteins F_TRIG ist *)

F_TRIG1(cmd);

nb_edge := ANA(F_TRIG1.Q) + nb_edge;

(* AWL-Äquivalenz: *)

LD	cmd

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


SEMA

Argumente:

CLAIM	BOO	"test and set" Befehl

RELEASE	BOO	Freigabe des Semaphor

BUSY	BOO	Status des Semaphor

Beschreibung:

(* "x" ist eine boolesche Variable zu FALSE initialisiert*)

busy := x;

If claim Then

x := True;

Else

If release Then

busy := False;

x := False;

End_if;

End_if;


CTU

Argumente:

CU	BOO	Zähleingang (zählt, wenn CU = TRUE)

RESET	BOO	Zurücksetzen auf null (prioritär)

PV	INT	programmierter Maximalwert

Q	BOO	overflow: TRUE wenn CV = PV

CV	INT	Aktuelles Zählergebnis

Achtung: Der CTU-Baustein erkennt nicht die steigenden oder fallenden Flanken des Zähleingangs (CU). Er muß einem "R_TRIG" oder "F_TRIG"-Baustein zugeordnet werden, wenn ein Impuls-Zähler erstellt werden soll.

Beschreibung:

Schrittweise zählen (ganzzahlig) von 0 aufwärts bis zu einem gegebenen Wert.

(* FBS-Programm mit "CTU"-Funktionsbaustein *)

(* ST-Äquivalenz: Es wird angenommen, daß R_TRIG1 eine Instance des Bausteins R_TRIG ist und CTU1 eine Instance des Bausteins CTU *)

CTU1(R_TRIG1(command),NOT(auto_mode),100);

overflow := CTU1.Q;

result := CTU1.CV;

(* AWL-Äquivalenz: *)

LD	command

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTU1.cu

LDN	auto_mode

ST	CTU1.reset

LD	100

ST	CTU1.pv

CAL	CTU1

LD	CTU1.Q

ST	overflow

LD	CTU1.cv

ST	result


CTD

Argumente:

CD	BOO	Zähleingang (zählt abwärts, wenn CD = TRUE)

LD	BOO	Ladebefehl (prioritär)

(CV = PV, wenn LD = TRUE)

PV	INT	Programmierter Initialwert

Q	BOO	underflow: TRUE, wenn CV = 0

CV	INT	Aktuelles Zählergebnis

Achtung: Der CTD-Baustein erkennt nicht die steigenden oder fallenden Flanken des Zähleingangs (CU). Er muß einem "R_TRIG" oder "F_TRIG"-Baustein zugeordnet werden, wenn ein Impuls-Zähler erstellt werden soll.

Beschreibung:

Schrittweise zählen (ganzzahlig) von einem gegebenen Wert abwärts bis 0

(* FBS-Programm mit "CTD"-Funktionsbaustein *)

(* ST-Äquivalenz: Es wird angenommen, daß F_TRIG1eine Instance des Bausteins F_TRIG ist und CTD1 eine Instance des Bausteins CTD *)

CTD1(F_TRIG1(command),load_cmd,100);

underflow := CTD1.Q;

result := CTD1.CV;

(* AWL-Äquivalenz: *)

LD	command

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ST	CTD1.cd

LD	load_cmd

ST	CTD1.load

LD	100

ST	CTD1.pv

CAL	CTD1

LD	CTD1.Q

ST	underflow

LD	CTD1.cv

ST	result


CTUD

Argumente:

CU	BOO	Zählen (Inkrementation, wenn CU = TRUE)

CD	BOO	Zwischenzählen (Dekrementation, wenn CD=TRUE)

R	BOO	zurück-auf-null-Befehl (prioritär)

(CV = 0, wenn RESET = TRUE)

LD	BOO	Ladebefehl (CV = PV, wenn LOAD = TRUE)

PV	INT	Programmierter Maximalwert

QU	BOO	Signal "voll": TRUE, wenn CV = PV

QD	BOO	Signal "leer": TRUE, wenn CV = 0

CV	INT	Aktuelles Zählergebnis

Achtung: Der CTUD-Baustein erkennt nicht die steigenden oder fallenden Flanken des Zähleingangs (CU). Er muß einem "R_TRIG" oder "F_TRIG"-Baustein zugeordnet werden, wenn ein Impuls-Zähler erstellt werden soll.

Beschreibung:

Schrittweise zählen (ganzzahlig) von 0 aufwärts bis zu einem gegebenen Wert

oder von einem gegebenen Wert abwärts bis 0

(* FBS-Programm mit "CTUD"-Funktionsbaustein *)

(* ST-Äquivalenz: Es wird angenommen, daß R_TRIG1 und R_TRIG2 zwei Instancen des Bausteins R_TRIG sind und daß CTUD1 eine Instance des Bausteins CTUD ist*)CTUD1(R_TRIG1(add_elt), R_TRIG2(sub_elt), reset_cmd, load_cmd,100);

full := CTUD1.QU;

empty := CTUD1.QD;

nb_elt := CTUD1.CV;

(* AWL-Äquivalenz: *)

LD	add_elt

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTUD1.cu

LD	sub_elt

ST	R_TRIG2.clk

CAL	R_TRIG2

LD	R_TRIG2.Q

ST	CTUD1.cd

LD	reset_cmd

ST	CTUD1.reset

LD	load_cmd

ST	CTUD1.load

LD	100

ST	CTUD1.pv

CAL	CTUD1

LD	CTUD1.QU

ST	full

LD	CTUD1.QD

ST	empty

LD	CTUD1.CV

ST	nb_elt


TON

Argumente:

IN	BOO	Wenn steigende Flanke, started Inkrementierung des internen Timers

Wenn fallende Flanke, stoppt internen Timer und setzt ihn zurück

PT	TMR	Programmierte Maximalzeit

Q	BOO	Wenn TRUE, ist die programmierte Zeit abgelaufen

ET	TMR	aktuelle verstrichene Zeit

Beschreibung:

Einen internen Timer bis zu einem bestimmten Wert inkrementieren.

Steuerungsdiagramm:


TOF

Argumente:

IN	BOO	Wenn fallende Flanke, startet Inkrementierung des internen Timers

Wenn steigende Flanke, stoppt internen Timer und setzt ihn zurück

PT	TMR	Programmierte Maximalzeit

Q	BOO	Wenn TRUE: Gesamtzeit nicht abgelaufen

ET	TMR	aktuelle verstrichene Zeit

Beschreibung:

Einen internen Timer bis zu einem bestimmten Wert inkrementieren.

Steuerungsdiagramm:


TP

Argumente:

IN	BOO	Wenn steigende Flanke, startet Inkrementierung des internen Timers (wenn noch nicht inkrementiert)

Wenn FALSE und nur wenn Timer abgelaufen ist, setzt den internen Timer zurück

Änderungen auf IN während des Zählens sind wirkungslos

PT	TMR	Programmierte Maximalzeit

Q	BOO	Wenn TRUE: Timer zählt

ET	TMR	aktuelle verstrichene Zeit

Beschreibung:

Einen internen Timer bis zu einem bestimmten Wert inkrementieren.

Steuerungsdiagramm:


CMP

Argumente:

VAL1	INT	alle vorzeichenbehafteten, analogen, ganzzahligen Werte

VAL2	INT	alle vorzeichenbehafteten, analogen, ganzzahligen Werte

LT	BOOL	TRUE, wenn val1 kleiner als val2 ist

EQ	BOOL	TRUE, wenn val1 gleich val2 ist

GT	BOOL	TRUE, wenn val1 größer als val2 ist

Beschreibung:

Vergleich von zwei Werten: Gibt Auskunft, ob die Werte gleich sind oder der erste Werte kleiner oder größer als der zweite Wert ist.

(* FBS-Programm mit "CMP"-Funktionsbaustein *)

(* ST-Äquivalenz: Es wird angenommen, daß CMP1eine Instance des Bausteins CMP ist *)

CMP1(level, max_level);

pump_cmd := CMP1.LT OR CMP1.EQ;

alarm := CMP1.GT AND NOT(manual_mode);

(* AWL-Äquivalenz: *)

LD	level

ST	CMP1.val1

LD	max_level

ST	CMP1.val2

CAL	CMP1

LD	CMP1.LT

OR	CMP1.EQ

ST	pump_cmd

LD	CMP1.GT

ANDN	manual_mode

ST	alarm


STACKINT

Argumente:

PUSH	BOO	Befehl "einkellern" (auf steigender Flanke)

Wert IN oben auf Stapel addieren

POP	BOO	Befehl "auskellern" (auf steigender Flanke)

im Stapel den letzten gepuschten Wert löschen (oben auf dem Stapel)

R1	BOO	Rücksetzen des Stapels auf Leerstand

IN	INT	aufzustapelnder Wert

N	INT	von der Anwendung definierte Größe des Stapels

EMPTY	BOO	TRUE, wenn der Stapel leer ist

OFLO	BOO	overflow: TRUE, wenn der Stapel voll ist

OUT	INT	Oberster Stackwert

Beschreibung:

Einen Stapel (Stack) von ganzzahligen Werten verwalten.

Der Funktionsbaustein "STACKINT" beinhaltet die Erkennung von steigenden Flanken für die Eingänge PUSH und POP (Befehle "einkellern" und "auskellern"). Der Stapel kann im Höchstfall 128 Elemente enthalten. Die von der Anwendung bestimmte Größe darf nicht kleiner als 1 und nicht größer als 128 sein.

Beachten Sie, daß der Wert OFLO nur nach einem Rücksetzen gültig ist (R1 wurde mindestens einmal zu TRUE forciert und auf FALSE zurückgesetzt).

(* FBS-Programm mit "STACKINT"-Funktionsbaustein; Fehlerverwaltung *)

(* ST-Äquivalenz: Es wird angenommen, daß STACKINT1 eine Instance des Bausteins STACKINT ist *)

STACKINT1(err_detect, acknoledge, manual_mode, err_code, max_err);

appli_alarm := auto_mode AND NOT(STACKINT1.EMPTY);

err_alarm := STACKINT1.OFLO;

last_error := STACKINT1.OUT;

(* AWL-Äquivalenz: *)

LD	err_detect

ST	STACKINT1.push

LD	acknoledge

ST	STACKINT1.pop

LD	manual_mode

ST	STACKINT1.r1

LD	err_code

ST	STACKINT1.IN

LD	max_err

ST	STACKINT1.N

CAL	STACKINT1

LD	auto_mode

ANDN	STACKINT1.empty

ST	appli_alarm

LD	STACKINT1.OFLO

ST	err_alarm

LD	STACKINT1.OUT

ST	last_error


AVERAGE

Argumente:

RUN	BOOL	TRUE=start / FALSE=erneute Initialisierung

XIN	REAL	alle analogen, realen Werte

N	BOOL	Anzahl der Samples (von der Anwendung definiert)

XOUT	REAL	aktueller Mittelwert des Eingangs XIN

Beschreibung:

Speichert einen Wert bei jedem Zyklus und berechnet den Mittelwert sämtlicher bereits gespeicherten Werte. Nur die letzten N Werte werden gespeichert.

Die Anzahl der Samples darf 128 nicht überschreiten. Wenn der Eingang "RUN" den Wert FALSE hat (erneute Initialisierung), ist der Ausgangswert gleich dem Eingangswert.

Wenn das Maximum N der gespeicherten Werte erreicht ist, wird der erste gespeicherte Wert vom letzten gespeicherten Wert überschrieben.

(* FBS-Programm mit "AVERAGE"-Funktionsbaustein : *)

(* ST-Äquivalenz: AVERAGE1 ist eine Instance des Bausteins AVERAGE *)

AVERAGE1((auto_mode & store_cmd), sensor_value, 100);

ave_value := AVERAGE1.XOUT;

(* AWL-Äquivalenz: *)

LD	auto_mode

AND	store_cmd

ST	AVERAGE1.run

LD	sensor_value

ST	AVERAGE1.xin

LD	100

ST	AVERAGE1.N

CAL	AVERAGE1

LD	AVERAGE1.XOUT

ST	ave_value


HYSTER

Argumente:

XIN1	REAL	alle analogen, realen Werte

XIN2	REAL	testet, ob XIN1den Wert XIN2+EPS überschritten hat

EPS	REAL	Wert der Hysterese (muß positif sein)

Q	BOO	TRUE, wenn XIN1 den Wert XIN2+EPS überschritten hat und noch nicht unter XIN2-EPS liegt

Beschreibung:

Hysterese auf einem realen Wert für einen Höchstwert

Steurungsdiagrammbeispiel :


LIM_ALRM

Argumente:

H	REAL	oberster Grenzwert

X	REAL	Eingang: alle analogen, realen Werte

L	REAL	unterster Grenzwert

EPS	REAL	Wert der Hysterese (muß positif sein)

QH	BOO	Alarm oberste Grenze: TRUE, wenn X über Höchstwert H liegt

Q	BOO	Alarm: Ausgang: TRUE, wenn X die Grenze überschritten hat

QL	BOO	Alarm unterste Grenze: TRUE, wenn X unter dem Tiefstwert  L liegt

Beschreibung:

Hysterese auf einem realen Wert für Höchst- und Tiefstwerte.

Auf die oberste und unterste Grenze wird eine Hysterese angewendet. Das Delta der Hysterese, das für die oberste und unterste Grenze benutzt wird, ist die Hälfte des EPS-Parameterwerts.

Steuerungsdiagrammbeispiel :


INTEGRAL

Argumente:

RUN	BOO	Modus: TRUE=Integration / FALSE=Warten

R1	BOO	zurück-auf-null-Befehl

XIN	REAL	Eingang: alle analoge, realen Werte

X0	REAL	Initialwert

CYCLE	TMR	Samples-Zeitspanne

Q	BOO	Not R1

XOUT	REAL	integrierter Wert

Beschreibung:

Integration eines realen Werts.

Wenn der Wert des Parameters "CYCLE" kleiner als die Zykluszeit der ISaGRAF-Anwendung ist, dann ist die Sample-Zeitspanne gleich der Zykluszeit der Anwendung.

(* FBS-Programm mit "INTEGRAL"-Baustein : *)

(* ST-Äquivalenz: INTEGRAL1 Instance des Bausteins INTEGRAL *)

INTEGRAL1(manual_mode, NOT(manual_mode), sensor_value, init_value, t#100ms);

controlled_value := INTEGRAL1.XOUT;

(* AWL-Äquivalenz: *)

LD	manual_mode

ST	INTEGRAL1.run

STN	INTEGRAL1.R1

LD	sensor_value

ST	INTEGRAL1.XIN

LD	init_value

ST	INTEGRAL1.X0

LD	t#100ms

ST	INTEGRAL1.CYCLE

CAL	INTEGRAL1

LD	INTEGRAL1.XOUT

ST	controlled_value


DERIVATE

Argumente:

RUN	BOO	Modus: TRUE=normal / FALSE=zurück auf null

XIN	REAL	Eingang: alle analogen, realen Werte

CYCLE	TMR	Sample-Zeitspanne

XOUT	REAL	Ausgang: Derivat des Signals

Beschreibung:

Differentiation eines realen Werts.

Wenn der Wert des Parameters "CYCLE" kleiner als die Zykluszeit der ISaGRAF-Anwendung ist, dann ist die Sample-Zeitspanne gleich der Zykluszeit der Anwendung.

(* FBS-Programm mit "DERIVATE"-Baustein : *)

(* ST-Äquivalenz: DERIVATE1 ist eine Instance des Bausteins DERIVATE *)

DERIVATE1(manual_mode, sensor_value, t#100ms);

derivated_value := DERIVATE1.XOUT;

(* AWL-Äquivalenz: *)

LD	manual_mode

ST	DERIVATE1.run

LD	sensor_value

ST	DERIVATE1.XIN

LD	t#100ms

ST	DERIVATE1.CYCLE

CAL	DERIVATE1

LD	DERIVATE1.XOUT

ST	derivated_value


BLINK

Argumente:

RUN	BOO	Modus: TRUE=blinken / FALSE=zurück auf null

CYCLE	TMR	Blinkperiode

Q	BOO	Ausgangs-Blinksignal

Beschreibung:

Generiert ein Blinksignal.

Steuerungsdiagramm :


SIG_GEN

Argumente:

RUN	BOO	Modus: TRUE=run / FALSE=zurück auf null

PERIOD	TMR	Periode (Dauer) einer Probe

MAXIMUM	INT	Maximaler Zählwert

PULSE	BOO	Bei jeder Probe invertiert

UP	INT	Zähler bei jeder Probe inkrementiert

END	BOO	TRUE, wenn Zählinkrementierung beendet ist

SINUS	REAL	Sinus (Periode = Zählzeit)

Wenn der Zählvorgang den Höchstwert erreicht hat, beginnt er wieder bei 0 (null). Folglich behält END den Wert TRUE nur für 1 PERIOD.

Steuerungsdiagramm:


Standard-Funktionen

Die folgenden Standard-Funktionen werden vom ISaGRAF-System unterstützt. Sie sind vordefiniert und brauchen in der Bibliothek nicht deklariert zu werden.

Mathematische Funktionen:

ABS	Absolutwert

EXPT	Exponent

POW	Potenzierung

LOG	Logarithmus

SQRT	Quadratwurzel

TRUNC	Ganzer Teil

Trigonometrische Funktionen:

ACOS	Arcuscosinus

ASIN	Arcussinus

ATAN	Arcustangens

COS	Cosinus

SIN	Sinus

TAN	Tangens

Manipulation von Verzeichnissen:

ROL	Rotation nach links

ROR	Rotation nach rechts

SHL	Verschiebung nach links

SHR	Verschiebung nach rechts

Daten-Manipulation:

MIN	Minimum

MAX	Maximum

LIMIT	Limit

MOD	Modulo

MUX4	Multiplexer (4 Eingänge)

MUX8	Multiplexer (8 Eingänge)

SEL	Binärer Selektor

ODD	Ungerade Parität

RAND	Zufallswert

Daten-Umrechnung:

ASCII	Zeichen  Ascii-Code

CHAR	Ascii-Code  Zeichen

Zeichenketten-Verwaltung:

MLEN	Aktuelle Länge

DELETE	Zeichen Löschen

INSERT	Zeichen Einsetzen

FIND	Zeichen Suchen

REPLACE	Zeichen Ersetzen

LEFT	Extraktion links

MID	Extraktion in der Mitte

RIGHT	Extraktion rechts

DAY_TIME	Aktuelle(s) Datum, Zeit

Tabellen-Verwaltung:

ARCREATE	Tabelle erstellen

ARREAD	Element Lesen

ARWRITE	Element Schreiben

Binärdatei-Verwaltung:

F_ROPEN	Öffnen einer Binärdatei im Lese-Modus

F_WOPEN	Öffnen einer Binärdatei im Schreib-Modus

F_CLOSE	Schließen einer Binärdatei

F_EOF	Ende einer Binärdatei testen

FA_READ	Einen analogen Wert in einer Binärdatei lesen

FA_WRITE	Einen analogen Wert in einer Binärdatei schreiben

FM_READ	Eine Zeichenkette in einer Binärdatei lesen

FM_WRITE	Eine Zeichenkette in einer Binärdatei schreiben

Anmerkung: Wenn eine neue "C"-Funktion erstellt ist, wird sie in der Form eines Funktionsbausteins für die FBS-Sprache verfügbar.


ABS

Argumente:

IN	REAL	alle vorzeichenbehafteten, realen Werte

Q	REAL	absoluter Wert (immer positiv)

Beschreibung:

Liefert den absoluten (positiven) Wert eines realen Werts.

(* FBS-Programm mit "ABS"-Baustein *)

(* ST-Äquivalenz *)

over := (ABS (delta) > range);

(* AWL-Äquivalenz: *)

LD	delta

ABS

GT 	range

ST	over


EXPT

Argumente:

IN	REAL	alle vorzeichenbehafteten, realen Werte

EXP	INT	ganzer Exponent

Q	REAL	(IN EXP)

Beschreibung:

Liefert das Ergebnis der Operation: (Basis Exponent) 'Basis' ist das erste Argument und 'Exponent' das zweite.

(* FBS-Programm mit "EXPT"-Baustein *)

(* ST-Äquivalenz *)

tb_size := ANA (EXPT (2.0, range) );

(* AWL-Äquivalenz *)

LD	2.0

EXPT	range

ANA

ST	tb_size


LOG

Argumente :

IN	REAL	muß größer als null sein

Q	REAL	Logarithmus (Basis 10) des Eingangswerts

Beschreibung:

Berechnet den Logarithmus (Basis 10) eines realen Werts.

(* FBS-Programm mit "LOG"-Baustein *)

(* ST-Äquivalenz *)

xpos := ABS ( xval );

xlog := LOG ( xpos );

(* AWL-Äquivalenz *)

LD	xval

ABS

ST	xpos

LOG

ST	xlog


POW

Argumente:

IN	REAL	zu potenzierende reale, analoge Zahl

EXP	REAL	Potenz von IN

Q	REAL	(IN EXP)

1.0 wenn IN ungleich 0.0 und EXP gleich 0.0 ist

0.0 wenn IN ist 0.0 und EXP negativ ist

0.0 wenn IN und EXP gleich 0.0 sind

0.0 wenn IN negativ und keine Ganzzahl ist

Beschreibung:

Liefert das reale Ergebnis der Operation: (Basis Exponent) 'Basis' ist das erste Argument und 'Exponent' das zweite. Der Exponent ist ein realer Wert.

(* FBS-Programm mit "POW"-Block *)

(* ST-Äquivalenz *)

result := POW (xval, power);

(* AWL-Äquivalenz *)

LD	xval

POW	power

ST	result


SQRT

Argumente:

IN	REAL	muß größer oder gleich null sein

Q	REAL	Quadratwurzel des Eingangswerts

Beschreibung:

Berechnet die Quadratwurzel eines realen Werts.

 (* FBS-Programm mit "SQRT"-Baustein *)

(* ST-Äquivalenz *)

xpos := ABS ( xval );

xroot := SQRT (xpos);

(* AWL-Äquivalenz *)

LD	xval

ABS

ST	xpos

SQRT

ST	xrout


TRUNC

Argumente:

IN	REAL	alle vorzeichenbehafteten, realen Werte

Q	REAL	größter, ganzzahliger Wert; kleiner oder gleich Eingabewert, wenn IN > 0

kleinster, ganzzahliger Wert; kleiner oder gleich Eingabewert, wenn IN < 0

Beschreibung:

Rundet einen realen Wert zu einem ganzzahligen Wert auf

(* FBS-Programm mit "TRUNC"-Baustein *)

(* ST-Äquivalenz *)

result:= TRUNC (+2.67) + TRUNC (-2.0891);

(* bedeutet: result:= 2.0 + (-2.0) := 0.0 *)

(* AWL-Äquivalenz *)

LD	2.67

TRUNC

ST	temporary	(* temporäres Ergebnis des ersten TRUNC *)

LD	-2.0891

TRUNC

ADD	temporary

ST	result


ACOS

Argumente:

IN	REAL	muß sich im Intervall [-1.0 .. +1.0] befinden

Q	REAL	Arcuscosinus des Eingangswerts im Intervall [0.0 .. PI]

= 0.0 für einen ungültigen Eingang

Beschreibung:

Berechnet den Arcuscosinus eines realen Werts.

(* FBS-Programm mit "COS"- und "ACOS"-Bausteinen *)

(* ST-Äquivalenz *)

cosine:= COS (angle);

result:= ACOS (cosine);   (* result ist gleich angle *)

(* AWL-Äquivalenz *)

LD	angle

COS

ST	cosine

ACOS

ST	result


ASIN

Argumente :

IN	REAL	muß sich im Intervall [-1.0 .. +1.0] befinden

Q	REAL	Arcussinus des Eingangswerts im Intervall [-PI/2 .. +PI/2]

= 0.0 für einen ungültigen Eingang

Beschreibung:

Berechnet den Arcussinus eines realen Werts.

(* FBS-Programm mit "SIN"- und "ASIN"-Bausteinen *)

(* ST-Äquivalenz *)

Sine := SIN (angle);

result:= ASIN (sine);   (* result ist gleich angle *)

(* AWL-Äquivalenz *)

LD	angle

SIN

ST	sine

ASIN

ST	result


ATAN

Argumente :

IN	REAL	alle analogen, realen Werte

Q	REAL	Arcustangens des Eingangswerts im Intervall [-PI/2 .. +PI/2]

= 0.0 für einen ungültigen Eingang

Beschreibung:

Berechnet den Arcustangens eines realen Werts.

(* FBD-Programm mit "TAN"- und "ATAN"-Bausteinen *)

(* ST-Äquivalenz *)

tangente := TAN (angle);

result:= ATAN (tangent);   (* result ist gleich angle *)

(* AWL-Äquivalenz *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


COS

Argumente :

IN	REAL	alle analogen, realen Werte

Q	REAL	Cosinus - im Intervall [-1.0 .. +1.0]

Beschreibung:

Berechnet den Cosinus eines realen Werts.

(* FBS-Programm mit "COS"- und "ACOS"-Bausteinen *)

(* ST-Äquivalenz *)

cosine := COS (angle);

result := ACOS (cosine); (* result ist gleich angle *)

(* AWL-Äquivalenz *)

LD	angle

COS

ST	cosine

ACOS

ST	result


SIN

Argumente :

IN	REAL	alle analogen, realen Werte

Q	REAL	Sinus des Eingangs - im Intervall [-1.0 .. +1.0]

Beschreibung:

Berechnet den Sinus eines realen Werts.

(* FBS-Programm mit "SIN"- und "ASIN"-Bausteinen *)

(* ST-Äquivalenz *)

sine := SIN (angle);

result := ASIN (sine); (* result ist gleich angle *)

(* AWL-Äquivalenz *)

LD	angle

SIN

ST	sine

ASIN

ST	result


TAN

Argumente :

IN	REAL	kann nicht gleich PI/2 Modulo PI sein

Q	REAL	Tangens des Eingangswerts

= 1E+38 für einen ungültigen Eingang

Beschreibung:

Berechnet den Tangens eines realen Werts.

(* FBD-Programm mit "TAN"- und "ATAN"-Bausteinen *)

(* ST-Äquivalenz *)

tangente := TAN (angle);

result:= ATAN (tangent);   (* result ist gleich angle *)

(* AWL-Äquivalenz *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


ROL

Argumente:

IN	INT	alle analogen, GANZZAHLIGEN Werte

NbR	INT	Anzahl der Rotationen von 1 Bit (im Intervall [1..31])

Q	INT	Wert nach links verschoben

ohne Effekt, wenn NbR <= 0

Beschreibung:

Bewirkt die Rotation der Bits einer Ganzzahl nach links. Die Rotation erfolgt auf 32 Bits:

(* FBS-Programm mit "ROL"-Baustein *)

(* ST-Äquivalenz *)

result := ROL (register, 1);

(* register = 2#0100_1101_0011_0101*)

(* result    = 2#1001_1010_0110_1010*)

(* AWL-Äquivalenz *)

LD	register

ROL	1

ST	result


ROR

Argumente :

IN	INT	alle analogen, GANZZAHLIGEN Werte

NbR	INT	Anzahl der Rotationen von 1 Bit

(im Intervall [1..31])

Q	INT	Wert nach rechts verschoben

ohne Effekt, wenn NbR <= 0

Beschreibung:

Bewirkt die Rotation der Bits einer Ganzzahl nach rechts. Die Rotation erfolgt auf 32 Bits:

(* FBS-Programm mit "ROR"-Baustein *)

(* ST-Äquivalenz *)

result := ROR (register, 1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1010_0110_1001_1010 *)

(* AWL-Äquivalenz *)

LD	register

ROR	1

ST	result


SHL

Argumente :

IN	INT	alle analogen, GANZZAHLIGEN Werte

NbS	INT	Anzahl der Verschiebungen von 1 Bit

(im Intervall [1..31])

Q	INT	Wert nach links verschoben

ohne Effekt, wenn NbS <= 0

der Wert 0 ersetzt das wertniedrigste Bit

Beschreibung:

Bewirkt die Verschiebung der Bits einer Ganzzahl nach links. Die Verschiebung erfolgt auf 32 Bits:

 (* FBS-Programm mit "SHL"-Baustein *)

(* ST-Äquivalenz *)

result := SHL (register,1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1001_1010_0110_1010 *)

(* AWL-Äquivalenz *)

LD	register

SHL	1

ST	result


SHR

Argumente :

IN	INT	alle analogen, GANZZAHLIGEN Werte

NbS	INT	Anzahl der Verschiebungen von 1 Bit

(im Intervall [1..31])

Q	INT	Wert nach rechts verschoben

ohne Effekt, wenn NbS <= 0

das werthöchste Bit wird bei jeder

Verschiebung kopiert

Beschreibung:

Bewirkt die Verschiebung der Bits einer Ganzzahl nach rechts. Die Verschiebung erfolgt auf 32 Bits:

(* FBS-Programm mit "SHR"-Baustein *)

(* ST-Äquivalenz *)

result := SHR (register,1);

(* register = 2#1100_1101_0011_0101 *)

(* result    = 2#1110_0110_1001_1010 *)

(* AWL-Äquivalenz *)

LD	register

SHR	1

ST	result


MIN

Argumente :

Wert_A	INT	alle vorzeichenbehafteten ganzzahligen Werte

Wert_B	INT	(kann nicht REAL sein)

Minimum	INT	Minimum der beiden Eingänge

Beschreibung:

Liefert das Minimum von zwei ganzzahligen Werten.

(* FBS-Programm mit "MIN"- und "MAX"-Bausteinen *)

(* ST-Äquivalenz *)

new_value := MAX (MIN (max_value, value), min_value);

(* bindet den Wert an die Forcierung [min_value..max_value] *)

(* AWL-Äquivalenz *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


MAX

Argumente :

IN1	INT	alle vorzeichenbehafteten,

ganzzahligen Werte

IN2	INT	(kann nicht REAL sein)

Q	INT	Maximum der beiden Eingänge

Beschreibung:

Liefert das Maximum von zwei ganzzahligen Werten.

(* FBS-Programm mit "MIN"- und "MAX"-Bausteinen *)

(* ST-Äquivalenz *)

new_value := MAX (MIN (max_value, value), min_value);

(*bindet den Wert an die Forcierung [min_value..max_value] *)

(* AWL-Äquivalenz *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


LIMIT

Argumente:

MIN	INT	Minimalwert

IN	INT	beliebiger analoger, ganzzahliger Wert

MAX	INT	Maximalwert

Q	INT	Grenzbereichwert

Beschreibung:

Begrenzt einen ganzzahligen Wert in ein bestimmtes Intervall. Ganz gleich, ob er seinen Wert beibehält, liegt dieser immer zwischen Minimum und Maximum, oder er wird zu Maximum forciert, wenn er darüber liegt, oder zu Minimum, wenn er darunter liegt.

(* FBS-Programm mit "LIMIT"-Block *)

(* ST-Äquivalenz: *)

new_value := LIMIT (min_value, value, max_value);

(* bindet den Wert an die Forcierung [min_value..max_value] *)

(* AWL-Äquivalenz: *)

LD	min_value

LIMIT	value, max_value

ST	new_value


MOD

Argumente :

IN	INT	alle vorzeichenbehafteten, GANZZAHLIGEN Werte

Base	INT	muß größer als null sein

Q	INT	Modulo (Basis MOD Wert)

ergibt -1, wenn Base <= 0

Beschreibung:

Berechnet das Modulo eines ganzzahligen Werts.

(* FBS-Programm mit "MOD"-Baustein *)

(* ST-Äquivalenz *)

division_result := (value / divider); ganze Division *)

rest_of_division := MOD (value, divider); Rest der Division *)

(* AWL-Äquivalenz *)

LD	value

DIV	divider

ST	division_result

LD	value

MOD	divider

ST	rest_of_division


MUX4

Argumente:

SEL	INT	ganzzahliger Wert im Intervall [0..3]

IN1..IN4	INT	vorzeichenbehaftete, ganzzahlige Werte

Q	INT	= IN1 wenn SEL = 0

= IN2 wenn SEL = 1

= IN3 wenn SEL = 2

= IN4 wenn SEL = 3

= 0 für alle anderen Fälle

Beschreibung:

Multiplexer mit 4 Eingängen: wählt einen Wert aus 4 ganzzahligen Werten.

(* FBS-Baustein mit "MUX4"-Baustein *)

(* ST-Äquivalenz *)

range := MUX4 (choice, 1, 10, 100, 1000);

(* wählt aus 4 vordefinierten Bereichen, zum Beispiel, wenn choice 1 ist, ist range 10 *)

(* AWL-Äquivalenz *)

LD	choice

MUX4	1,10,100,1000

ST	range


MUX8

Argumente:

SEL	INT	ganzzahliger Wert im Intervall [0..7]

IN1..IN8	INT	vorzeichenbehaftete, ganzzahlige Werte

Q	INT	= IN1 wenn selector = 0

= IN2 wenn selector = 1

...

= IN8 wenn selector = 7

= 0 für alle anderen Fälle

Beschreibung:

Multiplexer mit 8 Eingängen: wählt einen Wert aus 8 ganzzahligen Werten.

 (* FBS-Programm mit "MUX8"-Baustein *)

(* ST-Äquivalenz *)

range := MUX8 (choice, 1, 5, 10, 50, 100, 500, 1000, 5000);

(* wählt aus 8 vordefinierten Bereichen, zum Beispiel, wenn choice 3 ist, ist range 50 *)

(* AWL-Äquivalenz *)

LD	choice

MUX8	1,5,10,50,100,500,1000,5000

ST	range


ODD

Argumente:

IN	INT	alle vorzeichenbehafteten, ganzzahligen Werte

Q	BOO	TRUE, wenn der Wert ungerade ist

FALSE, wenn der Wert gerade ist

Beschreibung:

Testet die Parität einer Ganzzahl: Ergebnis gerade oder ungerade.

 (* FBS-Programm mit "ODD"-Baustein *)

(* ST-Äquivalenz *)

If Not (ODD (value)) Then Return; End_if;

value := value + 1;

(* liefert immer gerade Werte *)

(* AWL-Äquivalenz *)

LD	value

ODD

RETNC

LD	value

ADD	1

ST	value


RAND

Argumene:

base	INT	definiert das Intervall der zugelassenen Werte

Q	INT	zufälliger Wert im Intervall [0..base-1]

Beschreibung:

Liefert einen zufälligen ganzzahligen Wert in einem bestimmten Bereich.

(* FBS-Programm mit "RAND"-Baustein *)

(* ST-Äquivalenz *)

selected := MUX4 ( RAND (4), 1, 4, 8, 16 );

(*

Zufallswahl: 1 von 4 vordefinierten Werten

Der vom RAND-Aufruf gelieferte Wert ist im Satz [0..3],

also erhält 'selected', ausgegeben von MUX4, 'zufällig' den Wert

1, wenn 0 von RAND ausgegeben wird,

oder 4, wenn 1 von RAND ausgegeben wird,

oder 8, wenn 2 von RAND ausgegeben wird,

oder 16, wenn 3 von RAND ausgegeben wird

*)

(* AWL-Äquivalenz *)

LD	4

RAND

MUX4	1,4,8,16

ST	selected


SEL

Argumente:

SEL	BOO	zeigt den gewählten Wert an

IN1, IN2	INT	analoge, ganzzahlige Werte

Q	INT	= value1 wenn SEL = FALSE

= value2 wenn SEL = TRUE

Beschreibung:

Binärer Selektor: wählt einen Wert aus 2 ganzzahligen Werten.

 (* FBS-Programm mit "SEL"-Baustein *)

(* ST-Äquivalenz *)

ProCmd := SEL (AutoMode, ManuCmd, InpCmd);

(* Auswahl des Prozeßbefehls *)

(* AWL-Äquivalenz *)

LD	AutoMode

SEL	ManuCmd,InpCmd

ST	ProCmd


ASCII

Argumente:

IN	ZK	nicht leere Zeichenkette

Pos	INT	Position des ausgewählten Zeichens

im Intervall [1 .. Länge] (Länge ist die Länge der Zeichenkette IN)

Code	INT	Ascii-Code des ausgewählten Zeichens

(im Intervall [0 .. 255])

0, wenn Pos nicht in der Kette ist

Beschreibung:

Liefert den ASCII-Code eines Zeichens in einer Zeichenkette.

(* FBS-Programm mit "ASCII"-Baustein *)

(* ST-Äquivalenz *)

FirstChr := ASCII (message, 1);

(* FirstChr ist der Ascii-Code des ersten Zeichens der Kette *)

(* AWL-Äquivalenz *)

LD	message

ASCII	1

ST	FirstChr


CHAR

Argumente:

Code	INT	Ascii-Code im Intervall [0 .. 255]

Q	ZK	Kette mit einem Zeichen

das Zeichen hat den spezifizierten Ascii-Code

(der Ascii-Code wird benutzt, Modulo 256)

Beschreibung:

Liefert eine Zeichenkette mit einem Zeichen von einem gegebenen ASCII-Code.

 (* FBS-Programm mit "CHAR"-Baustein *)

(* ST-Äquivalenz *)

Display := CHAR ( value + 48 );

(* value ist im Intervall [0..9] *)

(* 48 ist der Ascii-Code von '0' *)

(*das Ergebnis ist eine Kette aus 1 Zeichen von '0' bis '9' *)

(* AWL-Äquivalenz *)

LD	value

ADD	48

CHAR

ST	Display


DELETE

Argumente:

IN	ZK	nicht leere Zeichenkette

NbC	INT	Anzahl der zu löschenden Zeichen

Pos	INT	Position des ersten zu löschenden Zeichens

(die erste gültige Pos = 1)

Q	ZK	geänderte Kette

Kette leer, wenn Pos < 1

Initialkette, wenn Pos > Länge

oder wenn NbC <= 0

Beschreibung:

Löscht einen Teil einer Zeichenkette.

 (* FBS-Programm mit "DELETE"-Baustein *)

(* ST-Äquivalenz *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string = 'ABCDEFGH' *)

sub_string := DELETE (complete_string, 4, 3); (* sub_string = 'ABGH' *)

(* AWL-Äquivalenz *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

DELETE	4,3

ST 	sub_string


FIND

Argumente:

In	ZK	beliebige Zeichenkette

Pat	ZK	gesuchte Kette - nicht leer(Pattern)

Pos	INT	= 0 wenn Kette Pat nicht gefunden hat

= Position der ersten Zeichens des ersten Vorkommens der Kette Pat

(die erste gültige Position ist 1)

diese Funktion unterscheidet zwischen Groß- und Kleinbuchstaben

Beschreibung:

Findet einen Sub-String (Kette) in einer Zeichenkette. Liefert die Position der Kette in der Zeichenkette.

(* FBS-Programm mit "FIND"-Baustein *)

(* ST-Äquivalenz *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string = 'ABCDEFGH' *)

found := FIND (complete_string, 'CDEF'); (* found = 3 *)

(* AWL-Äquivalenz *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

FIND	'CDEF'

ST 	found


INSERT

Argumente:

IN	ZK	Initialkette

Str	ZK	einzusetzende Zeichenkette

Pos	INT	Einsatzposition

Einfügen erfolgt vor der Position

(die erste gültige Position ist 1)

Q	ZK	geänderte Kette

leere Kette, wenn Position <= 0

Verkettung beider Ketten, wenn Position

größer als die ursprüngliche Länge (der Kette IN)

Beschreibung:

Einfügen eines Sub-String (Kette) an der gegebenen Position in einer Zeichenkette.

(* FBS-Programm mit "INSERT"-Baustein *)

(* ST-Äquivalenz *)

MyName := INSERT ('Mr JONES', 'Frank ', 4);

(* MyName is 'Mr Frank JONES' *)

(* AWL-Äquivalenz *)

LD	'Mr JONES'

INSERT	'Frank ',4

ST 	MyName


LEFT

Argumente:

IN	ZK	nicht leere Zeichenkette

NbC	INT	Anzahl der herauszunehmenden Zeichen

kann nicht größer als die Länge der Kette IN sein

Q	ZK	linker Teil (Länge = NbC)

leere Kette NbC <= 0

Initialkette IN, wenn NbC >= IN Kettenlänge

Beschreibung:

Nimmt den linken Teil einer Zeichenkette heraus. Die Anzahl der herauszunehmenden Zeichen wird geliefert.

(* FBS-Programm mit "LEFT"- und "RIGHT"-Bausteinen *)

(* ST-Äquivalenz *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string = '56781234'

der vom Aufruf RIGHT ausgegebene Wert ist '5678'

der vom Aufruf LEFT ausgegebene Wert ist '1234' *)

(* AWL-Äquivalenz: Zuerst erfolgt der Aufruf von LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* Zwischenergebnis *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


MID

Argumente:

IN	ZK	nicht leere Zeichenkette

NbC	INT	Anzahl der herauszunehmenden Zeichen

kann nicht größer als die Länge der Kette IN sein

Pos	INT	Position des ersten, herauszunehmenden Zeichens

das erste Zeichen der Kette ist das Zeichen, auf das Pos zeigt

(die erste gültige Position ist 1)

Q	ZK	herausgenommene Kette (Länge = NbC)

leere Kette, wenn die Parameter ungültig sind

Beschreibung:

Nimmt einen Teil einer Zeichenkette heraus. Die Anzahl der herauszunehmenden Zeichen und das erste Zeichen werden geliefert.

(* FBS-Programm mit "MID"-Baustein *)

(* ST-Äquivalenz *)

sub_string := MID ('abcdefgh', 2, 4);

(* sub_string ist 'de' *)

(* AWL-Äquivalenz *)

LD	'abcdefgh'

MID	2,4

ST	sub_string


MLEN

Argumente:

IN	ZK	Kette aus beliebigen Zeichen

NbC	INT	Anzahl der Zeichen in der Kette

Beschreibung:

Berechnet die Länge einer Zeichenkette.

(* FBS-Programm mit "MLEN"-Baustein *)

(* ST-Äquivalenz *)

nbchar := MLEN (complete_string);

If (nbchar < 3) Then Return; End_if;

prefix := LEFT (complete_string, 3);

(* dieses Programm nimmt die 3 Zeichen auf der linken Seite der Kette heraus und gibt das Ergebnis in die Zeichenketten-Variable prefix.

Nichts geschieht, wenn die Zeichenkette weniger als 3 Zeichen enthält *)

(* AWL-Äquivalenz *)

LD	complete_string

MLEN

ST	nbchar

LT	3

RETC

LD	complete_string

LEFT	3

ST	prefix


REPLACE

Argumente:

IN	ZK	Initialkette

Str	ZK	einzufügende Kette (um NbC Zeichen zu ersetzen)

NbC	INT	Anzahl der zu löschenden Zeichen

Pos	INT	Position des ersten geänderten Zeichens

(die erste gültige Position ist 1)

Q	ZK	geänderte Kette:

- NbC Zeichen gelöscht von der Position Pos

- dann wird die Kette Str an dieser Position eingesetzt

ergibt eine leere Kette, wenn Pos <= 0

ergibt eine Verkettung (IN+Str), wenn Pos größer als die Länge der Kette IN ist

liefert Initialkette IN, wenn NbC <= 0

Beschreibung:

Ersetzt einen Teil einer Zeichenkette durch eine neue Zeichenfolge.

(* FBS-Programm mit "REPLACE"-Baustein *)

(* ST-Äquivalenz *)

MyName := REPLACE ('Mr X JONES, 'Frank', 1, 4);

(* MyName ist 'Mr Frank JONES' *)

(* AWL-Äquivalenz *)

LD	'Mr X JONES'

REPLACE	'Frank',1,4

ST	MyName


RIGHT

Argumente:

IN	ZK	nicht leere Zeichenkette

NbC	INT	Anzahl der herauszunehmenden Zeichen

kann nicht größer als die Länge der Kette IN sein

Q	ZK	rechts herausgenommener Teil (Länge = NbC)

leere Kette, wenn NbC <= 0

Komplette Kette, wenn NbC >= Kettenlänge

Beschreibung:

Nimmt den rechten Teil einer Zeichenkette heraus. Die Anzahl der herauszunehmenden Zeichen wird geliefert.

(* FBS-Programm mit "LEFT"- und "RIGHT"-Bausteinen *)

(* ST-Äquivalenz *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string ist '56781234'

der vom Aufruf RIGHT gegebene Wert ist '5678'

der vom Aufruf LEFT gegebene Wert ist '1234' *)

(* AWL-Äquivalenz: Zuerst erfolgt der Aufruf an LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* Zwischenergebnis *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


DAY_TIME

Argumente:

SEL	INT	Auswahl der Information

0= aktuelles Datum

1= aktuelle Zeit

2= Wochentag

Q	ZK	Datum/Zeit in Textform

'JJJJ/MM/TT' wenn SEL = 0

'HH:MM:SS' wenn SEL = 1

Wochentag, wenn SEL = 2 ('Monday')

(Wochentage stets in Englisch)

Beschreibung:

Liefert das aktuelle Datum oder die aktuelle Uhrzeit als Zeichenkette.

(* FBS-Programm mit "DAY_TIME"-Baustein *)

(* ST-Äquivalenz: *)

Display := Day_Time (0) + ' ; ' + Day_Time (1);

(* Text hat stets das Format: 'JJJJ/MM/TT ; HH:MM:SS' *)

(* AWL-Äquivalenz: Zuerst erfolgt der Aufruf an day_time(1) *)

LD	1

DAY_TIME

ST	hour_str 	(* Zwischenergebnis *)

LD	0

DAY_TIME

ADD	' ; '

ADD	hour_str

ST 	Display


ARCREATE

Argumente:

ID	INT	Tabellen-Identifizierer (muß im Intervall [0..15] liegen)

Size	INT	Anzahl der zu erstellenden Tabellenelemente

ok	INT	Ausführungsprotokoll :

1 = OK

2 = Identifizierer ungültig oder Tabelle bereits erstellt

3 = Größe ungültig

4 = nicht genug Speicher

Beschreibung:

Erstellung einer Ganzzahl-Tabelle.

Achtung: In einer Anwendung können höchstens 16 Tabellen erstellt werden. Sie enthalten analoge, ganzzahlige Werte. Da der Speicherplatz dynamisch zugeordnet wird, kann diese Funktion das System beschädigen oder fatale Fehler herbeiführen, wenn die Tabelle zuviel des verfügbaren Speicherraums in Anspruch nimmt.

(* FBS-Programm mit Tabellen-Verwaltung *)

(* ST-Äquivalenz *)

array_error := (ARCREATE (ident, 16) <> 1));

(* AWL-Äquivalenz *)

LD	ident

ARCREATE	16

NE 	1

ST	array_error


ARREAD

Argumente:

ID	INT	Tabellen-Identifizierer (muß im Intervall [0..15] liegen)

Pos	INT	Position des Elements in der Tabelle

im Intervall [0 .. Größe-1]

value	INT	Wert des Elements

0, wenn die Argumente ungültig sind

Beschreibung:

Liest ein Element in einer Ganzzahl-Tabelle.

(* FBS-Programm mit Tabellen-Verwaltung *)

(* ST-Äquivalenz *)

If (array_error) Then Return; End_if;

read_value := ARREAD (ident, index);

(* array_error kommt vom Aufruf ARCREATE *)

(* AWL-Äquivalenz *)

LD	array_error

RETC

LD	ident

ARREAD	index

ST	read_value


ARWRITE

Argumente:

ID	INT	Tabellen-Identifizierer (muß im Intervall [0..15] liegen)

Pos	INT	Position des Elements in der Tabelle

im Intervall [0 .. Größe-1]

IN	INT	neuer Wert für das Element

ok	INT	Ausführungsprotokoll :

1 = OK

2 = Identifizierer ungültig

3 = Pos ungültig

Beschreibung:

Speichert (schreibt) einen Wert in einer Ganzzahl-Tabelle.

(* FBS-Programm mit Tabellen-Verwaltung *)

(* ST-Äquivalenz *)

If (array_error) Then Return; End_if;

write_status := ARWRITE (Ident, Index, value);

(* array_error kommt vom Aufruf ARCREATE *)

(* AWL-Äquivalenz *)

LD	array_error

RETC

LD	ident

ARWRITE	index,value

ST	write_status


F_ROPEN

Argumente:

Path	MSG	Dateiname

kann den Zugriffspfad zur Datei einschließen, mit den Zeichen \ oder / , um ein Verzeichnis zu spezifizieren. Um die Datenaustauschbarkeit zu erleichtern, sind / und \ äquivalent.

ID	INT	Dateinummer

0, wenn ein Fehler auftritt: Datei existiert nicht.

Beschreibung:

Öffnet eine Binärdatei im Lese-Modus. Zur Benutzung mit FX_READ und F_CLOSE.

Diese Funktion ist nicht im ISaGRAF-Simulator vorhanden.

(* FBS-Programm mit Dateiverwaltungs-Bausteinen *)

(* ST-Äquivalenz: *)

file_id := F_ROPEN('c:\data \data.bin');

error := (file_id=0);

(* AWL-Äquivalenz: *)

LD	'c:\data\data.bin'

F_ROPEN

ST	file_id

EQ	0

ST	error


F_WOPEN

Argumente:

Path	MSG	Dateiname

kann den Zugriffspfad zur Datei einschließen, mit den Zeichen \ oder / , um ein Verzeichnis zu spezifizieren. Um die Datenaustauschbarkeit zu erleichtern, sind / und \ äquivalent.

ID	INT	Dateinummer

0, wenn ein Fehler auftritt. Wenn die Datei schon existiert, wird sie überschrieben.

Beschreibung:

Öffnet eine Binärdatei im Schreib-Modus. Zur Benutzung mit FX_WRITE und F_CLOSE.

Diese Funktion ist nicht im ISaGRAF-Simulator vorhanden.

(*FBS-Programm mit Dateiverwaltungs-Bausteinen *)

(* ST-Äquivalenz: *)

file_id := F_WOPEN('c:\data \data.bin');

error := (file_id=0);

(* AWL-Äquivalenz: *)

LD	'c:\data\data.bin'

F_WOPEN

ST	file_id

EQ	0

ST	error


F_CLOSE

Argumente:

ID	INT	Dateinummer: Rückgabe von F_ROPEN oder F_WOPEN.

ok	BOO	Rückgabestatus

TRUE, wenn Datei Schließen OK ist

FALSE, wenn ein Fehler aufgetreten ist

Beschreibung:

Schließt eine Binärdatei, die mit den Funktionen F_ROPEN oder F_WOPEN geöffnet wurde.

Diese Funktion ist nicht im ISaGRAF-Simulator vorhanden.

(*FBS-Programm mit Dateiverwaltungs-Bausteinen *)

(* ST-Äquivalenz: *)

file_id := F_ROPEN('data.bin');

ok := F_CLOSE(file_id);

(* AWL-Äquivalenz: *)

LD	'data.bin'

F_ROPEN

ST	file_id

F_CLOSE	(* file_id ist schon im aktuellen AWL-Ergebnis *)

ST 	ok


F_EOF

Argumente:

ID	INT	Dateinummer: Rückgabe von F_ROPEN oder F_WOPEN.

ok	BOO	zeigt Dateiende an

TRUE, wenn das Ende der Datei beim letzten Aufruf  eines Lese- oder Schreibvorgangs erreicht wurde.

Mit FM_READ kann die zuetzt gelesene Zeichenkette einer Datei falsch sein, wenn das letzte Zeichen kein Zeichenketten-Endzeichen ist.

Beschreibung:

Testet, ob das Dateiende erreicht ist.

Diese Funktion ist nicht im ISaGRAF-Simulator vorhanden.

(*FBS-Programm mit Dateiverwaltungs-Bausteinen *)

(* ST-Äquivalenz: *)

file_id := F_ROPEN('data.bin');

WHILE not(F_EOF(file_id))

VAL := FA_READ(file_id);

END_WHILE;

MESSAGE := 'last val = ' + msg(VAL);

ok := F_CLOSE(file_id);

(* AWL-Äquivalenz: *)

LD	'data.bin'

F_ROPEN

ST	file_id

LD 	file_id

F_EOF

JMPC	END_OF_FILE

NOT_EOF:	LD 	file_id

FA_READ

ST	VAL

LD 	file_id

F_EOF

JMPNC	NOT_EOF 	(* wenn nicht eof, weiter lesen *)

END_OF_FILE:	LD	VAL

MSG

ST	val_msg	(* Umrechnung von VAL in eine Zeichenkette *)

LD	'last val = '

ADD	val_msg

ST	MESSAGE

LD 	file_id

F_CLOSE

ST	ok


FA_READ

Argumente:

ID	INT	Dateinummer: Rückgabe von F_ROPEN.

Q	INT	ganzzahliger analoger Wert aus Datei gelesen

Beschreibung:

Ließt ANALOGE Variablen aus einer Binärdatei. Zur Benutzung mit F_ROPEN und F_CLOSE.

Diese Prozedur erstellt einen sequentiellen Zugriff auf die Datei von der vorherigen Position aus.

Der erste Aufruf nach F_ROPEN liest die ersten 4 Bytes der Datei,

jeder Aufruf puscht den Lese-Pointer.

Um zu prüfen, ob das Dateiende erreicht ist, benutzen Sie F_EOF.

Diese Funktion ist nicht im ISaGRAF-Simulator vorhanden.

(*FBS-Programm mit Dateiverwaltungs-Bausteinen *)

(* ST-Äquivalenz: *)

file_id := F_ROPEN('voltramp.bin');

vstart := FA_READ(file_id);

vend := FA_READ(file_id);

vinc := FA_READ(file_id);

delta_tim := tmr(FA_READ(file_id));

ok := F_CLOSE(file_id);

(* AWL-Äquivalenz: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FA_READ	(* vstart lesen *)

ST	vstart

LD 	file_id

FA_READ	(*vend lesen *)

ST	vend

LD 	file_id

FA_READ	(*vinc lesen *)

ST	vinc

LD 	file_id

FA_READ	(*delta_tim lesen *)

TMR	(* Umrechnung in Timer *)

ST	delta_tim

LD 	file_id

F_CLOSE

ST	ok


FA_WRITE

Argumente:

ID	INT	Dateinummer: Rückgabe von F_WOPEN.

IN	INT	Ganzzahliger analoger in der Datei zu schreibender Wert

OK	BOO	Ausführungsstatus: TRUE, wenn ok

Beschreibung:

Schreibt ANALOGE Variablen in eine Binärdatei.

Diese Prozedur erstellt einen sequentiellen Zugriff auf die Datei von der vorherigen Position aus.

Der erste Aufruf an F_WOPEN schreibt die ersten 4 Bytes der Datei,

jeder Aufruf puscht den Schreib-Pointer.

Diese Funktion ist nicht im ISaGRAF-Simulator vorhanden.

(* FBS-Programm *)

(* ST-Äquivalenz: *)

file_id := F_WOPEN('voltramp.bin');

nb_written  := 0;

nb_written := nb_written + ana(FA_WRITE(file_id,vstart));

nb_written := nb_written + ana(FA_WRITE(file_id,vend));

nb_written := nb_written + ana(FA_WRITE(file_id,vinc));

nb_written := nb_written + ana(FA_WRITE(file_id,ana(delta_tim)));

ok := F_CLOSE(file_id);

IF ( nb_written <> 4) THEN

ERROR := ERR_FILE;

END_IF;

(* AWL-Äquivalenz: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

LD	0

ST	nb_written

LD 	file_id	(*vstart schreiben*)

FA_WRITE	vstart

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(*vend schreiben *)

FA_WRITE	vend

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(*vinc schreiben *)

FA_WRITE	vinc

ANA

ADD	nb_written

LD	(*delta_tim schreiben *)

ANA	(* zu ganzzahligem Wert umrechnen *)

ST	ana_delta_tim

LD 	file_id

FA_WRITE	ana_delta_tim

ANA

ADD	nb_written

ST	nb_written

F_CLOSE

ST	ok

LD	nb_written

EQ	4

RETC	(* zurückgeben, wenn gleich 4 *)

LD	ERR_FILE	(* sonst Fehler *)

ST	ERROR


FM_READ

Argumente:

ID	INT	Dateinummer: Rückgabe von F_ROPEN.

Q	MSG	Zeichenketten-Wert aus Datei gelesen

Beschreibung:

Liest ZEICHENKETTEN-Variable aus einer Binärdatei.

Zu benutzen mit F_ROPEN und F_CLOSE.

Diese Prozedur erstellt einen sequentiellen Zugriff auf die Datei von der vorherigen Position aus.

Der erste Aufruf an F_ROPEN liest die erste Zeichenkette der Datei,

jeder Aufruf puscht den Lese-Pointer.

Eine Zeichenkette endet in (0), Zeilenende ('\n') oder Return ('\r');

Um zu prüfen, ob das Ende der Datei erreicht ist, benutzen Sie F_EOF.

Diese Funktion ist nicht im ISaGRAF-Simulator vorhanden.

(*FBS-Programm mit Dateiverwaltungs-Bausteinen *)

(* ST-Äquivalenz: *)

file_id := F_ROPEN('voltramp.bin');

status1 := FM_READ(file_id);

status2 := FM_READ(file_id);

IF (F_EOF(file_id)) THEN

ERROR := ERR_FILE;

unused_eof_mes := FM_READ(file_id);

END_IF;

ok := F_CLOSE(file_id);

(* AWL-Äquivalenz: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FM_READ	(*Status1 lesen*)

ST	status1

LD 	file_id

FM_READ	(*Status2 lesen *)

ST	status2

LD 	file_id

F_EOF

JMPNC	CLOSE_FILE (*wenn Dateiende, kein Sprung *)

LD	ERR_FILE

ST	ERROR

LD 	file_id

FM_READ	(*unused_eof_mes lesen*)

ST	unused_eof_mes

CLOSE_FILE	LD 	file_id

F_CLOSE

ST	ok


FM_WRITE

Argumente:

ID	INT	Dateinummer: Rückgabe von F_WOPEN.

IN	MSG	Zeichenketten-Wert in die Datei zu schreiben

ok	BOO	Ausführungsstatus

TRUE, wenn erfolgreich

Beschreibung:

Schreibt ZEICHENKETTEN-Variable in eine Binärdatei.

Zu benutzen mit F_WOPEN und F_CLOSE.

Eine Zeichenkette wird in die Datei als eine in null endende Zeichenkette geschrieben.

Diese Prozedur erstellt einen sequentiellen Zugriff auf die Datei von der vorherigen Position aus.

Der erste Aufruf an F_WOPEN schreibt die erste Zeichenkette der Datei,

jeder Aufruf puscht den Schreib-Pointer.

Diese Funktion ist nicht im ISaGRAF-Simulator vorhanden.

(*FBS-Programm mit Dateiverwaltungs-Bausteinen *)

(* ST-Äquivalenz: *)

file_id := F_WOPEN('trace.txt');

ok := FM_WRITE(file_id,'First message');

ok := FM_WRITE(file_id,'Last message');

ok := F_CLOSE(file_id);

(* AWL-Äquivalenz: *)

LD	'trace.txt'

F_WOPEN

ST	file_id

FM_WRITE	'First message'	(*first msg schreiben *)

ST	ok

LD 	file_id

FM_WRITE	'Last message'	(*second msg schreiben *)

ST	ok

LD 	file_id

F_CLOSE

ST	ok


Standard-Operatoren
Index

-	ARWRITE	F_ROPEN	MSG	SHR
& (AND)	ASCII	F_TRIG	MUX4	SIG_GEN
*	ASIN	F_WOPEN	MUX8	SIN
/	ATAN	FA_READ	Neg	SQRT
+	AVERAGE	FA_WRITE	NOT_MASK	SR
<	BLINK	FIND	ODD	STACKINT
<=	BOO	FM_READ	OPERATE	SYSTEM
<>	CAT	FM_WRITE	OR_MASK	TAN
=	CHAR	HYSTER	POW	TMR
=1 (XOR)	CMP	INSERT	R_TRIG	TOF
>	COS	INTEGRAL	RAND	TON
>=	CTD	LEFT	REAL	TP
>=1 (OR)	CTU	LIM_ALRM	REPLACE	TRUNC
1 Gain	CTUD	LIMIT	RIGHT	XOR_MASK
ABS	DAY_TIME	LOG	ROL
ACOS	DELETE	MAX	ROR
ANA	DERIVATE	MID	RS
AND_MASK	EXPT	MIN	SEL
ARCREATE	F_CLOSE	MLEN	SEMA
ARREAD	F_EOF	MOD	SHL


 FD-Sprache

Das Flußdiagramm (FD) ist eine grafische Sprache für die Beschreibung sequentieller Operationen. Flußdiagramme bestehen aus Aktionen und Tests. Der Datenfluß zwischen den Aktionen und Tests wird durch gerichtete Verbindungslinien dargestellt. Die Darstellung von Verzweigungen und Zusammenführungen erfolgt durch Mehrfachverbindungen. Die Aktionen und Tests können in den Programmiersprachen ST, KOP und AWL beschrieben werden, und Funktionen und Funktionsbausteine, die in beliebigen anderen Sprachen (außer AS) geschriebenen wurden, aufrufen. Flußdiagramme können andere Flußdiagramme aufrufen. Das aufgerufene FD-Programm ist ein Unterprogramm des aufrufenden FD-Programms.

Grundlegende FD-Komponenten

Beispiele komplexer FD-Strukturen

Dynamisches Verhalten des FD

FD-Syntax


FD-Komponenten

Es folgen die grafischen Komponenten der Flußdiagramm-Sprache:

Anfang eines Flußdiagramms

Ende eines Flußdiagramms

FD-Datenflußverbindungen

FD-Aktionen

FD-Tests

FD-Unterprogramme

Spezifische E/A-Aktionen im FD

FD-Anschlüsse

FD-Kommentare


Anfang eines Flußdiagramms

Am Anfang eines FD-Programms steht das "Begin"-Symbol. Dieses Symbol ist einmalig und darf nicht weggelassen werden. Es stellt bei seiner Aktivierung den Initialzustand des Flußdiagramms dar und sieht folgendermaßen aus:

Das "Begin"-Symbol muß an ein anderes Objekt des Flußdiagramms (nach unten hin) angeschlossen werden, sonst ist das Flußdiagramm ungültig.


Ende eines Flußdiagramms

Das "End"-Symbol bildet den Abschluß eines Flußdiagramms. Es ist einmalig und darf nicht weggelassen werden. Dieses Symbol stellt den abschließenden Zustand des Flußdiagramms dar und muß an sein Ende gesetzt werden, selbst wenn das Diagramm in einer unendlichen Schleife ausgeführt wird und kein eigentlicher Anschluß zum "End"-Symbol besteht. Das "End"-Symbol sieht so aus:

Normalerweise besitzt das "End"-Symbol einen Anschluß nach oben zu den anderen Objekten eines Flußdiagramms. Es gibt auch Flußdiagramme, bei denen das "End"-Symbol nicht angeschlossen ist (unendliche Schleifenausführung), in diesem Fall bleibt es jedoch am Ende des Diagramms sichtbar.


FD-Datenflußverbindungen

Die sogenannte Datenflußverbindung ist eine Linie, die den Datenfluß zwischen zwei Diagrammpunkten darstellt. Sie endet in einem Pfeil. Hier die Abbildung einer solchen Verbindung:

Es ist nicht möglich, zwei Verbindungen am gleichen Quellenpunkt anzuschließen.


FD-Aktionen

Die Aktionssymbole stellen auszuführende Aktionen dar. Aktionen werden jeweils mit einer Nummer und einem Namen gekennzeichnet. Es folgt die Abbildung eines "Aktionssymbols":

Zwei unterschiedliche Objekte eines Flußdiagramms können nicht den gleichen Namen oder die gleiche logische Nummer besitzen. Die Programmiersprache für Aktionen ist wahlweise ST, KOP oder AWL. Eine Aktion besitzt stets zwei Anschlußverbindungen, davon führt eine zur Aktion hin und eine andere von der Aktion weg.


FD-Tests

Ein FD-Test stellt eine boolesche Bedingung dar und wird mit einer Nummer und einem Namen gekennzeichnet. Entsprechend der Bewertung des zugeordneten ST-, KOP- oder AWL-Ausdrucks wird der Datenfluß zu einem "YES" oder "NO" Pfad geleitet. Es folgen die verschiedenen Möglichkeiten, solche Testsymbole zu zeichnen:

Zwei unterschiedliche Objekte eines Flußdiagramms können nicht den gleichen Namen oder die gleiche logische Nummer besitzen. Die Programmierung eines Tests ist wahlweise:

- ein Ausdruck in ST,

- ein einzelnes Rung im KOP, wobei kein Symbol mit der einzigen Spule verbunden ist, oder

- mehrere Anweisungen in AWL. Das AWL-Register (oder aktuelles Ergebnis) wird benutzt, um die Bedingung zu bewerten.

Beim Programmieren im ST-Text kann wahlweise ein Semikolon auf den Ausdruck folgen. Beim Programmieren im KOP stellt die einzige Spule den Wert der Bedingung dar. Eine Bedingung ist entweder:

- 0 oder FALSE (leitet den Datenfluß zu NO)

- 1 oder TRUE (leitet den Datenfluß zu YES)

Ein Test besitzt stets eine Eingangsverbindung und zwei definierte Ausgangsanschlüsse.


FD-Unterprogramme

Das System ermöglicht die Beschreibung einer Hierarchiestruktur. Die FD-Programme werden in einer hierarchischen Baumstruktur angeordnet. Jedes FD-Programm kann andere FD-Programme aufrufen. Diese Programme bezeichnet man als Sohnprogramme des aufrufenden FD-Programms. FD-Programme, die andere FD-Programme aufrufen, werden Vaterprogramme genannt. Die FD-Programme werden in einer hierarchischen Baumstruktur miteinander verknüpft und stehen in einer "Vater-Sohn"-Beziehung zueinander:

Das Unterprogramm-Symbol in einem Flußdiagramm stellt den Aufruf eines untergeordneten Flußdiagramms dar. Die Ausführung des aufrufenden FD-Programms wird unterbrochen, bis die Ausführung des Unterprogramms beendet ist. Ein FD-Unterprogramm wird mit einer Nummer und einem Namen gekennzeichnet, wie andere Programme, Funktionen oder Funktionsbausteine. Es folgt das Symbol eines "Unterprogrammaufrufs":

Zwei unterschiedliche Objekte eines Flußdiagramms können nicht die gleiche logische Nummer besitzen. Die Grundregeln der FD-Hierarchiestruktur sind:

- FD-Programme, die keinem Vaterprogramm untergeordnet sind, bezeichnet man als FD-Hauptprogramme.

- FD-Hauptprogramme werden beim Anwendungsstart vom System aktiviert.

- Ein Programm kann mehrere Sohnprogramme besitzen.

- Ein Sohnprogramm kann nicht mehrere Vaterprogramme besitzen.

- Ein Sohnprogramm kann nur von seinem Vaterprogramm aufgerufen werden.

- Ein Programm kann keine Sohnprogramme seiner eigenen Sohnprogramme aufrufen.

Ein und dasselbe Unterprogramm kann mehrmals im Vaterdiagramm erscheinen, dagegen kann es nicht in verschiedenen Zweigen einer parallelen Verzweigung auftreten. Der Aufruf eines Unterprogramms im Flußdiagramm stellt die vollständige Ausführung des Unterdiagramms dar. Solange das Sohndiagramm ausgeführt wird, bleibt die Ausführung des Vaterdiagramms unterbrochen. Für die Unterprogramm-Aufrufbausteine gelten die gleichen Anschlußregeln wie für die Aktionen.


Spezifische E/A-Aktionen im FD

Das Symbol einer spezifischen E/A-Aktion stellt auszuführende Aktionen dar. Wie alle Aktionen werden auch die spezifischen E/A-Aktionen jeweils mit einer Nummer und einem Namen gekennzeichnet. Standardaktionen und spezifische E/A-Aktionen benutzen die gleiche Semantik. Die spezifischen E/A-Aktionen sollen das Flußdiagramm leserlicher machen und nicht-portierbare Abschnitte des Diagramms hervorheben. Die Verwendung von spezifischen E/A-Aktionen ist optionell. Das Symbol einer "spezifischen E/A-Aktion" sieht so aus:

Spezifische E/A-Aktionsbausteine haben die gleichen Eigenschaften wie Standardaktionen, sie werden mit denselben Programmiersprachen geschrieben und die Anschlußregeln sind identisch.


FD-Anschlüsse

Ein FD-Anschluß stellt die Verbindung von zwei Diagrammpunkten her, ohne daß diese Verbindung gezeichnet werden muß. Ein solcher Anschluß wird als Kreis dargestellt und ist an die Quelle des Datenflusses angeschlossen. Je nach Richtung des Datenflusses wird das Anschlußsymbol an der entsprechenden Seite mit der Identifizierung des Zielpunkts vervollständigt (im allgemeinen der Name eines Zielsymbols). Es folgt die grafische Darstellungsweise eines Anschlusses:

Das Anschlußziel ist stets ein bereits definiertes FD-Symbol. Das Zielsymbol wird durch seine logische Nummer identifiziert.


FD-Kommentare

Die Kommentarfelder enthalten Text, der keinen Einfluß auf die Semantik des Flußdiagramms nimmt, und können an beliebigen freien Stellen im Dokumentfenster eines Flußdiagramms eingefügt werden. Kommentare dienen der Programmdokumentation. Das "Kommentarsymbol" sieht folgendermaßen aus:


Beispiele komplexer FD-Strukturen
Beipiele komplexer FD-Strukturen

Dieser Abschnitt zeigt Beispiele komplexer Strukturen, wie sie in einem Flußdiagramm definiert werden können. Solche Strukturen sind Kombinationen von miteinander verbundenen Grundobjekten.

	IF / THEN / ELSE (1) hier können "THEN" Aktionen eingefügt werden (2) hier können "ELSE" Aktionen eingefügt werden
	REPEAT / UNTIL (3) hier können wiederholte Aktionen eingefügt werden
	WHILE / DO (3) hier können wiederholte Aktionen eingefügt werden


Dynamisches Verhalten des FD

Die Ausführung eines Flußdiagramms kann folgendermaßen erklärt werden:

- Das "Begin"-Symbol belegt einen Zielsystemzyklus.

- Das "End"-Symbol belegt einen Zielsystemzyklus und beendet die Diagrammausführung. Wenn dieses Symbol erreicht ist, werden keine Aktionen des Flußdiagramms mehr ausgeführt.

- Die Ausführung einer Aktion belegt einen Zielsystemzyklus.

Hinweis: Im Gegensatz zu AS-Aktionen sind FD-Aktionen keine stabilen Zustände. Die Anweisungen werden nicht wiederholt, während das Aktionssymbol markiert ist.


FD-Syntax

Außer der Syntaxregeln der zugeordneten ST-, KOP- und AWL-Programmierung gibt es noch einige andere Syntaxregeln, die sich auf das Flußdiagramm selbst beziehen. Folgende Regeln sind zu beachten:

- Alle "Anschlußpunkte" aller Symbole müssen angeschlossen werden. (Nur der Anschluß zum "End"-Symbol darf weggelassen werden.)

- Alle Symbole müssen miteinander verbunden werden. (Isolierte Abschnitte sind unzulässig.)

- Alle Anschlüsse müssen ein gültiges Ziel haben.

Andere Syntaxfehler können auftreten:

-Leere Aktionen (keine Programmierung) werden beim Runtime-Scheduling als Schritte betrachtet.

- Leere Tests (keine Programmierung) werden als "immer true" betrachtet.