631 lines
18 KiB
XML
631 lines
18 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<TcPlcObject Version="1.1.0.1">
|
|
<POU Name="FB_AnalogInput" Id="{532e1013-5a2e-43c7-8863-3ad112d7d7e8}" SpecialFunc="None">
|
|
<Declaration><![CDATA[FUNCTION_BLOCK 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;
|
|
|
|
// Error and warning config data
|
|
stAnalogEWConfig : ST_ANALOG_EW_CONFIG;
|
|
|
|
// Global switch to dissable all errors
|
|
xReleaseErrors : BOOL := TRUE;
|
|
|
|
// Enables or dissables errors from min max values
|
|
xReleaseLimitErrors : BOOL := FALSE;
|
|
|
|
// Enables or dissables hardware errors
|
|
xReleaseHardwareErrors : BOOL := TRUE;
|
|
|
|
// Input to confirm all errors
|
|
xConfirmAlarms : BOOL;
|
|
|
|
// Input to tell the fb thats ist used inside a unit test
|
|
// Fb will not throw error messages
|
|
{attribute 'hide'}
|
|
xInUnitTestMode : BOOL := FALSE;
|
|
END_VAR
|
|
VAR_OUTPUT
|
|
// Scaled output value
|
|
rScaledValue : REAL;
|
|
|
|
// Error in function block
|
|
xError : BOOL;
|
|
|
|
// Warning active
|
|
xWarning : BOOL;
|
|
|
|
// Low level error
|
|
xErrorLow : BOOL;
|
|
|
|
// Low level warning
|
|
xWarningLow : BOOL;
|
|
|
|
// High level warning
|
|
xWarningHigh : BOOL;
|
|
|
|
//High level error
|
|
xErrorHigh : BOOL;
|
|
END_VAR
|
|
VAR
|
|
// Scaling factor for conversion
|
|
_rConversionFactor : REAL;
|
|
|
|
// Base offset for scaling factor
|
|
_rBaseOffset : REAL;
|
|
|
|
// Min warning level
|
|
_rMinWarningLevel : REAL;
|
|
|
|
// Max warning level
|
|
_rMaxWarningLevel : REAL;
|
|
|
|
// Min error level
|
|
_rMinErrorLevel : REAL;
|
|
|
|
// Max error level
|
|
_rMaxErrorLevel : REAL;
|
|
|
|
// Scaling config error
|
|
_xConfigError : BOOL := FALSE;
|
|
|
|
// Limits config error
|
|
_xEWConfigError : BOOL := FALSE;
|
|
|
|
// Delayed Signal warning low
|
|
_fbSignalDelayWarningLow : FB_ReleaseSignal;
|
|
|
|
// Delayed Signal warning high
|
|
_fbSignalDelayWarningHigh : FB_ReleaseSignal;
|
|
|
|
// Delayed Signal error low
|
|
_fbSignalDelayErrorLow : FB_ReleaseSignal;
|
|
|
|
// Delayed signal error high
|
|
_fbSignalDelayErrorHigh : FB_ReleaseSignal;
|
|
|
|
// Delayed signal for underrange error
|
|
_fbSignalDelayUnderrangeError : FB_ReleaseSignal;
|
|
|
|
// Delayed signal for overload error
|
|
_fbSignalDelayOverloadError : FB_ReleaseSignal;
|
|
|
|
// Delayed signal for card error
|
|
_fbSignalDelayCardError : FB_ReleaseSignal;
|
|
|
|
// Helper variables used in reset error flag
|
|
_xAlarmsActive : BOOL;
|
|
_xInputErrorsActive : BOOL;
|
|
|
|
// Max process value
|
|
_iAIMax : INT;
|
|
|
|
// Min process value
|
|
_iAIMin : INT;
|
|
|
|
// Clamped analog value
|
|
_iClampedAnalogValue : INT;
|
|
|
|
// Internal scaled value
|
|
_rScaledValue : REAL;
|
|
|
|
// Name of the function block
|
|
_sName : STRING;
|
|
|
|
// Internal warning flags
|
|
_xWarningLow : BOOL;
|
|
_xWarningHigh : BOOL;
|
|
_xWarning : BOOL;
|
|
|
|
// Internal error flag
|
|
_xErrorLow : BOOL;
|
|
_xErrorHigh : BOOL;
|
|
_xError : BOOL;
|
|
|
|
// Alarm handlers
|
|
_fbAlarmCardError : FB_TcAlarm;
|
|
_fbAlarmUnderrange : FB_TcAlarm;
|
|
_fbAlarmOverload : FB_TcAlarm;
|
|
_fbAlarmConfigError : FB_TcAlarm;
|
|
|
|
_fbAlarmErrorLow : FB_TcAlarm;
|
|
_fbAlarmWarningLow : FB_TcAlarm;
|
|
_fbAlarmWarningHigh : FB_TcAlarm;
|
|
_fbAlarmErrorHigh : FB_TcAlarm;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[// =========
|
|
// Prechecks
|
|
// =========
|
|
|
|
// Calculate scaling factors,
|
|
// scaling will be zero in case
|
|
// of invalid scaling parameters.
|
|
// Also checks if reference to config data is valid.
|
|
CalcScalingFactors();
|
|
|
|
// Check error and warning levels config
|
|
// Will later raise alarms if config is wrong
|
|
CheckEWLevels();
|
|
|
|
|
|
// ===========================
|
|
// Config error alarm handling
|
|
// ===========================
|
|
|
|
IF xReleaseErrors AND (_xConfigError OR (_xEWConfigError AND xReleaseLimitErrors)) THEN
|
|
// Latch error
|
|
_xError := TRUE;
|
|
|
|
// Raise alarm
|
|
IF (NOT xInUnitTestMode) AND (NOT _fbAlarmConfigError.bRaised) THEN
|
|
_fbAlarmConfigError.Raise(0);
|
|
END_IF
|
|
END_IF
|
|
|
|
// Clear alarm and confirm
|
|
// Auto confirm because error can only be cleared
|
|
// throught user action
|
|
IF (NOT _xConfigError) AND (NOT _xEWConfigError) AND _fbAlarmConfigError.bRaised THEN
|
|
_fbAlarmConfigError.Clear(0, TRUE);
|
|
END_IF
|
|
|
|
|
|
// ========================
|
|
// Analog value calculation
|
|
// ========================
|
|
|
|
// Clamp analogue input levels
|
|
_iClampedAnalogValue := MAX(_iAIMin, iAnalogValue);
|
|
_iClampedAnalogValue := MIN(_iAIMax, _iClampedAnalogValue);
|
|
|
|
// Calc scaled value
|
|
_rScaledValue := _iClampedAnalogValue * _rConversionFactor + _rBaseOffset;
|
|
|
|
|
|
// =========================
|
|
// Underrange alarm handling
|
|
// =========================
|
|
|
|
// Filter underrange error signal
|
|
_fbSignalDelayUnderrangeError(
|
|
xSignal:= xUnderrange,
|
|
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseHardwareErrors,
|
|
timOnDelay:= stAnalogEWConfig.stDelays.timHardwareSignalLevelOn,
|
|
timOffDelay:= stAnalogEWConfig.stDelays.timHardwareSignalLevelOff);
|
|
|
|
// Latch error signal
|
|
IF _fbSignalDelayUnderrangeError.xReleaseSignal THEN
|
|
_xError := TRUE;
|
|
END_IF
|
|
|
|
// Raise alarm
|
|
IF _fbSignalDelayUnderrangeError.xReleaseSignal AND (NOT xInUnitTestMode) AND (NOT _fbAlarmUnderrange.bRaised) THEN
|
|
_fbAlarmUnderrange.Raise(0);
|
|
END_IF
|
|
|
|
// Clear alarm
|
|
IF (NOT _fbSignalDelayUnderrangeError.xReleaseSignal) AND _fbAlarmUnderrange.bRaised THEN
|
|
_fbAlarmUnderrange.Clear(0, FALSE);
|
|
END_IF
|
|
|
|
// Confirm alarm
|
|
IF xConfirmAlarms AND (_fbAlarmUnderrange.eConfirmationState = TcEventConfirmationState.WaitForConfirmation) THEN
|
|
_fbAlarmUnderrange.Confirm(0);
|
|
END_IF
|
|
|
|
|
|
// =========================
|
|
// Overload alarm handling
|
|
// =========================
|
|
|
|
// Filter overload error signal
|
|
_fbSignalDelayOverloadError(
|
|
xSignal:= xOverrange,
|
|
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseHardwareErrors,
|
|
timOnDelay:= stAnalogEWConfig.stDelays.timHardwareSignalLevelOn,
|
|
timOffDelay:= stAnalogEWConfig.stDelays.timHardwareSignalLevelOff);
|
|
|
|
// Latch error signal
|
|
IF _fbSignalDelayOverloadError.xReleaseSignal THEN
|
|
_xError := TRUE;
|
|
END_IF
|
|
|
|
// Raise alarm
|
|
IF _fbSignalDelayOverloadError.xReleaseSignal AND (NOT xInUnitTestMode) AND (_fbAlarmOverload.bRaised) THEN
|
|
_fbAlarmOverload.Raise(0);
|
|
END_IF
|
|
|
|
// Clear alarm
|
|
IF (NOT _fbSignalDelayOverloadError.xReleaseSignal) AND _fbAlarmOverload.bRaised THEN
|
|
_fbAlarmOverload.Clear(0, FALSE);
|
|
END_IF
|
|
|
|
// Confirm alarm
|
|
IF xConfirmAlarms AND (_fbAlarmOverload.eConfirmationState = TcEventConfirmationState.WaitForConfirmation) THEN
|
|
_fbAlarmOverload.Confirm(0);
|
|
END_IF
|
|
|
|
|
|
// =========================
|
|
// Card alarm handling
|
|
// =========================
|
|
|
|
// Filter overload error signal
|
|
// EL30xx also sets this if an underrange or overrange error is present,
|
|
// so we filter this out
|
|
_fbSignalDelayCardError(
|
|
xSignal:= xErrorCard AND (NOT xUnderrange) AND (NOT xOverrange),
|
|
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseHardwareErrors,
|
|
timOnDelay:= stAnalogEWConfig.stDelays.timHardwareSignalLevelOn,
|
|
timOffDelay:= stAnalogEWConfig.stDelays.timHardwareSignalLevelOff);
|
|
|
|
// Latch error signal
|
|
IF _fbSignalDelayCardError.xReleaseSignal THEN
|
|
_xError := TRUE;
|
|
END_IF
|
|
|
|
// Raise alarm
|
|
IF _fbSignalDelayCardError.xReleaseSignal AND (NOT xInUnitTestMode) AND (_fbAlarmCardError.bRaised) THEN
|
|
_fbAlarmCardError.Raise(0);
|
|
END_IF
|
|
|
|
// Clear alarm
|
|
IF (NOT _fbSignalDelayCardError.xReleaseSignal) AND _fbAlarmCardError.bRaised THEN
|
|
_fbAlarmCardError.Clear(0, FALSE);
|
|
END_IF
|
|
|
|
// Confirm alarm
|
|
IF xConfirmAlarms AND (_fbAlarmCardError.eConfirmationState = TcEventConfirmationState.WaitForConfirmation) THEN
|
|
_fbAlarmCardError.Confirm(0);
|
|
END_IF
|
|
|
|
|
|
// ===========================
|
|
// Error high alarm handling
|
|
// ===========================
|
|
|
|
_fbSignalDelayErrorHigh(
|
|
xSignal:= (_rScaledValue >= _rMaxErrorLevel),
|
|
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseLimitErrors AND (NOT _xEWConfigError),
|
|
timOnDelay:= stAnalogEWConfig.stDelays.timErrorHighOn,
|
|
timOffDelay:= stAnalogEWConfig.stDelays.timErrorHighOff);
|
|
|
|
_xErrorHigh := _fbSignalDelayErrorHigh.xReleaseSignal;
|
|
|
|
// Latch error
|
|
IF _xErrorHigh THEN
|
|
_xError := TRUE;
|
|
END_IF
|
|
|
|
// Raise alarm
|
|
IF _fbSignalDelayErrorHigh.xReleaseSignal AND (NOT xInUnitTestMode) AND (NOT _fbAlarmErrorHigh.bRaised) THEN
|
|
_fbAlarmErrorHigh.Raise(0);
|
|
END_IF
|
|
|
|
// Clear alarm
|
|
IF (NOT _fbSignalDelayErrorHigh.xReleaseSignal) AND _fbAlarmErrorHigh.bRaised THEN
|
|
_fbAlarmErrorHigh.Clear(0, FALSE);
|
|
END_IF
|
|
|
|
// Confirm alarm
|
|
IF xConfirmAlarms AND (_fbAlarmErrorHigh.eConfirmationState = TcEventConfirmationState.WaitForConfirmation) THEN
|
|
_fbAlarmErrorHigh.Confirm(0);
|
|
END_IF
|
|
|
|
|
|
// ===========================
|
|
// Error low alarm handling
|
|
// ===========================
|
|
|
|
_fbSignalDelayErrorLow(
|
|
xSignal:= (_rScaledValue <= _rMinErrorLevel),
|
|
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseLimitErrors AND (NOT _xEWConfigError),
|
|
timOnDelay:= stAnalogEWConfig.stDelays.timErrorLowOn,
|
|
timOffDelay:= stAnalogEWConfig.stDelays.timErrorLowOff);
|
|
|
|
_xErrorLow := _fbSignalDelayErrorLow.xReleaseSignal;
|
|
|
|
// Latch error
|
|
IF _xErrorLow THEN
|
|
_xError := TRUE;
|
|
END_IF
|
|
|
|
// Raise alarm
|
|
IF _fbSignalDelayErrorLow.xReleaseSignal AND (NOT xInUnitTestMode) AND (NOT _fbAlarmErrorLow.bRaised) THEN
|
|
_fbAlarmErrorLow.Raise(0);
|
|
END_IF
|
|
|
|
// Clear alarm
|
|
IF (NOT _fbSignalDelayErrorLow.xReleaseSignal) AND _fbAlarmErrorLow.bRaised THEN
|
|
_fbAlarmErrorLow.Clear(0, FALSE);
|
|
END_IF
|
|
|
|
// Confirm alarm
|
|
IF xConfirmAlarms AND (_fbAlarmErrorLow.eConfirmationState = TcEventConfirmationState.WaitForConfirmation) THEN
|
|
_fbAlarmErrorLow.Confirm(0);
|
|
END_IF
|
|
|
|
|
|
// ===========================
|
|
// Warning high alarm handling
|
|
// ===========================
|
|
|
|
_fbSignalDelayWarningHigh(
|
|
xSignal:= (_rScaledValue >= _rMaxWarningLevel),
|
|
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseLimitErrors AND (NOT _xEWConfigError),
|
|
timOnDelay:= stAnalogEWConfig.stDelays.timWarningHighOn,
|
|
timOffDelay:= stAnalogEWConfig.stDelays.timWarningHighOff);
|
|
|
|
_xWarningHigh := _fbSignalDelayWarningHigh.xReleaseSignal;
|
|
|
|
// Raise alarm
|
|
IF _fbSignalDelayWarningHigh.xReleaseSignal AND (NOT xInUnitTestMode) AND (NOT _fbAlarmWarningHigh.bRaised) THEN
|
|
_fbAlarmWarningHigh.Raise(0);
|
|
END_IF
|
|
|
|
// Clear alarm
|
|
IF (NOT _fbSignalDelayWarningHigh.xReleaseSignal) AND _fbAlarmWarningHigh.bRaised THEN
|
|
_fbAlarmWarningHigh.Clear(0, FALSE);
|
|
END_IF
|
|
|
|
// Confirm alarm
|
|
IF xConfirmAlarms AND (_fbAlarmWarningHigh.eConfirmationState = TcEventConfirmationState.WaitForConfirmation) THEN
|
|
_fbAlarmWarningHigh.Confirm(0);
|
|
END_IF
|
|
|
|
|
|
// ===========================
|
|
// Warning low alarm handling
|
|
// ===========================
|
|
|
|
_fbSignalDelayWarningLow(
|
|
xSignal:= (_rScaledValue <= _rMinWarningLevel),
|
|
xRelease:= stAnalogIOConfig.xUsed AND xReleaseErrors AND xReleaseLimitErrors AND (NOT _xEWConfigError),
|
|
timOnDelay:= stAnalogEWConfig.stDelays.timWarningLowOn,
|
|
timOffDelay:= stAnalogEWConfig.stDelays.timWarningLowOff);
|
|
|
|
_xWarningLow := _fbSignalDelayWarningLow.xReleaseSignal;
|
|
|
|
// Raise alarm
|
|
IF _fbSignalDelayWarningLow.xReleaseSignal AND (NOT xInUnitTestMode) AND (NOT _fbAlarmWarningLow.bRaised) THEN
|
|
_fbAlarmWarningLow.Raise(0);
|
|
END_IF
|
|
|
|
// Clear alarm
|
|
IF (NOT _fbSignalDelayWarningLow.xReleaseSignal) AND _fbAlarmWarningLow.bRaised THEN
|
|
_fbAlarmWarningLow.Clear(0, FALSE);
|
|
END_IF
|
|
|
|
// Confirm alarm
|
|
IF xConfirmAlarms AND (_fbAlarmWarningLow.eConfirmationState = TcEventConfirmationState.WaitForConfirmation) THEN
|
|
_fbAlarmWarningLow.Confirm(0);
|
|
END_IF
|
|
|
|
|
|
// ============
|
|
// Warning flag
|
|
// ============
|
|
|
|
_xWarning := _xWarningLow OR _xWarningHigh;
|
|
|
|
|
|
// ================
|
|
// Reset error flag
|
|
// ================
|
|
|
|
_xAlarmsActive := _fbAlarmConfigError.bActive
|
|
OR _fbAlarmUnderrange.bActive
|
|
OR _fbAlarmOverload.bActive
|
|
OR _fbAlarmCardError.bActive
|
|
OR _fbAlarmErrorHigh.bActive
|
|
OR _fbAlarmErrorLow.bActive;
|
|
|
|
_xInputErrorsActive := _fbSignalDelayUnderrangeError.xReleaseSignal
|
|
OR _fbSignalDelayOverloadError.xReleaseSignal
|
|
OR _fbSignalDelayCardError.xReleaseSignal;
|
|
|
|
IF xConfirmAlarms AND _xError AND (NOT _xAlarmsActive) AND (NOT _xInputErrorsActive) AND (NOT _xConfigError) THEN
|
|
_xError := FALSE;
|
|
END_IF
|
|
|
|
// Copy internal signals to outputs
|
|
xWarningLow := _xWarningLow;
|
|
xWarningHigh := _xWarningHigh;
|
|
xWarning := _xWarning;
|
|
|
|
xErrorLow := _xErrorLow;
|
|
xErrorHigh := _xErrorHigh;
|
|
xError := _xError;
|
|
|
|
rScaledValue := _rScaledValue;]]></ST>
|
|
</Implementation>
|
|
<Method Name="CalcScalingFactors" Id="{e88dfbcd-1a0d-45a0-9d50-5ad8be2479c9}">
|
|
<Declaration><![CDATA[{attribute 'analysis' := '-56'}
|
|
METHOD PRIVATE CalcScalingFactors
|
|
VAR
|
|
_rNum : REAL;
|
|
_rDenom : REAL;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[// _lrConversionFactor := (lrPVMax - lrPVMin)/(udiAIMax - udiAIMin) + (rPVMin - ((lrPVMax - lrPVMin)/(udiAIMax - udiAIMin)*udiAIMin))
|
|
// Splitted in two calculations to catch division by zero
|
|
_rNum := (stAnalogIOConfig.rPVMax - stAnalogIOConfig.rPVMin);
|
|
_rDenom := INT_TO_REAL(stAnalogIOConfig.iAIMax - stAnalogIOConfig.iAIMin);
|
|
|
|
// Do not divide by 0 or a negative number
|
|
IF _rDenom > 0.0 THEN
|
|
_rConversionFactor := _rNum/_rDenom;
|
|
_rBaseOffset := stAnalogIOConfig.rPVMin - (_rConversionFactor * INT_TO_REAL(stAnalogIOConfig.iAIMin));
|
|
_iAIMax := stAnalogIOConfig.iAIMax;
|
|
_iAIMin := stAnalogIOConfig.iAIMin;
|
|
_xConfigError := FALSE;
|
|
ELSE
|
|
// Division by zero happened
|
|
// Or denom was negative
|
|
// Set scaling to zero
|
|
_rConversionFactor := 0.0;
|
|
_rBaseOffset := 0.0;
|
|
_iAIMax := 0;
|
|
_iAIMin := 0;
|
|
_xConfigError := TRUE;
|
|
END_IF]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="CheckEWLevels" Id="{6fcb5a6d-e37d-4efd-ad76-02026f476863}">
|
|
<Declaration><![CDATA[METHOD PRIVATE CheckEWLevels
|
|
VAR
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[// Reset (E)rror (W)arning config error
|
|
_xEWConfigError := FALSE;
|
|
|
|
// Check for EW config error
|
|
IF stAnalogEWConfig.stLevels.rWarningMin <= stAnalogEWConfig.stLevels.rErrorMin THEN
|
|
_xEWConfigError := TRUE;
|
|
END_IF
|
|
|
|
IF stAnalogEWConfig.stLevels.rWarningMax >= stAnalogEWConfig.stLevels.rErrorMax THEN
|
|
_xEWConfigError := TRUE;
|
|
END_IF
|
|
|
|
IF stAnalogEWConfig.stLevels.rWarningMin >= stAnalogEWConfig.stLevels.rWarningMax THEN
|
|
_xEWConfigError := TRUE;
|
|
END_IF
|
|
|
|
|
|
// Only write error and warning levels when there was no config error
|
|
IF (NOT _xEWConfigError) THEN
|
|
// Recreate alarm messages with the newly set limits
|
|
// if values have been changed
|
|
{analysis -54}
|
|
IF (_rMinErrorLevel <> stAnalogEWConfig.stLevels.rErrorMin)
|
|
OR (_rMinWarningLevel <> stAnalogEWConfig.stLevels.rWarningMin)
|
|
OR (_rMaxWarningLevel <> stAnalogEWConfig.stLevels.rWarningMax)
|
|
OR (_rMaxErrorLevel <> stAnalogEWConfig.stLevels.rErrorMax) THEN
|
|
{analysis +54}
|
|
CreateAlarmLimitsMSG();
|
|
END_IF
|
|
|
|
// Set new values
|
|
_rMinErrorLevel := stAnalogEWConfig.stLevels.rErrorMin;
|
|
_rMinWarningLevel := stAnalogEWConfig.stLevels.rWarningMin;
|
|
_rMaxWarningLevel := stAnalogEWConfig.stLevels.rWarningMax;
|
|
_rMaxErrorLevel := stAnalogEWConfig.stLevels.rErrorMax;
|
|
END_IF
|
|
]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="CreateAlarmLimitsMSG" Id="{d38eb5a5-80eb-4ab2-8c50-97431707ca20}">
|
|
<Declaration><![CDATA[{attribute 'analysis' := '-26'}
|
|
METHOD PRIVATE CreateAlarmLimitsMSG
|
|
VAR_INPUT
|
|
END_VAR
|
|
VAR
|
|
_sTempUnit : STRING;
|
|
_sTempErrorMin : STRING;
|
|
_sTempWarningMin : STRING;
|
|
_sTempWarningMax : STRING;
|
|
_sTempErrorMax : STRING;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[// Check if analog value has unit
|
|
IF stAnalogIOConfig.sUnit <> '' THEN
|
|
_sTempUnit := CONCAT(' ', stAnalogIOConfig.sUnit);
|
|
ELSE
|
|
_sTempUnit := '';
|
|
END_IF
|
|
|
|
// Create message parameter strings
|
|
_sTempErrorMin := CONCAT(REAL_TO_STRING(stAnalogEWConfig.stLevels.rErrorMin), _sTempUnit);
|
|
_sTempWarningMin := CONCAT(REAL_TO_STRING(stAnalogEWConfig.stLevels.rWarningMin), _sTempUnit);
|
|
_sTempWarningMax := CONCAT(REAL_TO_STRING(stAnalogEWConfig.stLevels.rWarningMax), _sTempUnit);
|
|
_sTempErrorMax := CONCAT(REAL_TO_STRING(stAnalogEWConfig.stLevels.rErrorMax), _sTempUnit);
|
|
|
|
{analysis -46}
|
|
// Inser message parameters
|
|
_fbAlarmErrorLow.ipArguments.Clear().AddString(_sName).AddString(_sTempErrorMin);
|
|
_fbAlarmWarningLow.ipArguments.Clear().AddString(_sName).AddString(_sTempWarningMin);
|
|
_fbAlarmWarningHigh.ipArguments.Clear().AddString(_sName).AddString(_sTempWarningMax);
|
|
_fbAlarmErrorHigh.ipArguments.Clear().AddString(_sName).AddString(_sTempErrorMax);
|
|
{analysis +46}]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="CreateAlarmMSG" Id="{e4d0fc74-1711-410b-9ec3-4af08afbc236}">
|
|
<Declaration><![CDATA[METHOD PRIVATE CreateAlarmMSG
|
|
VAR_INPUT
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[{analysis -46}
|
|
_fbAlarmCardError.ipArguments.Clear().AddString(_sName);
|
|
_fbAlarmUnderrange.ipArguments.Clear().AddString(_sName);
|
|
_fbAlarmOverload.ipArguments.Clear().AddString(_sName);
|
|
_fbAlarmConfigError.ipArguments.Clear().AddString(_sName);
|
|
{analysis +46}]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="FB_init" Id="{27512538-cc2f-4100-8046-022de49f067a}">
|
|
<Declaration><![CDATA[//FB_Init ist immer implizit verfügbar und wird primär für die Initialisierung verwendet.
|
|
//Der Rückgabewert wird nicht ausgewertet. Für gezielte Einflussnahme können Sie
|
|
//die Methoden explizit deklarieren und darin mit dem Standard-Initialisierungscode
|
|
//zusätzlichen Code bereitstellen. Sie können den Rückgabewert auswerten.
|
|
METHOD FB_Init: BOOL
|
|
VAR_INPUT
|
|
bInitRetains: BOOL; // TRUE: Die Retain-Variablen werden initialisiert (Reset warm / Reset kalt)
|
|
bInCopyCode: BOOL; // TRUE: Die Instanz wird danach in den Kopiercode kopiert (Online-Change)
|
|
|
|
// Name of analogue io
|
|
sName : STRING(80);
|
|
END_VAR]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[// Save io name
|
|
_sName := sName;
|
|
|
|
// Create alarm messages
|
|
CreateAlarmMSG();
|
|
CreateAlarmLimitsMSG();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Property Name="Name" Id="{103c7177-ef49-4a4b-98b1-06578d5fce31}">
|
|
<Declaration><![CDATA[PROPERTY Name : STRING(80)]]></Declaration>
|
|
<Get Name="Get" Id="{02e85b3f-9933-4282-a9d2-1ab27eb22499}">
|
|
<Declaration><![CDATA[VAR
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[Name := _sName;]]></ST>
|
|
</Implementation>
|
|
</Get>
|
|
<Set Name="Set" Id="{4215abec-259f-45d7-a31e-437036d4e241}">
|
|
<Declaration><![CDATA[VAR
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[_sName := Name;
|
|
|
|
// After a name change, all error messages have to be changed
|
|
CreateAlarmMSG();]]></ST>
|
|
</Implementation>
|
|
</Set>
|
|
</Property>
|
|
</POU>
|
|
</TcPlcObject> |