// ============================================================================
//
// = CONTEXT
//    TANGO Project - Abstract Electrometer Class Support Library
//
// = FILENAME
//    AbstractElectrometerClass.cpp
//
// = AUTHOR
//    X. Elattaoui
//
// $Author: xavela $
//
// $Revision: 1.3 $
//
// $Log: not supported by cvs2svn $
// Revision 1.2  2007/11/27 10:17:46  xavela
// xavier :
// - modif done on Novelec part :
// init_MCCE2() added
//
// Revision 1.1  2007/07/09 13:20:37  stephle
// initial import
//
//
// ============================================================================

// ============================================================================
// DEPENDENCIES
// ============================================================================
#include <iostream>
#include <sstream>
#include <string>
#include <Xstring.h>
#include "AbstractElectrometerClass.h"
#include "ElectrometerException.h"

// ============================================================================
// AbstractElectrometerClass::AbstractElectrometerClass
// ============================================================================
AbstractElectrometerClass::AbstractElectrometerClass (std::string comLink_device_name)
:	_device_proxy_name(comLink_device_name),
	_range(0),
	_rangeStr("NOT INITIALISED")
{
//	std::cout << "AbstractElectrometerClass::AbstractElectrometerClass <-" << std::endl;


//	std::cout << "AbstractElectrometerClass::AbstractElectrometerClass ->" << std::endl;
}

// ============================================================================
// AbstractElectrometerClass::~AbstractElectrometerClass
// ============================================================================
AbstractElectrometerClass::~AbstractElectrometerClass (void)
{
//	std::cout << "AbstractElectrometerClass::~AbstractElectrometerClass <-" << std::endl;

	if(_electrometerProtocol)
	{
		delete _electrometerProtocol;
		_electrometerProtocol = 0;
	}

//	std::cout << "AbstractElectrometerClass::~AbstractElectrometerClass ->" << std::endl;
}


// ============================================================================
// AbstractElectrometerClass::zero_check_on
// ============================================================================
void AbstractElectrometerClass::zero_check_on (void) 
{
	//- send command
	_electrometerProtocol->zero_check_on( );
}
// ============================================================================
// AbstractElectrometerClass::zero_check_off
// ============================================================================
void AbstractElectrometerClass::zero_check_off (void) 
{
	//- send command
	_electrometerProtocol->zero_check_off( );
}

// ============================================================================
// AbstractElectrometerClass::zero_correct_on
// ============================================================================
void AbstractElectrometerClass::zero_correct_on (void) 
{
	//- send command
	_electrometerProtocol->zero_correct_on( );
}

// ============================================================================
// AbstractElectrometerClass::zero_correct_off
// ============================================================================
void AbstractElectrometerClass::zero_correct_off (void) 
{
	//- send command
	_electrometerProtocol->zero_correct_off( );
}

// ============================================================================
// AbstractElectrometerClass::autoRange_ON
// ============================================================================
void AbstractElectrometerClass::autoRange_on (void) 
{
	_electrometerProtocol->autoRange_on( );
}

// ============================================================================
// AbstractElectrometerClass::autoRange_OFF
// ============================================================================
void AbstractElectrometerClass::autoRange_off (void) 
{
	_electrometerProtocol->autoRange_off( );
}

// ============================================================================
// AbstractElectrometerClass::auto_zero_on
// ============================================================================
void AbstractElectrometerClass::auto_zero_on (void) 
{
	_electrometerProtocol->auto_zero_on( );
}

// ============================================================================
// AbstractElectrometerClass::auto_zero_off
// ============================================================================
void AbstractElectrometerClass::auto_zero_off (void) 
{
	_electrometerProtocol->auto_zero_off( );
}

// ============================================================================
// AbstractElectrometerClass::init_keithley
// ============================================================================
void AbstractElectrometerClass::init_keithley (void) 
{
	_electrometerProtocol->init_keithley( );
}

// ============================================================================
// AbstractElectrometerClass::set_knplc
// ============================================================================
void AbstractElectrometerClass::set_knplc (std::string nplcValueStr) 
{
	_electrometerProtocol->set_knplc(nplcValueStr);
}

// ============================================================================
// AbstractElectrometerClass::get_knplc
// ============================================================================
std::string AbstractElectrometerClass::get_knplc (void) 
{
	return _electrometerProtocol->get_knplc( );
}

// ============================================================================
// AbstractElectrometerClass::set_triggercount
// ============================================================================
void AbstractElectrometerClass::set_triggercount (std::string trigCountStr) 
{
	_electrometerProtocol->set_triggercount(trigCountStr);
}

// ============================================================================
// AbstractElectrometerClass::get_triggercount
// ============================================================================
std::string AbstractElectrometerClass::get_triggercount (void) 
{
	return _electrometerProtocol->get_triggercount( );
}

// ============================================================================
// AbstractElectrometerClass::set_triggerdelay
// ============================================================================
void AbstractElectrometerClass::set_triggerdelay (std::string trigDelStr) 
{
	_electrometerProtocol->set_triggerdelay(trigDelStr);
}

// ============================================================================
// AbstractElectrometerClass::get_triggerdelay
// ============================================================================
std::string AbstractElectrometerClass::get_triggerdelay (void) 
{
	return _electrometerProtocol->get_triggerdelay( );
}

// ============================================================================
// AbstractElectrometerClass::set_triggerdelayAuto
// ============================================================================
void AbstractElectrometerClass::set_triggerdelayAuto (std::string trigDelAutoStr) 
{
	_electrometerProtocol->set_triggerdelayAuto(trigDelAutoStr);
}

// ============================================================================
// AbstractElectrometerClass::get_triggerdelayAuto
// ============================================================================
std::string AbstractElectrometerClass::get_triggerdelayAuto (void) 
{
	return _electrometerProtocol->get_triggerdelayAuto( );
}

// ============================================================================
// AbstractElectrometerClass::set_averagecount
// ============================================================================
void AbstractElectrometerClass::set_averagecount (std::string averCountStr) 
{
	_electrometerProtocol->set_averagecount(averCountStr);
}

// ============================================================================
// AbstractElectrometerClass::get_averagecount
// ============================================================================
std::string AbstractElectrometerClass::get_averagecount (void) 
{
	return _electrometerProtocol->get_averagecount( );
}

// ============================================================================
// AbstractElectrometerClass::set_averagecontrol
// ============================================================================
void AbstractElectrometerClass::set_averagecontrol (std::string averCtrlStr) 
{
	_electrometerProtocol->set_averagecontrol(averCtrlStr);
}

// ============================================================================
// AbstractElectrometerClass::get_averagecontrol
// ============================================================================
std::string AbstractElectrometerClass::get_averagecontrol (void) 
{
	return _electrometerProtocol->get_averagecontrol( );
}

// ============================================================================
// AbstractElectrometerClass::clear_registers
// ============================================================================
void AbstractElectrometerClass::clear_registers (void) 
{
	_electrometerProtocol->clear_registers();
}

// ============================================================================
// AbstractElectrometerClass::averageStateON
// ============================================================================
void AbstractElectrometerClass::averageStateON (void) 
{
	_electrometerProtocol->averageStateON();
}

// ============================================================================
// AbstractElectrometerClass::averageStateOFF
// ============================================================================
void AbstractElectrometerClass::averageStateOFF (void) 
{
	_electrometerProtocol->averageStateOFF();
}

// ============================================================================
// AbstractElectrometerClass::get_value
// ============================================================================
std::string AbstractElectrometerClass::get_value (void) 
{
	std::string argout("no data");
	argout = _electrometerProtocol->get_value( );

	return argout;
}

// ============================================================================
// AbstractElectrometerClass::get_integratedValue
// ============================================================================
std::vector<double> AbstractElectrometerClass::get_integratedValue (void) 
{
	return _electrometerProtocol->get_integratedValue( );
}

// ============================================================================
// AbstractElectrometerClass::get_fetchValue
// ============================================================================
std::vector<double> AbstractElectrometerClass::get_fetchValue (void) 
{
	return _electrometerProtocol->get_fetchValue( );
}

// ============================================================================
// AbstractElectrometerClass::reset
// ============================================================================
void AbstractElectrometerClass::reset (void) 
{
	_electrometerProtocol->reset( );
}

// ============================================================================
// AbstractElectrometerClass::local
// ============================================================================
void AbstractElectrometerClass::local (void) 
{
	_electrometerProtocol->local( );
}

// ============================================================================
// AbstractElectrometerClass::remote
// ============================================================================
void AbstractElectrometerClass::remote (void) 
{
	_electrometerProtocol->remote( );
}

// ============================================================================
// AbstractElectrometerClass::get_ElectroMeterMode
// ============================================================================
std::string AbstractElectrometerClass::get_ElectroMeterMode (void)
{ 
	return _electrometerProtocol->get_mode( );	
}

// ============================================================================
// AbstractElectrometerClass::get_ElectroMeterRange
// ============================================================================
std::string AbstractElectrometerClass::get_ElectroMeterRange (void)
{ 
	return _electrometerProtocol->get_range( );	
}

// ============================================================================
// AbstractElectrometerClass::get_ElectroMeterRange
// ============================================================================
bool AbstractElectrometerClass::get_overloadRangeState (void)
{ 
	return _electrometerProtocol->get_overloadRangeState( );	
}

// ============================================================================
// AbstractElectrometerClass::electrometer_status
// ============================================================================
std::string AbstractElectrometerClass::electrometer_status (void) 
{
	/**
	*	This command is sent for SCPI devices only, so the SCPI State is updated here
	*/
	std::string argout("no data");
	
	try
	{
		argout = _electrometerProtocol->get_raw_status( );
		//- if no error the error code is 0
		if( XString<short>::convertFromString(&argout[0]) == ON)
			set_electroState(ON);
		else
			set_electroState(ALARM);
	}
	catch(...)
	{
		set_electroState(FAULT);
		throw;
	}

	return argout;
}

// ============================================================================
// AbstractElectrometerClass::set_buffer_size
// ============================================================================
void AbstractElectrometerClass::set_buffer_size (void) 
{
  _electrometerProtocol->set_buffer_size();
}

// ============================================================================
// AbstractElectrometerClass::clear_buffer
// ============================================================================
void AbstractElectrometerClass::clear_buffer (void) 
{
  _electrometerProtocol->clear_buffer();
}

// ============================================================================
// AbstractElectrometerClass::store_raw_input
// ============================================================================
void AbstractElectrometerClass::store_raw_input (void) 
{
  _electrometerProtocol->store_raw_input();
}

// ============================================================================
// AbstractElectrometerClass::start_storing
// ============================================================================
void AbstractElectrometerClass::start_storing (void) 
{
  _electrometerProtocol->start_storing();
}

// ============================================================================
// AbstractElectrometerClass::enable_SRQBufferFull
// ============================================================================
void AbstractElectrometerClass::enable_SRQBufferFull (void) 
{
  _electrometerProtocol->enable_SRQBufferFull();
}

// ============================================================================
// AbstractElectrometerClass::disable_SRQBufferFull
// ============================================================================
void AbstractElectrometerClass::disable_SRQBufferFull (void) 
{
  _electrometerProtocol->disable_SRQBufferFull();
}

// ============================================================================
// AbstractElectrometerClass::readStatusByteRegister
// ============================================================================
std::string AbstractElectrometerClass::readStatusByteRegister (void) 
{
  return _electrometerProtocol->readStatusByteRegister();
}

// ============================================================================
// AbstractElectrometerClass::MODE -> Ampere, Volt, Ohm, Coulomb and V on I meters
// The general case is that following functions are not supported
//	When supported by a particular electrometer, these methods must be defined in the 
// corresponding electrometer class
// ============================================================================
// ============================================================================
// AbstractElectrometerClass::setAmperMeterMode
// ============================================================================
void AbstractElectrometerClass::setAmperMeterMode (void) 
{
	_electrometerProtocol->setAmperMeterMode( );
/*	throw electrometer::ElectrometerException("COMMAND_NOT_SUPPORTED", 
											"This Electrometer does not support this command.",
											"AbstractElectrometerClass::setAmperMeterMode( ).");
*/}

// ============================================================================
// AbstractElectrometerClass::setVoltMeterMode
// ============================================================================
void AbstractElectrometerClass::setVoltMeterMode (void) 
{
	_electrometerProtocol->setVoltMeterMode( );
/*	throw electrometer::ElectrometerException("COMMAND_NOT_SUPPORTED", 
											"This Electrometer does not support this command.",
											"AbstractElectrometerClass::setAmperMeterMode( ).");
*/}

// ============================================================================
// AbstractElectrometerClass::setOhmMeterMode
// ============================================================================
void AbstractElectrometerClass::setOhmMeterMode (void) 
{
	_electrometerProtocol->setOhmMeterMode( );
/*	throw electrometer::ElectrometerException("COMMAND_NOT_SUPPORTED", 
											"This Electrometer does not support this command.",
											"AbstractElectrometerClass::setAmperMeterMode( ).");
*/}


// ============================================================================
// AbstractElectrometerClass::setCoulombMeterMode
// ============================================================================
void AbstractElectrometerClass::setCoulombMeterMode (void) 
{
	_electrometerProtocol->setCoulombMeterMode( );
/*	throw electrometer::ElectrometerException("COMMAND_NOT_SUPPORTED", 
											"This Electrometer does not support this command.",
											"AbstractElectrometerClass::setAmperMeterMode( ).");
*/}

// ============================================================================
// AbstractElectrometerClass::get_ElectroMeterPolarity
// ============================================================================
std::string AbstractElectrometerClass::get_ElectroMeterPolarity (void) 
{
	return _electrometerProtocol->get_polarity( );
}

// ============================================================================
// AbstractElectrometerClass::get_ElectroMeterFrequency
// ============================================================================
std::string AbstractElectrometerClass::get_ElectroMeterFrequency (void) 
{
	return _electrometerProtocol->get_frequency( );
}

// ============================================================================
// AbstractElectrometerClass::get_ElectroMeterGain
// ============================================================================
std::string AbstractElectrometerClass::get_ElectroMeterGain (void) 
{
	return _electrometerProtocol->get_gain( );
}

// ============================================================================
// AbstractElectrometerClass::set_ElectroMeterPolarity
// ============================================================================
void AbstractElectrometerClass::set_ElectroMeterPolarity (std::string pola) 
{
	_electrometerProtocol->set_polarity(pola);
}

// ============================================================================
// AbstractElectrometerClass::set_ElectroMeterFrequency
// ============================================================================
void AbstractElectrometerClass::set_ElectroMeterFrequency (std::string freq) 
{
	_electrometerProtocol->set_frequency(freq);
}

// ============================================================================
// AbstractElectrometerClass::set_ElectroMeterGain
// ============================================================================
void AbstractElectrometerClass::set_ElectroMeterGain (std::string gain) 
{
	_electrometerProtocol->set_gain(gain);
}

// ============================================================================
// AbstractElectrometerClass::set_Zero_VonF_function
// ============================================================================
void AbstractElectrometerClass::set_Zero_VonF_function (void) 
{
	_electrometerProtocol->unable_zeroVF_func( );
}

// ============================================================================
// AbstractElectrometerClass::set_Offset_ZeroV1_function
// ============================================================================
void AbstractElectrometerClass::set_Offset_ZeroV1_function (void) 
{
	_electrometerProtocol->unable_offset_zeroV1_func( );
}

// ============================================================================
// AbstractElectrometerClass::set_Leakage_ZeroV2_function
// ============================================================================
void AbstractElectrometerClass::set_Leakage_ZeroV2_function (void) 
{
	_electrometerProtocol->unable_leakage_zeroV2_func( );
}

// ============================================================================
// AbstractElectrometerClass::set_Test_function
// ============================================================================
void AbstractElectrometerClass::set_Test_function (void) 
{
	_electrometerProtocol->unable_test_func( );
}

// ============================================================================
// AbstractElectrometerClass::set_Measure_function
// ============================================================================
void AbstractElectrometerClass::set_Measure_function (void) 
{
	_electrometerProtocol->unable_measure_func( );
}

// ============================================================================
// AbstractElectrometerClass::mcce_on
// ============================================================================
void AbstractElectrometerClass::mcce_on (void) 
{
	_electrometerProtocol->switch_MCCE2_ON( );
}

// ============================================================================
// AbstractElectrometerClass::mcce_off
// ============================================================================
void AbstractElectrometerClass::mcce_off (void) 
{
	_electrometerProtocol->switch_MCCE2_OFF( );
}

// ============================================================================
// AbstractElectrometerClass::mcce_init
// ============================================================================
void AbstractElectrometerClass::mcce_init (void) 
{
	_electrometerProtocol->init_MCCE2_for_communication( );
}