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

Changed all components to use HAL structs as in and outs

Browse Source 
- All components now use HAL structs as inputs and outputs
- Restructured library folders
- FB_Axis_PTP now implements the execute pattern with E_CmdResult
- Bumped version number to 2.0.0
This commit is contained in:
Matthias Heisig
2026-03-19 12:17:10 +01:00
parent 326ee2c0d0
commit cf9501ea01
64 changed files with 573 additions and 837 deletions
Download Patch File Download Diff File Expand all files Collapse all files

350
BaseComponents.tsproj
View File

@@ -136,357 +136,9 @@
</System>
<Plc>
<Project GUID="{4E62D9E7-436C-457D-8DC4-82D2FEF91C96}" Name="BasicComponents" PrjFilePath="BasicComponents\BasicComponents.plcproj" TmcFilePath="BasicComponents\BasicComponents.tmc" ReloadTmc="true" AmsPort="851" FileArchiveSettings="#x000e" CopyTmcToTarget="true" CopyTpyToTarget="false" SymbolicMapping="true">
<Instance Id="#x08502000" TcSmClass="TComPlcObjDef" KeepUnrestoredLinks="2" TmcHash="{CC57F9F8-FD4D-8A3D-E8DE-220E6C379AE4}" TmcPath="BasicComponents\BasicComponents.tmc">
<Instance Id="#x08502000" TcSmClass="TComPlcObjDef" KeepUnrestoredLinks="2" TmcHash="{864A6F78-5663-9977-8C53-B90BFD312EA0}" TmcPath="BasicComponents\BasicComponents.tmc">
<Name>BasicComponents Instance</Name>
<CLSID ClassFactory="TcPlc30">{08500001-0000-0000-F000-000000000064}</CLSID>
<Vars VarGrpType="1">
<Name>PlcTask Inputs</Name>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorLowOn.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorLowOn.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorLowOn.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorLowOn.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningLowOn.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningLowOn.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningLowOn.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningLowOn.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningHighOn.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningHighOn.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningHighOn.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningHighOn.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorHighOn.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorHighOn.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorHighOn.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorHighOn.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIOverrangeOn.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIOverrangeOn.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIOverrangeOn.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIOverrangeOn.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIUnderrangeOn.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIUnderrangeOn.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIUnderrangeOn.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIUnderrangeOn.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorLowOff.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorLowOff.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorLowOff.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorLowOff.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningLowOff.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningLowOff.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningLowOff.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningLowOff.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningHighOff.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningHighOff.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningHighOff.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIWarningHighOff.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorHighOff.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorHighOff.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorHighOff.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIErrorHighOff.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIUnderrangeOff.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIUnderrangeOff.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIUnderrangeOff.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIUnderrangeOff.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIOverrangeOff.iAnalogValue</Name>
<Comment><![CDATA[ Analog input value]]></Comment>
<Type>INT</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIOverrangeOff.xUnderrange</Name>
<Comment><![CDATA[ Card has detected an open circuit]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIOverrangeOff.xOverrange</Name>
<Comment><![CDATA[ Input is overloaded]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbAnalogInputTest._fbAIOverrangeOff.xErrorCard</Name>
<Comment><![CDATA[ Input card has error
EL30xx also sets this if an underrange or overrange error is present]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimeoutTestOpen._fbValveTimeout.xOpenFeedback</Name>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimeoutTestOpen._fbValveTimeout.xCloseFeedback</Name>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimeoutTestClose._fbValveTimeout.xOpenFeedback</Name>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimeoutTestClose._fbValveTimeout.xCloseFeedback</Name>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimoutTriggerOpen._fbValveTimeout.xOpenFeedback</Name>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimoutTriggerOpen._fbValveTimeout.xCloseFeedback</Name>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimoutTriggerClose._fbValveTimeout.xOpenFeedback</Name>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimoutTriggerClose._fbValveTimeout.xCloseFeedback</Name>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValveTestHMI._fbValveOC.xOpenFeedback</Name>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValveTestHMI._fbValveOC.xCloseFeedback</Name>
<Type>BOOL</Type>
</Var>
</Vars>
<Vars VarGrpType="2" AreaNo="1">
<Name>PlcTask Outputs</Name>
<Var>
<Name>PRG_MAIN._fbValve_TimeoutTestOpen._fbValveTimeout.xOpenValve</Name>
<Comment><![CDATA[ Use xOpenValve for normally closed valves]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimeoutTestOpen._fbValveTimeout.xCloseValve</Name>
<Comment><![CDATA[ Use xCloseValve for normally open valves]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimeoutTestClose._fbValveTimeout.xOpenValve</Name>
<Comment><![CDATA[ Use xOpenValve for normally closed valves]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimeoutTestClose._fbValveTimeout.xCloseValve</Name>
<Comment><![CDATA[ Use xCloseValve for normally open valves]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimoutTriggerOpen._fbValveTimeout.xOpenValve</Name>
<Comment><![CDATA[ Use xOpenValve for normally closed valves]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimoutTriggerOpen._fbValveTimeout.xCloseValve</Name>
<Comment><![CDATA[ Use xCloseValve for normally open valves]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimoutTriggerClose._fbValveTimeout.xOpenValve</Name>
<Comment><![CDATA[ Use xOpenValve for normally closed valves]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValve_TimoutTriggerClose._fbValveTimeout.xCloseValve</Name>
<Comment><![CDATA[ Use xCloseValve for normally open valves]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValveTestHMI._fbValveOC.xOpenValve</Name>
<Comment><![CDATA[ Use xOpenValve for normally closed valves]]></Comment>
<Type>BOOL</Type>
</Var>
<Var>
<Name>PRG_MAIN._fbValveTestHMI._fbValveOC.xCloseValve</Name>
<Comment><![CDATA[ Use xCloseValve for normally open valves]]></Comment>
<Type>BOOL</Type>
</Var>
</Vars>
<Contexts>
<Context>
<Id>0</Id>

BIN
BasicComponents.library
View File

Binary file not shown.

381
BasicComponents/BasicComponents.plcproj
View File

@@ -21,7 +21,7 @@
<GlobalVersionStructureIncluded>false</GlobalVersionStructureIncluded>
<Company>Heisig GmbH</Company>
<Title>BaseComponents</Title>
<ProjectVersion>1.3.4</ProjectVersion>
<ProjectVersion>2.0.0</ProjectVersion>
<DefaultNamespace>BC</DefaultNamespace>
<Author>M.Heisig</Author>
<Description>Basic components fb's (Valves, AI, AO, Motors, etc.)</Description>
@@ -45,218 +45,231 @@
</SelectedLibraryCategories>
</PropertyGroup>
<ItemGroup>
<Compile Include="Components\Analog\DUTs\ST_AnalogInput_IO.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Analog\DUTs\ST_AnalogOutput_IO.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Analog\DUTs\ST_ANALOG_EW_CONFIG.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Analog\DUTs\ST_ANALOG_EW_DELAYS.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Analog\DUTs\ST_ANALOG_EW_LEVELS.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Analog\DUTs\ST_ANALOG_IO_CONFIG.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Analog\POUs\FB_AnalogInput.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Analog\POUs\FB_AnalogOutput.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\AxisPTP\DUTs\E_AXIS_PTP_STATE.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\AxisPTP\DUTs\ST_AxisPTP_IO.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\AxisPTP\POUs\FB_AxisPTP.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Controller\POUs\FB_Limit.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Controller\POUs\FB_PI.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Controller\POUs\FB_PID.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Controller\POUs\FB_RampGenerator.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\EventListener\DUTs\E_EventType.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\EventListener\DUTs\ST_BufferEventEntry.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\EventListener\POUs\FB_EventListener.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Motor\FB_MotorBecker.TcPOU">
<SubType>Code</SubType>
<ExcludeFromBuild>true</ExcludeFromBuild>
</Compile>
<Compile Include="Components\Motor\Types\ST_MOTOR_BECKER_CONFIG.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Utilities\FB_AlarmMessage.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Utilities\FB_Blinker.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Utilities\FB_ReleaseSignal.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Utilities\FC_HashFNV1a_32Bit.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Utilities\F_GetTaskCycleTime.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Valves\DUTs\ST_ValveAnalogConfig.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Valves\DUTs\ST_ValveAnalog_IO.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Valves\DUTs\ST_ValveConfig.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Valves\DUTs\ST_Valve_IO.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Valves\POUs\FB_Valve.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="Components\Valves\POUs\FB_ValveAnalog.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="DUTs\E_CmdResult.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="GVLs\GVL_CONFIGS.TcGVL">
<SubType>Code</SubType>
<LinkAlways>true</LinkAlways>
</Compile>
<Compile Include="GVLs\GVL_TYPE_CONST.TcGVL">
<SubType>Code</SubType>
<LinkAlways>true</LinkAlways>
</Compile>
<Compile Include="HMI\Datentypen\ST_HMI_ANALOG_MOTOR_DATA.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Datentypen\ST_HMI_ANALOG_VALUE.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Datentypen\ST_HMI_ANALOG_VALVE_DATA.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Datentypen\ST_HMI_CONTROL_BUTTON.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Datentypen\ST_HMI_INTEGER_VALUE.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Datentypen\ST_HMI_INTERLOCK.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Datentypen\ST_HMI_VALVE_DATA.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Datentypen\T_INTERLOCK.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Enum\E_HMI_ANALOG_VALUE_STATUS.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Enum\E_HMI_BUTTON_FEEDBACK.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Enum\E_HMI_MODE.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Enum\E_HMI_MOTOR_STATUS.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="HMI\Enum\E_HMI_VALVE_STATUS.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="PlcTask.TcTTO">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Analog\FB_AnalogInput.TcPOU">
<Compile Include="PRG_MAIN.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Analog\FB_AnalogOutput.TcPOU">
<Compile Include="Unittests\AITests\FB_AnalogInputTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Analog\Types\ST_ANALOG_EW_CONFIG.TcDUT">
<Compile Include="Unittests\AnalogValveTests\FB_ValveAnalog_Test.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Analog\Types\ST_ANALOG_EW_DELAYS.TcDUT">
<Compile Include="Unittests\AOTests\FB_AnalogOutputTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Analog\Types\ST_ANALOG_EW_LEVELS.TcDUT">
<Compile Include="Unittests\ReleaseSignalTests\FB_ReleaseSignalTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Analog\Types\ST_ANALOG_IO_CONFIG.TcDUT">
<Compile Include="Unittests\UtilitiesTests\FB_BlinkerTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\AxisPTP\E_AXIS_PTP_STATE.TcDUT">
<Compile Include="Unittests\UtilitiesTests\FB_HashFNV1a_32BitTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\AxisPTP\FB_AxisPTP.TcPOU">
<Compile Include="Unittests\UtilitiesTests\FB_PT1Test.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\AxisPTP\ST_AxisPTP_IO.TcDUT">
<Compile Include="Unittests\UtilitiesTests\FB_RampGeneratorTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Controller\FB_Limit.TcPOU">
<Compile Include="Unittests\ValveTests\FB_ValveTestHMI.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Controller\FB_PI.TcPOU">
<Compile Include="Unittests\ValveTests\FB_ValveTestTimoutClose.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Controller\FB_PID.TcPOU">
<Compile Include="Unittests\ValveTests\FB_ValveTestTimoutOpen.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Controller\FB_RampGenerator.TcPOU">
<Compile Include="Unittests\ValveTests\FB_ValveTestTriggerTimoutClose.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\EventListener\FB_EventListener.TcPOU">
<Compile Include="Unittests\ValveTests\FB_ValveTestTriggerTimoutOpen.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\EventListener\Types\E_EventType.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\EventListener\Types\ST_BufferEventEntry.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Motor\FB_MotorBecker.TcPOU">
<SubType>Code</SubType>
<ExcludeFromBuild>true</ExcludeFromBuild>
</Compile>
<Compile Include="POUs\Components\Motor\Types\ST_MOTOR_BECKER_CONFIG.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Utilities\FB_AlarmMessage.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Utilities\FB_Blinker.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Utilities\FB_ReleaseSignal.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Utilities\FC_HashFNV1a_32Bit.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Utilities\F_GetTaskCycleTime.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Valves\FB_Valve.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Valves\FB_ValveAnalog.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Valves\Types\ST_ValveAnalogConfig.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Components\Valves\Types\ST_ValveConfig.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Constants\GVL_TYPE_CONST.TcGVL">
<SubType>Code</SubType>
<LinkAlways>true</LinkAlways>
</Compile>
<Compile Include="POUs\GVL\GVL_CONFIGS.TcGVL">
<SubType>Code</SubType>
<LinkAlways>true</LinkAlways>
</Compile>
<Compile Include="POUs\HMI\Datentypen\ST_HMI_ANALOG_MOTOR_DATA.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Datentypen\ST_HMI_ANALOG_VALUE.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Datentypen\ST_HMI_ANALOG_VALVE_DATA.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Datentypen\ST_HMI_CONTROL_BUTTON.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Datentypen\ST_HMI_INTEGER_VALUE.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Datentypen\ST_HMI_INTERLOCK.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Datentypen\ST_HMI_VALVE_DATA.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Datentypen\T_INTERLOCK.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Enum\E_HMI_ANALOG_VALUE_STATUS.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Enum\E_HMI_BUTTON_FEEDBACK.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Enum\E_HMI_MODE.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Enum\E_HMI_MOTOR_STATUS.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\HMI\Enum\E_HMI_VALVE_STATUS.TcDUT">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\PRG_MAIN.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\AITests\FB_AnalogInputTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\AnalogValveTests\FB_ValveAnalog_Test.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\AOTests\FB_AnalogOutputTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\ReleaseSignalTests\FB_ReleaseSignalTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\UtilitiesTests\FB_BlinkerTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\UtilitiesTests\FB_HashFNV1a_32BitTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\UtilitiesTests\FB_PT1Test.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\UtilitiesTests\FB_RampGeneratorTest.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\ValveTests\FB_ValveTestHMI.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\ValveTests\FB_ValveTestTimoutClose.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\ValveTests\FB_ValveTestTimoutOpen.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\ValveTests\FB_ValveTestTriggerTimoutClose.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\ValveTests\FB_ValveTestTriggerTimoutOpen.TcPOU">
<SubType>Code</SubType>
</Compile>
<Compile Include="POUs\Unittests\ValveTests\FB_Valve_Test.TcPOU">
<Compile Include="Unittests\ValveTests\FB_Valve_Test.TcPOU">
<SubType>Code</SubType>
</Compile>
</ItemGroup>
<ItemGroup>
<Folder Include="Components" />
<Folder Include="Components\Analog" />
<Folder Include="Components\Analog\DUTs" />
<Folder Include="Components\Analog\POUs" />
<Folder Include="Components\AxisPTP" />
<Folder Include="Components\AxisPTP\DUTs" />
<Folder Include="Components\AxisPTP\POUs" />
<Folder Include="Components\Controller" />
<Folder Include="Components\Controller\POUs" />
<Folder Include="Components\EventListener" />
<Folder Include="Components\EventListener\DUTs" />
<Folder Include="Components\EventListener\POUs" />
<Folder Include="Components\Motor" />
<Folder Include="Components\Motor\Types" />
<Folder Include="Components\Utilities" />
<Folder Include="Components\Valves" />
<Folder Include="Components\Valves\DUTs" />
<Folder Include="Components\Valves\POUs" />
<Folder Include="DUTs" />
<Folder Include="GVLs" />
<Folder Include="POUs\Components\Analog" />
<Folder Include="POUs\Components\Analog\Types" />
<Folder Include="POUs\Components\AxisPTP" />
<Folder Include="POUs\Components\EventListener" />
<Folder Include="POUs\Components\EventListener\Types" />
<Folder Include="POUs\Components\Motor">
<ExcludeFromBuild>true</ExcludeFromBuild>
</Folder>
<Folder Include="POUs\Components\Motor\Types" />
<Folder Include="POUs\Components\Controller" />
<Folder Include="POUs\Components\Utilities" />
<Folder Include="POUs\Components\Valves" />
<Folder Include="POUs\Components\Valves\Types" />
<Folder Include="POUs\Constants" />
<Folder Include="POUs\HMI" />
<Folder Include="POUs\HMI\Datentypen" />
<Folder Include="POUs\HMI\Enum" />
<Folder Include="POUs\GVL" />
<Folder Include="POUs\Components" />
<Folder Include="POUs\Unittests\AnalogValveTests" />
<Folder Include="POUs\Unittests\ReleaseSignalTests" />
<Folder Include="POUs\Unittests\UtilitiesTests" />
<Folder Include="POUs\Unittests\ValveTests" />
<Folder Include="POUs\Unittests" />
<Folder Include="POUs\Unittests\AITests" />
<Folder Include="POUs\Unittests\AOTests" />
<Folder Include="HMI" />
<Folder Include="HMI\Datentypen" />
<Folder Include="HMI\Enum" />
<Folder Include="Unittests" />
<Folder Include="Unittests\AITests" />
<Folder Include="Unittests\AnalogValveTests" />
<Folder Include="Unittests\AOTests" />
<Folder Include="Unittests\ReleaseSignalTests" />
<Folder Include="Unittests\UtilitiesTests" />
<Folder Include="Unittests\ValveTests" />
<Folder Include="VISUs" />
<Folder Include="POUs" />
</ItemGroup>
<ItemGroup>
<PlaceholderReference Include="Tc2_MC2">
@@ -310,8 +323,8 @@
<ProjectExtensions>
<PlcProjectOptions>
<XmlArchive>
<Data>
<o xml:space="preserve" t="OptionKey">
<Data>
<o xml:space="preserve" t="OptionKey">
<v n="Name">"&lt;ProjectRoot&gt;"</v>
<d n="SubKeys" t="Hashtable" ckt="String" cvt="OptionKey">
<v>{192FAD59-8248-4824-A8DE-9177C94C195A}</v>
@@ -2692,16 +2705,16 @@
</d>
<d n="Values" t="Hashtable" />
</o>
</Data>
<TypeList>
<Type n="Boolean">System.Boolean</Type>
<Type n="Hashtable">System.Collections.Hashtable</Type>
<Type n="Int32">System.Int32</Type>
<Type n="OptionKey">{54dd0eac-a6d8-46f2-8c27-2f43c7e49861}</Type>
<Type n="String">System.String</Type>
<Type n="UInt32">System.UInt32</Type>
</TypeList>
</XmlArchive>
</Data>
<TypeList>
<Type n="Boolean">System.Boolean</Type>
<Type n="Hashtable">System.Collections.Hashtable</Type>
<Type n="Int32">System.Int32</Type>
<Type n="OptionKey">{54dd0eac-a6d8-46f2-8c27-2f43c7e49861}</Type>
<Type n="String">System.String</Type>
<Type n="UInt32">System.UInt32</Type>
</TypeList>
</XmlArchive>
</PlcProjectOptions>
</ProjectExtensions>
</Project>

0
BasicComponents/POUs/Components/Analog/Types/ST_ANALOG_EW_CONFIG.TcDUT → BasicComponents/Components/Analog/DUTs/ST_ANALOG_EW_CONFIG.TcDUT
View File

0
BasicComponents/POUs/Components/Analog/Types/ST_ANALOG_EW_DELAYS.TcDUT → BasicComponents/Components/Analog/DUTs/ST_ANALOG_EW_DELAYS.TcDUT
View File

0
BasicComponents/POUs/Components/Analog/Types/ST_ANALOG_EW_LEVELS.TcDUT → BasicComponents/Components/Analog/DUTs/ST_ANALOG_EW_LEVELS.TcDUT
View File

0
BasicComponents/POUs/Components/Analog/Types/ST_ANALOG_IO_CONFIG.TcDUT → BasicComponents/Components/Analog/DUTs/ST_ANALOG_IO_CONFIG.TcDUT
View File

22
BasicComponents/Components/Analog/DUTs/ST_AnalogInput_IO.TcDUT Normal file
View File

@@ -0,0 +1,22 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<DUT Name="ST_AnalogInput_IO" Id="{e5e1217a-3b79-46bd-82c2-c2132f6c3fab}">
<Declaration><![CDATA[TYPE ST_AnalogInput_IO :
STRUCT
// Analog input value
i_iAnalogValue AT %I* : INT;
// Card has detected an open circuit
i_xUnderrange AT%I* : BOOL;
// Input is overloaded
i_xOverrange AT %I* : BOOL;
// Input card has error
// EL30xx also sets this if an underrange or overrange error is present
i_xErrorCard AT %I* : BOOL;
END_STRUCT
END_TYPE
]]></Declaration>
</DUT>
</TcPlcObject>

11
BasicComponents/Components/Analog/DUTs/ST_AnalogOutput_IO.TcDUT Normal file
View File

@@ -0,0 +1,11 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<DUT Name="ST_AnalogOutput_IO" Id="{1ae956eb-64b1-49ce-81a6-21db6ca74bc0}">
<Declaration><![CDATA[TYPE ST_AnalogOutput_IO :
STRUCT
o_iAnalogValue AT %Q* : INT;
END_STRUCT
END_TYPE
]]></Declaration>
</DUT>
</TcPlcObject>

24
BasicComponents/POUs/Components/Analog/FB_AnalogInput.TcPOU → BasicComponents/Components/Analog/POUs/FB_AnalogInput.TcPOU
View File

@@ -3,19 +3,6 @@
<POU Name="FB_AnalogInput" Id="{532e1013-5a2e-43c7-8863-3ad112d7d7e8}" SpecialFunc="None">
<Declaration><![CDATA[FUNCTION_BLOCK FINAL FB_AnalogInput
VAR_INPUT
// Analog input value
iAnalogValue AT %I* : INT;
// Card has detected an open circuit
xUnderrange AT%I* : BOOL;
// Input is overloaded
xOverrange AT %I* : BOOL;
// Input card has error
// EL30xx also sets this if an underrange or overrange error is present
xErrorCard AT %I* : BOOL;
// IO config data
stAnalogIOConfig : ST_ANALOG_IO_CONFIG;
@@ -64,6 +51,9 @@ VAR_OUTPUT
//High level error
xErrorHigh : BOOL;
END_VAR
VAR_IN_OUT
stIO : ST_AnalogInput_IO;
END_VAR
VAR
// Scaling factor for conversion
_rConversionFactor : REAL;
@@ -210,7 +200,7 @@ END_IF
// ========================
// Clamp analogue input levels
_iClampedAnalogValue := MAX(_iAIMin, iAnalogValue);
_iClampedAnalogValue := MAX(_iAIMin, stIO.i_iAnalogValue);
_iClampedAnalogValue := MIN(_iAIMax, _iClampedAnalogValue);
// Calc scaled value
@@ -222,7 +212,7 @@ _rScaledValue := _iClampedAnalogValue * _rConversionFactor + _rBaseOffset;
// =========================
_fbAlarmUnderrange(
xActive:= xUnderrange,
xActive:= stIO.i_xUnderrange,
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseHardwareErrors,
xAcknowledge:= xConfirmAlarms,
timOnDelay:= stAnalogEWConfig.stDelays.timHardwareSignalLevelOn,
@@ -240,7 +230,7 @@ END_IF
// =========================
_fbAlarmOverload(
xActive:= xOverrange,
xActive:= stIO.i_xOverrange,
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseHardwareErrors,
xAcknowledge:= xConfirmAlarms,
timOnDelay:= stAnalogEWConfig.stDelays.timHardwareSignalLevelOn,
@@ -261,7 +251,7 @@ END_IF
// EL30xx also sets this if an underrange or overrange error is present,
// so we filter this out
_fbAlarmCardError(
xActive:= xErrorCard AND (NOT xUnderrange) AND (NOT xOverrange),
xActive:= stIO.i_xErrorCard AND (NOT stIO.i_xUnderrange) AND (NOT stIO.i_xOverrange),
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseHardwareErrors,
xAcknowledge:= xConfirmAlarms,
timOnDelay:= stAnalogEWConfig.stDelays.timHardwareSignalLevelOn,

7
BasicComponents/POUs/Components/Analog/FB_AnalogOutput.TcPOU → BasicComponents/Components/Analog/POUs/FB_AnalogOutput.TcPOU
View File

@@ -21,12 +21,13 @@ VAR_INPUT
xInUnitTestMode : BOOL := FALSE;
END_VAR
VAR_OUTPUT
iAnalogValue AT %Q* : INT;
// Error in function block
xError : BOOL;
END_VAR
VAR_IN_OUT
// IO
stIO : ST_AnalogOutput_IO;
// HMI Interface
stHMIInterface : ST_HMI_ANALOG_VALUE;
END_VAR
@@ -117,7 +118,7 @@ _rSetpointInternal := MIN(_rSetpointInternal, _rPVMax);
// Calc scaled value
_rTempAnalogValue := _rSetpointInternal * _rConversionFactor + _rBaseOffset;
iAnalogValue := REAL_TO_INT(_rTempAnalogValue);
stIO.o_iAnalogValue := REAL_TO_INT(_rTempAnalogValue);
// ====================

1
BasicComponents/POUs/Components/AxisPTP/E_AXIS_PTP_STATE.TcDUT → BasicComponents/Components/AxisPTP/DUTs/E_AXIS_PTP_STATE.TcDUT
View File

@@ -19,6 +19,7 @@ TYPE E_AXIS_PTP_STATE :
WAIT_MOVING_RELATIVE,
START_MOVING_VELOCITY,
WAIT_MOVING_VELOCITY,
MOVING_VELO,
START_MOVING_MODULO,
WAIT_MOVING_MODULO,
START_HALTING,

0
BasicComponents/POUs/Components/AxisPTP/ST_AxisPTP_IO.TcDUT → BasicComponents/Components/AxisPTP/DUTs/ST_AxisPTP_IO.TcDUT
View File

101
BasicComponents/POUs/Components/AxisPTP/FB_AxisPTP.TcPOU → BasicComponents/Components/AxisPTP/POUs/FB_AxisPTP.TcPOU
View File

@@ -242,9 +242,7 @@ CASE _eState OF
E_AXIS_PTP_STATE.WAIT_MOVING_VELOCITY:
IF _fbMoveVelocity.Busy THEN
_fbMoveVelocity.Execute := FALSE;
xBusy := FALSE;
xDone := TRUE;
_eState := E_AXIS_PTP_STATE.IDLE;
_eState := E_AXIS_PTP_STATE.MOVING_VELO;
END_IF
IF _fbMoveVelocity.Error THEN
@@ -252,75 +250,100 @@ CASE _eState OF
_eState := E_AXIS_PTP_STATE.ENTER_ERROR;
END_IF
E_AXIS_PTP_STATE.MOVING_VELO:
IF _fbMoveVelocity.Error THEN
_eState := E_AXIS_PTP_STATE.ENTER_ERROR;
END_IF
E_AXIS_PTP_STATE.MOVING_MODULO:
// =============
// Move modulo
// =============
E_AXIS_PTP_STATE.START_MOVING_MODULO:
_fbMoveModulo.Execute := TRUE;
_eState := E_AXIS_PTP_STATE.WAIT_MOVING_MODULO;
E_AXIS_PTP_STATE.WAIT_MOVING_MODULO:
IF _fbMoveModulo.Done THEN
_xStartMoveModulo := FALSE;
_xBusy := FALSE;
_xDone := TRUE;
_eState := E_AXIS_PTP_STATE.ENABLED;
_fbMoveModulo.Execute := FALSE;
xBusy := FALSE;
xDone := TRUE;
_eState := E_AXIS_PTP_STATE.IDLE;
END_IF
IF _xExecuteHalt THEN
_xExecuteHalt := FALSE;
_xStartMoveModulo := FALSE;
_xHalt := TRUE;
_eState := E_AXIS_PTP_STATE.HALTING;
IF _fbMoveModulo.Error THEN
_fbMoveModulo.Execute := FALSE;
_eState := E_AXIS_PTP_STATE.ENTER_ERROR;
END_IF
IF _xError THEN
_xStartMoveModulo := FALSE;
// =======
// Halting
// =======
E_AXIS_PTP_STATE.START_HALTING:
_fbHalt.Execute := TRUE;
_eState := E_AXIS_PTP_STATE.WAIT_HALTING;
E_AXIS_PTP_STATE.WAIT_HALTING:
IF _fbHalt.Done THEN
_fbHalt.Execute := FALSE;
xBusy := FALSE;
xDone := TRUE;
_eState := E_AXIS_PTP_STATE.IDLE;
END_IF
IF _fbHalt.Error THEN
_fbHalt.Execute := FALSE;
_eState := E_AXIS_PTP_STATE.ENTER_ERROR;
END_IF
E_AXIS_PTP_STATE.HALTING:
IF (NOT _fbHalt.Busy) AND (NOT _xError) THEN
_xHalt := FALSE;
_xBusy := FALSE;
_xDone := TRUE;
_eState := E_AXIS_PTP_STATE.ENABLED;
// ==========
// Disableing
// ==========
E_AXIS_PTP_STATE.START_DISABLE:
_fbPower.Enable := FALSE;
_eState := E_AXIS_PTP_STATE.WAIT_DISABLE;
E_AXIS_PTP_STATE.WAIT_DISABLE:
IF (NOT _fbPower.Status) THEN
xBusy := FALSE;
xDone := TRUE;
_eState := E_AXIS_PTP_STATE.IDLE;
END_IF
IF _xError THEN
IF _fbPower.Error THEN
_eState := E_AXIS_PTP_STATE.ENTER_ERROR;
END_IF
E_AXIS_PTP_STATE.WAIT_FOR_DISABLE:
IF (NOT _fbPower.Status) AND (NOT _xError) THEN
_xBusy := FALSE;
_xDone := TRUE;
_eState := E_AXIS_PTP_STATE.OFF;
END_IF
IF _xError THEN
_eState := E_AXIS_PTP_STATE.ENTER_ERROR;
END_IF
// =====
// Error
// =====
E_AXIS_PTP_STATE.ENTER_ERROR:
xError := TRUE;
xBusy := FALSE;
xDone := FALSE;
_eState := E_AXIS_PTP_STATE.ERROR;
E_AXIS_PTP_STATE.ERROR:
IF xConfirmAlarms THEN
_xReset := TRUE;
_fbReset.Execute := TRUE;
_eState := E_AXIS_PTP_STATE.RESET;
END_IF
E_AXIS_PTP_STATE.RESET:
IF _fbReset.Done THEN
_xReset := FALSE;
_eState := E_AXIS_PTP_STATE.OFF;
_fbReset.Execute := FALSE;
_eState := E_AXIS_PTP_STATE.IDLE;
END_IF
IF _fbReset.Error THEN
_fbReset.Execute := FALSE;
_eState := E_AXIS_PTP_STATE.ENTER_ERROR;
END_IF
ELSE
_eState := E_AXIS_PTP_STATE.ERROR;
_eState := E_AXIS_PTP_STATE.ENTER_ERROR;
END_CASE

0
BasicComponents/POUs/Components/Controller/FB_Limit.TcPOU → BasicComponents/Components/Controller/POUs/FB_Limit.TcPOU
View File

0
BasicComponents/POUs/Components/Controller/FB_PI.TcPOU → BasicComponents/Components/Controller/POUs/FB_PI.TcPOU
View File

0
BasicComponents/POUs/Components/Controller/FB_PID.TcPOU → BasicComponents/Components/Controller/POUs/FB_PID.TcPOU
View File

0
BasicComponents/POUs/Components/Controller/FB_RampGenerator.TcPOU → BasicComponents/Components/Controller/POUs/FB_RampGenerator.TcPOU
View File

0
BasicComponents/POUs/Components/EventListener/Types/E_EventType.TcDUT → BasicComponents/Components/EventListener/DUTs/E_EventType.TcDUT
View File

0
BasicComponents/POUs/Components/EventListener/Types/ST_BufferEventEntry.TcDUT → BasicComponents/Components/EventListener/DUTs/ST_BufferEventEntry.TcDUT
View File

0
BasicComponents/POUs/Components/EventListener/FB_EventListener.TcPOU → BasicComponents/Components/EventListener/POUs/FB_EventListener.TcPOU
View File

0
BasicComponents/POUs/Components/Motor/FB_MotorBecker.TcPOU → BasicComponents/Components/Motor/FB_MotorBecker.TcPOU
View File

0
BasicComponents/POUs/Components/Motor/Types/ST_MOTOR_BECKER_CONFIG.TcDUT → BasicComponents/Components/Motor/Types/ST_MOTOR_BECKER_CONFIG.TcDUT
View File

0
BasicComponents/POUs/Components/Utilities/FB_AlarmMessage.TcPOU → BasicComponents/Components/Utilities/FB_AlarmMessage.TcPOU
View File

0
BasicComponents/POUs/Components/Utilities/FB_Blinker.TcPOU → BasicComponents/Components/Utilities/FB_Blinker.TcPOU
View File

0
BasicComponents/POUs/Components/Utilities/FB_ReleaseSignal.TcPOU → BasicComponents/Components/Utilities/FB_ReleaseSignal.TcPOU
View File

0
BasicComponents/POUs/Components/Utilities/FC_HashFNV1a_32Bit.TcPOU → BasicComponents/Components/Utilities/FC_HashFNV1a_32Bit.TcPOU
View File

0
BasicComponents/POUs/Components/Utilities/F_GetTaskCycleTime.TcPOU → BasicComponents/Components/Utilities/F_GetTaskCycleTime.TcPOU
View File

0
BasicComponents/POUs/Components/Valves/Types/ST_ValveAnalogConfig.TcDUT → BasicComponents/Components/Valves/DUTs/ST_ValveAnalogConfig.TcDUT
View File

16
BasicComponents/Components/Valves/DUTs/ST_ValveAnalog_IO.TcDUT Normal file
View File

@@ -0,0 +1,16 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<DUT Name="ST_ValveAnalog_IO" Id="{f148b3f6-7dc4-47f9-ae19-f3b88577c5b3}">
<Declaration><![CDATA[TYPE ST_ValveAnalog_IO :
STRUCT
stAnalogInputIO : ST_AnalogInput_IO;
i_xOpenFeedback AT %I* : BOOL;
i_xCloseFeedback AT %I* : BOOL;
stAnalogOutputIO : ST_AnalogOutput_IO;
END_STRUCT
END_TYPE
]]></Declaration>
</DUT>
</TcPlcObject>

0
BasicComponents/POUs/Components/Valves/Types/ST_ValveConfig.TcDUT → BasicComponents/Components/Valves/DUTs/ST_ValveConfig.TcDUT
View File

21
BasicComponents/Components/Valves/DUTs/ST_Valve_IO.TcDUT Normal file
View File

@@ -0,0 +1,21 @@
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
<DUT Name="ST_Valve_IO" Id="{f1913d56-9cee-47f4-8fd9-831b29501390}">
<Declaration><![CDATA[TYPE ST_Valve_IO :
STRUCT
// Valve is closed feedback
i_xOpenFeedback AT %I* : BOOL;
// Valve is open feedback
i_xCloseFeedback AT %I* : BOOL;
// Use xOpenValve for normally closed valves
o_xOpenValve AT %Q* : BOOL := FALSE;
// Use xCloseValve for normally open valves
o_xCloseValve AT %Q* : BOOL := TRUE;
END_STRUCT
END_TYPE
]]></Declaration>
</DUT>
</TcPlcObject>

20
BasicComponents/POUs/Components/Valves/FB_Valve.TcPOU → BasicComponents/Components/Valves/POUs/FB_Valve.TcPOU
View File

@@ -3,8 +3,7 @@
<POU Name="FB_Valve" Id="{658f8bac-5e87-43a2-9b4c-a425a60acda2}" SpecialFunc="None">
<Declaration><![CDATA[FUNCTION_BLOCK FINAL FB_Valve
VAR_INPUT
xOpenFeedback AT %I* : BOOL;
xCloseFeedback AT %I* : BOOL;
// Open and close the valve
xAutomaticOpen : BOOL;
@@ -38,16 +37,13 @@ VAR_INPUT
xInUnitTestMode : BOOL := FALSE;
END_VAR
VAR_OUTPUT
// Use xOpenValve for normally closed valves
xOpenValve AT %Q* : BOOL := FALSE;
// Use xCloseValve for normally open valves
xCloseValve AT %Q* : BOOL := TRUE;
// Error in valve active
xError : BOOL;
END_VAR
VAR_IN_OUT
// IO
stIO : ST_Valve_IO;
// HMI interface
stHMIInterface : ST_HMI_VALVE_DATA;
END_VAR
@@ -153,8 +149,8 @@ IF (NOT _xProcessINTLKOk) OR (NOT _xSafetyINTLKOk) THEN
END_IF
// Handle open close feedback
_xIsOpen := (stValveConfig.xHasOpenFeedback AND xOpenFeedback AND (NOT xCloseFeedback)) OR ((NOT stValveConfig.xHasOpenFeedback) AND _xOpenValve);
_xIsClosed := (stValveConfig.xHasClosedFeedback AND xCloseFeedback AND (NOT xOpenFeedback)) OR ((NOT stValveConfig.xHasClosedFeedback) AND (NOT _xOpenValve));
_xIsOpen := (stValveConfig.xHasOpenFeedback AND stIO.i_xOpenFeedback AND (NOT stIO.i_xCloseFeedback)) OR ((NOT stValveConfig.xHasOpenFeedback) AND _xOpenValve);
_xIsClosed := (stValveConfig.xHasClosedFeedback AND stIO.i_xCloseFeedback AND (NOT stIO.i_xOpenFeedback)) OR ((NOT stValveConfig.xHasClosedFeedback) AND (NOT _xOpenValve));
// ===========================
@@ -209,8 +205,8 @@ END_IF
// Copy internal signals to outputs
// ================================
xOpenValve := _xOpenValve;
xCloseValve := (NOT _xOpenValve);
stIO.o_xOpenValve := _xOpenValve;
stIO.o_xCloseValve := (NOT _xOpenValve);
xError := _xError;

26
BasicComponents/POUs/Components/Valves/FB_ValveAnalog.TcPOU → BasicComponents/Components/Valves/POUs/FB_ValveAnalog.TcPOU
View File

@@ -6,14 +6,6 @@ FUNCTION_BLOCK FINAL FB_ValveAnalog
VAR_INPUT
rSPAutomatic : REAL;
iFeedbackValue AT %I* : INT;
xFeedbackUnderrange AT %I* : BOOL;
xFeedbackOverrange AT %I* : BOOL;
xErrorCard AT %I* : BOOL;
xOpenFeedback AT %I* : BOOL;
xCloseFeedback AT %I* : BOOL;
// Open and close the valve
xAutomaticOpen : BOOL;
@@ -46,13 +38,14 @@ VAR_INPUT
xInUnitTestMode : BOOL := FALSE;
END_VAR
VAR_OUTPUT
// Ouput setpoint
iSetpoint AT %Q* : INT;
// Error in valve active
xError : BOOL;
END_VAR
VAR_IN_OUT
// IO
stIO : ST_ValveAnalog_IO;
// HMI interface
stHMIInterface : ST_HMI_ANALOG_VALVE_DATA;
END_VAR
@@ -231,8 +224,8 @@ _fbAnalogOutput(
xReleaseErrors:= xReleaseErrors,
xConfirmAlarms:= xConfirmAlarms,
xInUnitTestMode := xInUnitTestMode,
iAnalogValue=> iSetpoint,
xError => _xAnalogOutputError,
stIO := stIO.stAnalogOutputIO,
stHMIInterface:= stHMIInterface.stSetpoint);
IF _fbAnalogOutput.xError THEN
@@ -250,10 +243,6 @@ ELSE
END_IF
_fbAnalogInput(
iAnalogValue:= iFeedbackValue,
xUnderrange:= _xHasUnderrangeFeedback AND xFeedbackUnderrange,
xOverrange:= _xHasOverrangeFeedback AND xFeedbackOverrange,
xErrorCard:= _xHasCardError AND xErrorCard,
stAnalogIOConfig:= stValveConfig.stAnalogInputConfig,
stAnalogEWConfig:= stValveConfig.stAnalogInputEWConfig,
xReleaseErrors:= xReleaseErrors,
@@ -267,7 +256,8 @@ _fbAnalogInput(
xErrorLow=> ,
xWarningLow=> ,
xWarningHigh=> ,
xErrorHigh=> );
xErrorHigh=> ,
stIO := stIO.stAnalogInputIO);
IF _fbAnalogInput.xError THEN
_xError := TRUE;
@@ -279,8 +269,8 @@ END_IF
// Handle open close feedback
_xIsOpen := (stValveConfig.xHasOpenFeedback AND xOpenFeedback AND (NOT xCloseFeedback)) OR ((NOT stValveConfig.xHasOpenFeedback) AND (_rCurrentValvePosition >= stValveConfig.rPVIsOpen));
_xIsClosed := (stValveConfig.xHasClosedFeedback AND xCloseFeedback AND (NOT xOpenFeedback)) OR ((NOT stValveConfig.xHasClosedFeedback) AND (_rCurrentValvePosition <= stValveConfig.rPVIsOpen));
_xIsOpen := (stValveConfig.xHasOpenFeedback AND stIO.i_xOpenFeedback AND (NOT stIO.i_xCloseFeedback)) OR ((NOT stValveConfig.xHasOpenFeedback) AND (_rCurrentValvePosition >= stValveConfig.rPVIsOpen));
_xIsClosed := (stValveConfig.xHasClosedFeedback AND stIO.i_xCloseFeedback AND (NOT stIO.i_xOpenFeedback)) OR ((NOT stValveConfig.xHasClosedFeedback) AND (_rCurrentValvePosition <= stValveConfig.rPVIsOpen));
// Calculate target tolerance

0
BasicComponents/POUs/GVL/GVL_CONFIGS.TcGVL → BasicComponents/GVLs/GVL_CONFIGS.TcGVL
View File

0
BasicComponents/POUs/Constants/GVL_TYPE_CONST.TcGVL → BasicComponents/GVLs/GVL_TYPE_CONST.TcGVL
View File

0
BasicComponents/POUs/HMI/Datentypen/ST_HMI_ANALOG_MOTOR_DATA.TcDUT → BasicComponents/HMI/Datentypen/ST_HMI_ANALOG_MOTOR_DATA.TcDUT
View File

0
BasicComponents/POUs/HMI/Datentypen/ST_HMI_ANALOG_VALUE.TcDUT → BasicComponents/HMI/Datentypen/ST_HMI_ANALOG_VALUE.TcDUT
View File

0
BasicComponents/POUs/HMI/Datentypen/ST_HMI_ANALOG_VALVE_DATA.TcDUT → BasicComponents/HMI/Datentypen/ST_HMI_ANALOG_VALVE_DATA.TcDUT
View File

0
BasicComponents/POUs/HMI/Datentypen/ST_HMI_CONTROL_BUTTON.TcDUT → BasicComponents/HMI/Datentypen/ST_HMI_CONTROL_BUTTON.TcDUT
View File

0
BasicComponents/POUs/HMI/Datentypen/ST_HMI_INTEGER_VALUE.TcDUT → BasicComponents/HMI/Datentypen/ST_HMI_INTEGER_VALUE.TcDUT
View File

0
BasicComponents/POUs/HMI/Datentypen/ST_HMI_INTERLOCK.TcDUT → BasicComponents/HMI/Datentypen/ST_HMI_INTERLOCK.TcDUT
View File

0
BasicComponents/POUs/HMI/Datentypen/ST_HMI_VALVE_DATA.TcDUT → BasicComponents/HMI/Datentypen/ST_HMI_VALVE_DATA.TcDUT
View File

0
BasicComponents/POUs/HMI/Datentypen/T_INTERLOCK.TcDUT → BasicComponents/HMI/Datentypen/T_INTERLOCK.TcDUT
View File

0
BasicComponents/POUs/HMI/Enum/E_HMI_ANALOG_VALUE_STATUS.TcDUT → BasicComponents/HMI/Enum/E_HMI_ANALOG_VALUE_STATUS.TcDUT
View File

0
BasicComponents/POUs/HMI/Enum/E_HMI_BUTTON_FEEDBACK.TcDUT → BasicComponents/HMI/Enum/E_HMI_BUTTON_FEEDBACK.TcDUT
View File

0
BasicComponents/POUs/HMI/Enum/E_HMI_MODE.TcDUT → BasicComponents/HMI/Enum/E_HMI_MODE.TcDUT
View File

0
BasicComponents/POUs/HMI/Enum/E_HMI_MOTOR_STATUS.TcDUT → BasicComponents/HMI/Enum/E_HMI_MOTOR_STATUS.TcDUT
View File

0
BasicComponents/POUs/HMI/Enum/E_HMI_VALVE_STATUS.TcDUT → BasicComponents/HMI/Enum/E_HMI_VALVE_STATUS.TcDUT
View File

28
BasicComponents/POUs/PRG_MAIN.TcPOU → BasicComponents/PRG_MAIN.TcPOU
View File

@@ -4,20 +4,20 @@
<Declaration><![CDATA[{attribute 'analysis' := '-33'}
PROGRAM PRG_MAIN
VAR
// Analog I/O tests
_fbAnalogInputTest : FB_AnalogInputTest;
_fbAnalogOutputTest : FB_AnalogOutputTest;
// Valve tests
_fbValve_Test : FB_Valve_Test;
_fbValve_TimeoutTestOpen : FB_ValveTestTimoutOpen;
_fbValve_TimeoutTestClose : FB_ValveTestTimoutClose;
_fbValve_TimoutTriggerOpen : FB_ValveTestTriggerTimoutOpen;
_fbValve_TimoutTriggerClose : FB_ValveTestTriggerTimoutClose;
_fbValveAnalogTest : FB_ValveAnalog_Test;
_fbValveTestHMI : FB_ValveTestHMI;
// // Analog I/O tests
// _fbAnalogInputTest : FB_AnalogInputTest;
// _fbAnalogOutputTest : FB_AnalogOutputTest;
//
// // Valve tests
// _fbValve_Test : FB_Valve_Test;
// _fbValve_TimeoutTestOpen : FB_ValveTestTimoutOpen;
// _fbValve_TimeoutTestClose : FB_ValveTestTimoutClose;
// _fbValve_TimoutTriggerOpen : FB_ValveTestTriggerTimoutOpen;
// _fbValve_TimoutTriggerClose : FB_ValveTestTriggerTimoutClose;
//
// _fbValveAnalogTest : FB_ValveAnalog_Test;
//
// _fbValveTestHMI : FB_ValveTestHMI;
// Release signal test
_fbReleaseSignalTest : FB_ReleaseSignalTest;

256
BasicComponents/POUs/Unittests/AITests/FB_AnalogInputTest.TcPOU → BasicComponents/Unittests/AITests/FB_AnalogInputTest.TcPOU
View File

@@ -131,13 +131,13 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// run analog input
_fbAnalogInput(
iAnalogValue := 1234,
i_iAnalogValue := 1234,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xReleaseLimitErrors := TRUE,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xInUnitTestMode := TRUE,
xError=> _xError,
rScaledValue=> );
@@ -179,13 +179,13 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// run analog input
_fbAnalogInput(
iAnalogValue:= 1234,
i_iAnalogValue:= 1234,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xReleaseLimitErrors := TRUE,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xInUnitTestMode := TRUE,
xError=> _xError,
rScaledValue=> );
@@ -229,12 +229,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// run analog input
_fbAnalogInput(
iAnalogValue:= 1234,
i_iAnalogValue:= 1234,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xInUnitTestMode := TRUE,
xError=> _xError,
rScaledValue=> _rResult);
@@ -281,12 +281,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// Check with active release signal
_fbAI(
iAnalogValue:= 95,
i_iAnalogValue:= 95,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -304,10 +304,10 @@ AssertTrue(Condition:= _xResultErrorHigh, Message:= 'Error high is not active');
// Check without active release signal
_fbAI(
iAnalogValue:= 95,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_iAnalogValue:= 95,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= FALSE,
xError=> _xResultError,
rScaledValue=> ,
@@ -365,12 +365,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
IF NOT _xErrorHighOffInitDone THEN
_xErrorHighOffInitDone := TRUE;
_fbAIErrorHighOff(
iAnalogValue:= 95,
i_iAnalogValue:= 95,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -382,10 +382,10 @@ IF NOT _xErrorHighOffInitDone THEN
ELSE
_fbErrorHighOffTimer(IN := TRUE, PT := timOffTime);
_fbAIErrorHighOff(
iAnalogValue:= 50,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_iAnalogValue:= 50,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -454,12 +454,12 @@ _fbErrorHighOnTimer(IN := TRUE, PT := timOnTime);
// Check with active release signal
_fbAIErrorHighOn(
iAnalogValue:= 95,
i_iAnalogValue:= 95,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -518,12 +518,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// Error low with release
_fbAI(
iAnalogValue:= 0,
i_iAnalogValue:= 0,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -542,10 +542,10 @@ AssertFalse(Condition:= _xResultErrorHigh, Message:= 'Error high is active');
// Error low without release
_fbAI(
iAnalogValue:= 0,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_iAnalogValue:= 0,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= FALSE,
xError=> _xResultError,
rScaledValue=> ,
@@ -602,12 +602,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
IF NOT _xErrorLowOffInitDone THEN
_xErrorLowOffInitDone := TRUE;
_fbAIErrorLowOff(
iAnalogValue:= 5,
i_iAnalogValue:= 5,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -619,10 +619,10 @@ IF NOT _xErrorLowOffInitDone THEN
ELSE
_fbErrorLowOffTimer(IN := TRUE, PT := timOffTime);
_fbAIErrorLowOff(
iAnalogValue:= 50,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_iAnalogValue:= 50,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -688,12 +688,12 @@ _fbErrorLowOnTimer(IN := TRUE, PT := timOnTime);
// Check with active release signal
_fbAIErrorLowOn(
iAnalogValue:= 5,
i_iAnalogValue:= 5,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -753,12 +753,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// run analog input
_fbAnalogInput(
iAnalogValue:= 3071, // 0,75 * 4095 = 3071,25
i_iAnalogValue:= 3071, // 0,75 * 4095 = 3071,25
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xError=> ,
xInUnitTestMode := TRUE,
rScaledValue=> _rResult);
@@ -807,12 +807,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// run AI to check for overrange error
_fbAI(
iAnalogValue:= 50,
i_iAnalogValue:= 50,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= TRUE,
xErrorCard:= ,
i_xUnderrange:= FALSE,
i_xOverrange:= TRUE,
i_xErrorCard:= ,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -866,12 +866,12 @@ IF NOT _xOverrangeOffInitDone THEN
_xOverrangeOffInitDone := TRUE;
// run AI to check for overrange error
_fbAIOverrangeOff(
iAnalogValue:= 50,
i_iAnalogValue:= 50,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= TRUE,
xErrorCard:= ,
i_xUnderrange:= FALSE,
i_xOverrange:= TRUE,
i_xErrorCard:= ,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -884,12 +884,12 @@ END_IF
// run AI cyclically until overrange error is supposed to be off
_fbAIOverrangeOff(
iAnalogValue:= 50,
i_iAnalogValue:= 50,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= ,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= ,
xReleaseErrors := TRUE,
xReleaseHardwareErrors := TRUE,
xReleaseLimitErrors:= TRUE,
@@ -945,12 +945,12 @@ _fbOverrangeOnTimer(IN := TRUE, PT := T#100MS);
// run AI to check for overrange error
_fbAIOverrangeOn(
iAnalogValue:= 50,
i_iAnalogValue:= 50,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= TRUE,
xErrorCard:= ,
i_xUnderrange:= FALSE,
i_xOverrange:= TRUE,
i_xErrorCard:= ,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1003,12 +1003,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// run AI to check for underrange error
_fbAI(
iAnalogValue:= 50,
i_iAnalogValue:= 50,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= TRUE,
xOverrange:= FALSE,
xErrorCard:= ,
i_xUnderrange:= TRUE,
i_xOverrange:= FALSE,
i_xErrorCard:= ,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1062,12 +1062,12 @@ IF NOT _xUnderrangeOffInitDone THEN
_xUnderrangeOffInitDone := TRUE;
// run AI to check for underrange error
_fbAIUnderrangeOff(
iAnalogValue:= 50,
i_iAnalogValue:= 50,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= TRUE,
xOverrange:= FALSE,
xErrorCard:= ,
i_xUnderrange:= TRUE,
i_xOverrange:= FALSE,
i_xErrorCard:= ,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1080,12 +1080,12 @@ END_IF
// run AI cyclically until underrange error is supposed to be off
_fbAIUnderrangeOff(
iAnalogValue:= 0,
i_iAnalogValue:= 0,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= ,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= ,
xReleaseErrors := TRUE,
xReleaseHardwareErrors := TRUE,
xReleaseLimitErrors:= TRUE,
@@ -1141,12 +1141,12 @@ _fbUnderrangeOnTimer(IN := TRUE, PT := T#100MS);
// run AI to check for underrange error
_fbAIUnderrangeOn(
iAnalogValue:= 50,
i_iAnalogValue:= 50,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= TRUE,
xOverrange:= FALSE,
xErrorCard:= ,
i_xUnderrange:= TRUE,
i_xOverrange:= FALSE,
i_xErrorCard:= ,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1200,12 +1200,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// Check with active release signal
_fbAI(
iAnalogValue:= 85,
i_iAnalogValue:= 85,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1224,10 +1224,10 @@ AssertFalse(Condition:= _xResultErrorHigh, Message:= 'Error high is active');
// Check without active release signal
_fbAI(
iAnalogValue:= 85,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_iAnalogValue:= 85,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= FALSE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1283,12 +1283,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
IF NOT _xWarningHighOffInitDone THEN
_xWarningHighOffInitDone := TRUE;
_fbAIWarningHighOff(
iAnalogValue:= 85,
i_iAnalogValue:= 85,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1300,10 +1300,10 @@ IF NOT _xWarningHighOffInitDone THEN
ELSE
_fbWarningHighOffTimer(IN := TRUE, PT := timOffTime);
_fbAIWarningHighOff(
iAnalogValue:= 50,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_iAnalogValue:= 50,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1369,12 +1369,12 @@ _fbWarningHighOnTimer(IN := TRUE, PT := timOnTime);
// Check with active release signal
_fbAIWarningHighOn(
iAnalogValue:= 85,
i_iAnalogValue:= 85,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1433,12 +1433,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
// Warning low with release
_fbAI(
iAnalogValue:= 15,
i_iAnalogValue:= 15,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1457,10 +1457,10 @@ AssertFalse(Condition:= _xResultErrorHigh, Message:= 'Error high is active');
// Warning low without release
_fbAI(
iAnalogValue:= 15,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_iAnalogValue:= 15,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= FALSE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1517,12 +1517,12 @@ _stAnalogEWConfig.stDelays := _stDelayConfig;
IF NOT _xWarningLowOffInitDone THEN
_xWarningLowOffInitDone := TRUE;
_fbAIWarningLowOff(
iAnalogValue:= 15,
i_iAnalogValue:= 15,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1534,10 +1534,10 @@ IF NOT _xWarningLowOffInitDone THEN
ELSE
_fbWarningLowOffTimer(IN := TRUE, PT := timOffTime);
_fbAIWarningLowOff(
iAnalogValue:= 50,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_iAnalogValue:= 50,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,
@@ -1603,12 +1603,12 @@ _fbWarningLowOnTimer(IN := TRUE, PT := timOnTime);
// Check with active release signal
_fbAIWarningLowOn(
iAnalogValue:= 15,
i_iAnalogValue:= 15,
stAnalogIOConfig := _stAnalogInputConfig,
stAnalogEWConfig := _stAnalogEWConfig,
xUnderrange:= FALSE,
xOverrange:= FALSE,
xErrorCard:= FALSE,
i_xUnderrange:= FALSE,
i_xOverrange:= FALSE,
i_xErrorCard:= FALSE,
xReleaseLimitErrors:= TRUE,
xError=> _xResultError,
rScaledValue=> ,

24
BasicComponents/POUs/Unittests/AOTests/FB_AnalogOutputTest.TcPOU → BasicComponents/Unittests/AOTests/FB_AnalogOutputTest.TcPOU
View File

@@ -63,7 +63,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError,
xInUnitTestMode := TRUE);
@@ -112,7 +112,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError,
xInUnitTestMode := TRUE);
@@ -170,7 +170,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError,
xInUnitTestMode := TRUE);
@@ -198,7 +198,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError);
// reading error from HMI interface
@@ -251,7 +251,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError,
xInUnitTestMode := TRUE);
@@ -266,7 +266,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError);
// and evaluate result
@@ -280,7 +280,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError);
// and evaluate result
@@ -294,7 +294,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError);
// and evaluate result
@@ -308,7 +308,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError);
// and evaluate result
@@ -359,7 +359,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError,
xInUnitTestMode := TRUE);
@@ -410,7 +410,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError,
xInUnitTestMode := TRUE);
@@ -454,7 +454,7 @@ _fbAnalogOutput(
xReleaseErrors := ,
xConfirmAlarms := ,
stHMIInterface := _stHMIInterface,
iAnalogValue => _iAnalogOutput,
o_iAnalogValue => _iAnalogOutput,
xError => _xError,
xInUnitTestMode := TRUE);

18
BasicComponents/POUs/Unittests/AnalogValveTests/FB_ValveAnalog_Test.TcPOU → BasicComponents/Unittests/AnalogValveTests/FB_ValveAnalog_Test.TcPOU
View File

@@ -63,7 +63,7 @@ _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);
_fbValve(xAutomaticOpen := TRUE, stValveConfig := _stValveConfig, stHMIInterface := _stHMIValve, i_iFeedbackValue := 3000, xError => _xError, xInUnitTestMode := TRUE);
// assert result
AssertTrue(_xError, 'Expected NotInRangeError, got no error.');
@@ -102,7 +102,7 @@ _xOpenFeedback := FALSE;
_xCloseFeedback := FALSE;
_fbValve.xReleaseManualMode := TRUE;
_fbValve.ReqManualMode();
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
_fbValve(i_xOpenFeedback := _xOpenFeedback, i_xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
// We should now be in manual mode
@@ -112,7 +112,7 @@ AssertTrue(Condition := _fbValve.IsInManualMode, Message := 'Valve did not chang
// Test closed
_xOpenFeedback := FALSE;
_xCloseFeedback := TRUE;
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
_fbValve(i_xOpenFeedback := _xOpenFeedback, i_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');
@@ -120,14 +120,14 @@ AssertFalse(Condition := _fbValve.IsOpen, Message := 'Valve should not be open')
_xOpenFeedback := TRUE;
_xCloseFeedback := FALSE;
_stHMIValve.stSetpoint.rValue := 100.0;
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
_fbValve(i_xOpenFeedback := _xOpenFeedback, i_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);
_fbValve(i_xOpenFeedback := _xOpenFeedback, i_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>
@@ -161,7 +161,7 @@ _stValveConfig.xHasAnalogFeedback := TRUE;
_fbValve(
stValveConfig := _stValveConfig,
stHMIInterface := _stHMIValve,
xFeedbackOverrange := TRUE,
i_xFeedbackOverrange := TRUE,
xError => _xError,
xInUnitTestMode := TRUE);
@@ -199,7 +199,7 @@ _stValveConfig.xHasAnalogFeedback := TRUE;
_fbValve(
stValveConfig := _stValveConfig,
stHMIInterface := _stHMIValve,
xFeedbackUnderrange := TRUE,
i_xFeedbackUnderrange := TRUE,
xError => _xError,
xInUnitTestMode := TRUE);
@@ -487,7 +487,7 @@ IF _fbValve.IsOpen THEN
// 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');
AssertEquals_INT(Expected := 0, Actual := _fbValve.o_iSetpoint, Message := 'Analog output should be zero');
ELSE
AssertTrue(Condition := _fbValve.IsOpen, Message := 'Valve did not open before the test');
END_IF
@@ -535,7 +535,7 @@ IF _fbValve.IsOpen THEN
// 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');
AssertEquals_INT(Expected := 0, Actual := _fbValve.o_iSetpoint, Message := 'Analog output should be zero');
ELSE
AssertTrue(Condition := _fbValve.IsOpen, Message := 'Valve did not open before the test');
END_IF

0
BasicComponents/POUs/Unittests/ReleaseSignalTests/FB_ReleaseSignalTest.TcPOU → BasicComponents/Unittests/ReleaseSignalTests/FB_ReleaseSignalTest.TcPOU
View File

0
BasicComponents/POUs/Unittests/UtilitiesTests/FB_BlinkerTest.TcPOU → BasicComponents/Unittests/UtilitiesTests/FB_BlinkerTest.TcPOU
View File

0
BasicComponents/POUs/Unittests/UtilitiesTests/FB_HashFNV1a_32BitTest.TcPOU → BasicComponents/Unittests/UtilitiesTests/FB_HashFNV1a_32BitTest.TcPOU
View File

0
BasicComponents/POUs/Unittests/UtilitiesTests/FB_PT1Test.TcPOU → BasicComponents/Unittests/UtilitiesTests/FB_PT1Test.TcPOU
View File

0
BasicComponents/POUs/Unittests/UtilitiesTests/FB_RampGeneratorTest.TcPOU → BasicComponents/Unittests/UtilitiesTests/FB_RampGeneratorTest.TcPOU
View File

70
BasicComponents/POUs/Unittests/ValveTests/FB_ValveTestHMI.TcPOU → BasicComponents/Unittests/ValveTests/FB_ValveTestHMI.TcPOU
View File

@@ -46,13 +46,13 @@ _fbValve(
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
i_xOpenFeedback:= ,
i_xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= _stValveConfig,
xOpenValve=> ,
xCloseValve=> );
o_xOpenValve=> ,
o_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');
@@ -90,13 +90,13 @@ _fbValve(
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
i_xOpenFeedback:= ,
i_xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= _stValveConfig,
xOpenValve=> ,
xCloseValve=> );
o_xOpenValve=> ,
o_xCloseValve=> );
AssertFalse(Condition := _stHMIValve.stManualButton.xRelease, Message := 'Manual mode button was released but should not have been');
@@ -108,13 +108,13 @@ _fbValve(
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
i_xOpenFeedback:= ,
i_xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= ,
xOpenValve=> ,
xCloseValve=> );
o_xOpenValve=> ,
o_xCloseValve=> );
AssertTrue(Condition := _stHMIValve.stManualButton.xRelease, Message := 'Manual mode button was not released but should have been');
@@ -151,13 +151,13 @@ _fbValveOC(
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
i_xOpenFeedback:= ,
i_xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= _stValveConfig,
xOpenValve=> ,
xCloseValve=> );
o_xOpenValve=> ,
o_xCloseValve=> );
// Valve should now be in manual mode
AssertTrue(Condition := _fbValveOC.IsInManualMode, Message := 'Valve did not change to manual mode pre test');
@@ -170,16 +170,16 @@ _fbValveOC(
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
i_xOpenFeedback:= ,
i_xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= ,
xOpenValve=> ,
xCloseValve=> );
o_xOpenValve=> ,
o_xCloseValve=> );
// test for valve state and HMI feedback
AssertTrue(Condition := _fbValveOC.xOpenValve, Message := 'Valve did not open as requested by hmi button');
AssertTrue(Condition := _fbValveOC.o_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;
@@ -194,16 +194,16 @@ _fbValveOC(
wProcessINTLKUsed:= _wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
i_xOpenFeedback:= ,
i_xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= ,
xOpenValve=> ,
xCloseValve=> );
o_xOpenValve=> ,
o_xCloseValve=> );
// test for valve state and HMI feedback
AssertTrue(Condition := _fbValveOC.xCloseValve, Message := 'Valve did not close as requested by hmi button');
AssertTrue(Condition := _fbValveOC.o_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;
@@ -243,13 +243,13 @@ _fbValve(
wProcessINTLKUsed:= wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
i_xOpenFeedback:= ,
i_xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= _stValveConfig,
xOpenValve=> ,
xCloseValve=> );
o_xOpenValve=> ,
o_xCloseValve=> );
// Valve should now be in manual mode
AssertTrue(Condition := _fbValve.IsInManualMode, Message := 'Valve did not change to manual mode pre test');
@@ -265,15 +265,15 @@ _fbValve(
wProcessINTLKUsed:= wInterlocksUsed,
stHMIInterface:= _stHMIValve,
xError=> ,
xOpenFeedback:= ,
xCloseFeedback:= ,
i_xOpenFeedback:= ,
i_xCloseFeedback:= ,
xReleaseErrors:= ,
xConfirmAlarms:= ,
stValveConfig:= ,
xOpenValve=> ,
xCloseValve=> );
o_xOpenValve=> ,
o_xCloseValve=> );
AssertFalse(Condition := _fbValve.xOpenValve, Message := 'Valve did not block manual open command with active interlock');
AssertFalse(Condition := _fbValve.o_xOpenValve, Message := 'Valve did not block manual open command with active interlock');
TEST_FINISHED();]]></ST>
</Implementation>

4
BasicComponents/POUs/Unittests/ValveTests/FB_ValveTestTimoutClose.TcPOU → BasicComponents/Unittests/ValveTests/FB_ValveTestTimoutClose.TcPOU
View File

@@ -48,8 +48,8 @@ CASE _iState OF
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);
_xCloseFeedback := _fbValveTimeout.o_xCloseValve AND _fbDelayFeedbackSignalTimer.Q;
_fbValveTimeout(i_xOpenFeedback := _xOpenFeedback, i_xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
// test timeout after 200ms
IF _fbTimeoutCloseTestTimer.Q THEN

4
BasicComponents/POUs/Unittests/ValveTests/FB_ValveTestTimoutOpen.TcPOU → BasicComponents/Unittests/ValveTests/FB_ValveTestTimoutOpen.TcPOU
View File

@@ -48,9 +48,9 @@ CASE _iState OF
10:
// set open feedback after 50ms and call valve block
_xOpenFeedback := _fbValveTimeout.xOpenValve AND _fbDelayFeedbackSignalTimer.Q;
_xOpenFeedback := _fbValveTimeout.o_xOpenValve AND _fbDelayFeedbackSignalTimer.Q;
_xCloseFeedback := FALSE;
_fbValveTimeout(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
_fbValveTimeout(i_xOpenFeedback := _xOpenFeedback, i_xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
// test timeout after 200ms
IF _fbTimeoutOpenTestTimer.Q THEN

2
BasicComponents/POUs/Unittests/ValveTests/FB_ValveTestTriggerTimoutClose.TcPOU → BasicComponents/Unittests/ValveTests/FB_ValveTestTriggerTimoutClose.TcPOU
View File

@@ -50,7 +50,7 @@ CASE _iState OF
// both feedback false and call valve block
_xOpenFeedback := FALSE;
_xCloseFeedback := FALSE;
_fbValveTimeout(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, xInUnitTestMode := TRUE, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
_fbValveTimeout(i_xOpenFeedback := _xOpenFeedback, i_xCloseFeedback := _xCloseFeedback, xInUnitTestMode := TRUE, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
// test timeout after 200ms
IF _fbTimeoutCloseTestTimer.Q THEN

2
BasicComponents/POUs/Unittests/ValveTests/FB_ValveTestTriggerTimoutOpen.TcPOU → BasicComponents/Unittests/ValveTests/FB_ValveTestTriggerTimoutOpen.TcPOU
View File

@@ -51,7 +51,7 @@ CASE _iState OF
// both feedback false and call valve block
_xOpenFeedback := FALSE;
_xCloseFeedback := FALSE;
_fbValveTimeout(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, xInUnitTestMode := TRUE, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
_fbValveTimeout(i_xOpenFeedback := _xOpenFeedback, i_xCloseFeedback := _xCloseFeedback, xInUnitTestMode := TRUE, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig);
// test timeout after 200ms
IF _fbTimeoutOpenTestTimer.Q THEN

24
BasicComponents/POUs/Unittests/ValveTests/FB_Valve_Test.TcPOU → BasicComponents/Unittests/ValveTests/FB_Valve_Test.TcPOU
View File

@@ -53,7 +53,7 @@ _xOpenFeedback := FALSE;
_xCloseFeedback := FALSE;
_fbValve.xReleaseManualMode := TRUE;
_fbValve.ReqManualMode();
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
_fbValve(i_xOpenFeedback := _xOpenFeedback, i_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');
@@ -65,7 +65,7 @@ AssertFalse(Condition := _fbValve.IsClosed OR _fbValve.IsOpen, Message := 'Valve
// Test closed
_xOpenFeedback := FALSE;
_xCloseFeedback := TRUE;
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback,stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
_fbValve(i_xOpenFeedback := _xOpenFeedback, i_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');
@@ -74,14 +74,14 @@ _xOpenFeedback := TRUE;
_xCloseFeedback := FALSE;
_stHMIValve.stOpenButton.xRequest := TRUE;
_fbValve(stHMIInterface := _stHMIValve);
_fbValve(xOpenFeedback := _xOpenFeedback, xCloseFeedback := _xCloseFeedback, stHMIInterface := _stHMIValve, stValveConfig := _stValveConfig, xInUnitTestMode := TRUE);
_fbValve(i_xOpenFeedback := _xOpenFeedback, i_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);
_fbValve(i_xOpenFeedback := _xOpenFeedback, i_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>
@@ -347,16 +347,16 @@ IF _fbValve.IsOpen THEN
_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');
AssertFalse(Condition := _fbValve.o_xOpenValve, Message := 'Valve should not be open with active Interlock');
AssertTrue(Condition := _fbValve.o_xCloseValve, Message := 'Close output not active with active Interlock');
// Test the same with open valve when interlock active
_stValveConfig.xNormallyOpen := 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 := _fbValve.o_xOpenValve, Message := 'Valve should be open with active Interlock and inverted config');
AssertFalse(Condition := _fbValve.o_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
@@ -405,16 +405,16 @@ IF _fbValve.IsOpen THEN
_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');
AssertFalse(Condition := _fbValve.o_xOpenValve, Message := 'Valve should not be open with active Interlock');
AssertTrue(Condition := _fbValve.o_xCloseValve, Message := 'Close output not active with active Interlock');
// Test the same with open valve when interlock active
_stValveConfig.xNormallyOpen := 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 := _fbValve.o_xOpenValve, Message := 'Valve should be open with active Interlock and inverted config');
AssertFalse(Condition := _fbValve.o_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');