Heisig_GmbH/BasicComponents
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added more components

Browse Source
This commit is contained in:
Matthias Heisig
2025-11-13 09:19:39 +01:00
parent 4ad75a3534
commit ae9667622a
56 changed files with 7117 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

282
PLC/POUs/Unittests/ValveTests/FB_ValveTestHMI.TcPOU Normal file
View File

@@ -0,0 +1,282 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<POU Name="FB_ValveTestHMI" Id="{78a34e73-74e3-480e-93ae-396774638baf}" SpecialFunc="None">
<Declaration><![CDATA[FUNCTION_BLOCK FB_ValveTestHMI EXTENDS TcUnit.FB_TestSuite
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
// valve instance for Open/Close-Test
_fbValveOC : FB_Valve('');
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TestManualButtonRelease();
TestManualButtonModeChange();
TestManualModeButtonOpenClose();
TestManualModeOpenRelease();]]></ST>
</Implementation>
<Method Name="TestManualButtonModeChange" Id="{4fa4418c-a1e9-4136-b912-1dfb82f3064a}">
<Declaration><![CDATA[{warning disable C0394}
METHOD TestManualButtonModeChange
VAR
// valve instance
_fbValve : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// valve config
_stValveConfig : ST_ValveConfig;
// valve interlocks
_wInterlocks : T_INTERLOCK;
_wInterlocksUsed : T_INTERLOCK;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('TestManualButtonModeChange');
// set manual request button on HMI and call valve block
_stHMIValve.stManualButton.xRequest := TRUE;
_fbValve(
xReleaseManualMode:= TRUE,
wProcessINTLK:= _wInterlocks,
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= _stValveConfig,
xOpenValve=> ,
xCloseValve=> );
// Valve should now be in manual mode and xRequest should have been reset
AssertTrue(Condition := _fbValve.IsInManualMode, Message := 'Valve did not change to manual mode');
AssertFalse(Condition := _stHMIValve.stManualButton.xRequest, Message := 'Valve did not reset the manual mode button request');
TEST_FINISHED();]]></ST>
</Implementation>
</Method>
<Method Name="TestManualButtonRelease" Id="{6966094d-e9b6-4f8b-a399-9dea4a3eee19}">
<Declaration><![CDATA[{warning disable C0394}
METHOD TestManualButtonRelease
VAR
// valve instance
_fbValve : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// valve config
_stValveConfig : ST_ValveConfig;
// valve interlocks
_wInterlocks : T_INTERLOCK;
_wInterlocksUsed : T_INTERLOCK;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('TestManualButtonRelease');
// Test no release for HMI mode change
_fbValve(
xReleaseManualMode:= FALSE,
wProcessINTLK:= _wInterlocks,
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= _stValveConfig,
xOpenValve=> ,
xCloseValve=> );
AssertFalse(Condition := _stHMIValve.stManualButton.xRelease, Message := 'Manual mode button was released but should not have been');
// Test release for HMI mode change
_fbValve(
xReleaseManualMode:= TRUE,
wProcessINTLK:= _wInterlocks,
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= ,
xOpenValve=> ,
xCloseValve=> );
AssertTrue(Condition := _stHMIValve.stManualButton.xRelease, Message := 'Manual mode button was not released but should have been');
TEST_FINISHED();]]></ST>
</Implementation>
</Method>
<Method Name="TestManualModeButtonOpenClose" Id="{5447550c-d5f0-42c9-bcfd-b2ef662685c8}">
<Declaration><![CDATA[{warning disable C0394}
METHOD TestManualModeButtonOpenClose
VAR
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// valve config
_stValveConfig : ST_ValveConfig;
// valve interlocks
_wInterlocks : T_INTERLOCK;
_wInterlocksUsed : T_INTERLOCK;
// hmi button feedback
_eExpectedOpenButtonFeedback : E_HMI_BUTTON_FEEDBACK;
_eExpectedCloseButtonFeedback : E_HMI_BUTTON_FEEDBACK;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('TestManualModeButtonOpenClose');
// set manual request button on HMI and call valve block
_stHMIValve.stManualButton.xRequest := TRUE;
_fbValveOC(
xReleaseManualMode:= TRUE,
wProcessINTLK:= _wInterlocks,
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= _stValveConfig,
xOpenValve=> ,
xCloseValve=> );
// Valve should now be in manual mode
AssertTrue(Condition := _fbValveOC.IsInManualMode, Message := 'Valve did not change to manual mode pre test');
// Request open from HMI and call valve block
_stHMIValve.stOpenButton.xRequest := TRUE;
_fbValveOC(
xReleaseManualMode:= TRUE,
wProcessINTLK:= _wInterlocks,
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= ,
xOpenValve=> ,
xCloseValve=> );
// test for valve state and HMI feedback
AssertTrue(Condition := _fbValveOC.xOpenValve, Message := 'Valve did not open as requested by hmi button');
AssertFalse(Condition := _stHMIValve.stOpenButton.xRequest, Message := 'Valve did not reset open request');
_eExpectedOpenButtonFeedback := E_HMI_BUTTON_FEEDBACK.ACTIVE;
_eExpectedCloseButtonFeedback := E_HMI_BUTTON_FEEDBACK.NONE;
AssertEquals(Expected := _eExpectedOpenButtonFeedback, Actual := _stHMIValve.stOpenButton.eFeedback, Message := 'Valve did not send correct open button feedback signal while open');
AssertEquals(Expected := _eExpectedCloseButtonFeedback, Actual := _stHMIValve.stCloseButton.eFeedback, Message := 'Valve did not send correct close button feedback signal while open');
// Request close from HMI and call valve block
_stHMIValve.stCloseButton.xRequest := TRUE;
_fbValveOC(
xReleaseManualMode:= TRUE,
wProcessINTLK:= _wInterlocks,
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= ,
xOpenValve=> ,
xCloseValve=> );
// test for valve state and HMI feedback
AssertTrue(Condition := _fbValveOC.xCloseValve, Message := 'Valve did not close as requested by hmi button');
AssertFalse(Condition := _stHMIValve.stCloseButton.xRequest, Message := 'Valve did not reset close request');
_eExpectedOpenButtonFeedback := E_HMI_BUTTON_FEEDBACK.NONE;
_eExpectedCloseButtonFeedback := E_HMI_BUTTON_FEEDBACK.ACTIVE;
AssertEquals(Expected := _eExpectedCloseButtonFeedback, Actual := _stHMIValve.stCloseButton.eFeedback, Message := 'Valve did not send correct close button feedback signal while closed');
AssertEquals(Expected := _eExpectedOpenButtonFeedback, Actual := _stHMIValve.stOpenButton.eFeedback, Message := 'Valve did not send correct open button feedback signal while closed');
TEST_FINISHED();]]></ST>
</Implementation>
</Method>
<Method Name="TestManualModeOpenRelease" Id="{7b7870a1-a0b3-45c8-af76-55d8712c17bf}">
<Declaration><![CDATA[{warning disable C0394}
METHOD TestManualModeOpenRelease
VAR
// valve instance
_fbValve : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// valve config
_stValveConfig : ST_ValveConfig;
END_VAR
VAR CONSTANT
// valve interlocks
wInterlocks : T_INTERLOCK := 0;
wInterlocksUsed : T_INTERLOCK := 1;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('TestManualModeOpenRelease');
// set manual request button on HMI and call valve block
_stHMIValve.stManualButton.xRequest := TRUE;
_fbValve(
xReleaseManualMode:= TRUE,
wProcessINTLK:= wInterlocks,
wProcessINTLKUsed:= wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= _stValveConfig,
xOpenValve=> ,
xCloseValve=> );
// Valve should now be in manual mode
AssertTrue(Condition := _fbValve.IsInManualMode, Message := 'Valve did not change to manual mode pre test');
// Valve should not realease open button with active interlock
AssertFalse(Condition := _stHMIValve.stOpenButton.xRelease, Message := 'Valve did release open button but should not');
// Test if request is denied by valve with active interlocks
_stHMIValve.stOpenButton.xRequest := TRUE;
_fbValve(
xReleaseManualMode:= TRUE,
wProcessINTLK:= wInterlocks,
wProcessINTLKUsed:= wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= ,
xOpenValve=> ,
xCloseValve=> );
AssertFalse(Condition := _fbValve.xOpenValve, Message := 'Valve did not block manual open command with active interlock');
TEST_FINISHED();]]></ST>
</Implementation>
</Method>
</POU>
</TcPlcObject>

77
PLC/POUs/Unittests/ValveTests/FB_ValveTestTimoutClose.TcPOU Normal file
View File

@@ -0,0 +1,77 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<POU Name="FB_ValveTestTimoutClose" Id="{676995cc-e0f8-4711-82b2-410116e6831b}" SpecialFunc="None">
<Declaration><![CDATA[FUNCTION_BLOCK FB_ValveTestTimoutClose EXTENDS TcUnit.FB_TestSuite
VAR
// feedback result
_xOpenFeedback : BOOL := FALSE;
_xCloseFeedback : BOOL := FALSE;
// valve instance
_fbValveTimeout : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// test timings
_fbTimeoutCloseTestTimer : TON := (PT := T#200MS);
_fbDelayFeedbackSignalTimer : TON := (PT := T#50MS);
// test finished
_xTestTimeoutFinished : BOOL;
// current test state
_iState : INT;
// vlave config
_stValveConfig : ST_ValveConfig := (timTimeoutOpen := t#0MS, timTimeoutClose := T#100MS);
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TestClose();]]></ST>
</Implementation>
<Method Name="TestClose" Id="{b2dc7638-d362-4caf-a205-a2aede6d9720}">
<Declaration><![CDATA[METHOD TestClose
VAR_INPUT
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('TestClose');
CASE _iState OF
0:
// request automatic close and start timers
_fbValveTimeout(xAutomaticOpen := FALSE, stHMIInterface := _stHMIValve);
_fbTimeoutCloseTestTimer.IN := TRUE;
_fbDelayFeedbackSignalTimer.IN := TRUE;
_iState := 10;
10:
// set close feedback after 50ms and call valve block
_xOpenFeedback := FALSE;
_xCloseFeedback := _fbValveTimeout.xCloseValve AND _fbDelayFeedbackSignalTimer.Q;
_fbValveTimeout(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
// test timeout after 200ms
IF _fbTimeoutCloseTestTimer.Q THEN
_iState := 20;
_fbDelayFeedbackSignalTimer.IN := FALSE;
_fbTimeoutCloseTestTimer.IN := FALSE;
END_IF
20:
// assert IsClosed and no error
_xTestTimeoutFinished := TRUE;
AssertTrue(Condition := _fbValveTimeout.IsClosed AND NOT _fbValveTimeout.xError, Message := 'Valve threw close timeout error');
END_CASE
// call timer
_fbTimeoutCloseTestTimer();
_fbDelayFeedbackSignalTimer();
IF _xTestTimeoutFinished THEN
TEST_FINISHED();
END_IF]]></ST>
</Implementation>
</Method>
</POU>
</TcPlcObject>

78
PLC/POUs/Unittests/ValveTests/FB_ValveTestTimoutOpen.TcPOU Normal file
View File

@@ -0,0 +1,78 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<POU Name="FB_ValveTestTimoutOpen" Id="{49e1a729-e622-4855-a7d7-67a9f99d1550}" SpecialFunc="None">
<Declaration><![CDATA[FUNCTION_BLOCK FB_ValveTestTimoutOpen EXTENDS TcUnit.FB_TestSuite
VAR
// valve feedback
_xOpenFeedback : BOOL := FALSE;
_xCloseFeedback : BOOL := FALSE;
// valve instance
_fbValveTimeout : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// test timings
_fbTimeoutOpenTestTimer : TON := (PT := T#200MS);
_fbDelayFeedbackSignalTimer : TON := (PT := T#50MS);
// test finished
_xTestTimeoutFinished : BOOL;
// current test state
_iState : INT;
// valve config
_stValveConfig : ST_ValveConfig := (timTimeoutOpen := t#100MS, timTimeoutClose := T#0MS);
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TestOpen();]]></ST>
</Implementation>
<Method Name="TestOpen" Id="{4f96f391-c47b-4572-833e-9be45b3993f5}">
<Declaration><![CDATA[METHOD TestOpen
VAR_INPUT
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('TestOpen');
CASE _iState OF
0:
// request automatic open and start timers
_fbValveTimeout(xAutomaticOpen := TRUE, stHMIInterface := _stHMIValve);
_fbTimeoutOpenTestTimer.IN := TRUE;
_fbDelayFeedbackSignalTimer.IN := TRUE;
_iState := 10;
10:
// set open feedback after 50ms and call valve block
_xOpenFeedback := _fbValveTimeout.xOpenValve AND _fbDelayFeedbackSignalTimer.Q;
_xCloseFeedback := FALSE;
_fbValveTimeout(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
// test timeout after 200ms
IF _fbTimeoutOpenTestTimer.Q THEN
_iState := 20;
_fbDelayFeedbackSignalTimer.IN := FALSE;
_fbTimeoutOpenTestTimer.IN := FALSE;
END_IF
20:
// assert IsOpen and no error
_xTestTimeoutFinished := TRUE;
AssertTrue(Condition := _fbValveTimeout.IsOpen AND NOT _fbValveTimeout.xError, Message := 'Valve threw open timeout error');
END_CASE
// call timer
_fbTimeoutOpenTestTimer();
_fbDelayFeedbackSignalTimer();
IF _xTestTimeoutFinished THEN
TEST_FINISHED();
END_IF]]></ST>
</Implementation>
</Method>
</POU>
</TcPlcObject>

78
PLC/POUs/Unittests/ValveTests/FB_ValveTestTriggerTimoutClose.TcPOU Normal file
View File

@@ -0,0 +1,78 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<POU Name="FB_ValveTestTriggerTimoutClose" Id="{492c2d14-a1aa-412e-b759-1e35a3301e66}" SpecialFunc="None">
<Declaration><![CDATA[FUNCTION_BLOCK FB_ValveTestTriggerTimoutClose EXTENDS TcUnit.FB_TestSuite
VAR
// valve feedback
_xOpenFeedback : BOOL := FALSE;
_xCloseFeedback : BOOL := FALSE;
// valve instance
_fbValveTimeout : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// test timings
_fbTimeoutCloseTestTimer : TON := (PT := T#100MS);
_fbDelayFeedbackSignalTimer : TON := (PT := T#200MS);
// test finished
_xTestTimeoutFinished : BOOL;
// current test state
_iState : INT;
// valve config
_stValveConfig : ST_ValveConfig := (timTimeoutOpen := t#0MS, timTimeoutClose := T#100MS, xHasClosedFeedback := TRUE);
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TestTriggerTimeoutClose();]]></ST>
</Implementation>
<Method Name="TestTriggerTimeoutClose" Id="{cc9351d2-a43b-4e56-9e5b-6d2747045073}">
<Declaration><![CDATA[METHOD TestTriggerTimeoutClose
VAR_INPUT
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('TestTriggerTimeoutClose');
CASE _iState OF
0:
// request automatic close and start timers
_fbValveTimeout(xAutomaticOpen := FALSE, stHMIInterface := _stHMIValve);
_fbTimeoutCloseTestTimer.IN := TRUE;
_fbDelayFeedbackSignalTimer.IN := TRUE;
_iState := 10;
10:
// both feedback false and call valve block
_xOpenFeedback := FALSE;
_xCloseFeedback := FALSE;
_fbValveTimeout(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, xInUnitTestMode := TRUE, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
// test timeout after 200ms
IF _fbTimeoutCloseTestTimer.Q THEN
_iState := 20;
_fbDelayFeedbackSignalTimer.IN := FALSE;
_fbTimeoutCloseTestTimer.IN := FALSE;
END_IF
20:
// assert error
_xTestTimeoutFinished := TRUE;
AssertTrue(Condition := _fbValveTimeout.xError, Message := 'Valve did not throw an close timeout error');
END_CASE
// call timer
_fbTimeoutCloseTestTimer();
_fbDelayFeedbackSignalTimer();
IF _xTestTimeoutFinished THEN
TEST_FINISHED();
END_IF]]></ST>
</Implementation>
</Method>
</POU>
</TcPlcObject>

79
PLC/POUs/Unittests/ValveTests/FB_ValveTestTriggerTimoutOpen.TcPOU Normal file
View File

@@ -0,0 +1,79 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<POU Name="FB_ValveTestTriggerTimoutOpen" Id="{3357d110-5f1d-4d49-b94c-6c4cc8f6b306}" SpecialFunc="None">
<Declaration><![CDATA[FUNCTION_BLOCK FB_ValveTestTriggerTimoutOpen EXTENDS TcUnit.FB_TestSuite
VAR
// valve feedback
_xOpenFeedback : BOOL := FALSE;
_xCloseFeedback : BOOL := FALSE;
// valve instance
_fbValveTimeout : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// test timings
_fbTimeoutOpenTestTimer : TON := (PT := T#100MS);
_fbDelayFeedbackSignalTimer : TON := (PT := T#200MS);
// test finished
_xTestTimeoutFinished : BOOL;
// current test state
_iState : INT;
// valve config
_stValveConfig : ST_ValveConfig := (timTimeoutOpen := t#100MS, timTimeoutClose := T#0MS, xHasOpenFeedback := TRUE);
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TestTriggerTimeoutOpen();]]></ST>
</Implementation>
<Method Name="TestTriggerTimeoutOpen" Id="{2b990579-8e3f-4c9d-9f7f-cb96af520f83}">
<Declaration><![CDATA[METHOD TestTriggerTimeoutOpen
VAR_INPUT
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('TestTriggerTimeoutOpen');
CASE _iState OF
0:
// request automatic open and start timers
_fbValveTimeout(xAutomaticOpen := TRUE, stHMIInterface := _stHMIValve);
_fbTimeoutOpenTestTimer.IN := TRUE;
_fbDelayFeedbackSignalTimer.IN := TRUE;
_fbValveTimeout.xInUnitTestMode := TRUE;
_iState := 10;
10:
// both feedback false and call valve block
_xOpenFeedback := FALSE;
_xCloseFeedback := FALSE;
_fbValveTimeout(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, xInUnitTestMode := TRUE, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
// test timeout after 200ms
IF _fbTimeoutOpenTestTimer.Q THEN
_iState := 20;
_fbDelayFeedbackSignalTimer.IN := FALSE;
_fbTimeoutOpenTestTimer.IN := FALSE;
END_IF
20:
// assert error
_xTestTimeoutFinished := TRUE;
AssertTrue(Condition := _fbValveTimeout.xError, Message := 'Valve did not throw an open timeout error');
END_CASE
// call timer
_fbTimeoutOpenTestTimer();
_fbDelayFeedbackSignalTimer();
IF _xTestTimeoutFinished THEN
TEST_FINISHED();
END_IF]]></ST>
</Implementation>
</Method>
</POU>
</TcPlcObject>

427
PLC/POUs/Unittests/ValveTests/FB_Valve_Test.TcPOU Normal file
View File

@@ -0,0 +1,427 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<POU Name="FB_Valve_Test" Id="{1304864d-3fed-4e82-bcdb-9dc7e4b2a441}" SpecialFunc="None">
<Declaration><![CDATA[FUNCTION_BLOCK FB_Valve_Test EXTENDS TcUnit.FB_TestSuite
VAR
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[// Automatic Mode
SwitchToAutomaticMode();
OpenValveInAutomaticMode();
// Manual Mode
SwitchToManualMode();
OpenValveInManualMode();
// Test interlocks
TestProcessInterlocks();
TestProcessINTLKsInAutomaticMode();
TestProcessINTLKsInManualMode();
// Check feedback signals
CheckOpenCloseFeedbacks();
]]></ST>
</Implementation>
<Method Name="CheckOpenCloseFeedbacks" Id="{a28ac9cc-3e5a-4aec-ae25-5e2418416c2e}">
<Declaration><![CDATA[{warning disable C0394}
METHOD CheckOpenCloseFeedbacks
VAR
// valve instance
_fbValve : FB_Valve('');
// valve config
_stHMIValve : ST_HMI_VALVE_DATA;
_stValveConfig : ST_ValveConfig;
// valve feedback
_xOpenFeedback : BOOL;
_xCloseFeedback : BOOL;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('CheckOpenCloseFeedbacks');
// set timeout to zero and open+close feedback present
_stValveConfig.timTimeoutClose := T#0S;
_stValveConfig.timTimeoutOpen := T#0S;
_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 not closed and not opened
AssertFalse(Condition := _fbValve.IsClosed OR _fbValve.IsOpen, Message := 'Valve should not signal open or closed with no feedback signals');
// 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.stOpenButton.xRequest := TRUE;
_fbValve(stHMIInterface := _stHMIValve);
_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="OpenValveInAutomaticMode" Id="{0b9852fb-7e89-42e5-977d-75ac8ce8f431}">
<Declaration><![CDATA[{warning disable C0394}
METHOD OpenValveInAutomaticMode
VAR
// valve instance
_fbValve : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// valve state
_xResult : BOOL;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('OpenValveInAutomaticMode');
// Set in automatic mode
_fbValve.ReqAutomaticMode();
// Open valve
_fbValve(xAutomaticOpen := TRUE, stHMIInterface := _stHMIValve);
// Needs one cycle to write outputs
_fbValve(stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
// evaluate valve state
_xResult := _fbValve.IsOpen AND NOT _fbValve.IsClosed;
AssertTrue(_xResult, 'Valve did not open in Automatic Mode');
TEST_FINISHED();]]></ST>
</Implementation>
</Method>
<Method Name="OpenValveInManualMode" Id="{ebd3a3ca-f259-4efb-b134-f4d858027ff8}">
<Declaration><![CDATA[{warning disable C0394}
METHOD OpenValveInManualMode
VAR
// valve instance
_fbValve : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// valve state
_xResult : BOOL;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('OpenValveInManualMode');
// Needs one cycle to write outputs
_fbValve.xReleaseManualMode := TRUE;
// Set in manual mode
_fbValve.ReqManualMode();
// Open valve
_stHMIValve.stOpenButton.xRequest := TRUE;
_fbValve(stHMIInterface := _stHMIValve);
_fbValve(stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
// evaluate valve state
_xResult := _fbValve.IsOpen AND NOT _fbValve.IsClosed;
AssertTrue(_xResult, 'Valve did not open in Manual Mode');
TEST_FINISHED();]]></ST>
</Implementation>
</Method>
<Method Name="SwitchToAutomaticMode" Id="{f0347789-26a5-4296-ac7a-3320d7d68b7f}">
<Declaration><![CDATA[{warning disable C0394}
METHOD SwitchToAutomaticMode
VAR
// valve instance
_fbValve : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// valve state
_xResult : BOOL;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('SwitchToAutomaticMode');
// request switch to automatic modes
_fbValve.ReqAutomaticMode();
// call valve and read values
_fbValve(stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
// set result
_xResult := _fbValve.IsInAutomaticMode;
// assert result
AssertTrue(_xResult, 'Valve did not change into Automatic Mode');
TEST_FINISHED();]]></ST>
</Implementation>
</Method>
<Method Name="SwitchToManualMode" Id="{f3a6a0eb-d468-45b4-ae0e-31d573348f7d}">
<Declaration><![CDATA[{warning disable C0394}
METHOD SwitchToManualMode
VAR
// valve instance
_fbValve : FB_Valve('');
// valve state
_xResult : BOOL;
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
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="{a963e3c3-4c6c-44cd-913b-cd94b66ce40c}">
<Declaration><![CDATA[{warning disable C0394}
{attribute 'analysis' := '-81'}
METHOD TestProcessInterlocks
VAR
// valve instance
_fbValve : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_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;
// interlock test result
_axInterlockTestResultFalse : ARRAY[0..GVL_CONFIGS.MAX_INTERLOCKS-1] OF BOOL;
_axInterlockTestResultTrue : ARRAY[0..GVL_CONFIGS.MAX_INTERLOCKS-1] OF BOOL;
// interlock comulated 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 with interlocks and evaluate result
_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="{d6681863-baa6-4f1c-bb6d-7d6ecd0c4518}">
<Declaration><![CDATA[{warning disable C0394}
METHOD TestProcessINTLKsInAutomaticMode
VAR
// valve instance
_fbValve : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// valve interlocks
_wInterlocks : T_INTERLOCK;
_wInterlocksUsed : T_INTERLOCK;
// valve config
_stValveConfig : ST_ValveConfig;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[TEST('TestProcessINTLKsInAutomaticMode');
_wInterlocks.0 := 1;
_wInterlocksUsed.0 := 1;
// Switch to automatic mode
_fbValve.ReqAutomaticMode();
_fbValve(wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve, xInUnitTestMode := TRUE);
// Open valve in automatic mode
_fbValve(xAutomaticOpen := TRUE, stHMIInterface := _stHMIValve);
_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.xOpenValve, Message := 'Valve should not be open with active Interlock');
AssertTrue(Condition := _fbValve.xCloseValve, Message := 'Close output not active with active Interlock');
// Test the same with open valve when interlock active
_stValveConfig.xOpenWhenInterlocksActive := TRUE;
_fbValve(stValveConfig := _stValveConfig, wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve);
// Valve should now be open
AssertTrue(Condition := _fbValve.xOpenValve, Message := 'Valve should be open with active Interlock and inverted config');
AssertFalse(Condition := _fbValve.xCloseValve, Message := 'Close output active with active Interlock and inverted config');
ELSE
AssertTrue(Condition := _fbValve.IsOpen, Message := 'Valve did not open before the test');
END_IF
TEST_FINISHED();]]></ST>
</Implementation>
</Method>
<Method Name="TestProcessINTLKsInManualMode" Id="{24ef6949-9116-427c-aa82-83ed6d197c5c}">
<Declaration><![CDATA[{warning disable C0394}
METHOD TestProcessINTLKsInManualMode
VAR
// valve instance
_fbValve : FB_Valve('');
// valve hmi data
_stHMIValve : ST_HMI_VALVE_DATA;
// valve interlocks
_wInterlocks : T_INTERLOCK;
_wInterlocksUsed : T_INTERLOCK;
// valve config
_stValveConfig : ST_ValveConfig;
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.stOpenButton.xRequest := TRUE;
_fbValve(stHMIInterface := _stHMIValve);
_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.xOpenValve, Message := 'Valve should not be open with active Interlock');
AssertTrue(Condition := _fbValve.xCloseValve, Message := 'Close output not active with active Interlock');
// Test the same with open valve when interlock active
_stValveConfig.xOpenWhenInterlocksActive := TRUE;
_fbValve(stValveConfig := _stValveConfig, wProcessINTLK := _wInterlocks, wProcessINTLKUsed := _wInterlocksUsed, stHMIInterface := _stHMIValve);
// Valve should now be open
AssertTrue(Condition := _fbValve.xOpenValve, Message := 'Valve should be open with active Interlock and inverted config');
AssertFalse(Condition := _fbValve.xCloseValve, Message := 'Close output active with active Interlock and inverted config');
AssertTrue(Condition := _stHMIValve.stOpenButton.eFeedback = E_HMI_BUTTON_FEEDBACK.ACTIVE, Message := 'Open button should be set active with active Interlock and inverted config');
ELSE
AssertTrue(Condition := _fbValve.IsOpen, Message := 'Valve did not open before the test');
END_IF
TEST_FINISHED();]]></ST>
</Implementation>
</Method>
</POU>
</TcPlcObject>