diff --git a/src/AlarmHandler.cpp b/src/AlarmHandler.cpp
index 83883f8a9523854eb70ead93cfe6081be5f2696b..5352f1c326726439dbefd165899b31ac9417162c 100644
--- a/src/AlarmHandler.cpp
+++ b/src/AlarmHandler.cpp
@@ -113,19 +113,19 @@ static const char __FILE__rev[] = __FILE__ " $Revision: 1.29 $";
 //================================================================
 //  Attributes managed are:
 //================================================================
-//  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)
-//  alarmSummary                |  Tango::DevString	Spectrum  ( max = 10000)
+//  alarmAudible               |  Tango::DevBoolean	Scalar
+//  StatisticsResetTime        |  Tango::DevDouble	Scalar
+//  alarm                      |  Tango::DevString	Spectrum  ( max = 1024)
+//  alarmNormal                |  Tango::DevString	Spectrum  ( max = 10000)
+//  alarmUnacknowledged        |  Tango::DevString	Spectrum  ( max = 10000)
+//  alarmAcknowledged          |  Tango::DevString	Spectrum  ( max = 10000)
+//  alarmUnacknowledgedNormal  |  Tango::DevString	Spectrum  ( max = 10000)
+//  alarmShelved               |  Tango::DevString	Spectrum  ( max = 10000)
+//  alarmOutOfService          |  Tango::DevString	Spectrum  ( max = 10000)
+//  alarmSilenced              |  Tango::DevString	Spectrum  ( max = 10000)
+//  alarmList                  |  Tango::DevString	Spectrum  ( max = 10000)
+//  alarmFrequency             |  Tango::DevDouble	Spectrum  ( max = 10000)
+//  alarmSummary               |  Tango::DevString	Spectrum  ( max = 10000)
 //================================================================
 
 namespace AlarmHandler_ns
@@ -319,17 +319,17 @@ void AlarmHandler::delete_device()
 	//Tango::leavefunc();
 	delete prepare_alm_mtx;
 	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::delete_device
-	delete[] attr_audibleAlarm_read;
+	delete[] attr_alarmAudible_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;
+	delete[] attr_alarmNormal_read;
+	delete[] attr_alarmUnacknowledged_read;
+	delete[] attr_alarmAcknowledged_read;
+	delete[] attr_alarmUnacknowledgedNormal_read;
+	delete[] attr_alarmShelved_read;
+	delete[] attr_alarmOutOfService_read;
+	delete[] attr_alarmSilenced_read;
+	delete[] attr_alarmList_read;
+	delete[] attr_alarmFrequency_read;
 	delete[] attr_alarmSummary_read;
 }
 
@@ -373,17 +373,17 @@ void AlarmHandler::init_device()
 	//	Get the device properties from database
 	get_device_property();
 	
-	attr_audibleAlarm_read = new Tango::DevBoolean[1];
+	attr_alarmAudible_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];
+	attr_alarmNormal_read = new Tango::DevString[10000];
+	attr_alarmUnacknowledged_read = new Tango::DevString[10000];
+	attr_alarmAcknowledged_read = new Tango::DevString[10000];
+	attr_alarmUnacknowledgedNormal_read = new Tango::DevString[10000];
+	attr_alarmShelved_read = new Tango::DevString[10000];
+	attr_alarmOutOfService_read = new Tango::DevString[10000];
+	attr_alarmSilenced_read = new Tango::DevString[10000];
+	attr_alarmList_read = new Tango::DevString[10000];
+	attr_alarmFrequency_read = new Tango::DevDouble[10000];
 	attr_alarmSummary_read = new Tango::DevString[10000];
 	/*----- PROTECTED REGION ID(AlarmHandler::init_device) ENABLED START -----*/
 /*	for(size_t i=0; i<MAX_ALARMS; i++)
@@ -900,21 +900,21 @@ void AlarmHandler::read_attr_hardware(TANGO_UNUSED(vector<long> &attr_list))
 
 //--------------------------------------------------------
 /**
- *	Read attribute audibleAlarm related method
+ *	Read attribute alarmAudible 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 AlarmHandler::read_audibleAlarm(Tango::Attribute &attr)
+void AlarmHandler::read_alarmAudible(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_audibleAlarm(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_audibleAlarm) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmAudible(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmAudible) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_audibleAlarm_read);
+	attr.set_value(attr_alarmAudible_read);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_audibleAlarm
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmAudible
 }
 //--------------------------------------------------------
 /**
@@ -1118,165 +1118,165 @@ void AlarmHandler::read_alarm(Tango::Attribute &attr)
 }
 //--------------------------------------------------------
 /**
- *	Read attribute normalAlarms related method
+ *	Read attribute alarmNormal related method
  *	Description: List of alarms in normal state
  *
  *	Data type:	Tango::DevString
  *	Attr type:	Spectrum max = 10000
  */
 //--------------------------------------------------------
-void AlarmHandler::read_normalAlarms(Tango::Attribute &attr)
+void AlarmHandler::read_alarmNormal(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_normalAlarms(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_normalAlarms) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmNormal(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmNormal) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_normalAlarms_read, normalAlarms_sz);
+	attr.set_value(attr_alarmNormal_read, normalAlarms_sz);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_normalAlarms
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmNormal
 }
 //--------------------------------------------------------
 /**
- *	Read attribute unacknowledgedAlarms related method
+ *	Read attribute alarmUnacknowledged related method
  *	Description: List of alarms in unacknowledged state
  *
  *	Data type:	Tango::DevString
  *	Attr type:	Spectrum max = 10000
  */
 //--------------------------------------------------------
-void AlarmHandler::read_unacknowledgedAlarms(Tango::Attribute &attr)
+void AlarmHandler::read_alarmUnacknowledged(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_unacknowledgedAlarms(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_unacknowledgedAlarms) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmUnacknowledged(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmUnacknowledged) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_unacknowledgedAlarms_read, unacknowledgedAlarms_sz);
+	attr.set_value(attr_alarmUnacknowledged_read, unacknowledgedAlarms_sz);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_unacknowledgedAlarms
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmUnacknowledged
 }
 //--------------------------------------------------------
 /**
- *	Read attribute acknowledgedAlarms related method
+ *	Read attribute alarmAcknowledged related method
  *	Description: List of alarms in acknowledged state
  *
  *	Data type:	Tango::DevString
  *	Attr type:	Spectrum max = 10000
  */
 //--------------------------------------------------------
-void AlarmHandler::read_acknowledgedAlarms(Tango::Attribute &attr)
+void AlarmHandler::read_alarmAcknowledged(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_acknowledgedAlarms(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_acknowledgedAlarms) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmAcknowledged(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmAcknowledged) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_acknowledgedAlarms_read, acknowledgedAlarms_sz);
+	attr.set_value(attr_alarmAcknowledged_read, acknowledgedAlarms_sz);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_acknowledgedAlarms
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmAcknowledged
 }
 //--------------------------------------------------------
 /**
- *	Read attribute unacknowledgedNormalAlarms related method
+ *	Read attribute alarmUnacknowledgedNormal related method
  *	Description: List of alarms in unacknowledged normal state
  *
  *	Data type:	Tango::DevString
  *	Attr type:	Spectrum max = 10000
  */
 //--------------------------------------------------------
-void AlarmHandler::read_unacknowledgedNormalAlarms(Tango::Attribute &attr)
+void AlarmHandler::read_alarmUnacknowledgedNormal(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_unacknowledgedNormalAlarms(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_unacknowledgedNormalAlarms) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmUnacknowledgedNormal(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmUnacknowledgedNormal) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_unacknowledgedNormalAlarms_read, unacknowledgedNormalAlarms_sz);
+	attr.set_value(attr_alarmUnacknowledgedNormal_read, unacknowledgedNormalAlarms_sz);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_unacknowledgedNormalAlarms
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmUnacknowledgedNormal
 }
 //--------------------------------------------------------
 /**
- *	Read attribute shelvedAlarms related method
+ *	Read attribute alarmShelved related method
  *	Description: List of alarms in shelved state
  *
  *	Data type:	Tango::DevString
  *	Attr type:	Spectrum max = 10000
  */
 //--------------------------------------------------------
-void AlarmHandler::read_shelvedAlarms(Tango::Attribute &attr)
+void AlarmHandler::read_alarmShelved(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_shelvedAlarms(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_shelvedAlarms) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmShelved(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmShelved) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_shelvedAlarms_read, shelvedAlarms_sz);
+	attr.set_value(attr_alarmShelved_read, shelvedAlarms_sz);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_shelvedAlarms
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmShelved
 }
 //--------------------------------------------------------
 /**
- *	Read attribute outOfServiceAlarms related method
+ *	Read attribute alarmOutOfService related method
  *	Description: List of alarms in out of service state
  *
  *	Data type:	Tango::DevString
  *	Attr type:	Spectrum max = 10000
  */
 //--------------------------------------------------------
-void AlarmHandler::read_outOfServiceAlarms(Tango::Attribute &attr)
+void AlarmHandler::read_alarmOutOfService(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_outOfServiceAlarms(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_outOfServiceAlarms) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmOutOfService(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmOutOfService) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_outOfServiceAlarms_read, outOfServiceAlarms_sz);
+	attr.set_value(attr_alarmOutOfService_read, outOfServiceAlarms_sz);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_outOfServiceAlarms
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmOutOfService
 }
 //--------------------------------------------------------
 /**
- *	Read attribute silencedAlarms related method
+ *	Read attribute alarmSilenced related method
  *	Description: List of alarms in silenced state
  *
  *	Data type:	Tango::DevString
  *	Attr type:	Spectrum max = 10000
  */
 //--------------------------------------------------------
-void AlarmHandler::read_silencedAlarms(Tango::Attribute &attr)
+void AlarmHandler::read_alarmSilenced(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_silencedAlarms(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_silencedAlarms) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmSilenced(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmSilenced) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_silencedAlarms_read, silencedAlarms_sz);
+	attr.set_value(attr_alarmSilenced_read, silencedAlarms_sz);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_silencedAlarms
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmSilenced
 }
 //--------------------------------------------------------
 /**
- *	Read attribute listAlarms related method
+ *	Read attribute alarmList related method
  *	Description: List of all alarms
  *
  *	Data type:	Tango::DevString
  *	Attr type:	Spectrum max = 10000
  */
 //--------------------------------------------------------
-void AlarmHandler::read_listAlarms(Tango::Attribute &attr)
+void AlarmHandler::read_alarmList(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_listAlarms(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_listAlarms) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmList(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmList) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_listAlarms_read, listAlarms_sz);
+	attr.set_value(attr_alarmList_read, listAlarms_sz);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_listAlarms
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmList
 }
 //--------------------------------------------------------
 /**
- *	Read attribute frequencyAlarms related method
+ *	Read attribute alarmFrequency related method
  *	Description: List of frequency of evaluation of all alarms
  *
  *	Data type:	Tango::DevDouble
  *	Attr type:	Spectrum max = 10000
  */
 //--------------------------------------------------------
-void AlarmHandler::read_frequencyAlarms(Tango::Attribute &attr)
+void AlarmHandler::read_alarmFrequency(Tango::Attribute &attr)
 {
-	DEBUG_STREAM << "AlarmHandler::read_frequencyAlarms(Tango::Attribute &attr) entering... " << endl;
-	/*----- PROTECTED REGION ID(AlarmHandler::read_frequencyAlarms) ENABLED START -----*/
+	//DEBUG_STREAM << "AlarmHandler::read_alarmFrequency(Tango::Attribute &attr) entering... " << endl;
+	/*----- PROTECTED REGION ID(AlarmHandler::read_alarmFrequency) ENABLED START -----*/
 	//	Set the attribute value
-	attr.set_value(attr_frequencyAlarms_read, listAlarms_sz);
+	attr.set_value(attr_alarmFrequency_read, listAlarms_sz);
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_frequencyAlarms
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::read_alarmFrequency
 }
 //--------------------------------------------------------
 /**
@@ -1544,27 +1544,27 @@ void AlarmHandler::ack(const Tango::DevVarStringArray *argin)
 			//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_change_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_change_event("alarmAudible",attr_alarmAudible_read);
 		push_change_event("alarmSummary",attr_alarmSummary_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);
+		push_archive_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_archive_event("alarmAudible",attr_alarmAudible_read);
 		push_archive_event("alarmSummary",attr_alarmSummary_read);
 
 	} catch(Tango::DevFailed& e)
@@ -1586,7 +1586,7 @@ void AlarmHandler::ack(const Tango::DevVarStringArray *argin)
 //--------------------------------------------------------
 void AlarmHandler::load(Tango::DevString argin)
 {
-	DEBUG_STREAM << "AlarmHandler::Load()  - " << argin << endl;
+	DEBUG_STREAM << "AlarmHandler::Load()  - " << device_name << endl;
 	/*----- PROTECTED REGION ID(AlarmHandler::load) ENABLED START -----*/
 	//	Add your own code
 	string s;
@@ -1862,27 +1862,27 @@ void AlarmHandler::remove(Tango::DevString argin)
 			//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_change_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_change_event("alarmAudible",attr_alarmAudible_read);
 		push_change_event("alarmSummary",attr_alarmSummary_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);
+		push_archive_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_archive_event("alarmAudible",attr_alarmAudible_read);
 		push_archive_event("alarmSummary",attr_alarmSummary_read);
 	} catch(Tango::DevFailed& e)
 	{
@@ -2023,27 +2023,27 @@ void AlarmHandler::stop_audible()
 			//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_change_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_change_event("alarmAudible",attr_alarmAudible_read);
 		push_change_event("alarmSummary",attr_alarmSummary_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);
+		push_archive_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_archive_event("alarmAudible",attr_alarmAudible_read);
 		push_archive_event("alarmSummary",attr_alarmSummary_read);
 	} catch(Tango::DevFailed& e)
 	{
@@ -2161,27 +2161,27 @@ void AlarmHandler::silence(const Tango::DevVarStringArray *argin)
 			//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_change_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_change_event("alarmAudible",attr_alarmAudible_read);
 		push_change_event("alarmSummary",attr_alarmSummary_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);
+		push_archive_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_archive_event("alarmAudible",attr_alarmAudible_read);
 		push_archive_event("alarmSummary",attr_alarmSummary_read);
 	} catch(Tango::DevFailed& e)
 	{
@@ -2454,27 +2454,27 @@ void AlarmHandler::modify(Tango::DevString argin)
 			//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_change_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_change_event("alarmAudible",attr_alarmAudible_read);
 		push_change_event("alarmSummary",attr_alarmSummary_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);
+		push_archive_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_archive_event("alarmAudible",attr_alarmAudible_read);
 		push_archive_event("alarmSummary",attr_alarmSummary_read);
 	} catch(Tango::DevFailed& e)
 	{
@@ -2636,23 +2636,23 @@ void AlarmHandler::shelve(const Tango::DevVarStringArray *argin)
 			//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("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
 		push_change_event("alarmSummary",attr_alarmSummary_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("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
 		push_archive_event("alarmSummary",attr_alarmSummary_read);
 	} catch(Tango::DevFailed& e)
 	{
@@ -2750,23 +2750,23 @@ void AlarmHandler::enable(Tango::DevString argin)
 			//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("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
 		push_change_event("alarmSummary",attr_alarmSummary_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("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
 		push_archive_event("alarmSummary",attr_alarmSummary_read);
 	} catch(Tango::DevFailed& e)
 	{
@@ -2876,27 +2876,27 @@ void AlarmHandler::disable(Tango::DevString argin)
 			//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_change_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_change_event("alarmAudible",attr_alarmAudible_read);
 		push_change_event("alarmSummary",attr_alarmSummary_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);
+		push_archive_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_archive_event("alarmAudible",attr_alarmAudible_read);
 		push_archive_event("alarmSummary",attr_alarmSummary_read);
 	} catch(Tango::DevFailed& e)
 	{
@@ -2970,27 +2970,27 @@ void AlarmHandler::stop_new()
 			//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_change_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_change_event("alarmAudible",attr_alarmAudible_read);
 		push_change_event("alarmSummary",attr_alarmSummary_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);
+		push_archive_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_archive_event("alarmAudible",attr_alarmAudible_read);
 		push_archive_event("alarmSummary",attr_alarmSummary_read);
 	} catch(Tango::DevFailed& e)
 	{
@@ -3732,13 +3732,13 @@ void AlarmHandler::do_alarm(bei_t& e)
 			size_t freq_ind = 0;
 			for (ai = alarms.v_alarm.begin(); ai != alarms.v_alarm.end(); ai++)
 			{
-				attr_frequencyAlarms_read[freq_ind] = ai->second.freq_counter;
+				attr_alarmFrequency_read[freq_ind] = ai->second.freq_counter;
 				freq_ind++;
 			}
 			alarms.vlock->readerOut();
 			prepare_alm_mtx->unlock();
-			push_change_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
-			push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
+			push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+			push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
 			return;
 		}
 		prepare_alarm_attr();//TODO: frequencyAlarm should be updated anyway
@@ -3754,27 +3754,27 @@ void AlarmHandler::do_alarm(bei_t& e)
 			//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_change_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_change_event("alarmAudible",attr_alarmAudible_read);
 		push_change_event("alarmSummary",attr_alarmSummary_read, alarmSummary_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);
-		push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
-		push_archive_event("audibleAlarm",attr_audibleAlarm_read);
+		push_archive_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_archive_event("alarmAudible",attr_alarmAudible_read);
 		push_archive_event("alarmSummary",attr_alarmSummary_read, alarmSummary_sz);
 	}
 	else
@@ -3981,27 +3981,27 @@ void AlarmHandler::timer_update()
 			//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_change_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_change_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_change_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_change_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_change_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_change_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_change_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_change_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_change_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_change_event("alarmAudible",attr_alarmAudible_read);
 		push_change_event("alarmSummary",attr_alarmSummary_read, alarmSummary_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);
-		push_archive_event("frequencyAlarms",&attr_frequencyAlarms_read[0], listAlarms_sz);
-		push_archive_event("audibleAlarm",attr_audibleAlarm_read);
+		push_archive_event("alarmNormal",&attr_alarmNormal_read[0], normalAlarms_sz);
+		push_archive_event("alarmUnacknowledged",&attr_alarmUnacknowledged_read[0], unacknowledgedAlarms_sz);
+		push_archive_event("alarmAcknowledged",&attr_alarmAcknowledged_read[0], acknowledgedAlarms_sz);
+		push_archive_event("alarmUnacknowledgedNormal",&attr_alarmUnacknowledgedNormal_read[0], unacknowledgedNormalAlarms_sz);
+		push_archive_event("alarmShelved",&attr_alarmShelved_read[0], shelvedAlarms_sz);
+		push_archive_event("alarmOutOfService",&attr_alarmOutOfService_read[0], outOfServiceAlarms_sz);
+		push_archive_event("alarmSilenced",&attr_alarmSilenced_read[0], silencedAlarms_sz);
+		push_archive_event("alarmList",&attr_alarmList_read[0], listAlarms_sz);
+		push_archive_event("alarmFrequency",&attr_alarmFrequency_read[0], listAlarms_sz);
+		push_archive_event("alarmAudible",attr_alarmAudible_read);
 		push_archive_event("alarmSummary",attr_alarmSummary_read, alarmSummary_sz);
 	} catch(Tango::DevFailed& e)
 	{
@@ -4944,20 +4944,20 @@ void AlarmHandler::prepare_alarm_attr()
 		if(ai->second.enabled == false)
 		{
 			outOfServiceAlarms_read[outOfServiceAlarms_sz] = ai->second.name;
-			attr_outOfServiceAlarms_read[outOfServiceAlarms_sz] = const_cast<char*>(outOfServiceAlarms_read[outOfServiceAlarms_sz].c_str());
+			attr_alarmOutOfService_read[outOfServiceAlarms_sz] = const_cast<char*>(outOfServiceAlarms_read[outOfServiceAlarms_sz].c_str());
 			/*strcpy(c_outOfServiceAlarms_read[outOfServiceAlarms_sz], ai->second.name.c_str());
-			attr_outOfServiceAlarms_read[outOfServiceAlarms_sz] = c_outOfServiceAlarms_read[outOfServiceAlarms_sz];*/
-			//attr_outOfServiceAlarms_read[outOfServiceAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
+			attr_alarmOutOfService_read[outOfServiceAlarms_sz] = c_outOfServiceAlarms_read[outOfServiceAlarms_sz];*/
+			//attr_alarmOutOfService_read[outOfServiceAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
 			outOfServiceAlarms_sz++;
 			almstate = "OOSRV";
 		}
 		else if(ai->second.shelved)
 		{
 			shelvedAlarms_read[shelvedAlarms_sz] = ai->second.name;
-			attr_shelvedAlarms_read[shelvedAlarms_sz] = const_cast<char*>(shelvedAlarms_read[shelvedAlarms_sz].c_str());
+			attr_alarmShelved_read[shelvedAlarms_sz] = const_cast<char*>(shelvedAlarms_read[shelvedAlarms_sz].c_str());
 			/*strcpy(c_shelvedAlarms_read[shelvedAlarms_sz], ai->second.name.c_str());
-			attr_shelvedAlarms_read[shelvedAlarms_sz] = c_shelvedAlarms_read[shelvedAlarms_sz];*/
-			//attr_shelvedAlarms_read[shelvedAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
+			attr_alarmShelved_read[shelvedAlarms_sz] = c_shelvedAlarms_read[shelvedAlarms_sz];*/
+			//attr_alarmShelved_read[shelvedAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
 			shelvedAlarms_sz++;
 			almstate = "SHLVD";
 		}
@@ -4966,50 +4966,50 @@ void AlarmHandler::prepare_alarm_attr()
 			if(ai->second.stat == S_ALARM && ai->second.ack == ACK)
 			{
 				acknowledgedAlarms_read[acknowledgedAlarms_sz] = ai->second.name;
-				attr_acknowledgedAlarms_read[acknowledgedAlarms_sz] = const_cast<char*>(acknowledgedAlarms_read[acknowledgedAlarms_sz].c_str());
+				attr_alarmAcknowledged_read[acknowledgedAlarms_sz] = const_cast<char*>(acknowledgedAlarms_read[acknowledgedAlarms_sz].c_str());
 				/*strcpy(c_acknowledgedAlarms_read[acknowledgedAlarms_sz], ai->second.name.c_str());
-				attr_acknowledgedAlarms_read[acknowledgedAlarms_sz] = c_acknowledgedAlarms_read[acknowledgedAlarms_sz];*/
-				//attr_acknowledgedAlarms_read[acknowledgedAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
+				attr_alarmAcknowledged_read[acknowledgedAlarms_sz] = c_acknowledgedAlarms_read[acknowledgedAlarms_sz];*/
+				//attr_alarmAcknowledged_read[acknowledgedAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
 				acknowledgedAlarms_sz++;
 				almstate = "ACKED";
 			}
 			else if(ai->second.stat == S_ALARM && ai->second.ack == NOT_ACK)
 			{
 				unacknowledgedAlarms_read[unacknowledgedAlarms_sz] = ai->second.name;
-				attr_unacknowledgedAlarms_read[unacknowledgedAlarms_sz] = const_cast<char*>(unacknowledgedAlarms_read[unacknowledgedAlarms_sz].c_str());
+				attr_alarmUnacknowledged_read[unacknowledgedAlarms_sz] = const_cast<char*>(unacknowledgedAlarms_read[unacknowledgedAlarms_sz].c_str());
 				/*strcpy(c_unacknowledgedAlarms_read[unacknowledgedAlarms_sz], ai->second.name.c_str());
-				attr_unacknowledgedAlarms_read[unacknowledgedAlarms_sz] = c_unacknowledgedAlarms_read[unacknowledgedAlarms_sz];*/
-				//attr_unacknowledgedAlarms_read[unacknowledgedAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
+				attr_alarmUnacknowledged_read[unacknowledgedAlarms_sz] = c_unacknowledgedAlarms_read[unacknowledgedAlarms_sz];*/
+				//attr_alarmUnacknowledged_read[unacknowledgedAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
 				unacknowledgedAlarms_sz++;
 				almstate = "UNACK";
 			}
 			else if(ai->second.stat == S_NORMAL && ai->second.ack == NOT_ACK)
 			{
 				unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz] = ai->second.name;
-				attr_unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz] = const_cast<char*>(unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz].c_str());
+				attr_alarmUnacknowledgedNormal_read[unacknowledgedNormalAlarms_sz] = const_cast<char*>(unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz].c_str());
 				/*strcpy(c_unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz], ai->second.name.c_str());
-				attr_unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz] = c_unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz];*/
-				//attr_unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
+				attr_alarmUnacknowledgedNormal_read[unacknowledgedNormalAlarms_sz] = c_unacknowledgedNormalAlarms_read[unacknowledgedNormalAlarms_sz];*/
+				//attr_alarmUnacknowledgedNormal_read[unacknowledgedNormalAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
 				unacknowledgedNormalAlarms_sz++;
 				almstate = "RTNUN";
 			}
 			else if(ai->second.stat == S_NORMAL && ai->second.ack == ACK)
 			{
 				normalAlarms_read[normalAlarms_sz] = ai->second.name;
-				attr_normalAlarms_read[normalAlarms_sz] = const_cast<char*>(normalAlarms_read[normalAlarms_sz].c_str());
+				attr_alarmNormal_read[normalAlarms_sz] = const_cast<char*>(normalAlarms_read[normalAlarms_sz].c_str());
 				/*strcpy(c_normalAlarms_read[normalAlarms_sz], ai->second.name.c_str());
-				attr_normalAlarms_read[normalAlarms_sz] = c_normalAlarms_read[normalAlarms_sz];*/
-				//attr_normalAlarms_read[normalAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
+				attr_alarmNormal_read[normalAlarms_sz] = c_normalAlarms_read[normalAlarms_sz];*/
+				//attr_alarmNormal_read[normalAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
 				normalAlarms_sz++;
 				almstate = "NORM";
 			}
 			if(ai->second.silenced > 0)
 			{
 				silencedAlarms_read[silencedAlarms_sz] = ai->second.name;
-				attr_silencedAlarms_read[silencedAlarms_sz] = const_cast<char*>(silencedAlarms_read[silencedAlarms_sz].c_str());
+				attr_alarmSilenced_read[silencedAlarms_sz] = const_cast<char*>(silencedAlarms_read[silencedAlarms_sz].c_str());
 				/*strcpy(c_silencedAlarms_read[silencedAlarms_sz], ai->second.name.c_str());
-				attr_silencedAlarms_read[silencedAlarms_sz] = c_silencedAlarms_read[silencedAlarms_sz];*/
-				//attr_silencedAlarms_read[silencedAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
+				attr_alarmSilenced_read[silencedAlarms_sz] = c_silencedAlarms_read[silencedAlarms_sz];*/
+				//attr_alarmSilenced_read[silencedAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
 				silencedAlarms_sz++;
 			}
 		}
@@ -5096,12 +5096,12 @@ void AlarmHandler::prepare_alarm_attr()
 		alm_summary += KEY(SILENT_TIME_REMAINING_KEY) + sval.str() + SEP;
 #endif
 #endif
-		attr_frequencyAlarms_read[listAlarms_sz] = ai->second.freq_counter;
+		attr_alarmFrequency_read[listAlarms_sz] = ai->second.freq_counter;
 		listAlarms_read[listAlarms_sz] = ai->second.name;
-		attr_listAlarms_read[listAlarms_sz] = const_cast<char*>(listAlarms_read[listAlarms_sz].c_str());
+		attr_alarmList_read[listAlarms_sz] = const_cast<char*>(listAlarms_read[listAlarms_sz].c_str());
 		/*strcpy(c_listAlarms_read[listAlarms_sz], ai->second.name.c_str());
-		attr_listAlarms_read[listAlarms_sz] = c_listAlarms_read[listAlarms_sz];*/
-		//attr_listAlarms_read[listAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
+		attr_alarmList_read[listAlarms_sz] = c_listAlarms_read[listAlarms_sz];*/
+		//attr_alarmList_read[listAlarms_sz] = CORBA::string_dup(ai->second.name.c_str());
 		listAlarms_sz++;
 
 		if(!is_audible && ai->second.is_new && ai->second.silenced <= 0 && ai->second.enabled && !ai->second.shelved)
@@ -5212,7 +5212,7 @@ void AlarmHandler::prepare_alarm_attr()
 		//attr_alarmSummary_read[alarmSummary_sz] = CORBA::string_dup(alm_summary.c_str());
 		alarmSummary_sz++;
 	}  /* for */
-	*attr_audibleAlarm_read = is_audible;
+	*attr_alarmAudible_read = is_audible;
 	alarms.vlock->readerOut();
 	prepare_alm_mtx->unlock();
 	vector<string> tmp_alarm_table;
diff --git a/src/AlarmHandler.h b/src/AlarmHandler.h
index bcd63570affbeecafece002fa6740b33d9d951ec..c5c457a65359325f64d2ba3ff6d99260a3bd2673 100644
--- a/src/AlarmHandler.h
+++ b/src/AlarmHandler.h
@@ -155,18 +155,18 @@ public:
 
 //	Attribute data members
 public:
-	Tango::DevBoolean	*attr_audibleAlarm_read;
+	Tango::DevBoolean	*attr_alarmAudible_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;
+	Tango::DevString	*attr_alarmNormal_read;
+	Tango::DevString	*attr_alarmUnacknowledged_read;
+	Tango::DevString	*attr_alarmAcknowledged_read;
+	Tango::DevString	*attr_alarmUnacknowledgedNormal_read;
+	Tango::DevString	*attr_alarmShelved_read;
+	Tango::DevString	*attr_alarmOutOfService_read;
+	Tango::DevString	*attr_alarmSilenced_read;
+	Tango::DevString	*attr_alarmList_read;
+	Tango::DevDouble	*attr_alarmFrequency_read;
 	Tango::DevString	*attr_alarmSummary_read;
 
 //	Constructors and destructors
@@ -230,14 +230,14 @@ public:
 	virtual void read_attr_hardware(vector<long> &attr_list);
 
 /**
- *	Attribute audibleAlarm related methods
+ *	Attribute alarmAudible 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);
+	virtual void read_alarmAudible(Tango::Attribute &attr);
+	virtual bool is_alarmAudible_allowed(Tango::AttReqType type);
 /**
  *	Attribute StatisticsResetTime related methods
  *	Description: Time elapsed in seconds since last Resetstatistics
@@ -257,86 +257,86 @@ public:
 	virtual void read_alarm(Tango::Attribute &attr);
 	virtual bool is_alarm_allowed(Tango::AttReqType type);
 /**
- *	Attribute normalAlarms related methods
+ *	Attribute alarmNormal 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);
+	virtual void read_alarmNormal(Tango::Attribute &attr);
+	virtual bool is_alarmNormal_allowed(Tango::AttReqType type);
 /**
- *	Attribute unacknowledgedAlarms related methods
+ *	Attribute alarmUnacknowledged 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);
+	virtual void read_alarmUnacknowledged(Tango::Attribute &attr);
+	virtual bool is_alarmUnacknowledged_allowed(Tango::AttReqType type);
 /**
- *	Attribute acknowledgedAlarms related methods
+ *	Attribute alarmAcknowledged 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);
+	virtual void read_alarmAcknowledged(Tango::Attribute &attr);
+	virtual bool is_alarmAcknowledged_allowed(Tango::AttReqType type);
 /**
- *	Attribute unacknowledgedNormalAlarms related methods
+ *	Attribute alarmUnacknowledgedNormal 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);
+	virtual void read_alarmUnacknowledgedNormal(Tango::Attribute &attr);
+	virtual bool is_alarmUnacknowledgedNormal_allowed(Tango::AttReqType type);
 /**
- *	Attribute shelvedAlarms related methods
+ *	Attribute alarmShelved 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);
+	virtual void read_alarmShelved(Tango::Attribute &attr);
+	virtual bool is_alarmShelved_allowed(Tango::AttReqType type);
 /**
- *	Attribute outOfServiceAlarms related methods
+ *	Attribute alarmOutOfService 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);
+	virtual void read_alarmOutOfService(Tango::Attribute &attr);
+	virtual bool is_alarmOutOfService_allowed(Tango::AttReqType type);
 /**
- *	Attribute silencedAlarms related methods
+ *	Attribute alarmSilenced 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);
+	virtual void read_alarmSilenced(Tango::Attribute &attr);
+	virtual bool is_alarmSilenced_allowed(Tango::AttReqType type);
 /**
- *	Attribute listAlarms related methods
+ *	Attribute alarmList 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);
+	virtual void read_alarmList(Tango::Attribute &attr);
+	virtual bool is_alarmList_allowed(Tango::AttReqType type);
 /**
- *	Attribute frequencyAlarms related methods
+ *	Attribute alarmFrequency 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);
+	virtual void read_alarmFrequency(Tango::Attribute &attr);
+	virtual bool is_alarmFrequency_allowed(Tango::AttReqType type);
 /**
  *	Attribute alarmSummary related methods
  *	Description: 
diff --git a/src/AlarmHandler.xmi b/src/AlarmHandler.xmi
index 256c9a07a52799a578c685f52abef3bc61aae636..71fd54fbcc5c93fb0fc9d1a8f79a44e50945bea6 100644
--- a/src/AlarmHandler.xmi
+++ b/src/AlarmHandler.xmi
@@ -154,7 +154,7 @@
       </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">
+    <attributes name="alarmAudible" 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"/>
@@ -177,7 +177,7 @@
       <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">
+    <attributes name="alarmNormal" 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"/>
@@ -185,7 +185,7 @@
       <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">
+    <attributes name="alarmUnacknowledged" 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"/>
@@ -193,7 +193,7 @@
       <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">
+    <attributes name="alarmAcknowledged" 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"/>
@@ -201,7 +201,7 @@
       <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">
+    <attributes name="alarmUnacknowledgedNormal" 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"/>
@@ -209,7 +209,7 @@
       <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">
+    <attributes name="alarmShelved" 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"/>
@@ -217,7 +217,7 @@
       <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">
+    <attributes name="alarmOutOfService" 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"/>
@@ -225,7 +225,7 @@
       <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">
+    <attributes name="alarmSilenced" 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"/>
@@ -233,7 +233,7 @@
       <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">
+    <attributes name="alarmList" 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"/>
@@ -241,7 +241,7 @@
       <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">
+    <attributes name="alarmFrequency" 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"/>
diff --git a/src/AlarmHandlerClass.cpp b/src/AlarmHandlerClass.cpp
index 3540916e8f0d7023b380f0b455c0abfbde11933c..36c770dfaaccd4b9605ddf95a030419d3226dbf9 100644
--- a/src/AlarmHandlerClass.cpp
+++ b/src/AlarmHandlerClass.cpp
@@ -621,31 +621,31 @@ void AlarmHandlerClass::attribute_factory(vector<Tango::Attr *> &att_list)
 	//	Add your own code
 	
 	/*----- PROTECTED REGION END -----*/	//	AlarmHandlerClass::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
+	//	Attribute : alarmAudible
+	alarmAudibleAttrib	*alarmaudible = new alarmAudibleAttrib();
+	Tango::UserDefaultAttrProp	alarmaudible_prop;
+	alarmaudible_prop.set_description("True if there is at least one alarm that needs audible indication on the GUI");
+	//	label	not set for alarmAudible
+	//	unit	not set for alarmAudible
+	//	standard_unit	not set for alarmAudible
+	//	display_unit	not set for alarmAudible
+	//	format	not set for alarmAudible
+	//	max_value	not set for alarmAudible
+	//	min_value	not set for alarmAudible
+	//	max_alarm	not set for alarmAudible
+	//	min_alarm	not set for alarmAudible
+	//	max_warning	not set for alarmAudible
+	//	min_warning	not set for alarmAudible
+	//	delta_t	not set for alarmAudible
+	//	delta_val	not set for alarmAudible
 	
-	audiblealarm->set_default_properties(audiblealarm_prop);
+	alarmaudible->set_default_properties(alarmaudible_prop);
 	//	Not Polled
-	audiblealarm->set_disp_level(Tango::OPERATOR);
+	alarmaudible->set_disp_level(Tango::OPERATOR);
 	//	Not Memorized
-	audiblealarm->set_change_event(true, false);
-	audiblealarm->set_archive_event(true, false);
-	att_list.push_back(audiblealarm);
+	alarmaudible->set_change_event(true, false);
+	alarmaudible->set_archive_event(true, false);
+	att_list.push_back(alarmaudible);
 
 	//	Attribute : StatisticsResetTime
 	StatisticsResetTimeAttrib	*statisticsresettime = new StatisticsResetTimeAttrib();
@@ -695,239 +695,239 @@ void AlarmHandlerClass::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
+	//	Attribute : alarmNormal
+	alarmNormalAttrib	*alarmnormal = new alarmNormalAttrib();
+	Tango::UserDefaultAttrProp	alarmnormal_prop;
+	alarmnormal_prop.set_description("List of alarms in normal state");
+	//	label	not set for alarmNormal
+	//	unit	not set for alarmNormal
+	//	standard_unit	not set for alarmNormal
+	//	display_unit	not set for alarmNormal
+	//	format	not set for alarmNormal
+	//	max_value	not set for alarmNormal
+	//	min_value	not set for alarmNormal
+	//	max_alarm	not set for alarmNormal
+	//	min_alarm	not set for alarmNormal
+	//	max_warning	not set for alarmNormal
+	//	min_warning	not set for alarmNormal
+	//	delta_t	not set for alarmNormal
+	//	delta_val	not set for alarmNormal
 	
-	normalalarms->set_default_properties(normalalarms_prop);
+	alarmnormal->set_default_properties(alarmnormal_prop);
 	//	Not Polled
-	normalalarms->set_disp_level(Tango::OPERATOR);
+	alarmnormal->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
+	alarmnormal->set_change_event(true, true);
+	alarmnormal->set_archive_event(true, true);
+	att_list.push_back(alarmnormal);
+
+	//	Attribute : alarmUnacknowledged
+	alarmUnacknowledgedAttrib	*alarmunacknowledged = new alarmUnacknowledgedAttrib();
+	Tango::UserDefaultAttrProp	alarmunacknowledged_prop;
+	alarmunacknowledged_prop.set_description("List of alarms in unacknowledged state");
+	//	label	not set for alarmUnacknowledged
+	//	unit	not set for alarmUnacknowledged
+	//	standard_unit	not set for alarmUnacknowledged
+	//	display_unit	not set for alarmUnacknowledged
+	//	format	not set for alarmUnacknowledged
+	//	max_value	not set for alarmUnacknowledged
+	//	min_value	not set for alarmUnacknowledged
+	//	max_alarm	not set for alarmUnacknowledged
+	//	min_alarm	not set for alarmUnacknowledged
+	//	max_warning	not set for alarmUnacknowledged
+	//	min_warning	not set for alarmUnacknowledged
+	//	delta_t	not set for alarmUnacknowledged
+	//	delta_val	not set for alarmUnacknowledged
 	
-	unacknowledgedalarms->set_default_properties(unacknowledgedalarms_prop);
+	alarmunacknowledged->set_default_properties(alarmunacknowledged_prop);
 	//	Not Polled
-	unacknowledgedalarms->set_disp_level(Tango::OPERATOR);
+	alarmunacknowledged->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
+	alarmunacknowledged->set_change_event(true, true);
+	alarmunacknowledged->set_archive_event(true, true);
+	att_list.push_back(alarmunacknowledged);
+
+	//	Attribute : alarmAcknowledged
+	alarmAcknowledgedAttrib	*alarmacknowledged = new alarmAcknowledgedAttrib();
+	Tango::UserDefaultAttrProp	alarmacknowledged_prop;
+	alarmacknowledged_prop.set_description("List of alarms in acknowledged state");
+	//	label	not set for alarmAcknowledged
+	//	unit	not set for alarmAcknowledged
+	//	standard_unit	not set for alarmAcknowledged
+	//	display_unit	not set for alarmAcknowledged
+	//	format	not set for alarmAcknowledged
+	//	max_value	not set for alarmAcknowledged
+	//	min_value	not set for alarmAcknowledged
+	//	max_alarm	not set for alarmAcknowledged
+	//	min_alarm	not set for alarmAcknowledged
+	//	max_warning	not set for alarmAcknowledged
+	//	min_warning	not set for alarmAcknowledged
+	//	delta_t	not set for alarmAcknowledged
+	//	delta_val	not set for alarmAcknowledged
 	
-	acknowledgedalarms->set_default_properties(acknowledgedalarms_prop);
+	alarmacknowledged->set_default_properties(alarmacknowledged_prop);
 	//	Not Polled
-	acknowledgedalarms->set_disp_level(Tango::OPERATOR);
+	alarmacknowledged->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
+	alarmacknowledged->set_change_event(true, true);
+	alarmacknowledged->set_archive_event(true, true);
+	att_list.push_back(alarmacknowledged);
+
+	//	Attribute : alarmUnacknowledgedNormal
+	alarmUnacknowledgedNormalAttrib	*alarmunacknowledgednormal = new alarmUnacknowledgedNormalAttrib();
+	Tango::UserDefaultAttrProp	alarmunacknowledgednormal_prop;
+	alarmunacknowledgednormal_prop.set_description("List of alarms in unacknowledged normal state");
+	//	label	not set for alarmUnacknowledgedNormal
+	//	unit	not set for alarmUnacknowledgedNormal
+	//	standard_unit	not set for alarmUnacknowledgedNormal
+	//	display_unit	not set for alarmUnacknowledgedNormal
+	//	format	not set for alarmUnacknowledgedNormal
+	//	max_value	not set for alarmUnacknowledgedNormal
+	//	min_value	not set for alarmUnacknowledgedNormal
+	//	max_alarm	not set for alarmUnacknowledgedNormal
+	//	min_alarm	not set for alarmUnacknowledgedNormal
+	//	max_warning	not set for alarmUnacknowledgedNormal
+	//	min_warning	not set for alarmUnacknowledgedNormal
+	//	delta_t	not set for alarmUnacknowledgedNormal
+	//	delta_val	not set for alarmUnacknowledgedNormal
 	
-	unacknowledgednormalalarms->set_default_properties(unacknowledgednormalalarms_prop);
+	alarmunacknowledgednormal->set_default_properties(alarmunacknowledgednormal_prop);
 	//	Not Polled
-	unacknowledgednormalalarms->set_disp_level(Tango::OPERATOR);
+	alarmunacknowledgednormal->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
+	alarmunacknowledgednormal->set_change_event(true, true);
+	alarmunacknowledgednormal->set_archive_event(true, true);
+	att_list.push_back(alarmunacknowledgednormal);
+
+	//	Attribute : alarmShelved
+	alarmShelvedAttrib	*alarmshelved = new alarmShelvedAttrib();
+	Tango::UserDefaultAttrProp	alarmshelved_prop;
+	alarmshelved_prop.set_description("List of alarms in shelved state");
+	//	label	not set for alarmShelved
+	//	unit	not set for alarmShelved
+	//	standard_unit	not set for alarmShelved
+	//	display_unit	not set for alarmShelved
+	//	format	not set for alarmShelved
+	//	max_value	not set for alarmShelved
+	//	min_value	not set for alarmShelved
+	//	max_alarm	not set for alarmShelved
+	//	min_alarm	not set for alarmShelved
+	//	max_warning	not set for alarmShelved
+	//	min_warning	not set for alarmShelved
+	//	delta_t	not set for alarmShelved
+	//	delta_val	not set for alarmShelved
 	
-	shelvedalarms->set_default_properties(shelvedalarms_prop);
+	alarmshelved->set_default_properties(alarmshelved_prop);
 	//	Not Polled
-	shelvedalarms->set_disp_level(Tango::OPERATOR);
+	alarmshelved->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
+	alarmshelved->set_change_event(true, true);
+	alarmshelved->set_archive_event(true, true);
+	att_list.push_back(alarmshelved);
+
+	//	Attribute : alarmOutOfService
+	alarmOutOfServiceAttrib	*alarmoutofservice = new alarmOutOfServiceAttrib();
+	Tango::UserDefaultAttrProp	alarmoutofservice_prop;
+	alarmoutofservice_prop.set_description("List of alarms in out of service state");
+	//	label	not set for alarmOutOfService
+	//	unit	not set for alarmOutOfService
+	//	standard_unit	not set for alarmOutOfService
+	//	display_unit	not set for alarmOutOfService
+	//	format	not set for alarmOutOfService
+	//	max_value	not set for alarmOutOfService
+	//	min_value	not set for alarmOutOfService
+	//	max_alarm	not set for alarmOutOfService
+	//	min_alarm	not set for alarmOutOfService
+	//	max_warning	not set for alarmOutOfService
+	//	min_warning	not set for alarmOutOfService
+	//	delta_t	not set for alarmOutOfService
+	//	delta_val	not set for alarmOutOfService
 	
-	outofservicealarms->set_default_properties(outofservicealarms_prop);
+	alarmoutofservice->set_default_properties(alarmoutofservice_prop);
 	//	Not Polled
-	outofservicealarms->set_disp_level(Tango::OPERATOR);
+	alarmoutofservice->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
+	alarmoutofservice->set_change_event(true, true);
+	alarmoutofservice->set_archive_event(true, true);
+	att_list.push_back(alarmoutofservice);
+
+	//	Attribute : alarmSilenced
+	alarmSilencedAttrib	*alarmsilenced = new alarmSilencedAttrib();
+	Tango::UserDefaultAttrProp	alarmsilenced_prop;
+	alarmsilenced_prop.set_description("List of alarms in silenced state");
+	//	label	not set for alarmSilenced
+	//	unit	not set for alarmSilenced
+	//	standard_unit	not set for alarmSilenced
+	//	display_unit	not set for alarmSilenced
+	//	format	not set for alarmSilenced
+	//	max_value	not set for alarmSilenced
+	//	min_value	not set for alarmSilenced
+	//	max_alarm	not set for alarmSilenced
+	//	min_alarm	not set for alarmSilenced
+	//	max_warning	not set for alarmSilenced
+	//	min_warning	not set for alarmSilenced
+	//	delta_t	not set for alarmSilenced
+	//	delta_val	not set for alarmSilenced
 	
-	silencedalarms->set_default_properties(silencedalarms_prop);
+	alarmsilenced->set_default_properties(alarmsilenced_prop);
 	//	Not Polled
-	silencedalarms->set_disp_level(Tango::OPERATOR);
+	alarmsilenced->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
+	alarmsilenced->set_change_event(true, true);
+	alarmsilenced->set_archive_event(true, true);
+	att_list.push_back(alarmsilenced);
+
+	//	Attribute : alarmList
+	alarmListAttrib	*alarmlist = new alarmListAttrib();
+	Tango::UserDefaultAttrProp	alarmlist_prop;
+	alarmlist_prop.set_description("List of all alarms");
+	//	label	not set for alarmList
+	//	unit	not set for alarmList
+	//	standard_unit	not set for alarmList
+	//	display_unit	not set for alarmList
+	//	format	not set for alarmList
+	//	max_value	not set for alarmList
+	//	min_value	not set for alarmList
+	//	max_alarm	not set for alarmList
+	//	min_alarm	not set for alarmList
+	//	max_warning	not set for alarmList
+	//	min_warning	not set for alarmList
+	//	delta_t	not set for alarmList
+	//	delta_val	not set for alarmList
 	
-	listalarms->set_default_properties(listalarms_prop);
+	alarmlist->set_default_properties(alarmlist_prop);
 	//	Not Polled
-	listalarms->set_disp_level(Tango::OPERATOR);
+	alarmlist->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
+	alarmlist->set_change_event(true, true);
+	alarmlist->set_archive_event(true, true);
+	att_list.push_back(alarmlist);
+
+	//	Attribute : alarmFrequency
+	alarmFrequencyAttrib	*alarmfrequency = new alarmFrequencyAttrib();
+	Tango::UserDefaultAttrProp	alarmfrequency_prop;
+	alarmfrequency_prop.set_description("List of frequency of evaluation of all alarms");
+	//	label	not set for alarmFrequency
+	//	unit	not set for alarmFrequency
+	//	standard_unit	not set for alarmFrequency
+	//	display_unit	not set for alarmFrequency
+	//	format	not set for alarmFrequency
+	//	max_value	not set for alarmFrequency
+	//	min_value	not set for alarmFrequency
+	//	max_alarm	not set for alarmFrequency
+	//	min_alarm	not set for alarmFrequency
+	//	max_warning	not set for alarmFrequency
+	//	min_warning	not set for alarmFrequency
+	//	delta_t	not set for alarmFrequency
+	//	delta_val	not set for alarmFrequency
 	
-	frequencyalarms->set_default_properties(frequencyalarms_prop);
+	alarmfrequency->set_default_properties(alarmfrequency_prop);
 	//	Not Polled
-	frequencyalarms->set_disp_level(Tango::OPERATOR);
+	alarmfrequency->set_disp_level(Tango::OPERATOR);
 	//	Not Memorized
-	frequencyalarms->set_change_event(true, true);
-	frequencyalarms->set_archive_event(true, true);
-	att_list.push_back(frequencyalarms);
+	alarmfrequency->set_change_event(true, true);
+	alarmfrequency->set_archive_event(true, true);
+	att_list.push_back(alarmfrequency);
 
 	//	Attribute : alarmSummary
 	alarmSummaryAttrib	*alarmsummary = new alarmSummaryAttrib();
diff --git a/src/AlarmHandlerClass.h b/src/AlarmHandlerClass.h
index 481cec4246409ef714df33f54fe371b0e701b1ae..dab18e97388796c64b4c3d96ed5f6fb0ce7d63ac 100644
--- a/src/AlarmHandlerClass.h
+++ b/src/AlarmHandlerClass.h
@@ -54,17 +54,17 @@ namespace AlarmHandler_ns
 //=========================================
 //	Define classes for attributes
 //=========================================
-//	Attribute audibleAlarm class definition
-class audibleAlarmAttrib: public Tango::Attr
+//	Attribute alarmAudible class definition
+class alarmAudibleAttrib: public Tango::Attr
 {
 public:
-	audibleAlarmAttrib():Attr("audibleAlarm",
+	alarmAudibleAttrib():Attr("alarmAudible",
 			Tango::DEV_BOOLEAN, Tango::READ) {};
-	~audibleAlarmAttrib() {};
+	~alarmAudibleAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_audibleAlarm(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmAudible(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_audibleAlarm_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmAudible_allowed(ty);}
 };
 
 //	Attribute StatisticsResetTime class definition
@@ -93,121 +93,121 @@ public:
 		{return (static_cast<AlarmHandler *>(dev))->is_alarm_allowed(ty);}
 };
 
-//	Attribute normalAlarms class definition
-class normalAlarmsAttrib: public Tango::SpectrumAttr
+//	Attribute alarmNormal class definition
+class alarmNormalAttrib: public Tango::SpectrumAttr
 {
 public:
-	normalAlarmsAttrib():SpectrumAttr("normalAlarms",
+	alarmNormalAttrib():SpectrumAttr("alarmNormal",
 			Tango::DEV_STRING, Tango::READ, 10000) {};
-	~normalAlarmsAttrib() {};
+	~alarmNormalAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_normalAlarms(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmNormal(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_normalAlarms_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmNormal_allowed(ty);}
 };
 
-//	Attribute unacknowledgedAlarms class definition
-class unacknowledgedAlarmsAttrib: public Tango::SpectrumAttr
+//	Attribute alarmUnacknowledged class definition
+class alarmUnacknowledgedAttrib: public Tango::SpectrumAttr
 {
 public:
-	unacknowledgedAlarmsAttrib():SpectrumAttr("unacknowledgedAlarms",
+	alarmUnacknowledgedAttrib():SpectrumAttr("alarmUnacknowledged",
 			Tango::DEV_STRING, Tango::READ, 10000) {};
-	~unacknowledgedAlarmsAttrib() {};
+	~alarmUnacknowledgedAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_unacknowledgedAlarms(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmUnacknowledged(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_unacknowledgedAlarms_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmUnacknowledged_allowed(ty);}
 };
 
-//	Attribute acknowledgedAlarms class definition
-class acknowledgedAlarmsAttrib: public Tango::SpectrumAttr
+//	Attribute alarmAcknowledged class definition
+class alarmAcknowledgedAttrib: public Tango::SpectrumAttr
 {
 public:
-	acknowledgedAlarmsAttrib():SpectrumAttr("acknowledgedAlarms",
+	alarmAcknowledgedAttrib():SpectrumAttr("alarmAcknowledged",
 			Tango::DEV_STRING, Tango::READ, 10000) {};
-	~acknowledgedAlarmsAttrib() {};
+	~alarmAcknowledgedAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_acknowledgedAlarms(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmAcknowledged(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_acknowledgedAlarms_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmAcknowledged_allowed(ty);}
 };
 
-//	Attribute unacknowledgedNormalAlarms class definition
-class unacknowledgedNormalAlarmsAttrib: public Tango::SpectrumAttr
+//	Attribute alarmUnacknowledgedNormal class definition
+class alarmUnacknowledgedNormalAttrib: public Tango::SpectrumAttr
 {
 public:
-	unacknowledgedNormalAlarmsAttrib():SpectrumAttr("unacknowledgedNormalAlarms",
+	alarmUnacknowledgedNormalAttrib():SpectrumAttr("alarmUnacknowledgedNormal",
 			Tango::DEV_STRING, Tango::READ, 10000) {};
-	~unacknowledgedNormalAlarmsAttrib() {};
+	~alarmUnacknowledgedNormalAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_unacknowledgedNormalAlarms(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmUnacknowledgedNormal(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_unacknowledgedNormalAlarms_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmUnacknowledgedNormal_allowed(ty);}
 };
 
-//	Attribute shelvedAlarms class definition
-class shelvedAlarmsAttrib: public Tango::SpectrumAttr
+//	Attribute alarmShelved class definition
+class alarmShelvedAttrib: public Tango::SpectrumAttr
 {
 public:
-	shelvedAlarmsAttrib():SpectrumAttr("shelvedAlarms",
+	alarmShelvedAttrib():SpectrumAttr("alarmShelved",
 			Tango::DEV_STRING, Tango::READ, 10000) {};
-	~shelvedAlarmsAttrib() {};
+	~alarmShelvedAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_shelvedAlarms(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmShelved(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_shelvedAlarms_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmShelved_allowed(ty);}
 };
 
-//	Attribute outOfServiceAlarms class definition
-class outOfServiceAlarmsAttrib: public Tango::SpectrumAttr
+//	Attribute alarmOutOfService class definition
+class alarmOutOfServiceAttrib: public Tango::SpectrumAttr
 {
 public:
-	outOfServiceAlarmsAttrib():SpectrumAttr("outOfServiceAlarms",
+	alarmOutOfServiceAttrib():SpectrumAttr("alarmOutOfService",
 			Tango::DEV_STRING, Tango::READ, 10000) {};
-	~outOfServiceAlarmsAttrib() {};
+	~alarmOutOfServiceAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_outOfServiceAlarms(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmOutOfService(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_outOfServiceAlarms_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmOutOfService_allowed(ty);}
 };
 
-//	Attribute silencedAlarms class definition
-class silencedAlarmsAttrib: public Tango::SpectrumAttr
+//	Attribute alarmSilenced class definition
+class alarmSilencedAttrib: public Tango::SpectrumAttr
 {
 public:
-	silencedAlarmsAttrib():SpectrumAttr("silencedAlarms",
+	alarmSilencedAttrib():SpectrumAttr("alarmSilenced",
 			Tango::DEV_STRING, Tango::READ, 10000) {};
-	~silencedAlarmsAttrib() {};
+	~alarmSilencedAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_silencedAlarms(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmSilenced(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_silencedAlarms_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmSilenced_allowed(ty);}
 };
 
-//	Attribute listAlarms class definition
-class listAlarmsAttrib: public Tango::SpectrumAttr
+//	Attribute alarmList class definition
+class alarmListAttrib: public Tango::SpectrumAttr
 {
 public:
-	listAlarmsAttrib():SpectrumAttr("listAlarms",
+	alarmListAttrib():SpectrumAttr("alarmList",
 			Tango::DEV_STRING, Tango::READ, 10000) {};
-	~listAlarmsAttrib() {};
+	~alarmListAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_listAlarms(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmList(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_listAlarms_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmList_allowed(ty);}
 };
 
-//	Attribute frequencyAlarms class definition
-class frequencyAlarmsAttrib: public Tango::SpectrumAttr
+//	Attribute alarmFrequency class definition
+class alarmFrequencyAttrib: public Tango::SpectrumAttr
 {
 public:
-	frequencyAlarmsAttrib():SpectrumAttr("frequencyAlarms",
+	alarmFrequencyAttrib():SpectrumAttr("alarmFrequency",
 			Tango::DEV_DOUBLE, Tango::READ, 10000) {};
-	~frequencyAlarmsAttrib() {};
+	~alarmFrequencyAttrib() {};
 	virtual void read(Tango::DeviceImpl *dev,Tango::Attribute &att)
-		{(static_cast<AlarmHandler *>(dev))->read_frequencyAlarms(att);}
+		{(static_cast<AlarmHandler *>(dev))->read_alarmFrequency(att);}
 	virtual bool is_allowed(Tango::DeviceImpl *dev,Tango::AttReqType ty)
-		{return (static_cast<AlarmHandler *>(dev))->is_frequencyAlarms_allowed(ty);}
+		{return (static_cast<AlarmHandler *>(dev))->is_alarmFrequency_allowed(ty);}
 };
 
 //	Attribute alarmSummary class definition
diff --git a/src/AlarmHandlerStateMachine.cpp b/src/AlarmHandlerStateMachine.cpp
index c065dfdcfbbdc548e62d4f4ae01f73744b7572d4..393ac93eba970227509ac4b5eb560e4bd5a89c1a 100644
--- a/src/AlarmHandlerStateMachine.cpp
+++ b/src/AlarmHandlerStateMachine.cpp
@@ -46,17 +46,17 @@ namespace AlarmHandler_ns
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_audibleAlarm_allowed()
- *	Description : Execution allowed for audibleAlarm attribute
+ *	Method      : AlarmHandler::is_alarmAudible_allowed()
+ *	Description : Execution allowed for alarmAudible attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_audibleAlarm_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmAudible_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for audibleAlarm attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::audibleAlarmStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmAudible attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmAudibleStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::audibleAlarmStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmAudibleStateAllowed_READ
 	return true;
 }
 
@@ -94,145 +94,145 @@ bool AlarmHandler::is_alarm_allowed(TANGO_UNUSED(Tango::AttReqType type))
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_normalAlarms_allowed()
- *	Description : Execution allowed for normalAlarms attribute
+ *	Method      : AlarmHandler::is_alarmNormal_allowed()
+ *	Description : Execution allowed for alarmNormal attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_normalAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmNormal_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for normalAlarms attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::normalAlarmsStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmNormal attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmNormalStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::normalAlarmsStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmNormalStateAllowed_READ
 	return true;
 }
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_unacknowledgedAlarms_allowed()
- *	Description : Execution allowed for unacknowledgedAlarms attribute
+ *	Method      : AlarmHandler::is_alarmUnacknowledged_allowed()
+ *	Description : Execution allowed for alarmUnacknowledged attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_unacknowledgedAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmUnacknowledged_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for unacknowledgedAlarms attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::unacknowledgedAlarmsStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmUnacknowledged attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmUnacknowledgedStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::unacknowledgedAlarmsStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmUnacknowledgedStateAllowed_READ
 	return true;
 }
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_acknowledgedAlarms_allowed()
- *	Description : Execution allowed for acknowledgedAlarms attribute
+ *	Method      : AlarmHandler::is_alarmAcknowledged_allowed()
+ *	Description : Execution allowed for alarmAcknowledged attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_acknowledgedAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmAcknowledged_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for acknowledgedAlarms attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::acknowledgedAlarmsStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmAcknowledged attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmAcknowledgedStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::acknowledgedAlarmsStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmAcknowledgedStateAllowed_READ
 	return true;
 }
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_unacknowledgedNormalAlarms_allowed()
- *	Description : Execution allowed for unacknowledgedNormalAlarms attribute
+ *	Method      : AlarmHandler::is_alarmUnacknowledgedNormal_allowed()
+ *	Description : Execution allowed for alarmUnacknowledgedNormal attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_unacknowledgedNormalAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmUnacknowledgedNormal_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for unacknowledgedNormalAlarms attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::unacknowledgedNormalAlarmsStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmUnacknowledgedNormal attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmUnacknowledgedNormalStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::unacknowledgedNormalAlarmsStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmUnacknowledgedNormalStateAllowed_READ
 	return true;
 }
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_shelvedAlarms_allowed()
- *	Description : Execution allowed for shelvedAlarms attribute
+ *	Method      : AlarmHandler::is_alarmShelved_allowed()
+ *	Description : Execution allowed for alarmShelved attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_shelvedAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmShelved_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for shelvedAlarms attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::shelvedAlarmsStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmShelved attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmShelvedStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::shelvedAlarmsStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmShelvedStateAllowed_READ
 	return true;
 }
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_outOfServiceAlarms_allowed()
- *	Description : Execution allowed for outOfServiceAlarms attribute
+ *	Method      : AlarmHandler::is_alarmOutOfService_allowed()
+ *	Description : Execution allowed for alarmOutOfService attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_outOfServiceAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmOutOfService_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for outOfServiceAlarms attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::outOfServiceAlarmsStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmOutOfService attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmOutOfServiceStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::outOfServiceAlarmsStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmOutOfServiceStateAllowed_READ
 	return true;
 }
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_silencedAlarms_allowed()
- *	Description : Execution allowed for silencedAlarms attribute
+ *	Method      : AlarmHandler::is_alarmSilenced_allowed()
+ *	Description : Execution allowed for alarmSilenced attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_silencedAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmSilenced_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for silencedAlarms attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::silencedAlarmsStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmSilenced attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmSilencedStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::silencedAlarmsStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmSilencedStateAllowed_READ
 	return true;
 }
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_listAlarms_allowed()
- *	Description : Execution allowed for listAlarms attribute
+ *	Method      : AlarmHandler::is_alarmList_allowed()
+ *	Description : Execution allowed for alarmList attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_listAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmList_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for listAlarms attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::listAlarmsStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmList attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmListStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::listAlarmsStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmListStateAllowed_READ
 	return true;
 }
 
 //--------------------------------------------------------
 /**
- *	Method      : AlarmHandler::is_frequencyAlarms_allowed()
- *	Description : Execution allowed for frequencyAlarms attribute
+ *	Method      : AlarmHandler::is_alarmFrequency_allowed()
+ *	Description : Execution allowed for alarmFrequency attribute
  */
 //--------------------------------------------------------
-bool AlarmHandler::is_frequencyAlarms_allowed(TANGO_UNUSED(Tango::AttReqType type))
+bool AlarmHandler::is_alarmFrequency_allowed(TANGO_UNUSED(Tango::AttReqType type))
 {
 
-	//	Not any excluded states for frequencyAlarms attribute in read access.
-	/*----- PROTECTED REGION ID(AlarmHandler::frequencyAlarmsStateAllowed_READ) ENABLED START -----*/
+	//	Not any excluded states for alarmFrequency attribute in read access.
+	/*----- PROTECTED REGION ID(AlarmHandler::alarmFrequencyStateAllowed_READ) ENABLED START -----*/
 	
-	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::frequencyAlarmsStateAllowed_READ
+	/*----- PROTECTED REGION END -----*/	//	AlarmHandler::alarmFrequencyStateAllowed_READ
 	return true;
 }