FB_CTRL_TRANSFERFUNCTION_2

FB_CTRL_TRANSFERFUNCTION_2 1:

Dieser Baustein berechnet eine diskrete Übertragungsfunktion mit der unten dargestellten zweiten Standardform. Die Übertragungsfunktion kann hierbei von beliebiger Ordnung „n“ sein.

In den Parameter-Arrays werden die Koeffizienten der folgenden Übertragungsfunktion abgelegt:

Beschreibung des Übertragungsverhaltens

Die interne Berechnung erfolgt in jedem Abtastschritt nach der zweiten Standardform, für die das folgende Blockschaltbild gilt:

FB_CTRL_TRANSFERFUNCTION_2 3:

Durch einige Umformungen lässt sich die Übertragungsfunktion auf die im Blockschaltbild dargestellte Form bringen:
FB_CTRL_TRANSFERFUNCTION_2 4:

Die Koeffizienten des Zählerpolynoms berechnen sich dabei nach der folgenden Vorschrift:
FB_CTRL_TRANSFERFUNCTION_2 5: FB_CTRL_TRANSFERFUNCTION_2 6:
FB_CTRL_TRANSFERFUNCTION_2 7:

Um diesen Funktionsbaustein nutzen zu können, müssen die folgenden Arrays vom Programmierer in der SPS angelegt werden:

aNumArray    : ARRAY[0..nTfOrder] OF FLOAT;
aDenArray    : ARRAY[0..nTfOrder] OF FLOAT;
aStTfData    : ARRAY[0..nTfOrder] OF ST_CTRL_TRANSFERFUNCTION_2_DATA;

In dem Array aNumArray werden die Koeffizienten „b₀“ bis „b_n“ abgelegt. Diese müssen folgendermaßen angeordnet werden:

aNumArray[0]:= b0;
aNumArray[1]:= b1;
...
aNumArray[n-1] := bn-1;
aNumArray[n] := bn;

In dem Array aDenArray werden die Koeffizienten „a₀“ bis a_n“ abgelegt. Diese müssen folgendermaßen angeordnet werden:

aDenArray[0]:= a0;
aDenArray[1]:= a1;
...
aDenArray[n-1] := an-1;
aDenArray[n] := an;

Die internen Daten, die der Baustein benötigt, werden in dem Array aStTfData abgelegt. Diese Daten dürfen innerhalb des SPS-Programms keinesfalls geändert werden. Diese Vorgehensweise wird auch in dem unten aufgeführten Beispielprogramm dargestellt.

VAR_INPUT

VAR_INPUT
    fIn          : FLOAT;
    fManValue    : FLOAT;
    eMode        : E_CTRL_MODE;
END_VAR

Name	Typ	Beschreibung
fIn	FLOAT	Eingang der Übertragungsfunktion
fManValue	FLOAT	Eingang, dessen Wert im Manual-Mode am Ausgang anliegt.
eMode	E_CTRL_MODE	Eingang, der die Betriebsart des Bausteins festlegt.

VAR_OUTPUT

VAR_OUTPUT
    fOut        : FLOAT;
    eState      : E_CTRL_STATE;
    bError      : BOOL;
    eErrorId    : E_CTRL_ERRORCODES;
END_VAR

Name	Typ	Beschreibung
fOut	FLOAT	Ausgang der Übertragungsfunktion
eState	E_CTRL_STATE	State des Funktionsbausteins
bError	BOOL	Liefert bei einem gesetzten `bError`-Ausgang die Fehlernummer.
eErrorId	E_CTRL_ERRORCODES	Wird TRUE, sobald ein Fehler eintritt.

VAR_IN_OUT

VAR_IN_OUT
    stParams    : ST_CTRL_TRANSFERFUNCTION_2_PARAMS;
END_VAR

Name	Typ	Beschreibung
stParams	ST_CTRL_TRANSFERFUNCTION_2_PARAMS	Parameterstruktur des Funktionsbausteins

stParams besteht aus den folgenden Elementen:

TYPE
ST_CTRL_TRANSFERFUNCTION_2_PARAMS:
STRUCT
    tTaskCycleTime                : TIME; 
    tCtrlCycleTime                : TIME := T#0ms; 
    nOrderOfTheTransferfunction   : USINT;
    pNumeratorArray_ADR           : POINTER TO FLOAT := 0;
    nNumeratorArray_SIZEOF        : UINT;
    pDenominatorArray_ADR         : POINTER TO FLOAT := 0;
    nDenomiantorArray_SIZEOF      : UINT;
    pTransferfunction2Data_ADR    : POINTER TO
ST_CTRL_TRANSFERFUNCTION_2_DATA;
    nTransferfunction2Data_SIZEOF : UINT;
END_STRUCT
END_TYPE

Name	Typ	Beschreibung
tTaskCycleTime	TIME	Zykluszeit, mit der der Funktionsbaustein aufgerufen wird. Diese entspricht der Task-Zykluszeit der aufrufenden Task, wenn der Baustein in jedem Zyklus aufgerufen wird.
tCtrlCycleTime	TIME	Zykluszeit, mit der der Regelkreis bearbeitet wird. Diese muss größer oder gleich der TaskCycleTime sein. Der Funktionsbaustein berechnet mit dieser Eingangsgröße intern, ob die Zustands- und Ausgangsgrößen im aktuellen Zyklus aktualisiert werden müssen.
nOrderOfTheTransferfunction	USINT	Ordnung der Übertragungsfunktion [0...]
pNumeratorArray_ADR	POINTER TO FLOAT	Adresse des Arrays mit den Zählerkoeffizienten
nNumeratorArray_SIZEOF	UINT	Größe des Arrays mit den Zählerkoeffizienten in Byte
pDenominatorArray_ADR	POINTER TO FLOAT	Adresse des Arrays mit den Nennerkoeffizienten
nDenomiantorArray_SIZEOF	UINT	Größe des Arrays mit den Nennerkoeffizienten in Byte
pTransferfunction2Data_ADR	POINTER TO ST_CTRL_ TRANSFERFUNCTION_2_DATA	Adresse des Daten-Arrays
nTransferfunction2Data_SIZEOF	UINT	Größe des Daten-Arrays in Byte

Beispiel:

PROGRAM PRG_TRANSFERFUNCTION_2_TEST
VAR CONSTANT
    nTfOrder : USINT := 2;
END_VAR
VAR
    aNumArray           : ARRAY[0..nTfOrder] OF FLOAT;
    aDenArray           : ARRAY[0..nTfOrder] OF FLOAT;
    aStTfData           : ARRAY[0..nTfOrder] OF ST_CTRL_TRANSFERFUNCTION_2_DATA;
    eMode               : E_CTRL_MODE;
    stParams            : ST_CTRL_TRANSFERFUNCTION_2_PARAMS;
    eErrorId            : E_CTRL_ERRORCODES;
    bError              : BOOL;
    fbTansferfunction   : FB_CTRL_TRANSFERFUNCTION_2;
    bInit               : BOOL := TRUE;
    fIn                 : FLOAT := 0;
    fOut                : FLOAT;
    b_0, b_1, b_2       : FLOAT;
    a_0,a_1,a_2         : FLOAT;
END_VAR
IF bInit THEN
    aNumArray[0] := 1.24906304658218E-007;
    aNumArray[1] := 2.49812609316437E-007;
    aNumArray[2] := 1.24906304658218E-007;
    aDenArray[0] := 0.998501124344101;
    aDenArray[1] := -1.99850062471888;
    aDenArray[2] := 1.0;
    stParams.tTaskCycleTime    := T#2ms;
    stParams.tCtrlCycleTime    := T#2ms;
    stParams.nOrderOfTheTransferfunction := nTfOrder;
    eMode := eCTRL_MODE_ACTIVE;
    bInit := FALSE;
END_IF
stParams.pNumeratorArray_ADR := ADR(aNumArray);
stParams.nNumeratorArray_SIZEOF := SIZEOF(aNumArray);
stParams.pDenominatorArray_ADR := ADR(aDenArray );
stParams.nDenominatorArray_SIZEOF := SIZEOF(aDenArray );
stParams.pTransferfunction2Data_ADR := ADR(aStTfData );
stParams.nTransferfunction2Data_SIZEOF := SIZEOF(aStTfData);
fbTansferfunction (fIn := fIn,
                   eMode := eMode,
                   stParams := stParams,
                   fOut => fOut,
                   eErrorId => eErrorId,
                   bError => bError);