if (EMStop.IsSet())
  HandleEMStop();

if (!EMStop.IsUnacknowledged() )
  EquipmentOperatorAcknowledgedEMStop();

if (alarmShouldBeSet())
  alarm.Set();
else if (alarmShouldBeCleared())
  alarm.Clear();

if (EMStop.Status()&STATUS_OK)
  RequestOKState();
else if (EMStop.Status()&STATUS_SET)
  PerformEmergencyMeasures();

#define STATUS_OK                         0x00000000

/** There is a NOTIFY alarm present.*/
#define STATUS_NOTIFY                     0x00000001

/** There is a WARNING alarm present.*/
#define STATUS_WARNING                    0x00000010

/** There is a LOW LEVEL alarm present.*/
#define STATUS_LEVEL_L                    0x00000020

/** There is a HIGH LEVEL alarm present.*/
#define STATUS_LEVEL_H                    0x00000040

/** There is an ERROR alarm present.*/
#define STATUS_ERROR                      0x00000100

/** There is a LOW-LOW LEVEL alarm present. */
#define STATUS_LEVEL_LL                   0x00000200

/** There is a HIGH-HIGH LEVEL alarm present. */
#define STATUS_LEVEL_HH                   0x00000400

/** There is an EMERGENCY alarm present. */
#define STATUS_EMERGENCY                  0x00000800

/** The signal value is forced (overridden). */
#define STATUS_VALUE_FORCED               0x00001000

/** The alarm is blocked due to too many repeats.*/
#define STATUS_REPEATBLOCKED              0x00002000

/** The alarm is blocked by the software. */
#define STATUS_PROCESSBLOCKED             0x00004000

/** The alarm is blocked by the user. */
#define STATUS_OPERATORBLOCKED            0x00008000

/** There is an Unacknowledged NOTIFY alarm present. */
#define STATUS_UNACKNOTIFY                0x00010000

/** There is an Unacknowledged WARNING alarm present. */
#define STATUS_UNACKWARNING               0x00100000

/** There is an Unacknowledged ERROR alarm present. */
#define STATUS_UNACKERROR                 0x01000000

/** There is an Unacknowledged EMERGENCY alarm present. */
#define STATUS_UNACKEMERGENCY             0x08000000

/** The alarm is disabled. */
#define STATUS_DISABLED                   0x20000000

/** The signal has a fault condition present.*/
#define STATUS_SIGNAL_FAULT               0x40000000

/** The component is suspended. */
#define STATUS_COMPONENT_SUSPENDED        0x80000000

/** There is an Unacknowledged alarm present of any level. */
#define STATUS_UNACK_MASK                 (STATUS_UNACKNOTIFY|STATUS_UNACKWARNING|STATUS_UNACKERROR|STATUS_UNACKEMERGENCY)

/** There is an Unacknowledged alarm present of any level. */
#define STATUS_UNACK                      STATUS_UNACK_MASK

/** There is an LOW-LOW ERROR alarm present. */
#define STATUS_ERROR_LL                   (STATUS_ERROR | STATUS_LEVEL_LL)

/** There is an HIGH-HIGH ERROR alarm present. */
#define STATUS_ERROR_HH                   (STATUS_ERROR | STATUS_LEVEL_HH)

/** There is an LOW WARNING alarm present. */
#define STATUS_WARNING_L                  (STATUS_WARNING | STATUS_LEVEL_L)

/** There is an HIGH WARNING alarm present. */
#define STATUS_WARNING_H                  (STATUS_WARNING | STATUS_LEVEL_H)

/** There is an alarm present that is SET. */
#define STATUS_SET                        (STATUS_EMERGENCY|STATUS_ERROR|STATUS_LEVEL_HH|STATUS_LEVEL_LL|STATUS_WARNING|STATUS_LEVEL_L|STATUS_LEVEL_H|STATUS_NOTIFY)

/** There is an EMERGENCY alarm present. */
#define STATUS_LEVEL_EMERGENCY            STATUS_EMERGENCY

/** There is an ERROR alarm present. */
#define STATUS_LEVEL_ERROR                STATUS_ERROR

/** There is an WARNING alarm present. */
#define STATUS_LEVEL_WARNING              STATUS_WARNING

/** There is a NOTIFY alarm present. */
#define STATUS_LEVEL_NOTIFY               STATUS_NOTIFY

/** There is an Unacknowledged NOTIFY alarm present. */
#define STATUS_LEVEL_UNACKNOTIFY          STATUS_UNACKNOTIFY

/** There is an Unacknowledged WARNING alarm present. */
#define STATUS_LEVEL_UNACKWARNING         STATUS_UNACKWARNING

/** There is an Unacknowledged ERROR alarm present. */
#define STATUS_LEVEL_UNACKERROR           STATUS_UNACKERROR

/** The alarm is blocked */
#define STATUS_BLOCKED                    (STATUS_REPEATBLOCKED|STATUS_PROCESSBLOCKED|STATUS_OPERATORBLOCKED)

Member Function Documentation

CDPAlarm::CDPAlarm()

Default constructs an instance of CDPAlarm.

CDPAlarm::~CDPAlarm()

Alarm object destructor

[virtual] void CDPAlarm::Acknowledge()

Acknowledge alarm if set. If a change is detected, loggingEnabled==true, and an EventLogger instance is found, ReportSimpleEvent with EVENT_ALARMACK is invoked.

[protected] void CDPAlarm::CheckInputAgainstConfiguredLevelValue(const e_AnalogueLevels levelType, const double currentInput, bool &setNow, unsigned int &newLevel)

If (errorLowEnabled || errorHighEnabled || warningLowEnabled || warningHighEnabled), this function is called to check if currentInput is above/below configured level. setNow becomes true if alarm should be Set, and then newLevel will be updated also. Clear() may be called.

[virtual] void CDPAlarm::Clear(bool checkTimeout = true)

Clear alarm. If a change is detected, loggingEnabled==true, and an EventLogger instance is found, ReportSimpleEvent with EVENT_ALARMCLEAR is invoked. If inputTimer is used, the timer will be stopped (inputTimer.Reset()) checkTimeout is unused.

[override virtual] void CDPAlarm::Configure(const char *xml)

Reimplemented from CDPObject::Configure().

Reads alarm configuration from .xml buffer. Called from owner (parent) Configure(...).

[override virtual] void CDPAlarm::Configure(XMLElementEx *pAlarmElement)

Reimplemented from CDPObject::Configure().

Reads alarm configuration from .xml buffer. Called from owner (parent) Configure(...).

[override virtual] void CDPAlarm::Create(const char *name, CDPComponent *pParent = NULL)

Reimplemented from CDPObject::Create().

Create alarm and clear status.

[override virtual protected] void CDPAlarm::CreateModel()

Reimplemented from CDPBaseObject::CreateModel().

Create the model and register messages.

CDPTime CDPAlarm::DateTimeLastModified()

Date and Time object was last modified

[override virtual] void CDPAlarm::Destroy()

Reimplemented from CDPBaseObject::Destroy().

Do pre-destructor stuff, like signalling to other objects that the component is about to die. This method should reverse what was done in Create().

[virtual] void CDPAlarm::Disable()

Disable the alarm. Will not even check alarm status.

[virtual] void CDPAlarm::Enable()

Enable the alarm.

[override virtual] void CDPAlarm::FillNodeChildren(CDP::StudioAPI::NodeStream &serializer) const

[virtual] CDPProperty<std::string> &CDPAlarm::GetAlarmText()

Return the alarm text string

std::string CDPAlarm::GetExtendedData() const

[override virtual] std::string CDPAlarm::GetProperty(std::string propertyName)

Reimplemented from CDPBaseObject::GetProperty().

Get the value of a property in this object.

[virtual] CDPProperty<std::string> &CDPAlarm::Group()

Return the alarm group

[override virtual] bool CDPAlarm::IsReadyToActivate()

[virtual] bool CDPAlarm::IsSet() const

Returns true if alarm is set.

[virtual] bool CDPAlarm::IsUnacknowledged() const

Returns true if alarm is not acknowledged.

unsigned int CDPAlarm::Level() const

Return the alarm level

See also Alarm Status Defines.

[protected] void CDPAlarm::LogEvent(unsigned int nEventType)

Helper function to log event

[protected] void CDPAlarm::Notify(int _handle)

[protected] void CDPAlarm::PossiblyEnableOrDisable_inputTimer()

This function will either set up timers for "LevelHighError", "LevelLowError", "LevelHighWarning" and "LevelLowWarning" (if configured), or for the inputTimer. The value from "Timeout" will be used when setting up the timers, but the timers are not started.

[override virtual] int CDPAlarm::ReceiveMessage(void *message)

Reimplemented from CDPBaseObject::ReceiveMessage().

Message processing.

[virtual] void CDPAlarm::Reset()

Clear status: Calls Acknowledge() and Clear().

[virtual] void CDPAlarm::Set(bool checkTimeout = true)

Set alarm if enabled. If a change is detected, loggingEnabled==true, and an EventLogger instance is found, ReportSimpleEvent with EVENT_ALARMSET is invoked. If checkTimeout is true and inputTimer is used: if timer is not running, timer is restarted. If timer has not timed out, function will return without alarm being Set. If checkTimeout is false: no checks on inputTimer will be done.

[virtual] void CDPAlarm::SetAlarmGroup(const std::string &newAlarmGroup)

Set the alarm group to the new string. If change detected, loggingEnabled, and an EventLogger is enabled and found, ReportExtendedEvent will be invoked with an EVENT_TEXT_CHANGE "Group" along with the group.

[virtual] void CDPAlarm::SetAlarmText(const std::string &newAlarmText)

Set the alarm text to the new string. If loggingEnabled, and an EventLogger is enabled and found, ReportExtendedEvent will be invoked with an EVENT_TEXT_CHANGE "Text" along with the text.

Note: to preserve the new alarm text across application reboots, call instead SetProperty("Text", newAlarmText);

void CDPAlarm::SetExtendedData(const std::string &extendedData)

[virtual] void CDPAlarm::SetLevel(unsigned int newLevel)

Set level to STATUS_NOTIFY, STATUS_WARNING, STATUS_ERROR. If loggingEnabled==true, and an EventLogger instance is found, ReportExtendedEvent with EVENT_PROPERTY_CHANGE "Level" and the new level (string integer) is invoked.

See also Alarm Status Defines.

[override virtual] void CDPAlarm::SetProperty(std::string propertyName, std::string propertyValue)

Reimplemented from CDPBaseObject::SetProperty().

Set a property in the object. Called by MessageSetProperty after property name and value has been figured out.

[override virtual] void CDPAlarm::SetPropertyHandler(CDPPropertyBase *pProp)

Reimplemented from CDPObject::SetPropertyHandler().

Do special handling for properties after they are set.

[override virtual] unsigned int CDPAlarm::Status() const

Reimplemented from CDPBaseObject::Status().

Returns alarm status. Compare with STATUS_xxx to determine what it means.

See also Alarm Status Defines.

[virtual] int CDPAlarm::Update(unsigned int &blockedStates, int currentState)

Called from owner CDPComponent::Process() to update alarm periodically. Updates blockedStates parameter if alarm is Set. Also handles re-reporting of events. Returns status.

See also Alarm Status Defines.

[protected] void CDPAlarm::UpdateLoggingEnabled(CDPPropertyBase *pProp)

Update LoggingEnabled on all properties in this object when LoggingEnabled property changes.

[override virtual] bool CDPAlarm::ValidatePropertyHandler(CDP::StudioAPI::CDPVariantValue &newValue, CDPPropertyBase *property)

Reimplemented from CDPObject::ValidatePropertyHandler().

Do special validation/changing of properties before they are set.