In benutzerdefinierte Funktionen umgewandelte Funktionsbausteine

Der Hauptzweck dieser Funktionen besteht darin, das Ersetzen von Funktionsbausteinen (FB) durch Funktionen (FUN) zu erleichtern. Mehrere FB-Instanzen in separaten Unterprogrammen werden durch eine Funktion in einem Unterprogramm ersetzt.

Funktionsbaustein	Umgewandelte Funktion

Beschränkungen:

Nicht alle Panasonic-Befehle können in einer gemeinsamen Funktion verwendet werden. Beispiele für Befehle, die nicht in einer gemeinsamen Funktion verwendet werden können:

• Bestimmte schnelle Zählerbefehle wie F166_HighSpeedCounter_Set, F165_HighSpeedCounter_Cam

• Bestimmte Positionierbefehle wie F166_PulseOutput_Set, F171_PulseOutput_Trapezoidal

Dies muss im Einzelnen geprüft werden.

Vorteile:

• Möglicherweise wesentlich weniger Programmcode erforderlich

• Möglicherweise wesentlich weniger Relais (R) erforderlich

• Verwendung in Schleifen mit Hilfe von Arrays der Speicher-SDTs möglich

Nachteile

• Erfordert zusätzlichen Entwicklungs- und Wartungsaufwand

• Die umgewandelte Funktion muss genau getestet werden

• Erfordert mehr Aufwand seitens des Anwenders

• Überwachung ist schwieriger, da es keine Instanz gibt, die überwacht werden kann, nur der letzte Aufruf wird überwacht

• Erfordert möglicherweise mehr Datenregister (DT)

• Die Leistungsfähigkeit der SPS ist vermindert, die Zykluszeit länger

Empfehlungen für die Verwendung:

• Funktionen sollten nur anstelle von Funktionsbausteinen verwendet werden, wenn unbedingt notwendig.

• Funktionen sollten nur so weit wie unbedingt notwendig anstelle von Funktionsbausteinen verwendet werden.

• Prüfen Sie genau, welcher Funktionsbaustein umgewandelt werden soll, um den maximalen Nutzen bei minimalem Aufwand zu ziehen.

• Die Entscheidung, ob ein Funktionsbaustein umgewandelt werden soll, sollte auf folgenden Hauptkriterien beruhen: Wie oft wird der Funktionsbaustein aufgerufen, wie viele Schritte erfordert der Funktionsbaustein?

Anhand folgender Formel wird berechnet, wie viele Programmcode-Schritte eingespart werden können.

Dies ist die aktuelle Situation:

• Ein bestimmter Funktionsbaustein

• wird X-mal aufgerufen

• verwendet Y Schritte => Gesamtzahl der Schritte: X * Y Schritte

• verwendet TON, SR, Pulsmerker

Der Funktionsbaustein kann durch eine Funktion ersetzt werden, die Folgendes erfordert:

• Zusätzliche Schritte für X Aufrufe, um die Speicher-SDT-Daten zweimal zu kopieren, d.h. etwa X * 2 * 7 Schritte (z.B. für zwei FP10_BKMV)

• Y * 2 Schritte für einen gemeinsamen Funktionsaufruf (es wird von einigen zusätzlichen Schritten ausgegangen)

• Ein gemeinsamer Aufruf von:

  • TON_FUN mit xxx Schritten

  • SR_FUN mit xxx Schritten

  • R_TRIG_FUN mit xxx Schritten

Rechenbeispiel für FP0H

Dieses Rechenbeispiel liefert nur ungefähre Werte.

• Ein bestimmter Funktionsbaustein

• wird 30-mal aufgerufen

• verwendet 750 Schritte => Gesamtzahl der Schritte: 30 * 750 Schritte = 22500 Schritte

• verwendet TON, SR, Pulsmerker

Der Funktionsbaustein kann durch eine Funktion ersetzt werden, die Folgendes erfordert:

• Zusätzliche Schritte für 30 Aufrufe, um die Speicher-SDT-Daten zweimal zu kopieren, d.h. 30 * 2 * 7 Schritte = 420 Schritte (z.B. für zwei FP10_BKMV)

• 750 * 2 Schritte für einen gemeinsamen Funktionsaufruf = 1500 Schritte (es wird von einigen zusätzlichen Schritten ausgegangen)

• Ein gemeinsamer Aufruf von:

  • TON_FUN mit 200 Schritten

  • SR_FUN mit 35 Schritten

  • R_TRIG_FUN mit 35 Schritten

Gesamtzahl der Schritte: 420 Schritte + 1500 Schritte + 200 Schritte + 35 Schritte + 35 Schritte = 2190 Schritte

Ergebnis: Mit dieser Funktion sparen Sie etwa 22500 Schritte - 2190 Schritte = 20310 Schritte ein.

Annahme: Eine Funktion XXX mit einer VAR_IN_OUTdutXXX vom Datentyp XXX_FUN_INSTANCE_DUT wird in allen Beispielen verwendet.

Operation	Ursprüngliches Programmierbeispiel	Umgewandeltes Programmierbeispiel
	Aufrufe
	FB POE-Kopf	FUN POE-Kopf
		SDT XXX_FUN_INSTANCE_DUT
Setzen Rücksetzen
KEEP
Bedingte Zuweisung, Rechenoperation
Variablenwerte erhöhen/verringern
Pulsmerker
Am Ende der Funktion: Gegebenenfalls einige Speichervariablen den entsprechenden Ausgangsvariablen zuweisen:
SR
RS
TON
TM_100ms

Annahme: Eine Funktion XXX mit einer VAR_IN_OUTdutXXX vom Datentyp XXX_FUN_INSTANCE_DUT wird in allen Beispielen verwendet.

if (bSet) then
	bSR1:=true;
elsif (bReset) then
	bSR1:=false;
end_if;

if (bSet) then
	dutInstance.bSR1:=true;
elsif (bReset) then
	dutInstance.bSR1:=false;
end_if;

bRS1 := KEEP(SetTrigger := bSet,
             ResetTrigger := bReset);

dutInstance.bRS1 := KEEP(SetTrigger := bSet,
                         ResetTrigger := bReset);

if (bReset) then
	di1:=0;
end_if;
if (bTrig) then
	w1 := ROL(IN := w1, N := 1);
end_if;

if (bReset) then
	dutInstance.di1 :=0;
end_if;
if (bTrig) then
	dutInstance.w1 := ROL(IN := dutInstance.w1, N := 1);
end_if;

di1:=di1+1;
w2:=w2 OR w1;

dutInstance.di1:=dutInstance.di1+1;

dutInstance.w2:=dutInstance.w2 OR dutInstance.w1;

if (DF(bSet) OR DFN(bSet)) then
	di2:=di2+1;
end_if;

R_TRIG_FUN(CLK := bSet,
           dutInstance := dutInstance.dutRTrig1,
           Q => bQTemp1);
F_TRIG_FUN(CLK := bSet,
           dutInstance := dutInstance.dutFTrig1,
           Q => bQTemp2);
if (bQTemp1 OR bQTemp2) then
    dutInstance.di2:=dutInstance.di2+1;
end_if;

bSR1:=dutInstance.bSR1;
bRS1:=dutInstance.bRS1;
di1:=dutInstance.di1;
di2:=dutInstance.di2;
w1:=dutInstance.w1;
w2:=dutInstance.w2;

SR_1(S1 := bSet,
     R := bReset,
     Q1 => bSR2);

SR_FUN(Set := bSet,
        Reset := bReset,
        dutInstance := dutInstance.dutSR_1, Q1 => bSR2);

RS_1(S := bSet,
      R1 := bReset,
      Q1 => bRS2);

RS_FUN(Set := bSet,
        Reset := bReset,
        dutInstance := dutInstance.dutRS_1,
        Q1 => bRS2);

TON1(IN := bIN,
      PT := T#10S,
      Q => bQ1, ET => tET1);

TON_FUN(IN := bIN,
        PT := T#10s,
        dutInstance := dutInstance.dutTon1,
        Q => bQ1, ET => dutInstance.tET1);

TM_100ms_1(start := bIN,
            SV := 100,
            T => bT1,
            EV => iEV1);

TM_100ms_FUN(start := bIN,
              SV := 100,
              dutInstance := dutInstance.dutTM_100ms_1,
              T => bT1, EV => dutInstance.iEV1);