SingleShotAO.cpp

static const char *RcsId = "$Id: DevServ.cpp 13293 2009-04-07 10:53:56Z pascal_verdier $";
//+=============================================================================
//
// file :         SingleShotAO.cpp
//
// description :  C++ source for the SingleShotAO and its commands. 
//                The class is derived from Device. It represents the
//                CORBA servant object which will be accessed from the
//                network. All commands which can be executed on the
//                SingleShotAO are implemented in this file.
//
// project :      TANGO Device Server
//
// $Author: pascal_verdier $
//
// $Revision: 13293 $
//
// $Revision: 13293 $
// $Date: 2009-04-07 12:53:56 +0200 (Tue, 07 Apr 2009) $
//
// SVN only:
// $HeadURL: $
//
// CVS only:
// $Source$
// $Log$
// Revision 3.5  2007/10/24 12:07:35  pascal_verdier
// Another spelling mistake correction
//
// Revision 3.4  2007/10/23 14:04:30  pascal_verdier
// Spelling mistakes correction
//
// Revision 3.3  2005/03/02 14:06:15  pascal_verdier
// namespace is different than class name.
//
// Revision 3.2  2004/11/08 11:33:16  pascal_verdier
// if device property not found in database, it takes class property value if exists.
//
// Revision 3.1  2004/09/06 09:27:05  pascal_verdier
// Modified for Tango 5 compatibility.
//
//
// copyleft :    Synchrotron SOLEIL 
//               L'Orme des merisiers - Saint Aubin
//               BP48 - 91192 Gif sur Yvette
//               FRANCE
//
//-=============================================================================
//
//  		This file is generated by POGO
//	(Program Obviously used to Generate tango Object)
//
//         (c) - Software Engineering Group - ESRF
//=============================================================================



//===================================================================
//
//	The following table gives the correspondence
//	between commands and method name.
//
//  Command name|  Method name
//	----------------------------------------
//  State   |  dev_state()
//  Status  |  dev_status()
//  Abort   |  abort()
//
//===================================================================


#include <tango.h>
#include <yat4tango/Logging.h>
#include <yat4tango/DeviceInfo.h>
#include <SingleShotAO.h>
#include <SingleShotAOClass.h>
#include "SingleShotAOTypesAndConsts.h"


namespace SingleShotAO_ns
{

//- check manager macro:
#define CHECK_MANAGER() \
	do \
	{ \
	if (! m_manager) \
	THROW_DEVFAILED("DEVICE_ERROR", \
	"request aborted - the manager isn't accessible ", \
	"SingleShotAO::check_manager"); \
} while (0)


//+----------------------------------------------------------------------------
//
// method : 		SingleShotAO::SingleShotAO(string &s)
// 
// description : 	constructor for simulated SingleShotAO
//
// in : - cl : Pointer to the DeviceClass object
//      - s : Device name 
//
//-----------------------------------------------------------------------------
SingleShotAO::SingleShotAO(Tango::DeviceClass *cl,string &s)
:TANGO_BASE_CLASS(cl,s.c_str())
{
	init_device();
}

SingleShotAO::SingleShotAO(Tango::DeviceClass *cl,const char *s)
:TANGO_BASE_CLASS(cl,s)
{
	init_device();
}

SingleShotAO::SingleShotAO(Tango::DeviceClass *cl,const char *s,const char *d)
:TANGO_BASE_CLASS(cl,s,d)
{
	init_device();
}


//+----------------------------------------------------------------------------
//
// method : 		SingleShotAO::delete_device()
// 
// description : 	will be called at device destruction or at init command.
//
//-----------------------------------------------------------------------------
void SingleShotAO::delete_device()
{
	DEBUG_STREAM << "SingleShotAO::delete_device(): entering... !" << endl;

	// Make sure running processes are aborted properly if channels are running
	//--------------------------------------------
	try
	{
		_abort();
	}
	catch (Tango::DevFailed &df)
	{
		ERROR_STREAM << df << endl;
		RETHROW_DEVFAILED(df,
						  "DRIVER_FAILURE",
						  "could not abort [caught Tango::DevFailed]",
						  "SingleShotAO::delete_device");
	}
	catch (...)
	{
		ERROR_STREAM << "SingleShotAO::init::unknown exception caught" << std::endl;
		THROW_DEVFAILED("DRIVER_FAILURE",
						"could not abort [unknown error]",
						"SingleShotAO::delete_device");
	}

	// Delete device allocated objects
	//--------------------------------------------
	yat4tango::TraceHelper t("SingleShotAO::delete_device", this);

	if (m_manager)
	{
		m_manager->exit();
		m_manager = NULL;
	}

	// Release the asl::SingleShotAO object
	//--------------------------------------------
	if (m_ssao) 
	{
		delete m_ssao;
		m_ssao = NULL;
	}

	// Remove dynamic attributes
	//--------------------------------------------
	if (m_dyn_attr_manager)
	{
		try
		{
			m_dyn_attr_manager->remove_attributes();
		}
		catch (...)
		{
			//- ignore any error
		}
	}

	// delete dynamic attributes manager
	if (m_dyn_attr_manager)
	{
		delete m_dyn_attr_manager;
		m_dyn_attr_manager = NULL;
	}

	// Remove the inner appender
	//--------------------------------------------
	yat4tango::Logging::release(this);
	yat4tango::DeviceInfo::release(this);
}


//+----------------------------------------------------------------------------
//
// method : 		SingleShotAO::init_device()
// 
// description : 	will be called at device initialization.
//
//-----------------------------------------------------------------------------
void SingleShotAO::init_device()
{
	//- initialize the inner appender (first thing to do)
	try
	{
		INFO_STREAM << "Create the InnerAppender & FileAppender in order to manage logs." << endl;
		yat4tango::Logging::initialize(this);
		
		INFO_STREAM << "Create the DeviceInfo in order to manage info on versions." << endl;
		yat4tango::DeviceInfo::initialize(this, YAT_XSTR(PROJECT_NAME), YAT_XSTR(PROJECT_VERSION));
		yat4tango::DeviceInfo::add_dependency(this, "ASL", ">=1.0");
	}
	catch (Tango::DevFailed &df)
	{
		ERROR_STREAM << df << std::endl;
		m_state = Tango::FAULT;
		m_currStatus = "initialization failed - could not instantiate the InnerAppender";
		return;
	}

	INFO_STREAM << "Initializing device";

	//- trace/profile this method
	yat4tango::TraceHelper t("SingleShotAO::init_device", this);

	// construct the AO manager
	//--------------------------------------------
	try
	{
		m_manager = new SingleShotAOManager(this);
	}
	catch (...)
	{
		ERROR_STREAM << "initialization failed - failed to create manager" << std::endl;
		m_currStatus = "initialization failed [failed to create manager]. See log for details";
		m_state = Tango::FAULT;
		return;
	}

	// Initialise variables to default values
	//--------------------------------------------

	//- init members
	m_ssao = NULL;
	critical_properties_missing = false;
	isInitOk = false;
	m_frequency = 0.0;
	m_dyn_attr_manager = NULL;
	m_state = Tango::INIT;

	// Initialise variables to default values
	//--------------------------------------------
	try 
	{
		get_device_property();
	}
	catch (const Tango::DevFailed& df)
	{
		ERROR_STREAM << "SingleShotAO::init_device::Tango::DevFailed exception caught "
			<< "while trying to read device properties from TANGO database"
			<< std::endl;
		std::string error_msg = df.errors[0].desc;
		std::istringstream error_stream(error_msg);
		std::string line;
		std::getline(error_stream, line); // Read the first line
		ERROR_STREAM << line << std::endl;
		while (std::getline(error_stream, line)) { // Read the rest of the lines
			ERROR_STREAM << " - " << line << std::endl;
		}
		m_currStatus = error_msg;
		m_state = Tango::FAULT;
		return;
	}
	catch (...)
	{
		//- update internal state
		ERROR_STREAM << "SingleShotAO::init_device::unknown exception caught "
			<< "while trying to read device properties from TANGO database"
			<< std::endl;
		m_currStatus = "Failed to get property. See log for details";
		m_state = Tango::FAULT;
		return;
	}

	//- abort initialization if properties missing
	if (critical_properties_missing) 
	{
		ERROR_STREAM << "configuration error - unspecified or invalid device properties";
		m_currStatus = "configuration error [unspecified or invalid device properties]. See log for details";
		m_state = Tango::FAULT;
		return;
	}

	//- allocate the asl::SingleShotAO object
	m_ssao = new asl::SingleShotAO;
	if (m_ssao == 0) 
	{
		m_currStatus = "Failed to create the SignleShotAO. See log for details";
		m_state = Tango::FAULT;
		return;
	}

	try
	{
		//- initialze the hardware
		m_ssao->init(boardTypeId, boardNum);
	}
	catch(const asl::DAQException& de)
	{
		ERROR_STREAM << daq_to_tango_exception(de) << endl;
		m_currStatus = "Failed to init the SignleShotAO. See log for details";
		m_state = Tango::FAULT;
		return;
	}
	catch(...)
	{
		ERROR_STREAM << "SingleShotAO::init_device::unknown exception caught"<<std::endl;
		m_currStatus = "Failed to init the SignleShotAO. See log for details";
		m_state = Tango::FAULT;
		return;
	}

  	// initialize channel number according to board type
	m_nb_chan = 0;
	if (boardType == k6208_BOARD_TYPE)
	{
		m_nb_chan = 8;
	}
	if (boardType == k6216_BOARD_TYPE)
	{
		m_nb_chan = 16;
	}

	INFO_STREAM << "Board has " << m_nb_chan << " channels" << endl;

	// test the manager
	if (!m_manager)
	{
		ERROR_STREAM << "initialization failed - the manager is not created" << std::endl;
		m_currStatus = "initialization failed [the manager is not created]. See log for details";
		m_state = Tango::FAULT;
		return;
	}


	// get frequency value in database
	//--------------------------------------------
	try
	{
		m_frequency = yat4tango::PropertyHelper::get_memorized_attribute<double>(this, "frequency");
		DEBUG_STREAM << "Frequency : " << m_frequency << endl;
	}
	catch (...)
	{
		DEBUG_STREAM << "No memorized value found for frequency. Defaulting to " << m_frequency << "." << std::endl;
	}


	// initialize the AO manager
	//--------------------------------------------
	try
	{
		m_manager->init(m_ssao, m_nb_chan, m_frequency, enableRamps);
	}
	catch (Tango::DevFailed & df)
	{
		ERROR_STREAM << df << std::endl;
		m_currStatus = "initialization failed - Manager initialization failed [see device log for details]";
		m_state = Tango::FAULT;
		return;
	}
	catch (...)
	{
		ERROR_STREAM << "initialization failed - failed to initialize manager" << std::endl;
		m_currStatus = "initialization failed [failed to initialize manager]. See log for details";
		m_state = Tango::FAULT;
		return;
	}

	// Remove existing dynamic attributes to avoid duplicates or other issues
	// --------------------------------------------
	if (m_dyn_attr_manager)
	{
		try
		{
			m_dyn_attr_manager->remove_attributes();
			delete m_dyn_attr_manager;
			m_dyn_attr_manager = NULL;
			DEBUG_STREAM << "Existing dynamic attributes manager cleaned up" << endl;
		} 
		catch (...)
		{
			ERROR_STREAM << "Error cleaning up existing dynamic attributes manager, continuing..." << endl;
			// Continue anyway - we'll create a new one
		}
	}

	// Create dynamic attributes
	//--------------------------------------------

  	// create dynamic attribute manager
	try
	{
		m_dyn_attr_manager = new yat4tango::DynamicAttributeManager(this);
	}
	catch (Tango::DevFailed &e)
	{
		ERROR_STREAM << e << std::endl;
		m_currStatus = "Failed to create Dynamic Attribute Manager. See log for details";
		m_state = Tango::FAULT;
		return;
	}
	catch (...)
	{
		ERROR_STREAM << "Failed to create Dynamic Attribute Manager" << std::endl;
		m_currStatus = "Failed to create Dynamic Attribute Manager. See log for details";
		m_state = Tango::FAULT;
		return;
	}


	// add dynamic attributes: channel, speed & initial for each channel
  	std::vector<yat4tango::DynamicAttributeInfo> l_dynAttrList;
	
	// Log how many attributes we're going to create
	INFO_STREAM << "Creating dynamic attributes for " << m_nb_chan << " channels.";
	INFO_STREAM << "Total attributes: " << m_nb_chan * (enableRamps ? 3 : 1) << endl;

	for (unsigned int l_cpt = 0; l_cpt < m_nb_chan; l_cpt++)
	{
		yat::OSStream oss;
		oss << l_cpt;

		// ╔═══════════════╗
		// ║ Channel value ║
		// ╚═══════════════╝
		yat4tango::DynamicAttributeInfo dai_channel;
		dai_channel.dev = this;
		dai_channel.tai.name = kCHANNEL + oss.str();
		dai_channel.tai.label = kCHANNEL + oss.str();

		//- describe the dyn attr we want...
		dai_channel.tai.data_type = Tango::DEV_DOUBLE;
		dai_channel.tai.data_format = Tango::SCALAR;
		dai_channel.tai.writable = Tango::READ_WRITE; // soso
		dai_channel.tai.disp_level = Tango::OPERATOR;
		dai_channel.tai.unit = "V";
		dai_channel.tai.standard_unit = "V";
		dai_channel.tai.display_unit = "V";
		dai_channel.tai.max_value = "10.0";
		dai_channel.tai.min_value = "-10.0";
		dai_channel.tai.description = "Output value for channel " + oss.str() + " (in measurementUnit).";
		dai_channel.tai.format = "%5.3f";
		dai_channel.cdb = false;

		//- read callback
		dai_channel.rcb = yat4tango::DynamicAttributeReadCallback::instanciate(const_cast<SingleShotAO&>(*this), 
			&SingleShotAO::read_channel);

		//- write callback
		dai_channel.wcb = yat4tango::DynamicAttributeWriteCallback::instanciate(const_cast<SingleShotAO&>(*this), 
			&SingleShotAO::write_channel);

		l_dynAttrList.push_back(dai_channel);

		// if enableRamps if false, skip speed and initial attributes
		if (!enableRamps)
		{
			DEBUG_STREAM << "Ramps are disabled. Skipping speed and initial attributes for channel " << l_cpt << std::endl;
			continue;
		}

		// ╔═══════════════╗
		// ║  Speed value  ║
		// ╚═══════════════╝
		yat4tango::DynamicAttributeInfo dai_speed;
		dai_speed.dev = this;
		dai_speed.tai.name = kSPEED + oss.str();
		dai_speed.tai.label = kSPEED + oss.str();

		//- describe the dyn attr we want...
		dai_speed.tai.data_type = Tango::DEV_DOUBLE;
		dai_speed.tai.data_format = Tango::SCALAR;
		dai_speed.tai.writable = Tango::READ_WRITE;
		dai_speed.tai.disp_level = Tango::OPERATOR;
		dai_speed.tai.unit = "V/s";
		dai_speed.tai.standard_unit = "V/s";
		dai_speed.tai.display_unit = "V/s";
		dai_speed.tai.description = "Speed for ramp generation, in V/s. If speed is NULL, no ramp generated but direct write on channel output " + oss.str() + " (in measurementUnit).";
		dai_speed.tai.format = "%5.3f";

		//- cleanup tango db option: cleanup tango db when removing this dyn. attr. (i.e. erase its properties from db)
		dai_speed.cdb = false;

		//- read callback
		dai_speed.rcb = yat4tango::DynamicAttributeReadCallback::instanciate(const_cast<SingleShotAO&>(*this), 
			&SingleShotAO::read_speed);

		//- write callback
		dai_speed.wcb = yat4tango::DynamicAttributeWriteCallback::instanciate(const_cast<SingleShotAO&>(*this), 
			&SingleShotAO::write_speed);
		
    	l_dynAttrList.push_back(dai_speed);
		

		// ╔═══════════════╗
		// ║ Initial value ║
		// ╚═══════════════╝
		yat4tango::DynamicAttributeInfo dai_initial;
		dai_initial.dev = this;
		dai_initial.tai.name = kINITIAL + oss.str();
		dai_initial.tai.label = kINITIAL + oss.str();

		//- describe the dyn attr we want...
		dai_initial.tai.data_type = Tango::DEV_DOUBLE;
		dai_initial.tai.data_format = Tango::SCALAR;
		dai_initial.tai.writable = Tango::READ_WRITE;
		dai_initial.tai.disp_level = Tango::OPERATOR;
		dai_initial.tai.unit = "V";
		dai_initial.tai.standard_unit = "V";
		dai_initial.tai.display_unit = "V";
		dai_initial.tai.description = "Initial value for ramp function, in V. Defaults to last written value in channel attribute " + oss.str() + ".";
		dai_initial.tai.format = "%5.3f";

		//- cleanup tango db option: cleanup tango db when removing this dyn. attr. (i.e. erase its properties from db)
		dai_initial.cdb = false;

		//- read callback
		dai_initial.rcb = yat4tango::DynamicAttributeReadCallback::instanciate(const_cast<SingleShotAO&>(*this), 
			&SingleShotAO::read_initial);

		//- write callback
		dai_initial.wcb = yat4tango::DynamicAttributeWriteCallback::instanciate(const_cast<SingleShotAO&>(*this), 
			&SingleShotAO::write_initial);
		
    	l_dynAttrList.push_back(dai_initial);
	}
	
	// Log the size of our attribute list before adding to manager
	INFO_STREAM << "Prepared " << l_dynAttrList.size() << " dynamic attributes for creation" << endl;
	
	// Add all attributes
	try 
	{
  		m_dyn_attr_manager->add_attributes(l_dynAttrList);
		INFO_STREAM << "Successfully added all dynamic attributes" << endl;
	}
	catch (Tango::DevFailed &df) 
	{
		ERROR_STREAM << "Failed to add dynamic attributes: " << df << endl;
		m_currStatus = "Failed to add dynamic attributes. See log for details";
		m_state = Tango::FAULT;
		return;
	}
	catch (...) 
	{
		ERROR_STREAM << "Unknown exception when adding dynamic attributes" << endl;
		m_currStatus = "Failed to add dynamic attributes. Unknown error";
		m_state = Tango::FAULT;
		return;
	}

	// Initialize maps in manager class for all channels
	try
	{
		for (unsigned int l_cpt = 0; l_cpt < m_nb_chan; l_cpt++)
		{
			// Initialize with default values
			m_manager->set_channel(l_cpt, 0.0);
			if (enableRamps)
			{
				m_manager->set_speed(l_cpt, 0.0);
				m_manager->set_initial(l_cpt, 0.0);
			}
		}
	}
	catch (Tango::DevFailed &df)
	{
		ERROR_STREAM << "Failed to initialize channel maps: " << df << endl;
		m_currStatus = "Failed to initialize channel maps. See log for details";
		m_state = Tango::FAULT;
		return;
	}

	// Get memorized values from database
	for (unsigned int l_cpt = 0; l_cpt < m_nb_chan; l_cpt++)
	{
		yat::OSStream oss;
		oss << l_cpt;

		// Helper function to get and set memorized attributes
		auto applyMemorizedAttr = [&](const std::string& attrPrefix, 
			void (SingleShotAOManager::*setter)(yat::uint16, double))
		{
			std::string attrName = attrPrefix + oss.str();
			try
			{
				double val = yat4tango::PropertyHelper::get_memorized_attribute<double>(this, attrName);
				DEBUG_STREAM << "Found memorized value for " << attrName << ": " << val << endl;

				// Write the value to the manager (that contains the "read" attributes values)
				(m_manager->*setter)(l_cpt, val);

				// Write the value to the "write" attributes using helper function
				setDynamicAttributeWriteValue(attrName, val);
			}
			catch (...)
			{
				DEBUG_STREAM << "No memorized value found for " << attrName << ". Setting default value." << std::endl;
			}
		};

		// Get and set memorized values for speed, initial and channel
		if (enableRamps)
		{
			applyMemorizedAttr(kSPEED, &SingleShotAOManager::set_speed);
			applyMemorizedAttr(kINITIAL, &SingleShotAOManager::set_initial); 
		}

		if (outputMemorizedChannelsAtInit)
		{
			applyMemorizedAttr(kCHANNEL, &SingleShotAOManager::write_channel_direct); // write memorized value to board output (directly, without ramp)
		} else {
			applyMemorizedAttr(kCHANNEL, &SingleShotAOManager::set_channel); // only apply memorized value to the device
		}
    }

	//- GO for task
	try
	{
		m_manager->go();
	}
	catch (Tango::DevFailed & df)
	{
		ERROR_STREAM << df << std::endl;
		m_currStatus = "initialization failed [failed to go for manager]";
		m_state = Tango::FAULT;
		return;
	}
	catch (...)
	{
		ERROR_STREAM << "initialization failed - failed to go for manager" << std::endl;
		m_currStatus = "initialization failed [failed to go for manager]. See log for details";
		m_state = Tango::FAULT;
		return;
	}

	//- update internal state
	m_state = Tango::ON;
	m_currStatus = "Device ready to execute AO request.";
	isInitOk = true;
}

//+------------------------------------------------------------------
/**
 * method : 		SingleShotAO::get_device_property()
 *
 * description : 	Read the device properties from database.
 *
 * @throws DevFailed if any critical property is missing, not set, or invalid
 */
void SingleShotAO::get_device_property()
{
	//	Read device properties from database
	//------------------------------------------------------------------
	Tango::DbData	dev_prop;
	dev_prop.push_back(Tango::DbDatum("BoardNum"));
	dev_prop.push_back(Tango::DbDatum("BoardType"));
	dev_prop.push_back(Tango::DbDatum("EnableRamps"));
	dev_prop.push_back(Tango::DbDatum("OutputMemorizedChannelsAtInit"));


	// Call database and extract values
	//--------------------------------------------
	if (Tango::Util::instance()->_UseDb==true)
	{
		get_db_device()->get_property(dev_prop);
	}

	Tango::DbDatum def_prop, cl_prop;
	SingleShotAOClass *ds_class = (static_cast<SingleShotAOClass *>(get_device_class()));
	int	i = -1;

	//- <BoardNum> -----------------------
	// Try to initialize BoardNum from class property
	cl_prop = ds_class->get_class_property(dev_prop[++i].name);
	if (cl_prop.is_empty()==false)	cl_prop  >>  boardNum;
	else {
		// Try to initialize BoardNum from default device value
		def_prop = ds_class->get_default_device_property(dev_prop[i].name);
		if (def_prop.is_empty() == false)
		{
			def_prop >> boardNum_default;
			def_prop >> boardNum;
		}
	}
	// And try to extract BoardNum value from database
	if (dev_prop[i].is_empty() == false) dev_prop[i] >> boardNum;
	INFO_STREAM << "Raw BoardNum parsed: " << boardNum << endl;

	//- <BoardType> -----------------------
	// Try to initialize BoardType from class property
	cl_prop = ds_class->get_class_property(dev_prop[++i].name);
	if (cl_prop.is_empty() == false) cl_prop >> boardType;
	else {
		// Try to initialize BoardType from default device value
		def_prop = ds_class->get_default_device_property(dev_prop[i].name);
		if (def_prop.is_empty() == false)
		{
			def_prop >> boardType_default;
			def_prop >> boardType;
		}
	}
	// And try to extract BoardType value from database
	if (dev_prop[i].is_empty() == false) dev_prop[i] >> boardType;
	INFO_STREAM << "Raw BoardType parsed: " << boardType << endl;

	//- <EnableRamps> -----------------------
	//	Try to initialize EnableRamps from class property
	cl_prop = ds_class->get_class_property(dev_prop[++i].name);
	if (cl_prop.is_empty() == false) cl_prop >> enableRamps;
	else {
		//	Try to initialize EnableRamps from default device value
		def_prop = ds_class->get_default_device_property(dev_prop[i].name);
		if (def_prop.is_empty() == false)
		{
			def_prop >> enableRamps_default;
			def_prop >> enableRamps;
		}
	}
	//	And try to extract EnableRamps value from database
	if (dev_prop[i].is_empty() == false) dev_prop[i] >> enableRamps;
	INFO_STREAM << "EnableRamps parsed: " << (enableRamps ? "true" : "false") << endl;

	//- <OutputMemorizedChannelsAtInit> -----------------------
	//	Try to initialize OutputMemorizedChannelsAtInit from class property
	cl_prop = ds_class->get_class_property(dev_prop[++i].name);
	if (cl_prop.is_empty() == false) cl_prop >> outputMemorizedChannelsAtInit;
	else {
		//	Try to initialize OutputMemorizedChannelsAtInit from default device value
		def_prop = ds_class->get_default_device_property(dev_prop[i].name);
		if (def_prop.is_empty() == false)
		{
			def_prop >> outputMemorizedChannelsAtInit_default;
			def_prop >> outputMemorizedChannelsAtInit;
		}
	}
	//	And try to extract OutputMemorizedChannelsAtInit value from database
	if (dev_prop[i].is_empty() == false) dev_prop[i] >> outputMemorizedChannelsAtInit;
	INFO_STREAM << "OutputMemorizedChannelsAtInit parsed: " << (outputMemorizedChannelsAtInit ? "true" : "false") << endl;


	// Create properties if empty and set default values
	//--------------------------------------------
	DEBUG_STREAM << "Creating properties if empty" << endl;
	yat4tango::PropertyHelper::create_property_if_empty(this, dev_prop, boardNum_default, "BoardNum");
	yat4tango::PropertyHelper::create_property_if_empty(this, dev_prop, boardType_default, "BoardType");
	yat4tango::PropertyHelper::create_property_if_empty(this, dev_prop, enableRamps_default, "EnableRamps");
	yat4tango::PropertyHelper::create_property_if_empty(this, dev_prop, outputMemorizedChannelsAtInit_default, "OutputMemorizedChannelsAtInit");


	// Check critical properties being valid
	//--------------------------------------------
	DEBUG_STREAM << "Checking if critical properties are valid:" << endl;
	critical_properties_missing = false;
	yat::OSStream errorMessages;
	errorMessages << "Critical properties are missing or invalid:" << endl;

	//- <BoardNum> -----------------------
	// Case 1 (error): boardNum is set to the default value in the database
	if (boardNum == boardNum_default)
	{
		errorMessages << "Device property <BoardNum> is not set (default value " << boardNum_default << " needs to be replaced)" << endl;
		critical_properties_missing = true;
	}
	// Case 2 (error): boardNum is set to a value outside the valid range
	else if (boardNum < 0 || boardNum > 7)
	{
		boardNum = 0;
		errorMessages << "Device property <BoardNum> is invalid. Valid range is [0..7]" << endl;
		critical_properties_missing = true;
	}
	// Case 3 (ok): boardNum is set to a valid value
	else
	{
		INFO_STREAM << "BoardNum resolved to " << boardNum << endl;
	}

	//- <BoardType> -----------------------
	// Case 1 (error): boardType is set to the default value in the database
	if (boardType == boardType_default || boardType == "")
	{
		errorMessages << "Device property <BoardType> is not set (default value " << boardType_default << " needs to be replaced)" << endl;
		critical_properties_missing = true;
	}
	// Case 2 (ok): boardType is set to a valid 
	else if (boardType == "MAO_6208")
	{
		boardType = k6208_BOARD_TYPE;
		boardTypeId = adl::PCI6208;
		INFO_STREAM << "BoardType resolved to PCI6208" << endl;
	}
	else if (boardType == "MAO_6216")
	{
		boardType = k6216_BOARD_TYPE;
		boardTypeId = adl::PCI6216;
		INFO_STREAM << "BoardType resolved to PCI6216" << endl;
	}
	// Case 3 (error): boardType is set to an invalid value
	else
	{
		boardType = kDEFAULT_BOARD_TYPE;
		boardTypeId = adl::PCI6208;
		errorMessages << "Device property <BoardType> is invalid [supported hw: MAO_6208 or MAO_6216]" << endl;
		critical_properties_missing = true;
	}


	// If any critical property is missing or invalid, throw an exception
	if (critical_properties_missing)
	{
		DEBUG_STREAM << "Critical properties are missing, throwing exception." << endl;
		THROW_DEVFAILED("DEVICE_ERROR", errorMessages.str().c_str(), "SingleShotAO::get_device_property");
	}
	else
	{
		DEBUG_STREAM << "All critical properties are valid." << endl;
	}
}


//+----------------------------------------------------------------------------
//
// method : 		SingleShotAO::always_executed_hook()
// 
// description : 	method always executed before any command is executed
//
//-----------------------------------------------------------------------------
void SingleShotAO::always_executed_hook()
{
	// nothing to do
}


//+----------------------------------------------------------------------------
//
// method : 		SingleShotAO::read_attr_hardware
// 
// description : 	Hardware acquisition for attributes.
//
//-----------------------------------------------------------------------------
void SingleShotAO::read_attr_hardware(vector<long> &attr_list)
{
	// nothing to do
}


//+----------------------------------------------------------------------------
//
// method : 		SingleShotAO::read_frequency
// 
// description : 	Extract real attribute values for Frequency acquisition result.
//
//-----------------------------------------------------------------------------
void SingleShotAO::read_frequency(Tango::Attribute &attr)
{
	attr.set_value(&m_frequency);
}


//+----------------------------------------------------------------------------
//
// method : 		SingleShotAO::write_frequency
// 
// description : 	Write Frequency attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SingleShotAO::write_frequency(Tango::WAttribute &attr)
{
	DEBUG_STREAM << "SingleShotAO::write_frequency(Tango::WAttribute &attr) entering... "<< endl;
	if (dev_state() != Tango::ON)
	{
		THROW_DEVFAILED("DEVICE_ERROR",
			"could not write frequency. The state must be ON.",
			"SingleShotAO::write_frequency");
	}
	CHECK_MANAGER();
	attr.get_write_value(m_frequency);
	m_manager->write_frequency(m_frequency);
	yat4tango::PropertyHelper::set_memorized_attribute(this, "frequency", m_frequency);
}


//+------------------------------------------------------------------
/**
*  method:  SingleShotAO::dev_state
*
*  description:  method to execute "State"
*  This command gets the device state (stored in its <i>device_state</i> data member) and returns it to the caller.
*
* @return  State Code
*
*/
//+------------------------------------------------------------------
Tango::DevState SingleShotAO::dev_state()
{ 
	if (isInitOk)
	{
		CHECK_MANAGER();
		m_state = m_manager->get_state();
	}
	return m_state;
}


//+------------------------------------------------------------------
/**
*  method:  SingleShotAO::dev_status
*
*  description:  method to execute "Status"
*  This command gets the device status (stored in its <i>device_status</i> data member) and returns it to the caller.
*
* @return  Status description
*
*/
//+------------------------------------------------------------------
Tango::ConstDevString SingleShotAO::dev_status()
{
	static std::string s = "";
	yat::OSStream oss;
	if (isInitOk)
	{
		CHECK_MANAGER();
		oss << m_manager->get_status() << std::endl;
	}
	else
	{
		oss << m_currStatus.c_str() << std::endl;
	}
	s = oss.str();
	return s.c_str();
}


//+------------------------------------------------------------------
/**
 * Extract the number from a dynamic attribute name with a specific prefix.
 * Used for parsing dynamic attribute names like "channelX", "speedX", "initialX"
 * where X is the channel number.
 * 
 * @param str The input string to search for numbers
 * @param prefix The expected prefix (e.g., "channel", "speed", "initial")
 * @return The number found after the prefix
 * @throws DevFailed if string doesn't start with prefix or no number is found
 */
int extractNumber(const std::string &str, const char* prefix) 
{
	// Validate string starts with the given prefix
	if (str.find(prefix) != 0)
	{
		THROW_DEVFAILED("DEVICE_ERROR",
			"String must start with the expected prefix",
			"SingleShotAO::extractNumber");
	}

	// Find first digit after the prefix
	size_t pos = strlen(prefix);

	// Extract and convert the number 
	std::string numberStr = str.substr(pos);
	if (numberStr.empty() || !isdigit(numberStr[0]))
	{
		THROW_DEVFAILED("DEVICE_ERROR",
			"No number found after prefix",
			"SingleShotAO::extractNumber");
	}

	return std::stoi(numberStr);
}

//+------------------------------------------------------------------
/**
*  method:  SingleShotAO::read_channel
*
*  description:  method to execute "read_channel" for dynamic attributes
*
*/
//+------------------------------------------------------------------
void SingleShotAO::read_channel(yat4tango::DynamicAttributeReadCallbackData & cbd)
{
	yat::AutoMutex<> guard(m_lock);
	std::string l_attr_name = cbd.dya->get_name();
	yat::uint16 l_idx = extractNumber(l_attr_name, kCHANNEL); // extract channel nb

    CHECK_MANAGER();
	double l_val = m_manager->get_channel(l_idx);
	cbd.tga->set_value(&l_val);
}


//+------------------------------------------------------------------
/**
*  method:  SingleShotAO::write_channel
*
*  description:  method to execute "write_channel" for dynamic attributes
*
*/
//+------------------------------------------------------------------
void SingleShotAO::write_channel(yat4tango::DynamicAttributeWriteCallbackData & cbd)
{
	double l_val;
	cbd.tga->get_write_value(l_val);
	cbd.tga->set_write_value(l_val);

	std::string l_attr_name = cbd.dya->get_name();
	yat::uint16 l_idx = extractNumber(l_attr_name, kCHANNEL); // extract channel nb

    CHECK_MANAGER();
	try
	{
		m_manager->write_channel(l_idx, l_val);
	}
	catch(Tango::DevFailed& df)
	{
		ERROR_STREAM << df<< endl;
		RETHROW_DEVFAILED(df,
			"DRIVER_FAILURE",
			"could not write channel [caught Tango::DevFailed]",
			"SingleShotAO::write_channel");
	}
	catch(...)
	{
		ERROR_STREAM << "SingleShotAOManager::write_channel::unknown exception caught"<<std::endl;
		THROW_DEVFAILED("DRIVER_FAILURE",
			"could not write channel [unknown error]",
			"SingleShotAO::write_channel");
	}
	DEBUG_STREAM << "SingleShotAO::write_channel(): channel " << l_idx << " value set to " << l_val << endl;

	yat4tango::PropertyHelper::set_memorized_attribute(this, l_attr_name, l_val);
	
	// Update the initial attribute to match the channel value
	std::string initialAttrName = kINITIAL + std::to_string(l_idx);
	yat4tango::PropertyHelper::set_memorized_attribute(this, initialAttrName, l_val);
	setDynamicAttributeWriteValue(initialAttrName, l_val);
	
	DEBUG_STREAM << "SingleShotAO::write_channel(): memorized attribute " << l_attr_name << " set to " << l_val << endl;
}


//+------------------------------------------------------------------
/**
*  method:  SingleShotAO::read_speed
*
*  description:  method to execute "read_speed" for dynamic attributes
*
*/
//+------------------------------------------------------------------
void SingleShotAO::read_speed(yat4tango::DynamicAttributeReadCallbackData & cbd)
{
	yat::AutoMutex<> guard(m_lock);
	std::string l_attr_name = cbd.dya->get_name();
	yat::uint16 l_idx = extractNumber(l_attr_name, kSPEED); // extract channel nb

    CHECK_MANAGER();
	double l_val = m_manager->get_speed(l_idx);
	cbd.tga->set_value(&l_val);
}


//+------------------------------------------------------------------
/**
*  method:  SingleShotAO::write_speed
*
*  description:  method to execute "write_speed" for dynamic attributes
*
*/
//+------------------------------------------------------------------
void SingleShotAO::write_speed(yat4tango::DynamicAttributeWriteCallbackData & cbd)
{
	DEBUG_STREAM << "SingleShotAO::write_speed(): entering... !" << endl;

	double l_val;
	cbd.tga->get_write_value(l_val);

	std::string l_attr_name = cbd.dya->get_name();
	yat::uint16 l_idx = extractNumber(l_attr_name, kSPEED); // extract channel nb
	if (l_val < 0)
	{
		l_val = -l_val;
	}

	CHECK_MANAGER();
	try
	{
		m_manager->set_speed(l_idx, l_val);
	}
	catch(Tango::DevFailed& df)
	{
		ERROR_STREAM << df<< endl;
		RETHROW_DEVFAILED(df,
			"DRIVER_FAILURE",
			"could not write speed [caught Tango::DevFailed]",
			"SingleShotAO::write_speed");
	}
	catch(...)
	{
		ERROR_STREAM << "SingleShotAO::write_speed::unknown exception caught" << std::endl;
		THROW_DEVFAILED("DRIVER_FAILURE",
			"could not write speed [unknown error]",
			"SingleShotAO::write_speed");
	}

	yat4tango::PropertyHelper::set_memorized_attribute(this, l_attr_name, l_val);
}


//+------------------------------------------------------------------
/**
*  method:  SingleShotAO::read_initial
*
*  description:  method to execute "read_initial" for dynamic attributes
*
*/
//+------------------------------------------------------------------
void SingleShotAO::read_initial(yat4tango::DynamicAttributeReadCallbackData & cbd)
{
	yat::AutoMutex<> guard(m_lock);
	std::string l_attr_name = cbd.dya->get_name();
	yat::uint16 l_idx = extractNumber(l_attr_name, kINITIAL); // extract channel nb

	CHECK_MANAGER();
	double l_val = m_manager->get_initial(l_idx);
	cbd.tga->set_value(&l_val);
}


//+------------------------------------------------------------------
/**
*  method:  SingleShotAO::write_initial
*
*  description:  method to execute "write_initial" for dynamic attributes
*
*/
//+------------------------------------------------------------------
void SingleShotAO::write_initial(yat4tango::DynamicAttributeWriteCallbackData & cbd)
{
	DEBUG_STREAM << "SingleShotAO::write_initial(): entering... !" << endl;

	double l_val;
	cbd.tga->get_write_value(l_val);

	std::string l_attr_name = cbd.dya->get_name();
	yat::uint16 l_idx = extractNumber(l_attr_name, kINITIAL); // extract channel nb

	CHECK_MANAGER();
	try
	{
		m_manager->set_initial(l_idx, l_val);
	}
	catch(Tango::DevFailed& df)
	{
		ERROR_STREAM << df<< endl;
		RETHROW_DEVFAILED(df,
			"DRIVER_FAILURE",
			"could not write initial [caught Tango::DevFailed]",
			"SingleShotAO::write_initial");
	}
	catch(...)
	{
		ERROR_STREAM << "SingleShotAO::write_initial::unknown exception caught"<<std::endl;
		THROW_DEVFAILED("DRIVER_FAILURE",
			"could not write initial [unknown error]",
			"SingleShotAO::write_initial");
	}

	yat4tango::PropertyHelper::set_memorized_attribute(this, l_attr_name, l_val);
}


//+------------------------------------------------------------------
/**
 * set the write value of a dynamic attribute
 * used to keep read and write values in sync
 */
bool SingleShotAO::setDynamicAttributeWriteValue(const std::string& attrName, double value)
{
    try
	{
        Tango::DeviceImpl* dev = static_cast<Tango::DeviceImpl*>(this);
        Tango::DevDouble val_to_write = value;
        
        // Get the attribute
        Tango::WAttribute& attr = dev->get_device_attr()->get_w_attr_by_name(attrName.c_str());
        // Set the write value
        attr.set_write_value(&val_to_write, 1);
        DEBUG_STREAM << "Set write value for " << attrName << " to " << value << endl;
        return true;
    }
    catch (Tango::DevFailed &df)
	{
        ERROR_STREAM << "Failed to set write value for " << attrName 
                    << ": " << df << endl;
        return false;
    }
    catch (...)
	{
        ERROR_STREAM << "Unknown exception setting write value for " 
                    << attrName << endl;
        return false;
    }
}


//+------------------------------------------------------------------
/**
 *	method:	SingleShotAO::abort
 *
 *	description:	method to execute "Abort"
 *	Aborts ramps in progress.
 *
 */
//+------------------------------------------------------------------
void SingleShotAO::abort()
{
	DEBUG_STREAM << "SingleShotAO::abort(): entering... !" << endl;
	try
	{
		_abort();
	}
	catch(Tango::DevFailed& df)
	{
		ERROR_STREAM << df<< endl;
		RETHROW_DEVFAILED(df,
			"DRIVER_FAILURE",
			"could not abort [caught Tango::DevFailed]",
			"SingleShotAO::abort");
	}
	catch(...)
	{
		ERROR_STREAM << "SingleShotAO::abort::unknown exception caught"<< std::endl;
		THROW_DEVFAILED("DRIVER_FAILURE",
			"could not abort [unknown error]",
			"SingleShotAO::abort");
	}
}

void SingleShotAO::_abort()
{
	CHECK_MANAGER();

	// memorize the current initial_values and value of channels
	for (unsigned int l_cpt = 0; l_cpt < m_nb_chan; l_cpt++)
	{
		if (m_manager->is_running(l_cpt))
		{
			DEBUG_STREAM << "Channel " << l_cpt << " is running. Memorizing values..." << std::endl;

			double l_val_channel = m_manager->get_channel(l_cpt);
			std::string l_channel_attr_name = kCHANNEL + std::to_string(l_cpt);
			yat4tango::PropertyHelper::set_memorized_attribute(this, l_channel_attr_name, l_val_channel);
			setDynamicAttributeWriteValue(l_channel_attr_name, l_val_channel);
			DEBUG_STREAM << "Memorizing " << l_channel_attr_name << " to " << l_val_channel << std::endl;

			std::string l_initial_attr_name = kINITIAL + std::to_string(l_cpt);
			yat4tango::PropertyHelper::set_memorized_attribute(this, l_initial_attr_name, l_val_channel);
			setDynamicAttributeWriteValue(l_initial_attr_name, l_val_channel);
			DEBUG_STREAM << "Memorizing " << l_initial_attr_name << " to " << l_val_channel << std::endl;
		}
	}
	m_manager->abort();
}

}	//	namespace