/******************************************************************************
 *                                                                         
 *               Nimbus auto-generated file
 *               !!! WARNING !!! -- DO NOT DIRECTLY EDIT THE CONTENTS OF THIS FILE.
 *				 Changes will be OVERWRITTEN by NIMBUS.
 *
 *****************************************************************************/
#include "StdAfx.h"
#include "CoAgilent34952A.h"


HRESULT IAgilent34952A_get_DAC(Agilent34952A* pT, IAgilent34952ADAC** val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952A"), _T("get_DAC"));
	NTL_METHOD_START(IAgilent34952A, get_DAC);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DAC"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34952A"), _T("get_DAC"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952A_get_DAC(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952A_get_Digital(Agilent34952A* pT, IAgilent34952ADigital** val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952A"), _T("get_Digital"));
	NTL_METHOD_START(IAgilent34952A, get_Digital);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Digital"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34952A"), _T("get_Digital"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952A_get_Digital(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952A_get_Totalize(Agilent34952A* pT, IAgilent34952ATotalize** val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952A"), _T("get_Totalize"));
	NTL_METHOD_START(IAgilent34952A, get_Totalize);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Totalize"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34952A"), _T("get_Totalize"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952A_get_Totalize(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADAC_get_Voltage(Agilent34952A* pT, BSTR ChannelList, double* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADAC"), _T("get_Voltage"));
	NTL_METHOD_START(IAgilent34952ADAC, get_Voltage);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Voltage"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34952ADAC"), _T("get_Voltage"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":SOUR:VOLT? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADAC_get_Voltage(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADAC_put_Voltage(Agilent34952A* pT, BSTR ChannelList, double val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADAC"), _T("put_Voltage"));
	NTL_METHOD_START(IAgilent34952ADAC, put_Voltage);
	CMethodTrace mt(pT, _T("IAgilent34952ADAC"), _T("put_Voltage"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":SOUR:VOLT %.15g, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADAC_put_Voltage(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_Configure(Agilent34952A* pT, BSTR ChannelList, Agilent34952ADigitalModeEnum Mode, Agilent34952ADirectionEnum Direction)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("Configure"));
	NTL_METHOD_START(IAgilent34952ADigital, Configure);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Mode), IN_PARAM(Direction), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CONF:DIG:WIDTH %s, (@%s); :CONF:DIG:STAT %s, (@%s)"), pT->EnumToString<Agilent34952ADigitalModeEnum>(Mode), LPCTSTR(COLE2T(ChannelList)), pT->EnumToString<Agilent34952ADirectionEnum>(Direction), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_Configure(ChannelList, Mode, Direction);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_QueryLastByte(Agilent34952A* pT, BSTR ChannelList, BYTE* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("QueryLastByte"));
	NTL_METHOD_START(IAgilent34952ADigital, QueryLastByte);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("QueryLastByte"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("QueryLastByte"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":SOUR:DIG:DATA? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_QueryLastByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_QueryLastWord(Agilent34952A* pT, BSTR ChannelList, short* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("QueryLastWord"));
	NTL_METHOD_START(IAgilent34952ADigital, QueryLastWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("QueryLastWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("QueryLastWord"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":SOUR:DIG:DATA:WORD? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_QueryLastWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_ReadBit(Agilent34952A* pT, BSTR ChannelList, long BitNumber, VARIANT_BOOL* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("ReadBit"));
	NTL_METHOD_START(IAgilent34952ADigital, ReadBit);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadBit"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("ReadBit"), IN_PARAM(ChannelList), IN_PARAM(BitNumber), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":DIG:DATA:BIT? %d, (@%s)"), BitNumber, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_ReadBit(ChannelList, BitNumber, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_ReadByte(Agilent34952A* pT, BSTR ChannelList, BYTE* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("ReadByte"));
	NTL_METHOD_START(IAgilent34952ADigital, ReadByte);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadByte"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("ReadByte"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":DIG:DATA:BYTE? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_ReadByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_ReadWord(Agilent34952A* pT, BSTR ChannelList, short* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("ReadWord"));
	NTL_METHOD_START(IAgilent34952ADigital, ReadWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("ReadWord"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":DIG:DATA:WORD? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_ReadWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_ReadLongWord(Agilent34952A* pT, BSTR ChannelList, long* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("ReadLongWord"));
	NTL_METHOD_START(IAgilent34952ADigital, ReadLongWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadLongWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("ReadLongWord"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":DIG:DATA:LWOR? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_ReadLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_WriteBit(Agilent34952A* pT, BSTR ChannelList, long BitNumber, long Data)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("WriteBit"));
	NTL_METHOD_START(IAgilent34952ADigital, WriteBit);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("WriteBit"), IN_PARAM(ChannelList), IN_PARAM(BitNumber), IN_PARAM(Data), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":SOUR:DIG:DATA:BIT %d,%d, (@%s)"), Data, BitNumber, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_WriteBit(ChannelList, BitNumber, Data);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_WriteByte(Agilent34952A* pT, BSTR ChannelList, BYTE Data)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("WriteByte"));
	NTL_METHOD_START(IAgilent34952ADigital, WriteByte);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("WriteByte"), IN_PARAM(ChannelList), IN_PARAM(Data), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":SOUR:DIG:DATA %d, (@%s)"), Data, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_WriteByte(ChannelList, Data);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_WriteWord(Agilent34952A* pT, BSTR ChannelList, short Data)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("WriteWord"));
	NTL_METHOD_START(IAgilent34952ADigital, WriteWord);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("WriteWord"), IN_PARAM(ChannelList), IN_PARAM(Data), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":SOUR:DIG:DATA:WORD %d, (@%s)"), Data, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_WriteWord(ChannelList, Data);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_WriteLongWord(Agilent34952A* pT, BSTR ChannelList, long Data)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("WriteLongWord"));
	NTL_METHOD_START(IAgilent34952ADigital, WriteLongWord);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("WriteLongWord"), IN_PARAM(ChannelList), IN_PARAM(Data), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":SOUR:DIG:DATA:LWOR %d, (@%s)"), Data, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_WriteLongWord(ChannelList, Data);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonData(Agilent34952A* pT, BSTR ChannelList, BYTE* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonData"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonData);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonData"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonData"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:DATA? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonData(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonData(Agilent34952A* pT, BSTR ChannelList, BYTE val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonData"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonData);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonData"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:DATA %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonData(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonEnable(Agilent34952A* pT, BSTR ChannelList, VARIANT_BOOL* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonEnable"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonEnable);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonEnable"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonEnable"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:STAT? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonEnable(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonEnable(Agilent34952A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonEnable"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonEnable);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonEnable"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:STAT %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonEnable(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonMask(Agilent34952A* pT, BSTR ChannelList, long* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonMask"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonMask);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonMask"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonMask"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:MASK? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonMask(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonMask(Agilent34952A* pT, BSTR ChannelList, long val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonMask"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonMask);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonMask"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:MASK %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonMask(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonType(Agilent34952A* pT, BSTR ChannelList, Agilent34952AComparisonTypeEnum* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonType"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonType"), _T("val"));
		*val = Agilent34952AComparisonTypeEqual;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonType"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:TYPE? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonType(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonType(Agilent34952A* pT, BSTR ChannelList, Agilent34952AComparisonTypeEnum val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonType"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonType);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonType"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:TYPE %s, (@%s)"), pT->EnumToString<Agilent34952AComparisonTypeEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonType(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_State(Agilent34952A* pT, BSTR ChannelList, VARIANT_BOOL* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_State"));
	NTL_METHOD_START(IAgilent34952ADigital, get_State);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_State"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_State"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":SOUR:DIG:STAT? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_State(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_Direction(Agilent34952A* pT, BSTR ChannelList, Agilent34952ADirectionEnum* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_Direction"));
	NTL_METHOD_START(IAgilent34952ADigital, get_Direction);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Direction"), _T("val"));
		*val = Agilent34952ADirectionInput;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_Direction"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T("CONF:DIG:STAT? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_Direction(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_Direction(Agilent34952A* pT, BSTR ChannelList, Agilent34952ADirectionEnum val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_Direction"));
	NTL_METHOD_START(IAgilent34952ADigital, put_Direction);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_Direction"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T("CONF:DIG:STAT %s, (@%s)"), pT->EnumToString<Agilent34952ADirectionEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_Direction(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonDataByte(Agilent34952A* pT, BSTR ChannelList, BYTE* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonDataByte"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonDataByte);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonDataByte"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonDataByte"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:DATA:BYTE? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonDataByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonDataByte(Agilent34952A* pT, BSTR ChannelList, BYTE val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonDataByte"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonDataByte);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonDataByte"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:DATA:BYTE %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonDataByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonDataWord(Agilent34952A* pT, BSTR ChannelList, short* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonDataWord"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonDataWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonDataWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonDataWord"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:DATA:WORD? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonDataWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonDataWord(Agilent34952A* pT, BSTR ChannelList, short val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonDataWord"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonDataWord);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonDataWord"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:DATA:WORD %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonDataWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonDataLongWord(Agilent34952A* pT, BSTR ChannelList, long* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonDataLongWord"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonDataLongWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonDataLongWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonDataLongWord"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:DATA:LWOR? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonDataLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonDataLongWord(Agilent34952A* pT, BSTR ChannelList, long val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonDataLongWord"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonDataLongWord);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonDataLongWord"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:DATA:LWOR %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonDataLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonMaskByte(Agilent34952A* pT, BSTR ChannelList, BYTE* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonMaskByte"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonMaskByte);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonMaskByte"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonMaskByte"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:MASK:BYTE? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonMaskByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonMaskByte(Agilent34952A* pT, BSTR ChannelList, BYTE val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonMaskByte"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonMaskByte);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonMaskByte"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:MASK:BYTE %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonMaskByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonMaskWord(Agilent34952A* pT, BSTR ChannelList, short* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonMaskWord"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonMaskWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonMaskWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonMaskWord"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:MASK:WORD? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonMaskWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonMaskWord(Agilent34952A* pT, BSTR ChannelList, short val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonMaskWord"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonMaskWord);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonMaskWord"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:MASK:WORD %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonMaskWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_get_ComparisonMaskLongWord(Agilent34952A* pT, BSTR ChannelList, long* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("get_ComparisonMaskLongWord"));
	NTL_METHOD_START(IAgilent34952ADigital, get_ComparisonMaskLongWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonMaskLongWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("get_ComparisonMaskLongWord"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:MASK:LWOR? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_get_ComparisonMaskLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ADigital_put_ComparisonMaskLongWord(Agilent34952A* pT, BSTR ChannelList, long val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ADigital"), _T("put_ComparisonMaskLongWord"));
	NTL_METHOD_START(IAgilent34952ADigital, put_ComparisonMaskLongWord);
	CMethodTrace mt(pT, _T("IAgilent34952ADigital"), _T("put_ComparisonMaskLongWord"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CALC:COMP:MASK:LWOR %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ADigital_put_ComparisonMaskLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ATotalize_ClearTotal(Agilent34952A* pT, BSTR ChannelList)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ATotalize"), _T("ClearTotal"));
	NTL_METHOD_START(IAgilent34952ATotalize, ClearTotal);
	CMethodTrace mt(pT, _T("IAgilent34952ATotalize"), _T("ClearTotal"), IN_PARAM(ChannelList), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":TOT:CLE:IMM (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ATotalize_ClearTotal(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ATotalize_Configure(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeTypeEnum Type, Agilent34952ATotalizeThresholdModeEnum Mode, Agilent34952ATotalizeSlopeEnum Slope)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ATotalize"), _T("Configure"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IAgilent34952ATotalize, Configure);
	CMethodTrace mt(pT, _T("IAgilent34952ATotalize"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Type), IN_PARAM(Mode), IN_PARAM(Slope), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":TOT:TYPE %s, (@%s); :TOT:THR %s, (@%s); :TOT:SLOP %s, (@%s)"), pT->EnumToString<Agilent34952ATotalizeTypeEnum>(Type), LPCTSTR(COLE2T(ChannelList)), pT->EnumToString<Agilent34952ATotalizeThresholdModeEnum>(Mode), LPCTSTR(COLE2T(ChannelList)), pT->EnumToString<Agilent34952ATotalizeSlopeEnum>(Slope), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ATotalize_Configure(ChannelList, Type, Mode, Slope);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ATotalize_ReadData(Agilent34952A* pT, BSTR ChannelList, double* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ATotalize"), _T("ReadData"));
	NTL_METHOD_START(IAgilent34952ATotalize, ReadData);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadData"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34952ATotalize"), _T("ReadData"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":TOT:DATA? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ATotalize_ReadData(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ATotalize_get_Mode(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeThresholdModeEnum* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ATotalize"), _T("get_Mode"));
	NTL_METHOD_START(IAgilent34952ATotalize, get_Mode);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Mode"), _T("val"));
		*val = Agilent34952ATotalizeThresholdModeAC;
	CMethodTrace mt(pT, _T("IAgilent34952ATotalize"), _T("get_Mode"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":TOT:THR? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ATotalize_get_Mode(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ATotalize_put_Mode(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeThresholdModeEnum val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ATotalize"), _T("put_Mode"));
	NTL_METHOD_START(IAgilent34952ATotalize, put_Mode);
	CMethodTrace mt(pT, _T("IAgilent34952ATotalize"), _T("put_Mode"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":TOT:THR %s, (@%s)"), pT->EnumToString<Agilent34952ATotalizeThresholdModeEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ATotalize_put_Mode(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ATotalize_get_ReadType(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeTypeEnum* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ATotalize"), _T("get_ReadType"));
	NTL_METHOD_START(IAgilent34952ATotalize, get_ReadType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ReadType"), _T("val"));
		*val = Agilent34952ATotalizeTypeRead;
	CMethodTrace mt(pT, _T("IAgilent34952ATotalize"), _T("get_ReadType"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":TOT:TYPE? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ATotalize_get_ReadType(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ATotalize_put_ReadType(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeTypeEnum val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ATotalize"), _T("put_ReadType"));
	NTL_METHOD_START(IAgilent34952ATotalize, put_ReadType);
	CMethodTrace mt(pT, _T("IAgilent34952ATotalize"), _T("put_ReadType"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":TOT:TYPE %s, (@%s)"), pT->EnumToString<Agilent34952ATotalizeTypeEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ATotalize_put_ReadType(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ATotalize_get_Slope(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeSlopeEnum* val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ATotalize"), _T("get_Slope"));
	NTL_METHOD_START(IAgilent34952ATotalize, get_Slope);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Slope"), _T("val"));
		*val = Agilent34952ATotalizeSlopePositive;
	CMethodTrace mt(pT, _T("IAgilent34952ATotalize"), _T("get_Slope"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":TOT:SLOP? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ATotalize_get_Slope(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34952ATotalize_put_Slope(Agilent34952A* pT, BSTR ChannelList, Agilent34952ATotalizeSlopeEnum val)
{
	Agilent34952A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34952A"), _T("IAgilent34952ATotalize"), _T("put_Slope"));
	NTL_METHOD_START(IAgilent34952ATotalize, put_Slope);
	CMethodTrace mt(pT, _T("IAgilent34952ATotalize"), _T("put_Slope"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":TOT:SLOP %s, (@%s)"), pT->EnumToString<Agilent34952ATotalizeSlopeEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34952ATotalize_put_Slope(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}

