From 498eaa739437b7ba18901fbb12ed0652c4ec5c70 Mon Sep 17 00:00:00 2001
From: gscalamera <graziano.scalamera@elettra.eu>
Date: Tue, 28 Mar 2017 16:21:11 +0200
Subject: [PATCH] Re-generated with pogo to add new commands and attributes:
Enable, Disable, Shelve, ... normalAlarms, shelvedAlarms, ...
---
src/Alarm.cpp | 1588 ++++++++++++++++++++++++++++---------
src/Alarm.h | 203 ++++-
src/Alarm.xmi | 168 +++-
src/AlarmClass.cpp | 637 ++++++++++-----
src/AlarmClass.h | 259 +++++-
src/AlarmStateMachine.cpp | 260 +++++-
src/alarm_table.cpp | 64 +-
src/alarm_table.h | 2 +
8 files changed, 2494 insertions(+), 687 deletions(-)
diff --git a/src/Alarm.cpp b/src/Alarm.cpp
index cfdbdde..7d985c8 100644
--- a/src/Alarm.cpp
+++ b/src/Alarm.cpp
@@ -98,23 +98,38 @@ static const char __FILE__rev[] = __FILE__ " $Revision: 1.29 $";
// The following table gives the correspondence
// between command and method names.
//
-// Command name | Method name
+// Command name | Method name
//================================================================
-// State | Inherited (no method)
-// Status | Inherited (no method)
-// Ack | ack
-// Load | load
-// Remove | remove
-// Configured | configured
-// StopNew | stop_new
-// Silence | silence
-// Modify | modify
+// State | Inherited (no method)
+// Status | Inherited (no method)
+// Ack | ack
+// Load | load
+// Remove | remove
+// SearchAlarm | search_alarm
+// StopAudible | stop_audible
+// Silence | silence
+// Modify | modify
+// Shelve | shelve
+// Enable | enable
+// Disable | disable
+// ResetStatistics | reset_statistics
//================================================================
//================================================================
-// Attributes managed is:
+// Attributes managed are:
//================================================================
-// alarm | Tango::DevString Spectrum ( max = 1024)
+// audibleAlarm | Tango::DevBoolean Scalar
+// StatisticsResetTime | Tango::DevDouble Scalar
+// alarm | Tango::DevString Spectrum ( max = 1024)
+// normalAlarms | Tango::DevString Spectrum ( max = 10000)
+// unacknowledgedAlarms | Tango::DevString Spectrum ( max = 10000)
+// acknowledgedAlarms | Tango::DevString Spectrum ( max = 10000)
+// unacknowledgedNormalAlarms | Tango::DevString Spectrum ( max = 10000)
+// shelvedAlarms | Tango::DevString Spectrum ( max = 10000)
+// outOfServiceAlarms | Tango::DevString Spectrum ( max = 10000)
+// silencedAlarms | Tango::DevString Spectrum ( max = 10000)
+// listAlarms | Tango::DevString Spectrum ( max = 10000)
+// frequencyAlarms | Tango::DevDouble Spectrum ( max = 10000)
//================================================================
namespace Alarm_ns
@@ -268,6 +283,17 @@ void Alarm::delete_device()
//Tango::leavefunc();
/*----- PROTECTED REGION END -----*/ // Alarm::delete_device
+ delete[] attr_audibleAlarm_read;
+ delete[] attr_StatisticsResetTime_read;
+ delete[] attr_normalAlarms_read;
+ delete[] attr_unacknowledgedAlarms_read;
+ delete[] attr_acknowledgedAlarms_read;
+ delete[] attr_unacknowledgedNormalAlarms_read;
+ delete[] attr_shelvedAlarms_read;
+ delete[] attr_outOfServiceAlarms_read;
+ delete[] attr_silencedAlarms_read;
+ delete[] attr_listAlarms_read;
+ delete[] attr_frequencyAlarms_read;
}
//--------------------------------------------------------
@@ -295,18 +321,37 @@ void Alarm::init_device()
cout << "ERROR: second instance of Alarm Server, exiting..." << endl;
exit(-1);
} //-------------------------------------------
- errThreshold = 0;
alarmedlock = new(ReadersWritersLock);
internallock = new(ReadersWritersLock);
dslock = new(ReadersWritersLock);
alarms.set_dev(this);
+ normalAlarms_read.reserve(MAX_ALARMS);
+ unacknowledgedAlarms_read.reserve(MAX_ALARMS);
+ acknowledgedAlarms_read.reserve(MAX_ALARMS);
+ unacknowledgedNormalAlarms_read.reserve(MAX_ALARMS);
+ shelvedAlarms_read.reserve(MAX_ALARMS);
+ outOfServiceAlarms_read.reserve(MAX_ALARMS);
+ silencedAlarms_read.reserve(MAX_ALARMS);
+ listAlarms_read.reserve(MAX_ALARMS);
+
/*----- PROTECTED REGION END -----*/ // Alarm::init_device_before
// Get the device properties from database
get_device_property();
+ attr_audibleAlarm_read = new Tango::DevBoolean[1];
+ attr_StatisticsResetTime_read = new Tango::DevDouble[1];
+ attr_normalAlarms_read = new Tango::DevString[10000];
+ attr_unacknowledgedAlarms_read = new Tango::DevString[10000];
+ attr_acknowledgedAlarms_read = new Tango::DevString[10000];
+ attr_unacknowledgedNormalAlarms_read = new Tango::DevString[10000];
+ attr_shelvedAlarms_read = new Tango::DevString[10000];
+ attr_outOfServiceAlarms_read = new Tango::DevString[10000];
+ attr_silencedAlarms_read = new Tango::DevString[10000];
+ attr_listAlarms_read = new Tango::DevString[10000];
+ attr_frequencyAlarms_read = new Tango::DevDouble[10000];
/*----- PROTECTED REGION ID(Alarm::init_device) ENABLED START -----*/
// Initialize device
@@ -328,21 +373,10 @@ void Alarm::init_device()
{
ERROR_STREAM << __FUNCTION__ << " Error reading Database property='" << e.errors[0].desc << "'";
}
- string server = "alarm-srv/test";
- Tango::DbServerInfo info = db->get_server_info(server);
- INFO_STREAM << " INFO: host=" << info.host;
delete db;
#endif
-
- dbPortint = atoi(dbPort.c_str());
- if(dbHost.empty() || dbUser.empty() || dbPasswd.empty() || dbName.empty() || (dbPortint == 0) || instanceName.empty())
- {
- ERROR_STREAM << "Alarm::init_device(): not all necessary properties are defined: DbHost="<<dbHost<<
- " DbUser="<<dbUser<<" DbPasswd="<<dbPasswd<<" DbName="<<dbName<<" DbPort="<<dbPortint<<" InstanceName="<<instanceName<< endl;
- cout << "Error: not all necessary properties are defined. Exiting..." << endl;
- exit(-2);
- }
+
ds_num = 0; //initialize number of lines returned by read_alarm
internal_counter = 0;
@@ -676,6 +710,11 @@ void Alarm::init_device()
for (int i=0; i< MAX_ALARMS ; i++)
ds[i]=(char *) (dss[i]);
+ timespec now;
+ clock_gettime(CLOCK_MONOTONIC, &now);
+ double dnow = (now.tv_sec) + ((double)(now.tv_nsec))/1000000000;
+ last_statistics_reset_time = dnow;
+
/*----- PROTECTED REGION END -----*/ // Alarm::init_device
}
@@ -697,16 +736,9 @@ void Alarm::get_device_property()
// Read device properties from database.
Tango::DbData dev_prop;
- dev_prop.push_back(Tango::DbDatum("AlarmStatus"));
dev_prop.push_back(Tango::DbDatum("GroupNames"));
- dev_prop.push_back(Tango::DbDatum("ErrThreshold"));
- dev_prop.push_back(Tango::DbDatum("DbHost"));
- dev_prop.push_back(Tango::DbDatum("DbUser"));
- dev_prop.push_back(Tango::DbDatum("DbPasswd"));
- dev_prop.push_back(Tango::DbDatum("DbName"));
- dev_prop.push_back(Tango::DbDatum("DbPort"));
- dev_prop.push_back(Tango::DbDatum("InstanceName"));
dev_prop.push_back(Tango::DbDatum("SubscribeRetryPeriod"));
+ dev_prop.push_back(Tango::DbDatum("StatisticsTimeWindow"));
// is there at least one property to be read ?
if (dev_prop.size()>0)
@@ -721,17 +753,6 @@ void Alarm::get_device_property()
(static_cast<AlarmClass *>(get_device_class()));
int i = -1;
- // Try to initialize AlarmStatus from class property
- cl_prop = ds_class->get_class_property(dev_prop[++i].name);
- if (cl_prop.is_empty()==false) cl_prop >> alarmStatus;
- else {
- // Try to initialize AlarmStatus from default device value
- def_prop = ds_class->get_default_device_property(dev_prop[i].name);
- if (def_prop.is_empty()==false) def_prop >> alarmStatus;
- }
- // And try to extract AlarmStatus value from database
- if (dev_prop[i].is_empty()==false) dev_prop[i] >> alarmStatus;
-
// Try to initialize GroupNames from class property
cl_prop = ds_class->get_class_property(dev_prop[++i].name);
if (cl_prop.is_empty()==false) cl_prop >> groupNames;
@@ -743,83 +764,6 @@ void Alarm::get_device_property()
// And try to extract GroupNames value from database
if (dev_prop[i].is_empty()==false) dev_prop[i] >> groupNames;
- // Try to initialize ErrThreshold from class property
- cl_prop = ds_class->get_class_property(dev_prop[++i].name);
- if (cl_prop.is_empty()==false) cl_prop >> errThreshold;
- else {
- // Try to initialize ErrThreshold from default device value
- def_prop = ds_class->get_default_device_property(dev_prop[i].name);
- if (def_prop.is_empty()==false) def_prop >> errThreshold;
- }
- // And try to extract ErrThreshold value from database
- if (dev_prop[i].is_empty()==false) dev_prop[i] >> errThreshold;
-
- // Try to initialize DbHost from class property
- cl_prop = ds_class->get_class_property(dev_prop[++i].name);
- if (cl_prop.is_empty()==false) cl_prop >> dbHost;
- else {
- // Try to initialize DbHost from default device value
- def_prop = ds_class->get_default_device_property(dev_prop[i].name);
- if (def_prop.is_empty()==false) def_prop >> dbHost;
- }
- // And try to extract DbHost value from database
- if (dev_prop[i].is_empty()==false) dev_prop[i] >> dbHost;
-
- // Try to initialize DbUser from class property
- cl_prop = ds_class->get_class_property(dev_prop[++i].name);
- if (cl_prop.is_empty()==false) cl_prop >> dbUser;
- else {
- // Try to initialize DbUser from default device value
- def_prop = ds_class->get_default_device_property(dev_prop[i].name);
- if (def_prop.is_empty()==false) def_prop >> dbUser;
- }
- // And try to extract DbUser value from database
- if (dev_prop[i].is_empty()==false) dev_prop[i] >> dbUser;
-
- // Try to initialize DbPasswd from class property
- cl_prop = ds_class->get_class_property(dev_prop[++i].name);
- if (cl_prop.is_empty()==false) cl_prop >> dbPasswd;
- else {
- // Try to initialize DbPasswd from default device value
- def_prop = ds_class->get_default_device_property(dev_prop[i].name);
- if (def_prop.is_empty()==false) def_prop >> dbPasswd;
- }
- // And try to extract DbPasswd value from database
- if (dev_prop[i].is_empty()==false) dev_prop[i] >> dbPasswd;
-
- // Try to initialize DbName from class property
- cl_prop = ds_class->get_class_property(dev_prop[++i].name);
- if (cl_prop.is_empty()==false) cl_prop >> dbName;
- else {
- // Try to initialize DbName from default device value
- def_prop = ds_class->get_default_device_property(dev_prop[i].name);
- if (def_prop.is_empty()==false) def_prop >> dbName;
- }
- // And try to extract DbName value from database
- if (dev_prop[i].is_empty()==false) dev_prop[i] >> dbName;
-
- // Try to initialize DbPort from class property
- cl_prop = ds_class->get_class_property(dev_prop[++i].name);
- if (cl_prop.is_empty()==false) cl_prop >> dbPort;
- else {
- // Try to initialize DbPort from default device value
- def_prop = ds_class->get_default_device_property(dev_prop[i].name);
- if (def_prop.is_empty()==false) def_prop >> dbPort;
- }
- // And try to extract DbPort value from database
- if (dev_prop[i].is_empty()==false) dev_prop[i] >> dbPort;
-
- // Try to initialize InstanceName from class property
- cl_prop = ds_class->get_class_property(dev_prop[++i].name);
- if (cl_prop.is_empty()==false) cl_prop >> instanceName;
- else {
- // Try to initialize InstanceName from default device value
- def_prop = ds_class->get_default_device_property(dev_prop[i].name);
- if (def_prop.is_empty()==false) def_prop >> instanceName;
- }
- // And try to extract InstanceName value from database
- if (dev_prop[i].is_empty()==false) dev_prop[i] >> instanceName;
-
// Try to initialize SubscribeRetryPeriod from class property
cl_prop = ds_class->get_class_property(dev_prop[++i].name);
if (cl_prop.is_empty()==false) cl_prop >> subscribeRetryPeriod;
@@ -831,6 +775,17 @@ void Alarm::get_device_property()
// And try to extract SubscribeRetryPeriod value from database
if (dev_prop[i].is_empty()==false) dev_prop[i] >> subscribeRetryPeriod;
+ // Try to initialize StatisticsTimeWindow from class property
+ cl_prop = ds_class->get_class_property(dev_prop[++i].name);
+ if (cl_prop.is_empty()==false) cl_prop >> statisticsTimeWindow;
+ else {
+ // Try to initialize StatisticsTimeWindow from default device value
+ def_prop = ds_class->get_default_device_property(dev_prop[i].name);
+ if (def_prop.is_empty()==false) def_prop >> statisticsTimeWindow;
+ }
+ // And try to extract StatisticsTimeWindow value from database
+ if (dev_prop[i].is_empty()==false) dev_prop[i] >> statisticsTimeWindow;
+
}
/*----- PROTECTED REGION ID(Alarm::get_device_property_after) ENABLED START -----*/
@@ -841,32 +796,6 @@ void Alarm::get_device_property()
*/
alarm_t tmp_alm;
tmp_alm.init_static_map(groupNames);
-
- /*
- * retrive last saved alarms status
- */
- if (alarmStatus.empty() == false) {
- for (vector<string>::iterator i = alarmStatus.begin(); \
- i != alarmStatus.end(); i++) {
- /*
- * test for string length; data[1].is_empty() will return false
- * when empty string eventually initialized with jive!!!!!!
- */
- if (i->length() != 0) {
- alarm_t tmp_alm;
- tmp_alm.str2alm(*i);
- tmp_alm.is_new = /*(tmp_alm.stat == S_ALARM) ? 1 :*/ 0; //don't beep at startup on old alarms
- stored.push_back(tmp_alm);
- }
- }
- }
- DEBUG_STREAM << "saved alarms table:" << endl;
- if (stored.empty() == false) {
- for (vector<alarm_t>::iterator a = stored.begin(); \
- a != stored.end(); a++) {
- DEBUG_STREAM << "\t" << a->alm2str() << endl;
- }
- }
/*----- PROTECTED REGION END -----*/ // Alarm::get_device_property_after
}
@@ -896,7 +825,7 @@ void Alarm::always_executed_hook()
//--------------------------------------------------------
void Alarm::read_attr_hardware(TANGO_UNUSED(vector<long> &attr_list))
{
- DEBUG_STREAM << "Alarm::read_attr_hardware(vector<long> &attr_list) entering... " << endl;
+ //DEBUG_STREAM << "Alarm::read_attr_hardware(vector<long> &attr_list) entering... " << endl;
/*----- PROTECTED REGION ID(Alarm::read_attr_hardware) ENABLED START -----*/
// Add your own code
@@ -908,6 +837,46 @@ void Alarm::read_attr_hardware(TANGO_UNUSED(vector<long> &attr_list))
/*----- PROTECTED REGION END -----*/ // Alarm::read_attr_hardware
}
+//--------------------------------------------------------
+/**
+ * Read attribute audibleAlarm related method
+ * Description: True if there is at least one alarm that needs audible indication on the GUI
+ *
+ * Data type: Tango::DevBoolean
+ * Attr type: Scalar
+ */
+//--------------------------------------------------------
+void Alarm::read_audibleAlarm(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_audibleAlarm(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_audibleAlarm) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_audibleAlarm_read);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_audibleAlarm
+}
+//--------------------------------------------------------
+/**
+ * Read attribute StatisticsResetTime related method
+ * Description: Time elapsed in seconds since last Resetstatistics
+ *
+ * Data type: Tango::DevDouble
+ * Attr type: Scalar
+ */
+//--------------------------------------------------------
+void Alarm::read_StatisticsResetTime(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_StatisticsResetTime(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_StatisticsResetTime) ENABLED START -----*/
+ timespec now;
+ clock_gettime(CLOCK_MONOTONIC, &now);
+ double dnow = (now.tv_sec) + ((double)(now.tv_nsec))/1000000000;
+ *attr_StatisticsResetTime_read = dnow - last_statistics_reset_time;
+ // Set the attribute value
+ attr.set_value(attr_StatisticsResetTime_read);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_StatisticsResetTime
+}
//--------------------------------------------------------
/**
* Read attribute alarm related method
@@ -1086,6 +1055,168 @@ void Alarm::read_alarm(Tango::Attribute &attr)
/*----- PROTECTED REGION END -----*/ // Alarm::read_alarm
}
+//--------------------------------------------------------
+/**
+ * Read attribute normalAlarms related method
+ * Description: List of alarms in normal state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+//--------------------------------------------------------
+void Alarm::read_normalAlarms(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_normalAlarms(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_normalAlarms) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_normalAlarms_read, normalAlarms_sz);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_normalAlarms
+}
+//--------------------------------------------------------
+/**
+ * Read attribute unacknowledgedAlarms related method
+ * Description: List of alarms in unacknowledged state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+//--------------------------------------------------------
+void Alarm::read_unacknowledgedAlarms(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_unacknowledgedAlarms(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_unacknowledgedAlarms) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_unacknowledgedAlarms_read, unacknowledgedAlarms_sz);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_unacknowledgedAlarms
+}
+//--------------------------------------------------------
+/**
+ * Read attribute acknowledgedAlarms related method
+ * Description: List of alarms in acknowledged state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+//--------------------------------------------------------
+void Alarm::read_acknowledgedAlarms(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_acknowledgedAlarms(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_acknowledgedAlarms) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_acknowledgedAlarms_read, acknowledgedAlarms_sz);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_acknowledgedAlarms
+}
+//--------------------------------------------------------
+/**
+ * Read attribute unacknowledgedNormalAlarms related method
+ * Description: List of alarms in unacknowledged normal state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+//--------------------------------------------------------
+void Alarm::read_unacknowledgedNormalAlarms(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_unacknowledgedNormalAlarms(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_unacknowledgedNormalAlarms) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_unacknowledgedNormalAlarms_read, unacknowledgedNormalAlarms_sz);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_unacknowledgedNormalAlarms
+}
+//--------------------------------------------------------
+/**
+ * Read attribute shelvedAlarms related method
+ * Description: List of alarms in shelved state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+//--------------------------------------------------------
+void Alarm::read_shelvedAlarms(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_shelvedAlarms(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_shelvedAlarms) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_shelvedAlarms_read, shelvedAlarms_sz);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_shelvedAlarms
+}
+//--------------------------------------------------------
+/**
+ * Read attribute outOfServiceAlarms related method
+ * Description: List of alarms in out of service state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+//--------------------------------------------------------
+void Alarm::read_outOfServiceAlarms(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_outOfServiceAlarms(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_outOfServiceAlarms) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_outOfServiceAlarms_read, outOfServiceAlarms_sz);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_outOfServiceAlarms
+}
+//--------------------------------------------------------
+/**
+ * Read attribute silencedAlarms related method
+ * Description: List of alarms in silenced state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+//--------------------------------------------------------
+void Alarm::read_silencedAlarms(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_silencedAlarms(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_silencedAlarms) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_silencedAlarms_read, silencedAlarms_sz);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_silencedAlarms
+}
+//--------------------------------------------------------
+/**
+ * Read attribute listAlarms related method
+ * Description: List of all alarms
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+//--------------------------------------------------------
+void Alarm::read_listAlarms(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_listAlarms(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_listAlarms) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_listAlarms_read, listAlarms_sz);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_listAlarms
+}
+//--------------------------------------------------------
+/**
+ * Read attribute frequencyAlarms related method
+ * Description: List of frequency of evaluation of all alarms
+ *
+ * Data type: Tango::DevDouble
+ * Attr type: Spectrum max = 10000
+ */
+//--------------------------------------------------------
+void Alarm::read_frequencyAlarms(Tango::Attribute &attr)
+{
+ DEBUG_STREAM << "Alarm::read_frequencyAlarms(Tango::Attribute &attr) entering... " << endl;
+ /*----- PROTECTED REGION ID(Alarm::read_frequencyAlarms) ENABLED START -----*/
+ // Set the attribute value
+ attr.set_value(attr_frequencyAlarms_read, listAlarms_sz);
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::read_frequencyAlarms
+}
//--------------------------------------------------------
/**
@@ -1247,18 +1378,43 @@ void Alarm::ack(const Tango::DevVarStringArray *argin)
if (found != alarmed.end())
{
alarm_container_t::iterator i = alarms.v_alarm.find(*si);
- if(i != alarms.v_alarm.end())
+
+ if(i == alarms.v_alarm.end())
{
- //update alarm ack in alarm table
- i->second.ack = ACK;
- //update alarm status from alarm table
- found->stat = i->second.stat;
+ INFO_STREAM << __func__ << ": alarm '" << *si << "' not found";
+ alarmedlock->readerOut();
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ continue;
+ }
+ if(!i->second.enabled || i->second.shelved)
+ {
+ DEBUG_STREAM << __func__ << ": alarm '" << *si << "' not enabled";
+ alarmedlock->readerOut();
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ continue;
}
+
+ //update alarm ack in alarm table
+ i->second.ack = ACK;
+ //update alarm status from alarm table
+ found->stat = i->second.stat;
+
if(found->ack == NOT_ACK)
{
Tango::DevEnum *attr_value = get_AlarmState_data_ptr(i->second.attr_name);
- //TODO: if not _SHLVD, _DSUPR, _OOSRV
- if((i->second.stat == S_NORMAL) && i->second.ack == ACK)
+ if(!i->second.enabled)
+ *attr_value = _OOSRV;
+ else if(i->second.shelved && i->second.silenced > 0)
+ *attr_value = _SHLVD;
+ else if((i->second.stat == S_NORMAL) && i->second.ack == ACK)
*attr_value = _NORM;
else if((i->second.stat == S_ALARM) && i->second.ack == NOT_ACK)
*attr_value = _UNACK;
@@ -1293,29 +1449,6 @@ void Alarm::ack(const Tango::DevVarStringArray *argin)
}
}
found->ack = ACK;
- } else {
- internallock->readerIn();
- found = find(internal.begin(), internal.end(), *si);
- if (found != internal.end()) {
- found->ack = ACK;
- } else {
- ostringstream o;
- o << "\"" << *si << "\" not in 'alarmed' or 'internal' table" << endl;
- WARN_STREAM << "Alarm::ack(): " << o.str() << endl;
- internallock->readerOut();
- alarmedlock->readerOut();
-#ifndef _RW_LOCK
- alarms.unlock();
-#else
- alarms.vlock->readerOut();
-#endif
- Tango::Except::throw_exception( \
- (const char*)"Alarm not found!!", \
- o.str(), \
- (const char*)"Alarm::ack()", Tango::ERR);
-
- }
- internallock->readerOut();
}
alarmedlock->readerOut();
#ifndef _RW_LOCK
@@ -1346,28 +1479,6 @@ void Alarm::ack(const Tango::DevVarStringArray *argin)
}
alarmedlock->writerOut();
}
- /*
- * always remove internal ACKnowlwdged alarms as
- * they'll wont switch to "NORMAL"
- */
- to_be_removed.name = "";
- to_be_removed.formula = "";
- to_be_removed.stat = S_ALARM;
- to_be_removed.ack = ACK;
- go = true;
- while (go) {
- internallock->writerIn();
- vector<alarm_t>::iterator found = \
- find(internal.begin(), internal.end(), to_be_removed);
- if (found != internal.end()) {
- DEBUG_STREAM << "Alarm::ack(): " << found->name \
- << " ACK, removing" << endl;
- internal.erase(found);
- } else {
- go = false;
- }
- internallock->writerOut();
- }
prepare_alarm_attr();
try
@@ -1380,8 +1491,31 @@ void Alarm::ack(const Tango::DevVarStringArray *argin)
push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
}
else
+ {
//attr.set_value(ds, ds_num, 0, false);
push_change_event("alarm",ds, ds_num, 0, false);
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_change_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_change_event("audibleAlarm",attr_audibleAlarm_read);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_archive_event("audibleAlarm",attr_audibleAlarm_read);
+
} catch(Tango::DevFailed& e)
{
ostringstream err;
@@ -1678,8 +1812,30 @@ void Alarm::remove(Tango::DevString argin)
push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
}
else
+ {
//attr.set_value(ds, ds_num, 0, false);
push_change_event("alarm",ds, ds_num, 0, false);
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_change_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_change_event("audibleAlarm",attr_audibleAlarm_read);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_archive_event("audibleAlarm",attr_audibleAlarm_read);
} catch(Tango::DevFailed& e)
{
ostringstream err;
@@ -1691,18 +1847,18 @@ void Alarm::remove(Tango::DevString argin)
}
//--------------------------------------------------------
/**
- * Command Configured related method
- * Description: Alarms configured
+ * Command SearchAlarm related method
+ * Description: Return list of configured alarms matching the filter string
*
- * @param argin String containing a filter for output, if empty return all alarms
- * @returns Alarms configured
+ * @param argin String containing a filter for output, if empty or * return all alarms
+ * @returns Configured alarms
*/
//--------------------------------------------------------
-Tango::DevVarStringArray *Alarm::configured(Tango::DevString argin)
+Tango::DevVarStringArray *Alarm::search_alarm(Tango::DevString argin)
{
Tango::DevVarStringArray *argout;
- DEBUG_STREAM << "Alarm::Configured() - " << device_name << endl;
- /*----- PROTECTED REGION ID(Alarm::configured) ENABLED START -----*/
+ DEBUG_STREAM << "Alarm::SearchAlarm() - " << device_name << endl;
+ /*----- PROTECTED REGION ID(Alarm::search_alarm) ENABLED START -----*/
// Add your own code
// POGO has generated a method core with argout allocation.
@@ -1718,6 +1874,32 @@ Tango::DevVarStringArray *Alarm::configured(Tango::DevString argin)
// Add your own code to control device here
string filter(argin);
+ string filter_begin(filter);
+ string filter_end("");
+
+ size_t start_pos = 0;
+/* string from("*");
+ string to("");
+ while((start_pos = filter.find(from, start_pos)) != std::string::npos)
+ {
+ filter.replace(start_pos, from.length(), to);
+ start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
+ }*/
+ start_pos = filter.find("*", start_pos);
+ if(start_pos != std::string::npos && start_pos == filter.size()-1) //* is the only character or at the end of the filter
+ {
+ filter.replace(start_pos, 1, "");
+ filter_begin = filter;
+ DEBUG_STREAM << __func__ << ": updated filter to: " << filter_begin;
+ }
+ /*else if(start_pos != std::string::npos) //* is in the middle of the filter
+ {
+ string filter_begin=filter.substr(0,start_pos);
+ string filter_end=filter.substr(start_pos+1);
+ DEBUG_STREAM << __func__ << ": splitted filter to: " << filter_begin << " - " << filter_end;
+ }*/
+
+
size_t found;
vector<string> alarm_filtered;
ostringstream os1;
@@ -1734,11 +1916,11 @@ Tango::DevVarStringArray *Alarm::configured(Tango::DevString argin)
for (ai = alarms.v_alarm.begin(); ai != alarms.v_alarm.end(); ai++)
{
found = 0;
- if(filter.length() != 0)
+ if(filter_begin.length() != 0)
{
- found = ai->first.find(filter);
+ found = ai->first.find(filter_begin);
}
- if((filter.length() == 0) || (found != string::npos))
+ if((filter_begin.length() == 0) || (found != string::npos))
{
ostringstream os;
os.clear();
@@ -1761,20 +1943,20 @@ Tango::DevVarStringArray *Alarm::configured(Tango::DevString argin)
i++;
}
- /*----- PROTECTED REGION END -----*/ // Alarm::configured
+ /*----- PROTECTED REGION END -----*/ // Alarm::search_alarm
return argout;
}
//--------------------------------------------------------
/**
- * Command StopNew related method
- * Description: Remove "NEW" field from alarm string (so alarm panel stop sound)
+ * Command StopAudible related method
+ * Description: Stop audible indications on the GUI
*
*/
//--------------------------------------------------------
-void Alarm::stop_new()
+void Alarm::stop_audible()
{
- DEBUG_STREAM << "Alarm::StopNew() - " << device_name << endl;
- /*----- PROTECTED REGION ID(Alarm::stop_new) ENABLED START -----*/
+ DEBUG_STREAM << "Alarm::StopAudible() - " << device_name << endl;
+ /*----- PROTECTED REGION ID(Alarm::stop_audible) ENABLED START -----*/
// Add your own code
//12-06-08: StopNew command set is_new to 0
@@ -1805,8 +1987,30 @@ void Alarm::stop_new()
push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
}
else
+ {
//attr.set_value(ds, ds_num, 0, false);
push_change_event("alarm",ds, ds_num, 0, false);
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_change_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_change_event("audibleAlarm",attr_audibleAlarm_read);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_archive_event("audibleAlarm",attr_audibleAlarm_read);
} catch(Tango::DevFailed& e)
{
ostringstream err;
@@ -1814,7 +2018,7 @@ void Alarm::stop_new()
INFO_STREAM << __func__<<": " << err.str() << endl;
}
- /*----- PROTECTED REGION END -----*/ // Alarm::stop_new
+ /*----- PROTECTED REGION END -----*/ // Alarm::stop_audible
}
//--------------------------------------------------------
/**
@@ -1853,9 +2057,14 @@ void Alarm::silence(const Tango::DevVarStringArray *argin)
//silenced already calculated in alarm_table::update, but here updated for panel also if state not changed:
//to see minutes countdown
if(dminutes < i->second.silent_time)
+ {
i->second.silenced = i->second.silent_time - floor(dminutes);
+ }
else
+ {
i->second.silenced = 0;
+ i->second.shelved = false;
+ }
}
if(i->second.silenced > 0)
{
@@ -1934,8 +2143,30 @@ void Alarm::silence(const Tango::DevVarStringArray *argin)
push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
}
else
+ {
//attr.set_value(ds, ds_num, 0, false);
push_change_event("alarm",ds, ds_num, 0, false);
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_change_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_change_event("audibleAlarm",attr_audibleAlarm_read);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_archive_event("audibleAlarm",attr_audibleAlarm_read);
} catch(Tango::DevFailed& e)
{
ostringstream err;
@@ -1990,7 +2221,8 @@ void Alarm::modify(Tango::DevString argin)
alm.cmd_action_n.clear();
alm.send_arg_n = false;
alm.dp_n = NULL;
- alm.enabled=1;
+ alm.enabled=true;
+ alm.shelved=false;
alm.formula_tree =
//boost::spirit::tree_parse_info< std::string::iterator, factory_t> tmp =
@@ -2075,7 +2307,7 @@ void Alarm::modify(Tango::DevString argin)
i->second.on_delay = alm.on_delay;
i->second.off_delay = alm.off_delay;
i->second.silent_time = alm.silent_time;
- i->second.silenced = alm.silenced;
+ i->second.silenced = (i->second.silent_time > 0) ? 0 : -1; //0: can be silenced, -1: cannot be silencedd;
i->second.cmd_name_a = alm.cmd_name_a;
i->second.cmd_dp_a = alm.cmd_dp_a;
i->second.cmd_action_a = alm.cmd_action_a;
@@ -2086,128 +2318,599 @@ void Alarm::modify(Tango::DevString argin)
//i->second.send_arg_n = alm.send_arg_n;
i->second.enabled = alm.enabled;
- } else {
- ostringstream o;
- o << __func__<<": syntax error in '" << alarm_string << "'" << ends;
- WARN_STREAM << o.str() << endl;
+ } else {
+ ostringstream o;
+ o << __func__<<": syntax error in '" << alarm_string << "'" << ends;
+ WARN_STREAM << o.str() << endl;
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->writerOut();
+#endif
+ Tango::Except::throw_exception( \
+ (const char*)o.str().c_str(), \
+ (const char*)"", \
+ (const char*)__func__, Tango::ERR);
+ }
+
+ //update attribute properties
+ events->update_property();
+
+ //delete proxy for actions
+ if(i->second.dp_a)
+ delete i->second.dp_a;
+ i->second.dp_a = NULL;
+ if(i->second.dp_n)
+ delete i->second.dp_n;
+ i->second.dp_n = NULL;
+
+ if(alm.cmd_name_a.length() > 0)
+ {
+ try {
+ i->second.dp_a = new Tango::DeviceProxy(i->second.cmd_dp_a);
+ i->second.dp_a->ping();
+ Tango::CommandInfo info = i->second.dp_a->command_query(i->second.cmd_action_a);
+ if(info.in_type != Tango::DEV_STRING)
+ {
+ ostringstream err;
+ err << "Error: command " << i->second.cmd_name_a << " does not accept a Tango::DevString as input value" << ends;
+ ERROR_STREAM << __func__<<": " << err.str() << endl;
+ set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
+ }
+ else
+ {
+ if(info.in_type == Tango::DEV_STRING)
+ i->second.send_arg_a = true;
+ else
+ i->second.send_arg_a = false;
+ DEBUG_STREAM << __func__<<": successfully connected to proxy=" << i->second.cmd_dp_a << " for action=" << i->second.cmd_action_a << endl;
+ }
+ } catch(Tango::DevFailed& e)
+ {
+ ostringstream err;
+ err << alm.name << ": error connecting to device proxy=" << i->second.cmd_dp_a << ", err=" << e.errors[0].desc << ends;
+ WARN_STREAM << __func__<<": " << err.str() << endl;
+ set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
+ }
+ }
+ if(alm.cmd_name_n.length() > 0)
+ {
+ try {
+ i->second.dp_n = new Tango::DeviceProxy(i->second.cmd_dp_n);
+ i->second.dp_n->ping();
+ Tango::CommandInfo info = i->second.dp_n->command_query(i->second.cmd_action_a);
+ if(info.in_type != Tango::DEV_STRING)
+ {
+ ostringstream err;
+ err << "Error: command " << i->second.cmd_name_n << " does not accept a Tango::DevString as input value" << ends;
+ ERROR_STREAM << __func__<<": " << err.str() << endl;
+ set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
+ }
+ else
+ {
+ if(info.in_type == Tango::DEV_STRING)
+ i->second.send_arg_n = true;
+ else
+ i->second.send_arg_n = false;
+ DEBUG_STREAM << __func__<<": successfully connected to proxy=" << i->second.cmd_dp_n << " for action=" << i->second.cmd_action_n << endl;
+ }
+ } catch(Tango::DevFailed& e)
+ {
+ ostringstream err;
+ err << alm.name << ": error connecting to device proxy=" << i->second.cmd_dp_n << ", err=" << e.errors[0].desc << ends;
+ WARN_STREAM << __func__<<": " << err.str() << endl;
+ set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
+ }
+ }
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->writerOut();
+#endif
+ return;
+ }
+ }
+ else
+ {
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->writerOut();
+#endif
+ ostringstream o;
+ o << "Alarm '"<<alm.name<<"' not found" << ends;
+ DEBUG_STREAM << o.str() << endl;
+ Tango::Except::throw_exception( \
+ (const char*)"Not found", \
+ (const char*)o.str().c_str(), \
+ (const char*)__func__, Tango::ERR);
+ }
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->writerOut();
+#endif
+
+ //------------------------------
+ //3: remove (set active=0 on db)
+ //------------------------------
+ remove((Tango::DevString)alm.name.c_str());
+ DEBUG_STREAM << "Alarm::Modify: removed alm name=" << alm.name << endl;
+ //------------------------------
+ //4: load modified alarm
+ //------------------------------
+ load(argin);
+
+ prepare_alarm_attr();
+ try
+ {
+ if(ds_num == 0)
+ {
+ //attr.set_value_date_quality(ds,0/*gettime()*/,Tango::ATTR_WARNING, ds_num, 0, false);
+ struct timeval now;
+ gettimeofday(&now,NULL);
+ push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
+ }
+ else
+ {
+ //attr.set_value(ds, ds_num, 0, false);
+ push_change_event("alarm",ds, ds_num, 0, false);
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_change_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_change_event("audibleAlarm",attr_audibleAlarm_read);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_archive_event("audibleAlarm",attr_audibleAlarm_read);
+ } catch(Tango::DevFailed& e)
+ {
+ ostringstream err;
+ err << "error pushing alarm change event err=" << e.errors[0].desc;
+ INFO_STREAM << __func__<<": " << err.str() << endl;
+ }
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::modify
+}
+//--------------------------------------------------------
+/**
+ * Command Shelve related method
+ * Description: Shelve an alarm: no state transition recorded, no audible nor visual indication
+ *
+ * @param argin String array containing alarm to be shelved
+ */
+//--------------------------------------------------------
+void Alarm::shelve(const Tango::DevVarStringArray *argin)
+{
+ DEBUG_STREAM << "Alarm::Shelve() - " << device_name << endl;
+ /*----- PROTECTED REGION ID(Alarm::shelve) ENABLED START -----*/
+
+ // Add your own code
+ vector<string> str;
+ str << (*argin);
+ vector<string>::iterator si;
+
+ for (si = str.begin(); si != str.end(); si++)
+ {
+#ifndef _RW_LOCK
+ alarms.lock();
+#else
+ alarms.vlock->readerIn();
+#endif
+ alarm_container_t::iterator i = alarms.v_alarm.find(*si);
+ if(i == alarms.v_alarm.end())
+ {
+ ostringstream err;
+ err << *si << " not found in configured alarms" << ends;
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ Tango::Except::throw_exception( \
+ (const char*)"NOT_FOUND", \
+ (const char*)err.str().c_str(), \
+ (const char*)__func__, Tango::ERR);
+ }
+ if(!i->second.enabled)
+ {
+ ostringstream err;
+ err << *si << " is not enabled" << ends;
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ Tango::Except::throw_exception( \
+ (const char*)"NOT_ENABLED", \
+ (const char*)err.str().c_str(), \
+ (const char*)__func__, Tango::ERR);
+ }
+ if(i->second.silenced > 0)
+ {
+ Tango::TimeVal now = gettime();
+ double dnow = now.tv_sec + ((double)now.tv_usec) / 1000000;
+ double dsilent = i->second.ts_time_silenced.tv_sec + ((double)i->second.ts_time_silenced.tv_usec) / 1000000;
+ double dminutes = (dnow - dsilent)/60;
+ //silenced already calculated in alarm_table::update, but here updated for panel also if state not changed:
+ //to see minutes countdown
+ if(dminutes < i->second.silent_time)//TODO: shelve_time ?
+ {
+ i->second.silenced = i->second.silent_time - floor(dminutes);//TODO: shelve_time ?
+ }
+ else
+ {
+ i->second.silenced = 0;
+ i->second.shelved = false;
+ }
+ }
+ if(i->second.shelved)
+ {
+ ostringstream err;
+ err << *si << " is already shelved" << ends;
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ Tango::Except::throw_exception( \
+ (const char*)"ALREADY_SHELVED", \
+ (const char*)err.str().c_str(), \
+ (const char*)__func__, Tango::ERR);
+ }
+ if(i->second.silent_time <= 0)
+ {
+ ostringstream err;
+ err << "Alarm " << *si << " cannot be shelved" << ends;
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ Tango::Except::throw_exception( \
+ (const char*)"NOT_ALLOWED", \
+ err.str(), \
+ (const char*)__func__, Tango::ERR);
+ }
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ }
+
+ for (si = str.begin(); si != str.end(); si++)
+ {
+#ifndef _RW_LOCK
+ alarms.lock();
+#else
+ alarms.vlock->readerIn();
+#endif
+ alarm_container_t::iterator i = alarms.v_alarm.find(*si);
+ if(i == alarms.v_alarm.end())
+ continue;
+ i->second.shelved = true;
+
+ //load silent time
+ i->second.ts_time_silenced = gettime();
+ i->second.silenced = i->second.silent_time; //TODO: shelve_time ?
+ //search also in alarmed
+ alarmedlock->writerIn();
+ vector<alarm_t>::iterator found = \
+ find(alarmed.begin(), alarmed.end(), *si);
+ if (found != alarmed.end())
+ {
+ alarmed.erase(found);
+ }
+ alarmedlock->writerOut();
+
+
+ Tango::DevEnum *attr_value = get_AlarmState_data_ptr(i->second.attr_name);
+
+ *attr_value = _SHLVD;
+ try
+ { //DevFailed for push events
+ if(i->second.ex_reason.length() == 0)
+ {
+ timeval now;
+ gettimeofday(&now, NULL);
+ push_change_event(i->second.attr_name,(Tango::DevEnum *)attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
+ push_archive_event(i->second.attr_name,(Tango::DevEnum *)attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
+ }
+ else
+ {
+ Tango::DevErrorList errors(1);
+ errors.length(1);
+ errors[0].desc = CORBA::string_dup(i->second.ex_desc.c_str());
+ errors[0].severity = Tango::ERR;
+ errors[0].reason = CORBA::string_dup(i->second.ex_reason.c_str());
+ errors[0].origin = CORBA::string_dup(i->second.ex_origin.c_str());
+ Tango::DevFailed except(errors);
+ push_change_event(i->second.attr_name, &except);
+ push_archive_event(i->second.attr_name, &except);
+ }
+ } catch(Tango::DevFailed & ex)
+ {
+ WARN_STREAM << "Alarm::"<<__func__<<": EXCEPTION PUSHING EVENTS: " << ex.errors[0].desc << endl;
+ }
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ }
+
+ prepare_alarm_attr();
+ try
+ {
+ if(ds_num == 0)
+ {
+ //attr.set_value_date_quality(ds,0/*gettime()*/,Tango::ATTR_WARNING, ds_num, 0, false);
+ struct timeval now;
+ gettimeofday(&now,NULL);
+ push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
+ }
+ else
+ {
+ //attr.set_value(ds, ds_num, 0, false);
+ push_change_event("alarm",ds, ds_num, 0, false);
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ } catch(Tango::DevFailed& e)
+ {
+ ostringstream err;
+ err << "error pushing alarm change event err=" << e.errors[0].desc;
+ INFO_STREAM << __func__<<": " << err.str() << endl;
+ }
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::shelve
+}
+//--------------------------------------------------------
+/**
+ * Command Enable related method
+ * Description: Enable an alarm from Out of service state
+ *
+ * @param argin Alarm name
+ */
+//--------------------------------------------------------
+void Alarm::enable(Tango::DevString argin)
+{
+ DEBUG_STREAM << "Alarm::Enable() - " << device_name << endl;
+ /*----- PROTECTED REGION ID(Alarm::enable) ENABLED START -----*/
+
+ // Add your own code
+ string arginname(argin);
+
+#ifndef _RW_LOCK
+ alarms.lock();
+#else
+ alarms.vlock->readerIn();
+#endif
+ alarm_container_t::iterator i = alarms.v_alarm.find(arginname);
+ if(i == alarms.v_alarm.end())
+ {
+ ostringstream err;
+ err << arginname << " not found in configured alarms" << ends;
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ Tango::Except::throw_exception( \
+ (const char*)"NOT_FOUND", \
+ (const char*)err.str().c_str(), \
+ (const char*)__func__, Tango::ERR);
+ }
+
+ i->second.enabled = true;
+
+ i->second.silenced = (i->second.silent_time > 0) ? 0 : -1; //0: can be silenced, -1: cannot be silenced
+ i->second.shelved = false;
+
+ Tango::DevEnum *attr_value = get_AlarmState_data_ptr(i->second.attr_name);
+
+ if((i->second.stat == S_NORMAL) && i->second.ack == ACK)
+ *attr_value = _NORM;
+ else if((i->second.stat == S_ALARM) && i->second.ack == NOT_ACK)
+ *attr_value = _UNACK;
+ else if((i->second.stat == S_ALARM) && i->second.ack == ACK)
+ *attr_value = _ACKED;
+ else if((i->second.stat == S_NORMAL) && i->second.ack == NOT_ACK)
+ *attr_value = _RTNUN;
+ try
+ { //DevFailed for push events
+ if(i->second.ex_reason.length() == 0)
+ {
+ timeval now;
+ gettimeofday(&now, NULL);
+ push_change_event(i->second.attr_name,(Tango::DevEnum *)attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
+ push_archive_event(i->second.attr_name,(Tango::DevEnum *)attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
+ }
+ else
+ {
+ Tango::DevErrorList errors(1);
+ errors.length(1);
+ errors[0].desc = CORBA::string_dup(i->second.ex_desc.c_str());
+ errors[0].severity = Tango::ERR;
+ errors[0].reason = CORBA::string_dup(i->second.ex_reason.c_str());
+ errors[0].origin = CORBA::string_dup(i->second.ex_origin.c_str());
+ Tango::DevFailed except(errors);
+ push_change_event(i->second.attr_name, &except);
+ push_archive_event(i->second.attr_name, &except);
+ }
+ } catch(Tango::DevFailed & ex)
+ {
+ WARN_STREAM << "Alarm::"<<__func__<<": EXCEPTION PUSHING EVENTS: " << ex.errors[0].desc << endl;
+ }
+
#ifndef _RW_LOCK
- alarms.unlock();
+ alarms.unlock();
#else
- alarms.vlock->writerOut();
+ alarms.vlock->readerOut();
#endif
- Tango::Except::throw_exception( \
- (const char*)o.str().c_str(), \
- (const char*)"", \
- (const char*)__func__, Tango::ERR);
- }
- //update attribute properties
- events->update_property();
+ prepare_alarm_attr();
+ try
+ {
+ if(ds_num == 0)
+ {
+ //attr.set_value_date_quality(ds,0/*gettime()*/,Tango::ATTR_WARNING, ds_num, 0, false);
+ struct timeval now;
+ gettimeofday(&now,NULL);
+ push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
+ }
+ else
+ {
+ //attr.set_value(ds, ds_num, 0, false);
+ push_change_event("alarm",ds, ds_num, 0, false);
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ } catch(Tango::DevFailed& e)
+ {
+ ostringstream err;
+ err << "error pushing alarm change event err=" << e.errors[0].desc;
+ INFO_STREAM << __func__<<": " << err.str() << endl;
+ }
- //delete proxy for actions
- if(i->second.dp_a)
- delete i->second.dp_a;
- i->second.dp_a = NULL;
- if(i->second.dp_n)
- delete i->second.dp_n;
- i->second.dp_n = NULL;
+ /*----- PROTECTED REGION END -----*/ // Alarm::enable
+}
+//--------------------------------------------------------
+/**
+ * Command Disable related method
+ * Description: Put an alarm in Out of service state
+ *
+ * @param argin Alarm name
+ */
+//--------------------------------------------------------
+void Alarm::disable(Tango::DevString argin)
+{
+ DEBUG_STREAM << "Alarm::Disable() - " << device_name << endl;
+ /*----- PROTECTED REGION ID(Alarm::disable) ENABLED START -----*/
+
+ // Add your own code
+ string arginname(argin);
- if(alm.cmd_name_a.length() > 0)
- {
- try {
- i->second.dp_a = new Tango::DeviceProxy(i->second.cmd_dp_a);
- i->second.dp_a->ping();
- Tango::CommandInfo info = i->second.dp_a->command_query(i->second.cmd_action_a);
- if(info.in_type != Tango::DEV_STRING)
- {
- ostringstream err;
- err << "Error: command " << i->second.cmd_name_a << " does not accept a Tango::DevString as input value" << ends;
- ERROR_STREAM << __func__<<": " << err.str() << endl;
- set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
- }
- else
- {
- if(info.in_type == Tango::DEV_STRING)
- i->second.send_arg_a = true;
- else
- i->second.send_arg_a = false;
- DEBUG_STREAM << __func__<<": successfully connected to proxy=" << i->second.cmd_dp_a << " for action=" << i->second.cmd_action_a << endl;
- }
- } catch(Tango::DevFailed& e)
- {
- ostringstream err;
- err << alm.name << ": error connecting to device proxy=" << i->second.cmd_dp_a << ", err=" << e.errors[0].desc << ends;
- WARN_STREAM << __func__<<": " << err.str() << endl;
- set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
- }
- }
- if(alm.cmd_name_n.length() > 0)
- {
- try {
- i->second.dp_n = new Tango::DeviceProxy(i->second.cmd_dp_n);
- i->second.dp_n->ping();
- Tango::CommandInfo info = i->second.dp_n->command_query(i->second.cmd_action_a);
- if(info.in_type != Tango::DEV_STRING)
- {
- ostringstream err;
- err << "Error: command " << i->second.cmd_name_n << " does not accept a Tango::DevString as input value" << ends;
- ERROR_STREAM << __func__<<": " << err.str() << endl;
- set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
- }
- else
- {
- if(info.in_type == Tango::DEV_STRING)
- i->second.send_arg_n = true;
- else
- i->second.send_arg_n = false;
- DEBUG_STREAM << __func__<<": successfully connected to proxy=" << i->second.cmd_dp_n << " for action=" << i->second.cmd_action_n << endl;
- }
- } catch(Tango::DevFailed& e)
- {
- ostringstream err;
- err << alm.name << ": error connecting to device proxy=" << i->second.cmd_dp_n << ", err=" << e.errors[0].desc << ends;
- WARN_STREAM << __func__<<": " << err.str() << endl;
- set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
- }
- }
#ifndef _RW_LOCK
- alarms.unlock();
+ alarms.lock();
#else
- alarms.vlock->writerOut();
+ alarms.vlock->readerIn();
#endif
- return;
- }
- }
- else
+ alarm_container_t::iterator i = alarms.v_alarm.find(arginname);
+ if(i == alarms.v_alarm.end())
{
+ ostringstream err;
+ err << arginname << " not found in configured alarms" << ends;
#ifndef _RW_LOCK
alarms.unlock();
#else
- alarms.vlock->writerOut();
+ alarms.vlock->readerOut();
#endif
- ostringstream o;
- o << "Alarm '"<<alm.name<<"' not found" << ends;
- DEBUG_STREAM << o.str() << endl;
- Tango::Except::throw_exception( \
- (const char*)"Not found", \
- (const char*)o.str().c_str(), \
- (const char*)__func__, Tango::ERR);
+ Tango::Except::throw_exception( \
+ (const char*)"NOT_FOUND", \
+ (const char*)err.str().c_str(), \
+ (const char*)__func__, Tango::ERR);
+ }
+
+ i->second.enabled = false;
+
+ i->second.silenced = (i->second.silent_time > 0) ? 0 : -1; //0: can be silenced, -1: cannot be silenced
+ i->second.shelved = false;
+
+ Tango::DevEnum *attr_value = get_AlarmState_data_ptr(i->second.attr_name);
+
+ *attr_value = _OOSRV;
+ try
+ { //DevFailed for push events
+ if(i->second.ex_reason.length() == 0)
+ {
+ timeval now;
+ gettimeofday(&now, NULL);
+ push_change_event(i->second.attr_name,(Tango::DevEnum *)attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
+ push_archive_event(i->second.attr_name,(Tango::DevEnum *)attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
+ }
+ else
+ {
+ Tango::DevErrorList errors(1);
+ errors.length(1);
+ errors[0].desc = CORBA::string_dup(i->second.ex_desc.c_str());
+ errors[0].severity = Tango::ERR;
+ errors[0].reason = CORBA::string_dup(i->second.ex_reason.c_str());
+ errors[0].origin = CORBA::string_dup(i->second.ex_origin.c_str());
+ Tango::DevFailed except(errors);
+ push_change_event(i->second.attr_name, &except);
+ push_archive_event(i->second.attr_name, &except);
+ }
+ } catch(Tango::DevFailed & ex)
+ {
+ WARN_STREAM << "Alarm::"<<__func__<<": EXCEPTION PUSHING EVENTS: " << ex.errors[0].desc << endl;
}
+
#ifndef _RW_LOCK
- alarms.unlock();
+ alarms.unlock();
#else
- alarms.vlock->writerOut();
+ alarms.vlock->readerOut();
#endif
- //------------------------------
- //3: remove (set active=0 on db)
- //------------------------------
- remove((Tango::DevString)alm.name.c_str());
- DEBUG_STREAM << "Alarm::Modify: removed alm name=" << alm.name << endl;
- //------------------------------
- //4: load modified alarm
- //------------------------------
- load(argin);
+ /*
+ * remove from alarmed
+ */
+ bool go = true;
+ while (go) {
+ alarmedlock->writerIn();
+ vector<alarm_t>::iterator found = \
+ find(alarmed.begin(), alarmed.end(), arginname);
+ if (found != alarmed.end()) {
+ DEBUG_STREAM << "Alarm::"<<__func__<<": " << found->name \
+ << " removing" << endl;
+ alarmed.erase(found);
+ } else {
+ go = false;
+ }
+ alarmedlock->writerOut();
+ }
prepare_alarm_attr();
try
@@ -2220,16 +2923,71 @@ void Alarm::modify(Tango::DevString argin)
push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
}
else
+ {
//attr.set_value(ds, ds_num, 0, false);
push_change_event("alarm",ds, ds_num, 0, false);
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_change_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_change_event("audibleAlarm",attr_audibleAlarm_read);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_archive_event("audibleAlarm",attr_audibleAlarm_read);
} catch(Tango::DevFailed& e)
{
ostringstream err;
err << "error pushing alarm change event err=" << e.errors[0].desc;
INFO_STREAM << __func__<<": " << err.str() << endl;
}
-
- /*----- PROTECTED REGION END -----*/ // Alarm::modify
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::disable
+}
+//--------------------------------------------------------
+/**
+ * Command ResetStatistics related method
+ * Description: Reset statistics
+ *
+ */
+//--------------------------------------------------------
+void Alarm::reset_statistics()
+{
+ DEBUG_STREAM << "Alarm::ResetStatistics() - " << device_name << endl;
+ /*----- PROTECTED REGION ID(Alarm::reset_statistics) ENABLED START -----*/
+
+ // Add your own code
+#ifndef _RW_LOCK
+ alarms.lock();
+#else
+ alarms.vlock->readerIn();
+#endif
+ for(alarm_container_t::iterator i = alarms.v_alarm.begin(); i!= alarms.v_alarm.end(); i++)
+ {
+ i->second.freq_counter = 0;
+ }
+ timespec now;
+ clock_gettime(CLOCK_MONOTONIC, &now);
+ double dnow = (now.tv_sec) + ((double)(now.tv_nsec))/1000000000;
+ last_statistics_reset_time = dnow;
+#ifndef _RW_LOCK
+ alarms.unlock();
+#else
+ alarms.vlock->readerOut();
+#endif
+ /*----- PROTECTED REGION END -----*/ // Alarm::reset_statistics
}
//--------------------------------------------------------
/**
@@ -2677,10 +3435,6 @@ void Alarm::do_alarm(bei_t& e)
if(found_ev != events->v_event.end())
{
found_ev->err_counter++;
- if(found_ev->err_counter >= errThreshold)
- {
- set_internal_alarm(e.ev_name, gettime(), o.str(), errThreshold);
- }
if(e.type == TYPE_TANGO_ERR)
found_ev->ex_reason = string("Event_ERROR");
else
@@ -2808,9 +3562,30 @@ void Alarm::do_alarm(bei_t& e)
push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
}
else
+ {
//attr.set_value(ds, ds_num, 0, false);
push_change_event("alarm",ds, ds_num, 0, false);
-
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_change_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_change_event("audibleAlarm",attr_audibleAlarm_read);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_archive_event("audibleAlarm",attr_audibleAlarm_read);
}
else
{
@@ -2834,22 +3609,26 @@ bool Alarm::do_alarm_eval(string alm_name, string ev_name, Tango::TimeVal ts)
alarm_container_t::iterator it = alarms.v_alarm.find(alm_name);
if(it != alarms.v_alarm.end())
{
+ it->second.freq_counter++;
string tmpname=it->first;
try {
string attr_values;
res = eval_formula(it->second.formula_tree, attr_values);
- DEBUG_STREAM << "Alarm::"<<__func__<<": Evaluation of " << it->second.formula << "; result=" << res.value << " quality=" << res.quality << endl;
- changed = alarms.update(tmpname, ts, res, attr_values, it->second.grp2str(), it->second.msg, it->second.formula); //update internal structure and log to db
- Tango::DevEnum *attr_value = get_AlarmState_data_ptr(it->second.attr_name);
- //TODO: if not _SHLVD, _DSUPR, _OOSRV
- if((it->second.stat == S_NORMAL) && it->second.ack == ACK)
- *attr_value = _NORM;
- else if((it->second.stat == S_ALARM) && it->second.ack == NOT_ACK)
- *attr_value = _UNACK;
- else if((it->second.stat == S_ALARM) && it->second.ack == ACK)
- *attr_value = _ACKED;
- else if((it->second.stat == S_NORMAL) && it->second.ack == NOT_ACK)
- *attr_value = _RTNUN;
+ DEBUG_STREAM << "Alarm::"<<__func__<<": Evaluation of " << it->second.formula << "; result=" << res.value << " quality=" << res.quality << endl;
+ changed = alarms.update(tmpname, ts, res, attr_values, it->second.grp2str(), it->second.msg, it->second.formula); //update internal structure and log to db
+ Tango::DevEnum *attr_value = get_AlarmState_data_ptr(it->second.attr_name);
+ if(!it->second.enabled)
+ *attr_value = _OOSRV;
+ else if(it->second.shelved && it->second.silenced > 0)
+ *attr_value = _SHLVD;
+ else if((it->second.stat == S_NORMAL) && it->second.ack == ACK)
+ *attr_value = _NORM;
+ else if((it->second.stat == S_ALARM) && it->second.ack == NOT_ACK)
+ *attr_value = _UNACK;
+ else if((it->second.stat == S_ALARM) && it->second.ack == ACK)
+ *attr_value = _ACKED;
+ else if((it->second.stat == S_NORMAL) && it->second.ack == NOT_ACK)
+ *attr_value = _RTNUN;
try
{ //DevFailed for push events
if(it->second.ex_reason.length() == 0)
@@ -3002,8 +3781,30 @@ void Alarm::timer_update()
push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
}
else
+ {
//attr.set_value(ds, ds_num, 0, false);
push_change_event("alarm",ds, ds_num, 0, false);
+ }
+ push_change_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_change_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_change_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_change_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_change_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_change_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_change_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_change_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_change_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_change_event("audibleAlarm",attr_audibleAlarm_read);
+ push_archive_event("normalAlarms",&attr_normalAlarms_read[0], normalAlarms_sz);
+ push_archive_event("unacknowledgedAlarms",&attr_unacknowledgedAlarms_read[0], unacknowledgedAlarms_sz);
+ push_archive_event("acknowledgedAlarms",&attr_acknowledgedAlarms_read[0], acknowledgedAlarms_sz);
+ push_archive_event("unacknowledgedNormalAlarms",&attr_unacknowledgedNormalAlarms_read[0], unacknowledgedNormalAlarms_sz);
+ push_archive_event("shelvedAlarms",&attr_shelvedAlarms_read[0], shelvedAlarms_sz);
+ push_archive_event("outOfServiceAlarms",&attr_outOfServiceAlarms_read[0], outOfServiceAlarms_sz);
+ push_archive_event("silencedAlarms",&attr_silencedAlarms_read[0], silencedAlarms_sz);
+ push_archive_event("listAlarms",&attr_listAlarms_read[0], listAlarms_sz);
+ push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+ push_archive_event("audibleAlarm",attr_audibleAlarm_read);
} catch(Tango::DevFailed& e)
{
ostringstream err;
@@ -3873,13 +4674,83 @@ void Alarm::prepare_alarm_attr()
{
alarm_container_t::iterator ai;
vector<alarm_t>::iterator aid;
+ bool is_audible=false;
#ifndef _RW_LOCK
alarms.lock();
#else
alarms.vlock->readerIn();
#endif
+ outOfServiceAlarms_read.clear();
+ shelvedAlarms_read.clear();
+ acknowledgedAlarms_read.clear();
+ unacknowledgedAlarms_read.clear();
+ unacknowledgedNormalAlarms_read.clear();
+ normalAlarms_read.clear();
+ silencedAlarms_read.clear();
+ listAlarms_read.clear();
+ outOfServiceAlarms_sz=0;
+ shelvedAlarms_sz=0;
+ acknowledgedAlarms_sz=0;
+ unacknowledgedAlarms_sz=0;
+ unacknowledgedNormalAlarms_sz=0;
+ normalAlarms_sz=0;
+ silencedAlarms_sz=0;
+ listAlarms_sz=0;
for (ai = alarms.v_alarm.begin(); ai != alarms.v_alarm.end(); ai++) {
- if (ai->second.stat == S_ALARM) {
+ if(ai->second.enabled == false)
+ {
+ outOfServiceAlarms_read.push_back(ai->second.name);
+ attr_outOfServiceAlarms_read[outOfServiceAlarms_sz] = const_cast<char*>(outOfServiceAlarms_read[outOfServiceAlarms_sz].c_str());
+ outOfServiceAlarms_sz++;
+ }
+ else if(ai->second.shelved)
+ {
+ shelvedAlarms_read.push_back(ai->second.name);
+ attr_shelvedAlarms_read[shelvedAlarms_sz] = const_cast<char*>(shelvedAlarms_read[shelvedAlarms_sz].c_str());
+ shelvedAlarms_sz++;
+ }
+ else
+ {
+ if(ai->second.stat == S_ALARM && ai->second.ack == ACK)
+ {
+ acknowledgedAlarms_read.push_back(ai->second.name);
+ attr_acknowledgedAlarms_read[acknowledgedAlarms_sz] = const_cast<char*>(acknowledgedAlarms_read[acknowledgedAlarms_sz].c_str());
+ acknowledgedAlarms_sz++;
+ }
+ else if(ai->second.stat == S_ALARM && ai->second.ack == NOT_ACK)
+ {
+ unacknowledgedAlarms_read.push_back(ai->second.name);
+ attr_unacknowledgedAlarms_read[unacknowledgedAlarms_sz] = const_cast<char*>(unacknowledgedAlarms_read[unacknowledgedAlarms_sz].c_str());
+ unacknowledgedAlarms_sz++;
+ }
+ else if(ai->second.stat == S_NORMAL && ai->second.ack == NOT_ACK)
+ {
+ unacknowledgedNormalAlarms_read.push_back(ai->second.name);
+ attr_unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz] = const_cast<char*>(unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz].c_str());
+ unacknowledgedNormalAlarms_sz++;
+ }
+ else if(ai->second.stat == S_NORMAL && ai->second.ack == ACK)
+ {
+ normalAlarms_read.push_back(ai->second.name);
+ attr_normalAlarms_read[normalAlarms_sz] = const_cast<char*>(normalAlarms_read[normalAlarms_sz].c_str());
+ normalAlarms_sz++;
+ }
+ if(ai->second.silenced > 0)
+ {
+ silencedAlarms_read.push_back(ai->second.name);
+ attr_silencedAlarms_read[silencedAlarms_sz] = const_cast<char*>(silencedAlarms_read[silencedAlarms_sz].c_str());
+ silencedAlarms_sz++;
+ }
+ }
+ attr_frequencyAlarms_read[listAlarms_sz] = ai->second.freq_counter;
+ listAlarms_read.push_back(ai->second.name);
+ attr_listAlarms_read[listAlarms_sz] = const_cast<char*>(listAlarms_read[listAlarms_sz].c_str());
+ listAlarms_sz++;
+
+ if(!is_audible && ai->second.is_new && ai->second.silenced <= 0 && ai->second.enabled && !ai->second.shelved)
+ is_audible = true;
+
+ if (ai->second.stat == S_ALARM && ai->second.enabled && !ai->second.shelved) {
/*
* alarm status is S_ALARM
*/
@@ -3965,6 +4836,7 @@ void Alarm::prepare_alarm_attr()
alarmedlock->readerOut();
} /* if else if */
} /* for */
+ *attr_audibleAlarm_read = is_audible;
#ifndef _RW_LOCK
alarms.unlock();
#else
@@ -3989,9 +4861,14 @@ void Alarm::prepare_alarm_attr()
//silenced already calculated in alarm_table::update, but here updated for panel also if state not changed:
//to see minutes countdown
if(dminutes < aid->silent_time)
+ {
aid->silenced = aid->silent_time - floor(dminutes);
+ }
else
+ {
aid->silenced = 0;
+ aid->shelved = false;
+ }
}
ostringstream os;
os.clear();
@@ -4004,33 +4881,6 @@ void Alarm::prepare_alarm_attr()
}
}
alarmedlock->readerOut();
- internallock->readerIn();
- if (internal.empty() == false) {
- for (aid = internal.begin(); aid != internal.end(); aid++) {
-
-/* size_t index;
- int count = 1;
- index = aid->stat.find("*");
- if((index != std::string::npos) && (index+1 != std::string::npos))
- {
-
- size_t last = aid->stat.size();
- string str_count= aid->stat.substr(index+1, last - index+1);
- count = strtol(str_count.c_str(), 0,10);
- }
- //do not show internal alarms that have a molteplicity less then errThreshold
- if((aid->msg.find()) && (count < errThreshold))
- continue;*/
-
- ostringstream os;
- os.clear();
- os << aid->ts.tv_sec << "\t" << aid->ts.tv_usec << "\t" \
- << aid->name << "\t" << aid->stat << "\t" << aid->ack \
- << "\t" << aid->on_counter << "\t" << aid->lev << "\t"<< -1/*silenced*/ <<"\t" << aid->grp2str() << "\t" << aid->msg << "\t "<< ends; //TODO: silenced for internal errors?
- tmp_alarm_table.push_back(os.str());
- }
- }
- internallock->readerOut();
dslock->writerIn();
int i;
// for (i = ds_num - 1; i >= 0; i--) {
diff --git a/src/Alarm.h b/src/Alarm.h
index 45bc9dd..931cb89 100644
--- a/src/Alarm.h
+++ b/src/Alarm.h
@@ -50,7 +50,7 @@
#include "event_table.h"
#include "SubscribeThread.h"
-#define MAX_ALARMS 1024
+#define MAX_ALARMS 10000
//#define _USE_ELETTRA_DB_RW
@@ -109,34 +109,51 @@ public:
Tango::DevLong attr_AttributeStoppedNumber_read;
Tango::DevLong attr_AttributeNumber_read;
+ vector<string> normalAlarms_read;
+ vector<string> unacknowledgedAlarms_read;
+ vector<string> acknowledgedAlarms_read;
+ vector<string> unacknowledgedNormalAlarms_read;
+ vector<string> shelvedAlarms_read;
+ vector<string> outOfServiceAlarms_read;
+ vector<string> silencedAlarms_read;
+ vector<string> listAlarms_read;
+
+ size_t normalAlarms_sz;
+ size_t unacknowledgedAlarms_sz;
+ size_t acknowledgedAlarms_sz;
+ size_t unacknowledgedNormalAlarms_sz;
+ size_t shelvedAlarms_sz;
+ size_t outOfServiceAlarms_sz;
+ size_t silencedAlarms_sz;
+ size_t listAlarms_sz;
+
+ double last_statistics_reset_time;
+
/*----- PROTECTED REGION END -----*/ // Alarm::Data Members
// Device property data members
public:
- // AlarmStatus: Persistent storage of the alarms status
- vector<string> alarmStatus;
// GroupNames: Labels for Group mask, first is for mask 0x00
vector<string> groupNames;
- // ErrThreshold: Threshold for Tango error for being internal alarms
- Tango::DevLong errThreshold;
- // DbHost: Host of the MySQL db
- string dbHost;
- // DbUser: Username for the MySQL db
- string dbUser;
- // DbPasswd: Password for the MySQL db
- string dbPasswd;
- // DbName: Db name for the MySQL db
- string dbName;
- // DbPort: Port of the MySQL db
- string dbPort;
- // InstanceName: Name used to associate configured alarm rules to this instance
- string instanceName;
- // SubscribeRetryPeriod: retry period in seconds
+ // SubscribeRetryPeriod: Retry subscription period in seconds
Tango::DevLong subscribeRetryPeriod;
+ // StatisticsTimeWindow: Time window to compute statistics in seconds
+ vector<Tango::DevLong> statisticsTimeWindow;
// Attribute data members
public:
+ Tango::DevBoolean *attr_audibleAlarm_read;
+ Tango::DevDouble *attr_StatisticsResetTime_read;
Tango::DevString *attr_alarm_read;
+ Tango::DevString *attr_normalAlarms_read;
+ Tango::DevString *attr_unacknowledgedAlarms_read;
+ Tango::DevString *attr_acknowledgedAlarms_read;
+ Tango::DevString *attr_unacknowledgedNormalAlarms_read;
+ Tango::DevString *attr_shelvedAlarms_read;
+ Tango::DevString *attr_outOfServiceAlarms_read;
+ Tango::DevString *attr_silencedAlarms_read;
+ Tango::DevString *attr_listAlarms_read;
+ Tango::DevDouble *attr_frequencyAlarms_read;
// Constructors and destructors
public:
@@ -198,6 +215,24 @@ public:
//--------------------------------------------------------
virtual void read_attr_hardware(vector<long> &attr_list);
+/**
+ * Attribute audibleAlarm related methods
+ * Description: True if there is at least one alarm that needs audible indication on the GUI
+ *
+ * Data type: Tango::DevBoolean
+ * Attr type: Scalar
+ */
+ virtual void read_audibleAlarm(Tango::Attribute &attr);
+ virtual bool is_audibleAlarm_allowed(Tango::AttReqType type);
+/**
+ * Attribute StatisticsResetTime related methods
+ * Description: Time elapsed in seconds since last Resetstatistics
+ *
+ * Data type: Tango::DevDouble
+ * Attr type: Scalar
+ */
+ virtual void read_StatisticsResetTime(Tango::Attribute &attr);
+ virtual bool is_StatisticsResetTime_allowed(Tango::AttReqType type);
/**
* Attribute alarm related methods
* Description:
@@ -207,6 +242,87 @@ public:
*/
virtual void read_alarm(Tango::Attribute &attr);
virtual bool is_alarm_allowed(Tango::AttReqType type);
+/**
+ * Attribute normalAlarms related methods
+ * Description: List of alarms in normal state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+ virtual void read_normalAlarms(Tango::Attribute &attr);
+ virtual bool is_normalAlarms_allowed(Tango::AttReqType type);
+/**
+ * Attribute unacknowledgedAlarms related methods
+ * Description: List of alarms in unacknowledged state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+ virtual void read_unacknowledgedAlarms(Tango::Attribute &attr);
+ virtual bool is_unacknowledgedAlarms_allowed(Tango::AttReqType type);
+/**
+ * Attribute acknowledgedAlarms related methods
+ * Description: List of alarms in acknowledged state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+ virtual void read_acknowledgedAlarms(Tango::Attribute &attr);
+ virtual bool is_acknowledgedAlarms_allowed(Tango::AttReqType type);
+/**
+ * Attribute unacknowledgedNormalAlarms related methods
+ * Description: List of alarms in unacknowledged normal state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+ virtual void read_unacknowledgedNormalAlarms(Tango::Attribute &attr);
+ virtual bool is_unacknowledgedNormalAlarms_allowed(Tango::AttReqType type);
+/**
+ * Attribute shelvedAlarms related methods
+ * Description: List of alarms in shelved state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+ virtual void read_shelvedAlarms(Tango::Attribute &attr);
+ virtual bool is_shelvedAlarms_allowed(Tango::AttReqType type);
+/**
+ * Attribute outOfServiceAlarms related methods
+ * Description: List of alarms in out of service state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+ virtual void read_outOfServiceAlarms(Tango::Attribute &attr);
+ virtual bool is_outOfServiceAlarms_allowed(Tango::AttReqType type);
+/**
+ * Attribute silencedAlarms related methods
+ * Description: List of alarms in silenced state
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+ virtual void read_silencedAlarms(Tango::Attribute &attr);
+ virtual bool is_silencedAlarms_allowed(Tango::AttReqType type);
+/**
+ * Attribute listAlarms related methods
+ * Description: List of all alarms
+ *
+ * Data type: Tango::DevString
+ * Attr type: Spectrum max = 10000
+ */
+ virtual void read_listAlarms(Tango::Attribute &attr);
+ virtual bool is_listAlarms_allowed(Tango::AttReqType type);
+/**
+ * Attribute frequencyAlarms related methods
+ * Description: List of frequency of evaluation of all alarms
+ *
+ * Data type: Tango::DevDouble
+ * Attr type: Spectrum max = 10000
+ */
+ virtual void read_frequencyAlarms(Tango::Attribute &attr);
+ virtual bool is_frequencyAlarms_allowed(Tango::AttReqType type);
// Dynamic attribute methods
public:
@@ -277,21 +393,21 @@ public:
virtual void remove(Tango::DevString argin);
virtual bool is_Remove_allowed(const CORBA::Any &any);
/**
- * Command Configured related method
- * Description: Alarms configured
+ * Command SearchAlarm related method
+ * Description: Return list of configured alarms matching the filter string
*
- * @param argin String containing a filter for output, if empty return all alarms
- * @returns Alarms configured
+ * @param argin String containing a filter for output, if empty or * return all alarms
+ * @returns Configured alarms
*/
- virtual Tango::DevVarStringArray *configured(Tango::DevString argin);
- virtual bool is_Configured_allowed(const CORBA::Any &any);
+ virtual Tango::DevVarStringArray *search_alarm(Tango::DevString argin);
+ virtual bool is_SearchAlarm_allowed(const CORBA::Any &any);
/**
- * Command StopNew related method
- * Description: Remove "NEW" field from alarm string (so alarm panel stop sound)
+ * Command StopAudible related method
+ * Description: Stop audible indications on the GUI
*
*/
- virtual void stop_new();
- virtual bool is_StopNew_allowed(const CORBA::Any &any);
+ virtual void stop_audible();
+ virtual bool is_StopAudible_allowed(const CORBA::Any &any);
/**
* Command Silence related method
* Description: Alarm temporarily silence
@@ -308,6 +424,37 @@ public:
*/
virtual void modify(Tango::DevString argin);
virtual bool is_Modify_allowed(const CORBA::Any &any);
+ /**
+ * Command Shelve related method
+ * Description: Shelve an alarm: no state transition recorded, no audible nor visual indication
+ *
+ * @param argin String array containing alarm to be shelved
+ */
+ virtual void shelve(const Tango::DevVarStringArray *argin);
+ virtual bool is_Shelve_allowed(const CORBA::Any &any);
+ /**
+ * Command Enable related method
+ * Description: Enable an alarm from Out of service state
+ *
+ * @param argin Alarm name
+ */
+ virtual void enable(Tango::DevString argin);
+ virtual bool is_Enable_allowed(const CORBA::Any &any);
+ /**
+ * Command Disable related method
+ * Description: Put an alarm in Out of service state
+ *
+ * @param argin Alarm name
+ */
+ virtual void disable(Tango::DevString argin);
+ virtual bool is_Disable_allowed(const CORBA::Any &any);
+ /**
+ * Command ResetStatistics related method
+ * Description: Reset statistics
+ *
+ */
+ virtual void reset_statistics();
+ virtual bool is_ResetStatistics_allowed(const CORBA::Any &any);
//--------------------------------------------------------
diff --git a/src/Alarm.xmi b/src/Alarm.xmi
index 8259fc3..0d750c1 100644
--- a/src/Alarm.xmi
+++ b/src/Alarm.xmi
@@ -5,45 +5,19 @@
<inheritances classname="Device_4Impl" sourcePath=""/>
<identification contact="at elettra.eu - graziano.scalamera" author="graziano.scalamera" emailDomain="elettra.eu" classFamily="SoftwareSystem" siteSpecific="" platform="Unix Like" bus="Not Applicable" manufacturer="" reference=""/>
</description>
- <deviceProperties name="AlarmStatus" description="Persistent storage of the alarms status">
- <type xsi:type="pogoDsl:StringVectorType"/>
- <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
- </deviceProperties>
<deviceProperties name="GroupNames" description="Labels for Group mask, first is for mask 0x00">
<type xsi:type="pogoDsl:StringVectorType"/>
<status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
</deviceProperties>
- <deviceProperties name="ErrThreshold" description="Threshold for Tango error for being internal alarms">
+ <deviceProperties name="SubscribeRetryPeriod" description="Retry subscription period in seconds">
<type xsi:type="pogoDsl:IntType"/>
<status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <DefaultPropValue>30</DefaultPropValue>
</deviceProperties>
- <deviceProperties name="DbHost" description="Host of the MySQL db">
- <type xsi:type="pogoDsl:StringType"/>
- <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
- </deviceProperties>
- <deviceProperties name="DbUser" description="Username for the MySQL db">
- <type xsi:type="pogoDsl:StringType"/>
- <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
- </deviceProperties>
- <deviceProperties name="DbPasswd" description="Password for the MySQL db">
- <type xsi:type="pogoDsl:StringType"/>
- <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
- </deviceProperties>
- <deviceProperties name="DbName" description="Db name for the MySQL db">
- <type xsi:type="pogoDsl:StringType"/>
- <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
- </deviceProperties>
- <deviceProperties name="DbPort" description="Port of the MySQL db">
- <type xsi:type="pogoDsl:StringType"/>
- <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
- </deviceProperties>
- <deviceProperties name="InstanceName" description="Name used to associate configured alarm rules to this instance">
- <type xsi:type="pogoDsl:StringType"/>
- <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
- </deviceProperties>
- <deviceProperties name="SubscribeRetryPeriod" description="retry period in seconds">
- <type xsi:type="pogoDsl:IntType"/>
+ <deviceProperties name="StatisticsTimeWindow" description="Time window to compute statistics in seconds">
+ <type xsi:type="pogoDsl:IntVectorType"/>
<status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <DefaultPropValue>60</DefaultPropValue>
</deviceProperties>
<commands name="State" description="This command gets the device state (stored in its <i>device_state</i> data member) and returns it to the caller." execMethod="dev_state" displayLevel="OPERATOR" polledPeriod="0">
<argin description="none.">
@@ -90,16 +64,16 @@
</argout>
<status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
</commands>
- <commands name="Configured" description="Alarms configured" execMethod="configured" displayLevel="OPERATOR" polledPeriod="0">
- <argin description="String containing a filter for output, if empty return all alarms">
+ <commands name="SearchAlarm" description="Return list of configured alarms matching the filter string" execMethod="search_alarm" displayLevel="OPERATOR" polledPeriod="0" isDynamic="false">
+ <argin description="String containing a filter for output, if empty or * return all alarms">
<type xsi:type="pogoDsl:StringType"/>
</argin>
- <argout description="Alarms configured">
+ <argout description="Configured alarms">
<type xsi:type="pogoDsl:StringArrayType"/>
</argout>
<status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
</commands>
- <commands name="StopNew" description="Remove "NEW" field from alarm string (so alarm panel stop sound)" execMethod="stop_new" displayLevel="OPERATOR" polledPeriod="0">
+ <commands name="StopAudible" description="Stop audible indications on the GUI" execMethod="stop_audible" displayLevel="OPERATOR" polledPeriod="0" isDynamic="false">
<argin description="">
<type xsi:type="pogoDsl:VoidType"/>
</argin>
@@ -126,6 +100,58 @@
</argout>
<status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
</commands>
+ <commands name="Shelve" description="Shelve an alarm: no state transition recorded, no audible nor visual indication" execMethod="shelve" displayLevel="OPERATOR" polledPeriod="0" isDynamic="false">
+ <argin description="String array containing alarm to be shelved">
+ <type xsi:type="pogoDsl:StringArrayType"/>
+ </argin>
+ <argout description="">
+ <type xsi:type="pogoDsl:VoidType"/>
+ </argout>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ </commands>
+ <commands name="Enable" description="Enable an alarm from Out of service state" execMethod="enable" displayLevel="OPERATOR" polledPeriod="0" isDynamic="false">
+ <argin description="Alarm name">
+ <type xsi:type="pogoDsl:StringType"/>
+ </argin>
+ <argout description="">
+ <type xsi:type="pogoDsl:VoidType"/>
+ </argout>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ </commands>
+ <commands name="Disable" description="Put an alarm in Out of service state" execMethod="disable" displayLevel="OPERATOR" polledPeriod="0" isDynamic="false">
+ <argin description="Alarm name">
+ <type xsi:type="pogoDsl:StringType"/>
+ </argin>
+ <argout description="">
+ <type xsi:type="pogoDsl:VoidType"/>
+ </argout>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ </commands>
+ <commands name="ResetStatistics" description="Reset statistics" execMethod="reset_statistics" displayLevel="OPERATOR" polledPeriod="0" isDynamic="false">
+ <argin description="">
+ <type xsi:type="pogoDsl:VoidType"/>
+ </argin>
+ <argout description="">
+ <type xsi:type="pogoDsl:VoidType"/>
+ </argout>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ </commands>
+ <attributes name="audibleAlarm" attType="Scalar" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:BooleanType"/>
+ <changeEvent fire="true" libCheckCriteria="false"/>
+ <archiveEvent fire="true" libCheckCriteria="false"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="True if there is at least one alarm that needs audible indication on the GUI" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
+ <attributes name="StatisticsResetTime" attType="Scalar" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:DoubleType"/>
+ <changeEvent fire="false" libCheckCriteria="false"/>
+ <archiveEvent fire="false" libCheckCriteria="false"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="Time elapsed in seconds since last Resetstatistics" label="" unit="s" standardUnit="1" displayUnit="s" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
<attributes name="alarm" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="1024" maxY="0">
<dataType xsi:type="pogoDsl:StringType"/>
<changeEvent fire="false" libCheckCriteria="false"/>
@@ -133,6 +159,78 @@
<status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
<properties description="" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
</attributes>
+ <attributes name="normalAlarms" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="10000" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:StringType"/>
+ <changeEvent fire="true" libCheckCriteria="true"/>
+ <archiveEvent fire="true" libCheckCriteria="true"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="List of alarms in normal state" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
+ <attributes name="unacknowledgedAlarms" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="10000" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:StringType"/>
+ <changeEvent fire="true" libCheckCriteria="true"/>
+ <archiveEvent fire="true" libCheckCriteria="true"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="List of alarms in unacknowledged state" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
+ <attributes name="acknowledgedAlarms" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="10000" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:StringType"/>
+ <changeEvent fire="true" libCheckCriteria="true"/>
+ <archiveEvent fire="true" libCheckCriteria="true"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="List of alarms in acknowledged state" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
+ <attributes name="unacknowledgedNormalAlarms" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="10000" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:StringType"/>
+ <changeEvent fire="true" libCheckCriteria="true"/>
+ <archiveEvent fire="true" libCheckCriteria="true"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="List of alarms in unacknowledged normal state" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
+ <attributes name="shelvedAlarms" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="10000" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:StringType"/>
+ <changeEvent fire="true" libCheckCriteria="true"/>
+ <archiveEvent fire="true" libCheckCriteria="true"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="List of alarms in shelved state" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
+ <attributes name="outOfServiceAlarms" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="10000" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:StringType"/>
+ <changeEvent fire="true" libCheckCriteria="true"/>
+ <archiveEvent fire="true" libCheckCriteria="true"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="List of alarms in out of service state" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
+ <attributes name="silencedAlarms" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="10000" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:StringType"/>
+ <changeEvent fire="true" libCheckCriteria="true"/>
+ <archiveEvent fire="true" libCheckCriteria="true"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="List of alarms in silenced state" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
+ <attributes name="listAlarms" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="10000" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:StringType"/>
+ <changeEvent fire="true" libCheckCriteria="true"/>
+ <archiveEvent fire="true" libCheckCriteria="true"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="List of all alarms" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
+ <attributes name="frequencyAlarms" attType="Spectrum" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="10000" maxY="" allocReadMember="true" isDynamic="false">
+ <dataType xsi:type="pogoDsl:DoubleType"/>
+ <changeEvent fire="true" libCheckCriteria="true"/>
+ <archiveEvent fire="true" libCheckCriteria="true"/>
+ <dataReadyEvent fire="false" libCheckCriteria="true"/>
+ <status abstract="false" inherited="false" concrete="true" concreteHere="true"/>
+ <properties description="List of frequency of evaluation of all alarms" label="" unit="" standardUnit="" displayUnit="" format="" maxValue="" minValue="" maxAlarm="" minAlarm="" maxWarning="" minWarning="" deltaTime="" deltaValue=""/>
+ </attributes>
<dynamicAttributes name="AlarmState" attType="Scalar" rwType="READ" displayLevel="OPERATOR" polledPeriod="0" maxX="" maxY="" allocReadMember="true" isDynamic="true">
<dataType xsi:type="pogoDsl:EnumType"/>
<changeEvent fire="true" libCheckCriteria="true"/>
diff --git a/src/AlarmClass.cpp b/src/AlarmClass.cpp
index eba9661..63d494f 100644
--- a/src/AlarmClass.cpp
+++ b/src/AlarmClass.cpp
@@ -222,7 +222,7 @@ CORBA::Any *RemoveClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in
//--------------------------------------------------------
/**
- * method : ConfiguredClass::execute()
+ * method : SearchAlarmClass::execute()
* description : method to trigger the execution of the command.
*
* @param device The device on which the command must be executed
@@ -231,17 +231,17 @@ CORBA::Any *RemoveClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in
* returns The command output data (packed in the Any object)
*/
//--------------------------------------------------------
-CORBA::Any *ConfiguredClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
+CORBA::Any *SearchAlarmClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
{
- cout2 << "ConfiguredClass::execute(): arrived" << endl;
+ cout2 << "SearchAlarmClass::execute(): arrived" << endl;
Tango::DevString argin;
extract(in_any, argin);
- return insert((static_cast<Alarm *>(device))->configured(argin));
+ return insert((static_cast<Alarm *>(device))->search_alarm(argin));
}
//--------------------------------------------------------
/**
- * method : StopNewClass::execute()
+ * method : StopAudibleClass::execute()
* description : method to trigger the execution of the command.
*
* @param device The device on which the command must be executed
@@ -250,10 +250,10 @@ CORBA::Any *ConfiguredClass::execute(Tango::DeviceImpl *device, const CORBA::Any
* returns The command output data (packed in the Any object)
*/
//--------------------------------------------------------
-CORBA::Any *StopNewClass::execute(Tango::DeviceImpl *device, TANGO_UNUSED(const CORBA::Any &in_any))
+CORBA::Any *StopAudibleClass::execute(Tango::DeviceImpl *device, TANGO_UNUSED(const CORBA::Any &in_any))
{
- cout2 << "StopNewClass::execute(): arrived" << endl;
- ((static_cast<Alarm *>(device))->stop_new());
+ cout2 << "StopAudibleClass::execute(): arrived" << endl;
+ ((static_cast<Alarm *>(device))->stop_audible());
return new CORBA::Any();
}
@@ -297,6 +297,84 @@ CORBA::Any *ModifyClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in
return new CORBA::Any();
}
+//--------------------------------------------------------
+/**
+ * method : ShelveClass::execute()
+ * description : method to trigger the execution of the command.
+ *
+ * @param device The device on which the command must be executed
+ * @param in_any The command input data
+ *
+ * returns The command output data (packed in the Any object)
+ */
+//--------------------------------------------------------
+CORBA::Any *ShelveClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
+{
+ cout2 << "ShelveClass::execute(): arrived" << endl;
+ const Tango::DevVarStringArray *argin;
+ extract(in_any, argin);
+ ((static_cast<Alarm *>(device))->shelve(argin));
+ return new CORBA::Any();
+}
+
+//--------------------------------------------------------
+/**
+ * method : EnableClass::execute()
+ * description : method to trigger the execution of the command.
+ *
+ * @param device The device on which the command must be executed
+ * @param in_any The command input data
+ *
+ * returns The command output data (packed in the Any object)
+ */
+//--------------------------------------------------------
+CORBA::Any *EnableClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
+{
+ cout2 << "EnableClass::execute(): arrived" << endl;
+ Tango::DevString argin;
+ extract(in_any, argin);
+ ((static_cast<Alarm *>(device))->enable(argin));
+ return new CORBA::Any();
+}
+
+//--------------------------------------------------------
+/**
+ * method : DisableClass::execute()
+ * description : method to trigger the execution of the command.
+ *
+ * @param device The device on which the command must be executed
+ * @param in_any The command input data
+ *
+ * returns The command output data (packed in the Any object)
+ */
+//--------------------------------------------------------
+CORBA::Any *DisableClass::execute(Tango::DeviceImpl *device, const CORBA::Any &in_any)
+{
+ cout2 << "DisableClass::execute(): arrived" << endl;
+ Tango::DevString argin;
+ extract(in_any, argin);
+ ((static_cast<Alarm *>(device))->disable(argin));
+ return new CORBA::Any();
+}
+
+//--------------------------------------------------------
+/**
+ * method : ResetStatisticsClass::execute()
+ * description : method to trigger the execution of the command.
+ *
+ * @param device The device on which the command must be executed
+ * @param in_any The command input data
+ *
+ * returns The command output data (packed in the Any object)
+ */
+//--------------------------------------------------------
+CORBA::Any *ResetStatisticsClass::execute(Tango::DeviceImpl *device, TANGO_UNUSED(const CORBA::Any &in_any))
+{
+ cout2 << "ResetStatisticsClass::execute(): arrived" << endl;
+ ((static_cast<Alarm *>(device))->reset_statistics());
+ return new CORBA::Any();
+}
+
//===================================================================
// Properties management
@@ -366,19 +444,6 @@ void AlarmClass::set_default_property()
// Set Default Class Properties
// Set Default device Properties
- prop_name = "AlarmStatus";
- prop_desc = "Persistent storage of the alarms status";
- prop_def = "";
- vect_data.clear();
- if (prop_def.length()>0)
- {
- Tango::DbDatum data(prop_name);
- data << vect_data ;
- dev_def_prop.push_back(data);
- add_wiz_dev_prop(prop_name, prop_desc, prop_def);
- }
- else
- add_wiz_dev_prop(prop_name, prop_desc);
prop_name = "GroupNames";
prop_desc = "Labels for Group mask, first is for mask 0x00";
prop_def = "";
@@ -392,88 +457,11 @@ void AlarmClass::set_default_property()
}
else
add_wiz_dev_prop(prop_name, prop_desc);
- prop_name = "ErrThreshold";
- prop_desc = "Threshold for Tango error for being internal alarms";
- prop_def = "";
- vect_data.clear();
- if (prop_def.length()>0)
- {
- Tango::DbDatum data(prop_name);
- data << vect_data ;
- dev_def_prop.push_back(data);
- add_wiz_dev_prop(prop_name, prop_desc, prop_def);
- }
- else
- add_wiz_dev_prop(prop_name, prop_desc);
- prop_name = "DbHost";
- prop_desc = "Host of the MySQL db";
- prop_def = "";
- vect_data.clear();
- if (prop_def.length()>0)
- {
- Tango::DbDatum data(prop_name);
- data << vect_data ;
- dev_def_prop.push_back(data);
- add_wiz_dev_prop(prop_name, prop_desc, prop_def);
- }
- else
- add_wiz_dev_prop(prop_name, prop_desc);
- prop_name = "DbUser";
- prop_desc = "Username for the MySQL db";
- prop_def = "";
- vect_data.clear();
- if (prop_def.length()>0)
- {
- Tango::DbDatum data(prop_name);
- data << vect_data ;
- dev_def_prop.push_back(data);
- add_wiz_dev_prop(prop_name, prop_desc, prop_def);
- }
- else
- add_wiz_dev_prop(prop_name, prop_desc);
- prop_name = "DbPasswd";
- prop_desc = "Password for the MySQL db";
- prop_def = "";
- vect_data.clear();
- if (prop_def.length()>0)
- {
- Tango::DbDatum data(prop_name);
- data << vect_data ;
- dev_def_prop.push_back(data);
- add_wiz_dev_prop(prop_name, prop_desc, prop_def);
- }
- else
- add_wiz_dev_prop(prop_name, prop_desc);
- prop_name = "DbName";
- prop_desc = "Db name for the MySQL db";
- prop_def = "";
- vect_data.clear();
- if (prop_def.length()>0)
- {
- Tango::DbDatum data(prop_name);
- data << vect_data ;
- dev_def_prop.push_back(data);
- add_wiz_dev_prop(prop_name, prop_desc, prop_def);
- }
- else
- add_wiz_dev_prop(prop_name, prop_desc);
- prop_name = "DbPort";
- prop_desc = "Port of the MySQL db";
- prop_def = "";
- vect_data.clear();
- if (prop_def.length()>0)
- {
- Tango::DbDatum data(prop_name);
- data << vect_data ;
- dev_def_prop.push_back(data);
- add_wiz_dev_prop(prop_name, prop_desc, prop_def);
- }
- else
- add_wiz_dev_prop(prop_name, prop_desc);
- prop_name = "InstanceName";
- prop_desc = "Name used to associate configured alarm rules to this instance";
- prop_def = "";
+ prop_name = "SubscribeRetryPeriod";
+ prop_desc = "Retry subscription period in seconds";
+ prop_def = "30";
vect_data.clear();
+ vect_data.push_back("30");
if (prop_def.length()>0)
{
Tango::DbDatum data(prop_name);
@@ -483,10 +471,11 @@ void AlarmClass::set_default_property()
}
else
add_wiz_dev_prop(prop_name, prop_desc);
- prop_name = "SubscribeRetryPeriod";
- prop_desc = "retry period in seconds";
- prop_def = "";
+ prop_name = "StatisticsTimeWindow";
+ prop_desc = "Time window to compute statistics in seconds";
+ prop_def = "60";
vect_data.clear();
+ vect_data.push_back("60");
if (prop_def.length()>0)
{
Tango::DbDatum data(prop_name);
@@ -528,104 +517,6 @@ void AlarmClass::write_class_property()
description << str_desc;
data.push_back(description);
- // put cvs or svn location
- string filename("Alarm");
- filename += "Class.cpp";
-
- // check for cvs information
- string src_path(CvsPath);
- start = src_path.find("/");
- if (start!=string::npos)
- {
- end = src_path.find(filename);
- if (end>start)
- {
- string strloc = src_path.substr(start, end-start);
- // Check if specific repository
- start = strloc.find("/cvsroot/");
- if (start!=string::npos && start>0)
- {
- string repository = strloc.substr(0, start);
- if (repository.find("/segfs/")!=string::npos)
- strloc = "ESRF:" + strloc.substr(start, strloc.length()-start);
- }
- Tango::DbDatum cvs_loc("cvs_location");
- cvs_loc << strloc;
- data.push_back(cvs_loc);
- }
- }
-
- // check for svn information
- else
- {
- string src_path(SvnPath);
- start = src_path.find("://");
- if (start!=string::npos)
- {
- end = src_path.find(filename);
- if (end>start)
- {
- header = "$HeadURL: ";
- start = header.length();
- string strloc = src_path.substr(start, (end-start));
-
- Tango::DbDatum svn_loc("svn_location");
- svn_loc << strloc;
- data.push_back(svn_loc);
- }
- }
- }
-
- // Get CVS or SVN revision tag
-
- // CVS tag
- string tagname(TagName);
- header = "$Name: ";
- start = header.length();
- string endstr(" $");
-
- end = tagname.find(endstr);
- if (end!=string::npos && end>start)
- {
- string strtag = tagname.substr(start, end-start);
- Tango::DbDatum cvs_tag("cvs_tag");
- cvs_tag << strtag;
- data.push_back(cvs_tag);
- }
-
- // SVN tag
- string svnpath(SvnPath);
- header = "$HeadURL: ";
- start = header.length();
-
- end = svnpath.find(endstr);
- if (end!=string::npos && end>start)
- {
- string strloc = svnpath.substr(start, end-start);
-
- string tagstr ("/tags/");
- start = strloc.find(tagstr);
- if ( start!=string::npos )
- {
- start = start + tagstr.length();
- end = strloc.find(filename);
- string strtag = strloc.substr(start, end-start-1);
-
- Tango::DbDatum svn_tag("svn_tag");
- svn_tag << strtag;
- data.push_back(svn_tag);
- }
- }
-
- // Get URL location
- string httpServ(HttpServer);
- if (httpServ.length()>0)
- {
- Tango::DbDatum db_doc_url("doc_url");
- db_doc_url << httpServ;
- data.push_back(db_doc_url);
- }
-
// Put inheritance
Tango::DbDatum inher_datum("InheritedFrom");
vector<string> inheritance;
@@ -700,6 +591,56 @@ void AlarmClass::attribute_factory(vector<Tango::Attr *> &att_list)
// Add your own code
/*----- PROTECTED REGION END -----*/ // AlarmClass::attribute_factory_before
+ // Attribute : audibleAlarm
+ audibleAlarmAttrib *audiblealarm = new audibleAlarmAttrib();
+ Tango::UserDefaultAttrProp audiblealarm_prop;
+ audiblealarm_prop.set_description("True if there is at least one alarm that needs audible indication on the GUI");
+ // label not set for audibleAlarm
+ // unit not set for audibleAlarm
+ // standard_unit not set for audibleAlarm
+ // display_unit not set for audibleAlarm
+ // format not set for audibleAlarm
+ // max_value not set for audibleAlarm
+ // min_value not set for audibleAlarm
+ // max_alarm not set for audibleAlarm
+ // min_alarm not set for audibleAlarm
+ // max_warning not set for audibleAlarm
+ // min_warning not set for audibleAlarm
+ // delta_t not set for audibleAlarm
+ // delta_val not set for audibleAlarm
+
+ audiblealarm->set_default_properties(audiblealarm_prop);
+ // Not Polled
+ audiblealarm->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ audiblealarm->set_change_event(true, false);
+ audiblealarm->set_archive_event(true, false);
+ att_list.push_back(audiblealarm);
+
+ // Attribute : StatisticsResetTime
+ StatisticsResetTimeAttrib *statisticsresettime = new StatisticsResetTimeAttrib();
+ Tango::UserDefaultAttrProp statisticsresettime_prop;
+ statisticsresettime_prop.set_description("Time elapsed in seconds since last Resetstatistics");
+ // label not set for StatisticsResetTime
+ statisticsresettime_prop.set_unit("s");
+ statisticsresettime_prop.set_standard_unit("1");
+ statisticsresettime_prop.set_display_unit("s");
+ // format not set for StatisticsResetTime
+ // max_value not set for StatisticsResetTime
+ // min_value not set for StatisticsResetTime
+ // max_alarm not set for StatisticsResetTime
+ // min_alarm not set for StatisticsResetTime
+ // max_warning not set for StatisticsResetTime
+ // min_warning not set for StatisticsResetTime
+ // delta_t not set for StatisticsResetTime
+ // delta_val not set for StatisticsResetTime
+
+ statisticsresettime->set_default_properties(statisticsresettime_prop);
+ // Not Polled
+ statisticsresettime->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ att_list.push_back(statisticsresettime);
+
// Attribute : alarm
alarmAttrib *alarm = new alarmAttrib();
Tango::UserDefaultAttrProp alarm_prop;
@@ -724,6 +665,240 @@ void AlarmClass::attribute_factory(vector<Tango::Attr *> &att_list)
// Not Memorized
att_list.push_back(alarm);
+ // Attribute : normalAlarms
+ normalAlarmsAttrib *normalalarms = new normalAlarmsAttrib();
+ Tango::UserDefaultAttrProp normalalarms_prop;
+ normalalarms_prop.set_description("List of alarms in normal state");
+ // label not set for normalAlarms
+ // unit not set for normalAlarms
+ // standard_unit not set for normalAlarms
+ // display_unit not set for normalAlarms
+ // format not set for normalAlarms
+ // max_value not set for normalAlarms
+ // min_value not set for normalAlarms
+ // max_alarm not set for normalAlarms
+ // min_alarm not set for normalAlarms
+ // max_warning not set for normalAlarms
+ // min_warning not set for normalAlarms
+ // delta_t not set for normalAlarms
+ // delta_val not set for normalAlarms
+
+ normalalarms->set_default_properties(normalalarms_prop);
+ // Not Polled
+ normalalarms->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ normalalarms->set_change_event(true, true);
+ normalalarms->set_archive_event(true, true);
+ att_list.push_back(normalalarms);
+
+ // Attribute : unacknowledgedAlarms
+ unacknowledgedAlarmsAttrib *unacknowledgedalarms = new unacknowledgedAlarmsAttrib();
+ Tango::UserDefaultAttrProp unacknowledgedalarms_prop;
+ unacknowledgedalarms_prop.set_description("List of alarms in unacknowledged state");
+ // label not set for unacknowledgedAlarms
+ // unit not set for unacknowledgedAlarms
+ // standard_unit not set for unacknowledgedAlarms
+ // display_unit not set for unacknowledgedAlarms
+ // format not set for unacknowledgedAlarms
+ // max_value not set for unacknowledgedAlarms
+ // min_value not set for unacknowledgedAlarms
+ // max_alarm not set for unacknowledgedAlarms
+ // min_alarm not set for unacknowledgedAlarms
+ // max_warning not set for unacknowledgedAlarms
+ // min_warning not set for unacknowledgedAlarms
+ // delta_t not set for unacknowledgedAlarms
+ // delta_val not set for unacknowledgedAlarms
+
+ unacknowledgedalarms->set_default_properties(unacknowledgedalarms_prop);
+ // Not Polled
+ unacknowledgedalarms->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ unacknowledgedalarms->set_change_event(true, true);
+ unacknowledgedalarms->set_archive_event(true, true);
+ att_list.push_back(unacknowledgedalarms);
+
+ // Attribute : acknowledgedAlarms
+ acknowledgedAlarmsAttrib *acknowledgedalarms = new acknowledgedAlarmsAttrib();
+ Tango::UserDefaultAttrProp acknowledgedalarms_prop;
+ acknowledgedalarms_prop.set_description("List of alarms in acknowledged state");
+ // label not set for acknowledgedAlarms
+ // unit not set for acknowledgedAlarms
+ // standard_unit not set for acknowledgedAlarms
+ // display_unit not set for acknowledgedAlarms
+ // format not set for acknowledgedAlarms
+ // max_value not set for acknowledgedAlarms
+ // min_value not set for acknowledgedAlarms
+ // max_alarm not set for acknowledgedAlarms
+ // min_alarm not set for acknowledgedAlarms
+ // max_warning not set for acknowledgedAlarms
+ // min_warning not set for acknowledgedAlarms
+ // delta_t not set for acknowledgedAlarms
+ // delta_val not set for acknowledgedAlarms
+
+ acknowledgedalarms->set_default_properties(acknowledgedalarms_prop);
+ // Not Polled
+ acknowledgedalarms->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ acknowledgedalarms->set_change_event(true, true);
+ acknowledgedalarms->set_archive_event(true, true);
+ att_list.push_back(acknowledgedalarms);
+
+ // Attribute : unacknowledgedNormalAlarms
+ unacknowledgedNormalAlarmsAttrib *unacknowledgednormalalarms = new unacknowledgedNormalAlarmsAttrib();
+ Tango::UserDefaultAttrProp unacknowledgednormalalarms_prop;
+ unacknowledgednormalalarms_prop.set_description("List of alarms in unacknowledged normal state");
+ // label not set for unacknowledgedNormalAlarms
+ // unit not set for unacknowledgedNormalAlarms
+ // standard_unit not set for unacknowledgedNormalAlarms
+ // display_unit not set for unacknowledgedNormalAlarms
+ // format not set for unacknowledgedNormalAlarms
+ // max_value not set for unacknowledgedNormalAlarms
+ // min_value not set for unacknowledgedNormalAlarms
+ // max_alarm not set for unacknowledgedNormalAlarms
+ // min_alarm not set for unacknowledgedNormalAlarms
+ // max_warning not set for unacknowledgedNormalAlarms
+ // min_warning not set for unacknowledgedNormalAlarms
+ // delta_t not set for unacknowledgedNormalAlarms
+ // delta_val not set for unacknowledgedNormalAlarms
+
+ unacknowledgednormalalarms->set_default_properties(unacknowledgednormalalarms_prop);
+ // Not Polled
+ unacknowledgednormalalarms->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ unacknowledgednormalalarms->set_change_event(true, true);
+ unacknowledgednormalalarms->set_archive_event(true, true);
+ att_list.push_back(unacknowledgednormalalarms);
+
+ // Attribute : shelvedAlarms
+ shelvedAlarmsAttrib *shelvedalarms = new shelvedAlarmsAttrib();
+ Tango::UserDefaultAttrProp shelvedalarms_prop;
+ shelvedalarms_prop.set_description("List of alarms in shelved state");
+ // label not set for shelvedAlarms
+ // unit not set for shelvedAlarms
+ // standard_unit not set for shelvedAlarms
+ // display_unit not set for shelvedAlarms
+ // format not set for shelvedAlarms
+ // max_value not set for shelvedAlarms
+ // min_value not set for shelvedAlarms
+ // max_alarm not set for shelvedAlarms
+ // min_alarm not set for shelvedAlarms
+ // max_warning not set for shelvedAlarms
+ // min_warning not set for shelvedAlarms
+ // delta_t not set for shelvedAlarms
+ // delta_val not set for shelvedAlarms
+
+ shelvedalarms->set_default_properties(shelvedalarms_prop);
+ // Not Polled
+ shelvedalarms->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ shelvedalarms->set_change_event(true, true);
+ shelvedalarms->set_archive_event(true, true);
+ att_list.push_back(shelvedalarms);
+
+ // Attribute : outOfServiceAlarms
+ outOfServiceAlarmsAttrib *outofservicealarms = new outOfServiceAlarmsAttrib();
+ Tango::UserDefaultAttrProp outofservicealarms_prop;
+ outofservicealarms_prop.set_description("List of alarms in out of service state");
+ // label not set for outOfServiceAlarms
+ // unit not set for outOfServiceAlarms
+ // standard_unit not set for outOfServiceAlarms
+ // display_unit not set for outOfServiceAlarms
+ // format not set for outOfServiceAlarms
+ // max_value not set for outOfServiceAlarms
+ // min_value not set for outOfServiceAlarms
+ // max_alarm not set for outOfServiceAlarms
+ // min_alarm not set for outOfServiceAlarms
+ // max_warning not set for outOfServiceAlarms
+ // min_warning not set for outOfServiceAlarms
+ // delta_t not set for outOfServiceAlarms
+ // delta_val not set for outOfServiceAlarms
+
+ outofservicealarms->set_default_properties(outofservicealarms_prop);
+ // Not Polled
+ outofservicealarms->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ outofservicealarms->set_change_event(true, true);
+ outofservicealarms->set_archive_event(true, true);
+ att_list.push_back(outofservicealarms);
+
+ // Attribute : silencedAlarms
+ silencedAlarmsAttrib *silencedalarms = new silencedAlarmsAttrib();
+ Tango::UserDefaultAttrProp silencedalarms_prop;
+ silencedalarms_prop.set_description("List of alarms in silenced state");
+ // label not set for silencedAlarms
+ // unit not set for silencedAlarms
+ // standard_unit not set for silencedAlarms
+ // display_unit not set for silencedAlarms
+ // format not set for silencedAlarms
+ // max_value not set for silencedAlarms
+ // min_value not set for silencedAlarms
+ // max_alarm not set for silencedAlarms
+ // min_alarm not set for silencedAlarms
+ // max_warning not set for silencedAlarms
+ // min_warning not set for silencedAlarms
+ // delta_t not set for silencedAlarms
+ // delta_val not set for silencedAlarms
+
+ silencedalarms->set_default_properties(silencedalarms_prop);
+ // Not Polled
+ silencedalarms->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ silencedalarms->set_change_event(true, true);
+ silencedalarms->set_archive_event(true, true);
+ att_list.push_back(silencedalarms);
+
+ // Attribute : listAlarms
+ listAlarmsAttrib *listalarms = new listAlarmsAttrib();
+ Tango::UserDefaultAttrProp listalarms_prop;
+ listalarms_prop.set_description("List of all alarms");
+ // label not set for listAlarms
+ // unit not set for listAlarms
+ // standard_unit not set for listAlarms
+ // display_unit not set for listAlarms
+ // format not set for listAlarms
+ // max_value not set for listAlarms
+ // min_value not set for listAlarms
+ // max_alarm not set for listAlarms
+ // min_alarm not set for listAlarms
+ // max_warning not set for listAlarms
+ // min_warning not set for listAlarms
+ // delta_t not set for listAlarms
+ // delta_val not set for listAlarms
+
+ listalarms->set_default_properties(listalarms_prop);
+ // Not Polled
+ listalarms->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ listalarms->set_change_event(true, true);
+ listalarms->set_archive_event(true, true);
+ att_list.push_back(listalarms);
+
+ // Attribute : frequencyAlarms
+ frequencyAlarmsAttrib *frequencyalarms = new frequencyAlarmsAttrib();
+ Tango::UserDefaultAttrProp frequencyalarms_prop;
+ frequencyalarms_prop.set_description("List of frequency of evaluation of all alarms");
+ // label not set for frequencyAlarms
+ // unit not set for frequencyAlarms
+ // standard_unit not set for frequencyAlarms
+ // display_unit not set for frequencyAlarms
+ // format not set for frequencyAlarms
+ // max_value not set for frequencyAlarms
+ // min_value not set for frequencyAlarms
+ // max_alarm not set for frequencyAlarms
+ // min_alarm not set for frequencyAlarms
+ // max_warning not set for frequencyAlarms
+ // min_warning not set for frequencyAlarms
+ // delta_t not set for frequencyAlarms
+ // delta_val not set for frequencyAlarms
+
+ frequencyalarms->set_default_properties(frequencyalarms_prop);
+ // Not Polled
+ frequencyalarms->set_disp_level(Tango::OPERATOR);
+ // Not Memorized
+ frequencyalarms->set_change_event(true, true);
+ frequencyalarms->set_archive_event(true, true);
+ att_list.push_back(frequencyalarms);
+
// Create a list of static attributes
create_static_attribute_list(get_class_attr()->get_attr_list());
@@ -796,23 +971,23 @@ void AlarmClass::command_factory()
Tango::OPERATOR);
command_list.push_back(pRemoveCmd);
- // Command Configured
- ConfiguredClass *pConfiguredCmd =
- new ConfiguredClass("Configured",
+ // Command SearchAlarm
+ SearchAlarmClass *pSearchAlarmCmd =
+ new SearchAlarmClass("SearchAlarm",
Tango::DEV_STRING, Tango::DEVVAR_STRINGARRAY,
- "String containing a filter for output, if empty return all alarms",
- "Alarms configured",
+ "String containing a filter for output, if empty or * return all alarms",
+ "Configured alarms",
Tango::OPERATOR);
- command_list.push_back(pConfiguredCmd);
+ command_list.push_back(pSearchAlarmCmd);
- // Command StopNew
- StopNewClass *pStopNewCmd =
- new StopNewClass("StopNew",
+ // Command StopAudible
+ StopAudibleClass *pStopAudibleCmd =
+ new StopAudibleClass("StopAudible",
Tango::DEV_VOID, Tango::DEV_VOID,
"",
"",
Tango::OPERATOR);
- command_list.push_back(pStopNewCmd);
+ command_list.push_back(pStopAudibleCmd);
// Command Silence
SilenceClass *pSilenceCmd =
@@ -832,6 +1007,42 @@ void AlarmClass::command_factory()
Tango::OPERATOR);
command_list.push_back(pModifyCmd);
+ // Command Shelve
+ ShelveClass *pShelveCmd =
+ new ShelveClass("Shelve",
+ Tango::DEVVAR_STRINGARRAY, Tango::DEV_VOID,
+ "String array containing alarm to be shelved",
+ "",
+ Tango::OPERATOR);
+ command_list.push_back(pShelveCmd);
+
+ // Command Enable
+ EnableClass *pEnableCmd =
+ new EnableClass("Enable",
+ Tango::DEV_STRING, Tango::DEV_VOID,
+ "Alarm name",
+ "",
+ Tango::OPERATOR);
+ command_list.push_back(pEnableCmd);
+
+ // Command Disable
+ DisableClass *pDisableCmd =
+ new DisableClass("Disable",
+ Tango::DEV_STRING, Tango::DEV_VOID,
+ "Alarm name",
+ "",
+ Tango::OPERATOR);
+ command_list.push_back(pDisableCmd);
+
+ // Command ResetStatistics
+ ResetStatisticsClass *pResetStatisticsCmd =
+ new ResetStatisticsClass("ResetStatistics",
+ Tango::DEV_VOID, Tango::DEV_VOID,
+ "",
+ "",
+ Tango::OPERATOR);
+ command_list.push_back(pResetStatisticsCmd);
+
/*----- PROTECTED REGION ID(AlarmClass::command_factory_after) ENABLED START -----*/
// Add your own code
diff --git a/src/AlarmClass.h b/src/AlarmClass.h
index 0d1676b..1b2a25d 100644
--- a/src/AlarmClass.h
+++ b/src/AlarmClass.h
@@ -58,6 +58,32 @@ namespace Alarm_ns
//=========================================
// Define classes for attributes
//=========================================
+// Attribute audibleAlarm class definition
+class audibleAlarmAttrib: public Tango::Attr
+{
+public:
+ audibleAlarmAttrib():Attr("audibleAlarm",
+ Tango::DEV_BOOLEAN, Tango::READ) {};
+ ~audibleAlarmAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_audibleAlarm(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_audibleAlarm_allowed(ty);}
+};
+
+// Attribute StatisticsResetTime class definition
+class StatisticsResetTimeAttrib: public Tango::Attr
+{
+public:
+ StatisticsResetTimeAttrib():Attr("StatisticsResetTime",
+ Tango::DEV_DOUBLE, Tango::READ) {};
+ ~StatisticsResetTimeAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_StatisticsResetTime(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_StatisticsResetTime_allowed(ty);}
+};
+
// Attribute alarm class definition
class alarmAttrib: public Tango::SpectrumAttr
{
@@ -71,6 +97,123 @@ public:
{return (static_cast<Alarm *>(dev))->is_alarm_allowed(ty);}
};
+// Attribute normalAlarms class definition
+class normalAlarmsAttrib: public Tango::SpectrumAttr
+{
+public:
+ normalAlarmsAttrib():SpectrumAttr("normalAlarms",
+ Tango::DEV_STRING, Tango::READ, 10000) {};
+ ~normalAlarmsAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_normalAlarms(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_normalAlarms_allowed(ty);}
+};
+
+// Attribute unacknowledgedAlarms class definition
+class unacknowledgedAlarmsAttrib: public Tango::SpectrumAttr
+{
+public:
+ unacknowledgedAlarmsAttrib():SpectrumAttr("unacknowledgedAlarms",
+ Tango::DEV_STRING, Tango::READ, 10000) {};
+ ~unacknowledgedAlarmsAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_unacknowledgedAlarms(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_unacknowledgedAlarms_allowed(ty);}
+};
+
+// Attribute acknowledgedAlarms class definition
+class acknowledgedAlarmsAttrib: public Tango::SpectrumAttr
+{
+public:
+ acknowledgedAlarmsAttrib():SpectrumAttr("acknowledgedAlarms",
+ Tango::DEV_STRING, Tango::READ, 10000) {};
+ ~acknowledgedAlarmsAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_acknowledgedAlarms(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_acknowledgedAlarms_allowed(ty);}
+};
+
+// Attribute unacknowledgedNormalAlarms class definition
+class unacknowledgedNormalAlarmsAttrib: public Tango::SpectrumAttr
+{
+public:
+ unacknowledgedNormalAlarmsAttrib():SpectrumAttr("unacknowledgedNormalAlarms",
+ Tango::DEV_STRING, Tango::READ, 10000) {};
+ ~unacknowledgedNormalAlarmsAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_unacknowledgedNormalAlarms(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_unacknowledgedNormalAlarms_allowed(ty);}
+};
+
+// Attribute shelvedAlarms class definition
+class shelvedAlarmsAttrib: public Tango::SpectrumAttr
+{
+public:
+ shelvedAlarmsAttrib():SpectrumAttr("shelvedAlarms",
+ Tango::DEV_STRING, Tango::READ, 10000) {};
+ ~shelvedAlarmsAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_shelvedAlarms(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_shelvedAlarms_allowed(ty);}
+};
+
+// Attribute outOfServiceAlarms class definition
+class outOfServiceAlarmsAttrib: public Tango::SpectrumAttr
+{
+public:
+ outOfServiceAlarmsAttrib():SpectrumAttr("outOfServiceAlarms",
+ Tango::DEV_STRING, Tango::READ, 10000) {};
+ ~outOfServiceAlarmsAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_outOfServiceAlarms(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_outOfServiceAlarms_allowed(ty);}
+};
+
+// Attribute silencedAlarms class definition
+class silencedAlarmsAttrib: public Tango::SpectrumAttr
+{
+public:
+ silencedAlarmsAttrib():SpectrumAttr("silencedAlarms",
+ Tango::DEV_STRING, Tango::READ, 10000) {};
+ ~silencedAlarmsAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_silencedAlarms(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_silencedAlarms_allowed(ty);}
+};
+
+// Attribute listAlarms class definition
+class listAlarmsAttrib: public Tango::SpectrumAttr
+{
+public:
+ listAlarmsAttrib():SpectrumAttr("listAlarms",
+ Tango::DEV_STRING, Tango::READ, 10000) {};
+ ~listAlarmsAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_listAlarms(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_listAlarms_allowed(ty);}
+};
+
+// Attribute frequencyAlarms class definition
+class frequencyAlarmsAttrib: public Tango::SpectrumAttr
+{
+public:
+ frequencyAlarmsAttrib():SpectrumAttr("frequencyAlarms",
+ Tango::DEV_DOUBLE, Tango::READ, 10000) {};
+ ~frequencyAlarmsAttrib() {};
+ virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
+ {(static_cast<Alarm *>(dev))->read_frequencyAlarms(att);}
+ virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
+ {return (static_cast<Alarm *>(dev))->is_frequencyAlarms_allowed(ty);}
+};
+
//=========================================
// Define classes for dynamic attributes
@@ -176,11 +319,11 @@ public:
{return (static_cast<Alarm *>(dev))->is_Remove_allowed(any);}
};
-// Command Configured class definition
-class ConfiguredClass : public Tango::Command
+// Command SearchAlarm class definition
+class SearchAlarmClass : public Tango::Command
{
public:
- ConfiguredClass(const char *name,
+ SearchAlarmClass(const char *name,
Tango::CmdArgType in,
Tango::CmdArgType out,
const char *in_desc,
@@ -188,22 +331,22 @@ public:
Tango::DispLevel level)
:Command(name,in,out,in_desc,out_desc, level) {};
- ConfiguredClass(const char *name,
+ SearchAlarmClass(const char *name,
Tango::CmdArgType in,
Tango::CmdArgType out)
:Command(name,in,out) {};
- ~ConfiguredClass() {};
+ ~SearchAlarmClass() {};
virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
- {return (static_cast<Alarm *>(dev))->is_Configured_allowed(any);}
+ {return (static_cast<Alarm *>(dev))->is_SearchAlarm_allowed(any);}
};
-// Command StopNew class definition
-class StopNewClass : public Tango::Command
+// Command StopAudible class definition
+class StopAudibleClass : public Tango::Command
{
public:
- StopNewClass(const char *name,
+ StopAudibleClass(const char *name,
Tango::CmdArgType in,
Tango::CmdArgType out,
const char *in_desc,
@@ -211,15 +354,15 @@ public:
Tango::DispLevel level)
:Command(name,in,out,in_desc,out_desc, level) {};
- StopNewClass(const char *name,
+ StopAudibleClass(const char *name,
Tango::CmdArgType in,
Tango::CmdArgType out)
:Command(name,in,out) {};
- ~StopNewClass() {};
+ ~StopAudibleClass() {};
virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
- {return (static_cast<Alarm *>(dev))->is_StopNew_allowed(any);}
+ {return (static_cast<Alarm *>(dev))->is_StopAudible_allowed(any);}
};
// Command Silence class definition
@@ -268,6 +411,98 @@ public:
{return (static_cast<Alarm *>(dev))->is_Modify_allowed(any);}
};
+// Command Shelve class definition
+class ShelveClass : public Tango::Command
+{
+public:
+ ShelveClass(const char *name,
+ Tango::CmdArgType in,
+ Tango::CmdArgType out,
+ const char *in_desc,
+ const char *out_desc,
+ Tango::DispLevel level)
+ :Command(name,in,out,in_desc,out_desc, level) {};
+
+ ShelveClass(const char *name,
+ Tango::CmdArgType in,
+ Tango::CmdArgType out)
+ :Command(name,in,out) {};
+ ~ShelveClass() {};
+
+ virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
+ virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
+ {return (static_cast<Alarm *>(dev))->is_Shelve_allowed(any);}
+};
+
+// Command Enable class definition
+class EnableClass : public Tango::Command
+{
+public:
+ EnableClass(const char *name,
+ Tango::CmdArgType in,
+ Tango::CmdArgType out,
+ const char *in_desc,
+ const char *out_desc,
+ Tango::DispLevel level)
+ :Command(name,in,out,in_desc,out_desc, level) {};
+
+ EnableClass(const char *name,
+ Tango::CmdArgType in,
+ Tango::CmdArgType out)
+ :Command(name,in,out) {};
+ ~EnableClass() {};
+
+ virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
+ virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
+ {return (static_cast<Alarm *>(dev))->is_Enable_allowed(any);}
+};
+
+// Command Disable class definition
+class DisableClass : public Tango::Command
+{
+public:
+ DisableClass(const char *name,
+ Tango::CmdArgType in,
+ Tango::CmdArgType out,
+ const char *in_desc,
+ const char *out_desc,
+ Tango::DispLevel level)
+ :Command(name,in,out,in_desc,out_desc, level) {};
+
+ DisableClass(const char *name,
+ Tango::CmdArgType in,
+ Tango::CmdArgType out)
+ :Command(name,in,out) {};
+ ~DisableClass() {};
+
+ virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
+ virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
+ {return (static_cast<Alarm *>(dev))->is_Disable_allowed(any);}
+};
+
+// Command ResetStatistics class definition
+class ResetStatisticsClass : public Tango::Command
+{
+public:
+ ResetStatisticsClass(const char *name,
+ Tango::CmdArgType in,
+ Tango::CmdArgType out,
+ const char *in_desc,
+ const char *out_desc,
+ Tango::DispLevel level)
+ :Command(name,in,out,in_desc,out_desc, level) {};
+
+ ResetStatisticsClass(const char *name,
+ Tango::CmdArgType in,
+ Tango::CmdArgType out)
+ :Command(name,in,out) {};
+ ~ResetStatisticsClass() {};
+
+ virtual CORBA::Any *execute (Tango::DeviceImpl *dev, const CORBA::Any &any);
+ virtual bool is_allowed (Tango::DeviceImpl *dev, const CORBA::Any &any)
+ {return (static_cast<Alarm *>(dev))->is_ResetStatistics_allowed(any);}
+};
+
/**
* The AlarmClass singleton definition
diff --git a/src/AlarmStateMachine.cpp b/src/AlarmStateMachine.cpp
index b38f2ae..d05999e 100644
--- a/src/AlarmStateMachine.cpp
+++ b/src/AlarmStateMachine.cpp
@@ -50,6 +50,38 @@ namespace Alarm_ns
// Attributes Allowed Methods
//=================================================
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_audibleAlarm_allowed()
+ * Description : Execution allowed for audibleAlarm attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_audibleAlarm_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for audibleAlarm attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::audibleAlarmStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::audibleAlarmStateAllowed_READ
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_StatisticsResetTime_allowed()
+ * Description : Execution allowed for StatisticsResetTime attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_StatisticsResetTime_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for StatisticsResetTime attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::StatisticsResetTimeStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::StatisticsResetTimeStateAllowed_READ
+ return true;
+}
+
//--------------------------------------------------------
/**
* Method : Alarm::is_alarm_allowed()
@@ -66,6 +98,150 @@ bool Alarm::is_alarm_allowed(TANGO_UNUSED(Tango::AttReqType type))
return true;
}
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_normalAlarms_allowed()
+ * Description : Execution allowed for normalAlarms attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_normalAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for normalAlarms attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::normalAlarmsStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::normalAlarmsStateAllowed_READ
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_unacknowledgedAlarms_allowed()
+ * Description : Execution allowed for unacknowledgedAlarms attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_unacknowledgedAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for unacknowledgedAlarms attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::unacknowledgedAlarmsStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::unacknowledgedAlarmsStateAllowed_READ
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_acknowledgedAlarms_allowed()
+ * Description : Execution allowed for acknowledgedAlarms attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_acknowledgedAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for acknowledgedAlarms attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::acknowledgedAlarmsStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::acknowledgedAlarmsStateAllowed_READ
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_unacknowledgedNormalAlarms_allowed()
+ * Description : Execution allowed for unacknowledgedNormalAlarms attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_unacknowledgedNormalAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for unacknowledgedNormalAlarms attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::unacknowledgedNormalAlarmsStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::unacknowledgedNormalAlarmsStateAllowed_READ
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_shelvedAlarms_allowed()
+ * Description : Execution allowed for shelvedAlarms attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_shelvedAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for shelvedAlarms attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::shelvedAlarmsStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::shelvedAlarmsStateAllowed_READ
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_outOfServiceAlarms_allowed()
+ * Description : Execution allowed for outOfServiceAlarms attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_outOfServiceAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for outOfServiceAlarms attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::outOfServiceAlarmsStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::outOfServiceAlarmsStateAllowed_READ
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_silencedAlarms_allowed()
+ * Description : Execution allowed for silencedAlarms attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_silencedAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for silencedAlarms attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::silencedAlarmsStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::silencedAlarmsStateAllowed_READ
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_listAlarms_allowed()
+ * Description : Execution allowed for listAlarms attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_listAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for listAlarms attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::listAlarmsStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::listAlarmsStateAllowed_READ
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_frequencyAlarms_allowed()
+ * Description : Execution allowed for frequencyAlarms attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_frequencyAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+{
+
+ // Not any excluded states for frequencyAlarms attribute in read access.
+ /*----- PROTECTED REGION ID(Alarm::frequencyAlarmsStateAllowed_READ) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::frequencyAlarmsStateAllowed_READ
+ return true;
+}
+
//--------------------------------------------------------
/**
* Method : Alarm::is_AlarmState_allowed()
@@ -150,31 +326,31 @@ bool Alarm::is_Remove_allowed(TANGO_UNUSED(const CORBA::Any &any))
//--------------------------------------------------------
/**
- * Method : Alarm::is_Configured_allowed()
- * Description : Execution allowed for Configured attribute
+ * Method : Alarm::is_SearchAlarm_allowed()
+ * Description : Execution allowed for SearchAlarm attribute
*/
//--------------------------------------------------------
-bool Alarm::is_Configured_allowed(TANGO_UNUSED(const CORBA::Any &any))
+bool Alarm::is_SearchAlarm_allowed(TANGO_UNUSED(const CORBA::Any &any))
{
- // Not any excluded states for Configured command.
- /*----- PROTECTED REGION ID(Alarm::ConfiguredStateAllowed) ENABLED START -----*/
+ // Not any excluded states for SearchAlarm command.
+ /*----- PROTECTED REGION ID(Alarm::SearchAlarmStateAllowed) ENABLED START -----*/
- /*----- PROTECTED REGION END -----*/ // Alarm::ConfiguredStateAllowed
+ /*----- PROTECTED REGION END -----*/ // Alarm::SearchAlarmStateAllowed
return true;
}
//--------------------------------------------------------
/**
- * Method : Alarm::is_StopNew_allowed()
- * Description : Execution allowed for StopNew attribute
+ * Method : Alarm::is_StopAudible_allowed()
+ * Description : Execution allowed for StopAudible attribute
*/
//--------------------------------------------------------
-bool Alarm::is_StopNew_allowed(TANGO_UNUSED(const CORBA::Any &any))
+bool Alarm::is_StopAudible_allowed(TANGO_UNUSED(const CORBA::Any &any))
{
- // Not any excluded states for StopNew command.
- /*----- PROTECTED REGION ID(Alarm::StopNewStateAllowed) ENABLED START -----*/
+ // Not any excluded states for StopAudible command.
+ /*----- PROTECTED REGION ID(Alarm::StopAudibleStateAllowed) ENABLED START -----*/
- /*----- PROTECTED REGION END -----*/ // Alarm::StopNewStateAllowed
+ /*----- PROTECTED REGION END -----*/ // Alarm::StopAudibleStateAllowed
return true;
}
@@ -208,6 +384,66 @@ bool Alarm::is_Modify_allowed(TANGO_UNUSED(const CORBA::Any &any))
return true;
}
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_Shelve_allowed()
+ * Description : Execution allowed for Shelve attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_Shelve_allowed(TANGO_UNUSED(const CORBA::Any &any))
+{
+ // Not any excluded states for Shelve command.
+ /*----- PROTECTED REGION ID(Alarm::ShelveStateAllowed) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::ShelveStateAllowed
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_Enable_allowed()
+ * Description : Execution allowed for Enable attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_Enable_allowed(TANGO_UNUSED(const CORBA::Any &any))
+{
+ // Not any excluded states for Enable command.
+ /*----- PROTECTED REGION ID(Alarm::EnableStateAllowed) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::EnableStateAllowed
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_Disable_allowed()
+ * Description : Execution allowed for Disable attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_Disable_allowed(TANGO_UNUSED(const CORBA::Any &any))
+{
+ // Not any excluded states for Disable command.
+ /*----- PROTECTED REGION ID(Alarm::DisableStateAllowed) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::DisableStateAllowed
+ return true;
+}
+
+//--------------------------------------------------------
+/**
+ * Method : Alarm::is_ResetStatistics_allowed()
+ * Description : Execution allowed for ResetStatistics attribute
+ */
+//--------------------------------------------------------
+bool Alarm::is_ResetStatistics_allowed(TANGO_UNUSED(const CORBA::Any &any))
+{
+ // Not any excluded states for ResetStatistics command.
+ /*----- PROTECTED REGION ID(Alarm::ResetStatisticsStateAllowed) ENABLED START -----*/
+
+ /*----- PROTECTED REGION END -----*/ // Alarm::ResetStatisticsStateAllowed
+ return true;
+}
+
/*----- PROTECTED REGION ID(Alarm::AlarmStateAllowed.AdditionalMethods) ENABLED START -----*/
diff --git a/src/alarm_table.cpp b/src/alarm_table.cpp
index c693bfa..9bf5bdf 100644
--- a/src/alarm_table.cpp
+++ b/src/alarm_table.cpp
@@ -41,6 +41,7 @@ alarm_t::alarm_t()
grp=0;
on_counter=0;
off_counter=0;
+ freq_counter=0;
stat = S_NORMAL;
ack = ACK;
on_delay = 0;
@@ -49,6 +50,7 @@ alarm_t::alarm_t()
cmd_name_a=string("");
cmd_name_n=string("");
enabled=true;
+ shelved=false;
}
bool alarm_t::operator==(const alarm_t &that)
@@ -389,9 +391,16 @@ bool alarm_table::update(const string& alm_name, Tango::TimeVal ts, formula_res_
double dsilent = found->second.ts_time_silenced.tv_sec + ((double)found->second.ts_time_silenced.tv_usec) / 1000000;
double dminutes = (dnow - dsilent)/60;
if(dminutes < found->second.silent_time)
+ {
found->second.silenced = found->second.silent_time - floor(dminutes);
+ }
else
+ {
found->second.silenced = 0;
+ found->second.shelved = false;
+ found->second.is_new = 0;
+ found->second.ack = ACK;
+ }
}
found->second.quality = res.quality;
found->second.ex_reason = res.ex_reason;
@@ -569,34 +578,50 @@ bool alarm_table::timer_update()
{
bool status_on_delay;
bool status_off_delay;
- if(i->second.on_delay == 0 && i->second.off_delay == 0)
+ if(i->second.on_delay == 0 && i->second.off_delay == 0 && !i->second.shelved && i->second.silenced <=0)
continue; //if not enabled on or off delay, nothing to do in timer
if(i->second.on_delay > 0) //if enabled on delay
status_on_delay = (i->second.on_counter >= 1) && ((ts.tv_sec - i->second.on_delay) > i->second.ts_on_delay.tv_sec); //waiting for on delay has passed
if(i->second.off_delay > 0) //if enabled off delay
status_off_delay = (i->second.off_counter >= 1) && ((ts.tv_sec - i->second.off_delay) > i->second.ts_off_delay.tv_sec); //waiting for off delay has passed
+ //look here also if shelved time ended
+ bool old_shelved = i->second.shelved;
+ int old_silenced = i->second.silenced;
+ if(i->second.silenced > 0)
+ {
+ Tango::TimeVal now = gettime();
+ double dnow = now.tv_sec + ((double)now.tv_usec) / 1000000;
+ double dsilent = i->second.ts_time_silenced.tv_sec + ((double)i->second.ts_time_silenced.tv_usec) / 1000000;
+ double dminutes = (dnow - dsilent)/60;
+ if(dminutes < i->second.silent_time)
+ {
+ i->second.silenced = i->second.silent_time - floor(dminutes);
+ }
+ else
+ {
+ i->second.silenced = 0;
+ i->second.shelved = false;
+ i->second.is_new = 0;
+ i->second.ack = ACK;
+ }
+ }
+ //if just ended silence time, set ret_changed to true so to push events
+ //TODO: not interested in executing commands?
+ if(old_silenced>0 && i->second.silenced == 0)
+ ret_changed = true;
//if status changed:
// - from S_NORMAL to S_ALARM considering also on delay
//or
// - from S_ALARM to S_NORMAL considering also off delay
- if(status_on_delay && (i->second.stat == S_NORMAL) || (status_off_delay && (i->second.stat == S_ALARM)))
+ //or
+ // - from shelved to not shelved
+ if(status_on_delay && (i->second.stat == S_NORMAL) || (status_off_delay && (i->second.stat == S_ALARM)) || (old_shelved && !i->second.shelved))
{
ret_changed = true;
- if(i->second.silenced > 0)
- {
- Tango::TimeVal now = gettime();
- double dnow = now.tv_sec + ((double)now.tv_usec) / 1000000;
- double dsilent = i->second.ts_time_silenced.tv_sec + ((double)i->second.ts_time_silenced.tv_usec) / 1000000;
- double dminutes = (dnow - dsilent)/60;
- if(dminutes < i->second.silent_time)
- i->second.silenced = i->second.silent_time - floor(dminutes);
- else
- i->second.silenced = 0;
- }
if(status_on_delay)
- i->second.ack = NOT_ACK; //if changing from NORMAL to ALARM -> NACK
+ i->second.ack = NOT_ACK; //if changing from NORMAL to ALARM but not ended shelved time -> NACK
i->second.ts = ts; /* store event timestamp into alarm timestamp */ //here update ts only if status changed
if(status_on_delay)
{
@@ -692,8 +717,11 @@ bool alarm_table::timer_update()
}
}
- //TODO: if not _SHLVD, _DSUPR, _OOSRV
- if((status_off_delay) && i->second.ack == ACK)
+ if(!i->second.enabled)
+ *(i->second.attr_value) = _OOSRV;
+ else if(i->second.shelved && i->second.silenced > 0)
+ *(i->second.attr_value) = _SHLVD;
+ else if((status_off_delay) && i->second.ack == ACK)
*(i->second.attr_value) = _NORM;
else if((status_on_delay) && i->second.ack == NOT_ACK)
*(i->second.attr_value) = _UNACK;
@@ -707,8 +735,8 @@ bool alarm_table::timer_update()
{
timeval now;
gettimeofday(&now, NULL);
- mydev->push_change_event(i->second.attr_name,(Tango::DevBoolean *)i->second.attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
- mydev->push_archive_event(i->second.attr_name,(Tango::DevBoolean *)i->second.attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
+ mydev->push_change_event(i->second.attr_name,(Tango::DevEnum *)i->second.attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
+ mydev->push_archive_event(i->second.attr_name,(Tango::DevEnum *)i->second.attr_value,now,(Tango::AttrQuality)i->second.quality, 1/*size*/, 0, false);
}
else
{
diff --git a/src/alarm_table.h b/src/alarm_table.h
index c3d974b..fc02c75 100644
--- a/src/alarm_table.h
+++ b/src/alarm_table.h
@@ -269,8 +269,10 @@ class alarm_t {
string stat,
ack;
bool enabled;
+ bool shelved;
unsigned int on_counter;
unsigned int off_counter;
+ unsigned int freq_counter;
tree_parse_info_t formula_tree;
--
GitLab