547 lines
17 KiB
XML
547 lines
17 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<TcPlcObject Version="1.1.0.1">
|
|
<POU Name="FB_ValveAnalog_Test" Id="{9dc8ec77-f523-463e-8c0f-b11bbdcadb17}" SpecialFunc="None">
|
|
<Declaration><![CDATA[FUNCTION_BLOCK FB_ValveAnalog_Test EXTENDS TcUnit.FB_TestSuite
|
|
VAR
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[// Automatic Mode
|
|
SwitchToAutomaticMode();
|
|
|
|
// Manual Mode
|
|
SwitchToManualMode();
|
|
|
|
// Test interlocks
|
|
TestProcessInterlocks();
|
|
TestProcessINTLKsInAutomaticMode();
|
|
TestProcessINTLKsInManualMode();
|
|
|
|
// Check feedback signals
|
|
CheckOpenCloseFeedbacks();
|
|
|
|
// Test Open/Close Valves
|
|
OpenCloseValveInAutomaticMode();
|
|
OpenCloseValveInManualMode();
|
|
|
|
// check range errors
|
|
CheckNotInRangeError();
|
|
CheckOverrange();
|
|
CheckUnderrange();]]></ST>
|
|
</Implementation>
|
|
<Method Name="CheckNotInRangeError" Id="{f10fdc9b-52ba-49cf-9c89-aee87b8a1ee1}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD CheckNotInRangeError
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve config
|
|
_stValveConfig : ST_ValveAnalogConfig;
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve error output
|
|
_xError : BOOL;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('CheckNotInRangeError');
|
|
|
|
// config valve to
|
|
_stValveConfig.xHasAnalogFeedback := TRUE;
|
|
_stValveConfig.rTargetTolerance := 5;
|
|
_stValveConfig.timNotInRange := T#0S;
|
|
_stValveConfig.stAnalogInputConfig.iAIMax :=4095;
|
|
_stValveConfig.stAnalogInputConfig.iAIMin :=0;
|
|
_stValveConfig.stAnalogInputConfig.rPVMax :=100;
|
|
_stValveConfig.stAnalogInputConfig.rPVMin :=0;
|
|
|
|
// Set in automatic mode and open valve
|
|
_fbValve.ReqAutomaticMode();
|
|
_fbValve.rSPAutomatic := 100;
|
|
|
|
// needs one cycle to write values (scaled feedback ~75, tolerance 95 to 105)
|
|
_fbValve(xAutomaticOpen := TRUE, stValveConfig := _stValveConfig, stHMIInterface := _stHMIValve, iFeedbackValue := 3000, xError => _xError, xInUnitTestMode := TRUE);
|
|
|
|
// assert result
|
|
AssertTrue(_xError, 'Expected NotInRangeError, got no error.');
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="CheckOpenCloseFeedbacks" Id="{ce54a6cd-7831-4ab3-aa0c-464e9a0018d6}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD CheckOpenCloseFeedbacks
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve config
|
|
_stValveConfig : ST_ValveAnalogConfig;
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve feedback
|
|
_xOpenFeedback : BOOL := FALSE;
|
|
_xCloseFeedback : BOOL := FALSE;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('CheckOpenCloseFeedbacks');
|
|
|
|
// set open+close feedback to present, analog feedback to false
|
|
_stValveConfig.xHasAnalogFeedback := FALSE;
|
|
_stValveConfig.xHasOpenFeedback := TRUE;
|
|
_stValveConfig.xHasClosedFeedback := TRUE;
|
|
|
|
// Test feedbacks in manual mode
|
|
_xOpenFeedback := FALSE;
|
|
_xCloseFeedback := FALSE;
|
|
_fbValve.xReleaseManualMode := TRUE;
|
|
_fbValve.ReqManualMode();
|
|
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
|
|
|
|
|
|
// We should now be in manual mode
|
|
AssertTrue(Condition := _fbValve.IsInManualMode, Message := 'Valve did not changed to manual mode');
|
|
|
|
|
|
// Test closed
|
|
_xOpenFeedback := FALSE;
|
|
_xCloseFeedback := TRUE;
|
|
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
|
|
AssertTrue(Condition := _fbValve.IsClosed, Message := 'Valve should be closed');
|
|
AssertFalse(Condition := _fbValve.IsOpen, Message := 'Valve should not be open');
|
|
|
|
// Test opened
|
|
_xOpenFeedback := TRUE;
|
|
_xCloseFeedback := FALSE;
|
|
_stHMIValve.stSetpoint.rValue := 100.0;
|
|
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
|
|
AssertTrue(Condition := _fbValve.IsOpen, Message := 'Valve should be open');
|
|
AssertFalse(Condition := _fbValve.IsClosed, Message := 'Valve should not be closed');
|
|
|
|
// Test open and close
|
|
_xOpenFeedback := TRUE;
|
|
_xCloseFeedback := TRUE;
|
|
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
|
|
AssertFalse(Condition := _fbValve.IsClosed OR _fbValve.IsOpen, Message := 'Valve should not signal open or closed with both feedback signals high');
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="CheckOverrange" Id="{6a8f595e-e480-42ad-a991-d9700b5e80d0}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD CheckOverrange
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve config
|
|
_stValveConfig : ST_ValveAnalogConfig;
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve error output
|
|
_xError : BOOL;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('CheckOverrange');
|
|
|
|
// set delay to zero to make single cycle test possible (AnalogInput is tested individually)
|
|
_stValveConfig.stAnalogInputEWConfig.stDelays.timHardwareSignalLevelOn := T#0S;
|
|
_stValveConfig.xHasAnalogFeedback := TRUE;
|
|
|
|
// needs one cycle to write values, xOverrange must be connected.
|
|
_fbValve(
|
|
stValveConfig := _stValveConfig,
|
|
stHMIInterface := _stHMIValve,
|
|
xFeedbackOverrange := TRUE,
|
|
xError => _xError,
|
|
xInUnitTestMode := TRUE);
|
|
|
|
// assert result
|
|
AssertTrue(_xError, 'Expected Overrange error, got no error.');
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="CheckUnderrange" Id="{4d7e06e3-a833-4b91-a285-8e2fb59100bd}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD CheckUnderrange
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve config
|
|
_stValveConfig : ST_ValveAnalogConfig;
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve error output
|
|
_xError : BOOL;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('CheckUnderrange');
|
|
|
|
// set delay to zero to make single cycle test possible (AnalogInput is tested individually)
|
|
_stValveConfig.stAnalogInputEWConfig.stDelays.timHardwareSignalLevelOn := T#0S;
|
|
_stValveConfig.xHasAnalogFeedback := TRUE;
|
|
|
|
// needs one cycle to write values, xUnderrange must be connected.
|
|
_fbValve(
|
|
stValveConfig := _stValveConfig,
|
|
stHMIInterface := _stHMIValve,
|
|
xFeedbackUnderrange := TRUE,
|
|
xError => _xError,
|
|
xInUnitTestMode := TRUE);
|
|
|
|
// assert result
|
|
AssertTrue(_xError, 'Expected Underrange error, got no error.');
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="OpenCloseValveInAutomaticMode" Id="{fc3da46f-724a-400a-ab82-86cb17e3d842}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD OpenCloseValveInAutomaticMode
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve state
|
|
_xResult : BOOL;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('OpenCloseValveInAutomaticMode');
|
|
|
|
// Set in automatic mode
|
|
_fbValve.ReqAutomaticMode();
|
|
|
|
// Open valve
|
|
_fbValve.rSPAutomatic := 100;
|
|
|
|
// Needs one cycle to write outputs
|
|
_fbValve(xAutomaticOpen := TRUE, stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
|
|
|
|
// evaluate valve state
|
|
_xResult := _fbValve.IsOpen AND NOT _fbValve.IsClosed;
|
|
AssertTrue(_xResult, 'Valve did not open in Automatic Mode');
|
|
|
|
// Close valve
|
|
_fbValve.rSPAutomatic := 0;
|
|
|
|
// Needs one cycle to write outputs
|
|
_fbValve(xAutomaticOpen := FALSE, stHMIInterface := _stHMIValve);
|
|
|
|
// evaluate valve state
|
|
_xResult := _fbValve.IsClosed AND NOT _fbValve.IsOpen;
|
|
AssertTrue(_xResult, 'Valve did not close in Automatic Mode');
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="OpenCloseValveInManualMode" Id="{1349619a-f843-4cf9-9143-1a752f089a58}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD OpenCloseValveInManualMode
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve state
|
|
_xResult : BOOL;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('OpenCloseValveInManualMode');
|
|
|
|
// release manual mode
|
|
_fbValve.xReleaseManualMode := TRUE;
|
|
|
|
// Set in manual mode
|
|
_fbValve.ReqManualMode();
|
|
|
|
// Open valve and call block
|
|
_stHMIValve.stSetpoint.rValue := 100;
|
|
_stHMIValve.stOpenButton.xRequest := TRUE;
|
|
_fbValve(stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
|
|
|
|
// evaluate valve state
|
|
_xResult := _fbValve.IsOpen AND NOT _fbValve.IsClosed;
|
|
AssertTrue(_xResult, 'Valve did not open in Manual Mode');
|
|
|
|
// Close valve and call block
|
|
_stHMIValve.stCloseButton.xRequest := TRUE;
|
|
_fbValve(stHMIInterface := _stHMIValve);
|
|
|
|
// evaluate valve state
|
|
_xResult := _fbValve.IsClosed AND NOT _fbValve.IsOpen;
|
|
AssertTrue(_xResult, 'Valve did not close in Manual Mode');
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="SwitchToAutomaticMode" Id="{7c51a185-7dd4-4b8d-9873-f1eaa22c97e6}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD SwitchToAutomaticMode
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve state
|
|
_xResult : BOOL;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('SwitchToAutomaticMode');
|
|
|
|
// request switch to automatic mode
|
|
_fbValve.ReqAutomaticMode();
|
|
|
|
// call valve block
|
|
_fbValve(stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
|
|
|
|
// assert valve mode
|
|
_xResult := _fbValve.IsInAutomaticMode;
|
|
AssertTrue(_xResult, 'Valve did not change into Automatic Mode');
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="SwitchToManualMode" Id="{84f7ce91-9e5d-4bc0-8681-d7a35657e9a9}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD SwitchToManualMode
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve state
|
|
_xResult : BOOL;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('SwitchToManualMode');
|
|
|
|
// Test switch without xReleaseManualMode
|
|
_fbValve.xReleaseManualMode := FALSE;
|
|
_fbValve.ReqManualMode();
|
|
_fbValve(stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
|
|
_xResult := NOT _fbValve.IsInManualMode;
|
|
AssertTrue(_xResult, 'Valve changed to Manual Mode but this mode was not released');
|
|
|
|
// Test with xReleaseManualMode
|
|
_fbValve.xReleaseManualMode := TRUE;
|
|
_fbValve.ReqManualMode();
|
|
_fbValve(stHMIInterface := _stHMIValve);
|
|
_xResult := _fbValve.IsInManualMode;
|
|
AssertTrue(_xResult, 'Valve did not changed to Manual Mode');
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="TestProcessInterlocks" Id="{2152677d-8778-48f4-98dc-366509ac6287}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
{attribute 'analysis' := '-81'}
|
|
METHOD TestProcessInterlocks
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve state
|
|
_xResult : BOOL;
|
|
|
|
// current interlock
|
|
_usiCounter : USINT;
|
|
|
|
// Init all entries to TRUE
|
|
_wInterlocks : T_INTERLOCK := 2#1111_1111_1111_1111;//[GVL_VALVE.MAX_INTERLOCKS(TRUE)];
|
|
_wInterlocksUsed : T_INTERLOCK := 2#1111_1111_1111_1111;
|
|
|
|
// induvidual interlock test result
|
|
_axInterlockTestResultFalse : ARRAY[0..GVL_CONFIGS.MAX_INTERLOCKS-1] OF BOOL;
|
|
_axInterlockTestResultTrue : ARRAY[0..GVL_CONFIGS.MAX_INTERLOCKS-1] OF BOOL;
|
|
|
|
// comulated interlock test result
|
|
_xInterlocksFalseOK : BOOL;
|
|
_xInterlocksTrueOK : BOOL;
|
|
END_VAR
|
|
|
|
VAR CONSTANT
|
|
// loop iterations for interlock test
|
|
usiEndValue : USINT := GVL_CONFIGS.MAX_INTERLOCKS-1;
|
|
END_VAR]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[// Test interlocks as reutrn value
|
|
TEST('TestProcessInterlocks');
|
|
|
|
// call valve block and evaluate interlocks
|
|
_fbValve(wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
|
|
_xResult := _fbValve.ProcessInterlocksOK;
|
|
|
|
AssertTrue(_xResult, 'Interlocks not Ok but should be');
|
|
|
|
// Test each interlock individually
|
|
// Save the result in the two following variables
|
|
_xInterlocksFalseOK := TRUE;
|
|
_xInterlocksTrueOK := TRUE;
|
|
|
|
FOR _usiCounter := 0 TO usiEndValue DO
|
|
|
|
// Test one interlock for false and then disable it
|
|
_wInterlocks := SHL(_wInterlocks, 1);
|
|
_fbValve(wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve);
|
|
|
|
// Save result in an array for later debugging if necessary
|
|
_axInterlockTestResultFalse[_usiCounter] := _fbValve.ProcessInterlocksOK;
|
|
|
|
// Save global result
|
|
IF _fbValve.ProcessInterlocksOK THEN
|
|
_xInterlocksFalseOK := FALSE;
|
|
END_IF
|
|
// Disable this interlock after testing it
|
|
_wInterlocksUsed := SHL(_wInterlocksUsed, 1);
|
|
|
|
// Test if, after disabling the interlock, the interlocks are ok again
|
|
_fbValve(wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve);
|
|
|
|
// Save result in an array for later debugging if necessary
|
|
_axInterlockTestResultTrue[_usiCounter] := _fbValve.ProcessInterlocksOK;
|
|
|
|
// Save global result
|
|
IF NOT _fbValve.ProcessInterlocksOK THEN
|
|
_xInterlocksTrueOK := FALSE;
|
|
END_IF
|
|
END_FOR
|
|
|
|
// Test False interlocks result
|
|
AssertTrue(_xInterlocksFalseOK, 'Interlock should not be ok but are');
|
|
|
|
// Test False interlocks result
|
|
AssertTrue(_xInterlocksTrueOK, 'Interlock should be ok but are not');
|
|
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="TestProcessINTLKsInAutomaticMode" Id="{468a3341-78b1-4d81-96e1-32c340664094}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD TestProcessINTLKsInAutomaticMode
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;
|
|
|
|
// valve analog config
|
|
_stAnalogValveConfig : ST_ValveAnalogConfig;
|
|
|
|
// valve interlocks
|
|
_wInterlocks : T_INTERLOCK;
|
|
_wInterlocksUsed : T_INTERLOCK;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('TestProcessINTLKsInAutomaticMode');
|
|
_wInterlocks.0 := 1;
|
|
_wInterlocksUsed.0 := 1;
|
|
|
|
// Switch to automatic mode
|
|
_fbValve.ReqAutomaticMode();
|
|
_fbValve(wProcessINTLK := _wInterlocks, stValveConfig := _stAnalogValveConfig, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
|
|
|
|
// Open valve in automatic mode
|
|
_fbValve.rSPAutomatic := 100;
|
|
_fbValve(xAutomaticOpen := TRUE, wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve);
|
|
|
|
// Test if valve is open, when not we have an intermediate error
|
|
// which should have been found by another test
|
|
IF _fbValve.IsOpen THEN
|
|
// Activate an interlock
|
|
_wInterlocks.0 := 0;
|
|
_fbValve(wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve);
|
|
|
|
// Valve should now be closed
|
|
AssertFalse(Condition := _fbValve.IsOpen, Message := 'Valve should not be open with active Interlock');
|
|
AssertTrue(Condition := _fbValve.IsClosed, Message := 'Close output not active with active Interlock');
|
|
AssertEquals_INT(Expected := 0, Actual := _fbValve.iSetpoint, Message := 'Analog output should be zero');
|
|
ELSE
|
|
AssertTrue(Condition := _fbValve.IsOpen, Message := 'Valve did not open before the test');
|
|
END_IF
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="TestProcessINTLKsInManualMode" Id="{65a15a58-c0c0-4568-a4e1-3f436c3d6baa}">
|
|
<Declaration><![CDATA[{warning disable C0394}
|
|
METHOD TestProcessINTLKsInManualMode
|
|
VAR
|
|
// valve instance
|
|
_fbValve : FB_ValveAnalog('');
|
|
|
|
// valve hmi data
|
|
_stHMIValve : ST_HMI_ANALOG_VALVE_DATA;;
|
|
|
|
// valve interlocks
|
|
_wInterlocks : T_INTERLOCK;
|
|
_wInterlocksUsed : T_INTERLOCK;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[TEST('TestProcessINTLKsInManualMode');
|
|
_wInterlocks.0 := 1;
|
|
_wInterlocksUsed.0 := 1;
|
|
|
|
// Switch to manual mode
|
|
_fbValve.xReleaseManualMode := TRUE;
|
|
_fbValve.ReqManualMode();
|
|
_fbValve(wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
|
|
|
|
// Open valve in manual mode
|
|
_stHMIValve.stSetpoint.rValue := 100.0;
|
|
_stHMIValve.stOpenButton.xRequest := TRUE;
|
|
_fbValve(wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve);
|
|
|
|
// Test if valve is open, when not we have an intermediate error
|
|
// which should have been found by another test
|
|
IF _fbValve.IsOpen THEN
|
|
// Activate an interlock
|
|
_wInterlocks.0 := 0;
|
|
_fbValve(wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve);
|
|
|
|
// Valve should now be closed
|
|
AssertFalse(Condition := _fbValve.IsOpen, Message := 'Valve should not be open with active Interlock');
|
|
AssertTrue(Condition := _fbValve.IsClosed, Message := 'Close output not active with active Interlock');
|
|
AssertEquals_INT(Expected := 0, Actual := _fbValve.iSetpoint, Message := 'Analog output should be zero');
|
|
ELSE
|
|
AssertTrue(Condition := _fbValve.IsOpen, Message := 'Valve did not open before the test');
|
|
END_IF
|
|
|
|
TEST_FINISHED();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
</POU>
|
|
</TcPlcObject> |