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


HRESULT IAgilent34950AHandshake_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeModeEnum Mode, double Threshold, double Level)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("Configure"));
	NTL_METHOD_START(IAgilent34950AHandshake, Configure);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Mode), IN_PARAM(Threshold), IN_PARAM(Level), NULL);

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

	strCmd.Format(_T(":CONF:DIG:HAND %s, %.15g, %.15g, NORM, (@%s)"), pT->EnumToString<Agilent34950AHandshakeModeEnum>(Mode), Threshold, Level, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AHandshake_Configure(ChannelList, Mode, Threshold, Level);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AHandshake_GetPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineIDEnum Mode, Agilent34950APolarityEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("GetPolarity"));
	NTL_METHOD_START(IAgilent34950AHandshake, GetPolarity);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetPolarity"), _T("val"));
		*val = Agilent34950APolarityNormal;
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("GetPolarity"), IN_PARAM(ChannelList), IN_PARAM(Mode), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":CONF:DIG:HAND:POL? %s, (@%s)"), pT->EnumToString<Agilent34950AHandshakeLineIDEnum>(Mode), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AHandshake_GetPolarity(ChannelList, Mode, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AHandshake_SetPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineIDEnum Mode, Agilent34950APolarityEnum Polarity)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("SetPolarity"));
	NTL_METHOD_START(IAgilent34950AHandshake, SetPolarity);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("SetPolarity"), IN_PARAM(ChannelList), IN_PARAM(Mode), IN_PARAM(Polarity), NULL);

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

	strCmd.Format(_T(":CONF:DIG:HAND:POL %s, %s, (@%s)"), pT->EnumToString<Agilent34950APolarityEnum>(Polarity), pT->EnumToString<Agilent34950AHandshakeLineIDEnum>(Mode), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AHandshake_SetPolarity(ChannelList, Mode, Polarity);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_put_AsyncTimeout(Agilent34950A* pT, BSTR ChannelList, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("put_AsyncTimeout"));
	NTL_METHOD_START(IAgilent34950AHandshake, put_AsyncTimeout);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("put_AsyncTimeout"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CONF:DIG:HAND:ASYN:TIM %.15g, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AHandshake_put_AsyncTimeout(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_put_CycleTime(Agilent34950A* pT, BSTR ChannelList, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("put_CycleTime"));
	NTL_METHOD_START(IAgilent34950AHandshake, put_CycleTime);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("put_CycleTime"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CONF:DIG:HAND:CTIM %.15g, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AHandshake_put_CycleTime(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_put_Level(Agilent34950A* pT, BSTR ChannelList, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("put_Level"));
	NTL_METHOD_START(IAgilent34950AHandshake, put_Level);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("put_Level"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_get_Mode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeModeEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("get_Mode"));
	NTL_METHOD_START(IAgilent34950AHandshake, get_Mode);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Mode"), _T("val"));
		*val = Agilent34950AHandshakeModeAsynchronous;
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("get_Mode"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_put_Mode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeModeEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("put_Mode"));
	NTL_METHOD_START(IAgilent34950AHandshake, put_Mode);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("put_Mode"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_put_Rate(Agilent34950A* pT, BSTR ChannelList, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("put_Rate"));
	NTL_METHOD_START(IAgilent34950AHandshake, put_Rate);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("put_Rate"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CONF:DIG:HAND:RATE %.15g, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AHandshake_put_Rate(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AHandshake_get_State(Agilent34950A* pT, BSTR ChannelList, Agilent34950AStateEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("get_State"));
	NTL_METHOD_START(IAgilent34950AHandshake, get_State);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_State"), _T("val"));
		*val = Agilent34950AStateHiImpedance;
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("get_State"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_put_State(Agilent34950A* pT, BSTR ChannelList, Agilent34950AStateEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("put_State"));
	NTL_METHOD_START(IAgilent34950AHandshake, put_State);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("put_State"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_get_SyncStrobe(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeStrobeSourceEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("get_SyncStrobe"));
	NTL_METHOD_START(IAgilent34950AHandshake, get_SyncStrobe);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SyncStrobe"), _T("val"));
		*val = Agilent34950AHandshakeStrobeSourceInternal;
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("get_SyncStrobe"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_put_SyncStrobe(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeStrobeSourceEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("put_SyncStrobe"));
	NTL_METHOD_START(IAgilent34950AHandshake, put_SyncStrobe);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("put_SyncStrobe"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CONF:DIG:HAND:SYNC:STR %s, (@%s)"), pT->EnumToString<Agilent34950AHandshakeStrobeSourceEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AHandshake_put_SyncStrobe(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_put_Threshold(Agilent34950A* pT, BSTR ChannelList, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("put_Threshold"));
	NTL_METHOD_START(IAgilent34950AHandshake, put_Threshold);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("put_Threshold"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_get_Drive(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("get_Drive"));
	NTL_METHOD_START(IAgilent34950AHandshake, get_Drive);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Drive"), _T("val"));
		*val = Agilent34950AHandshakeLineTypeActive;
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("get_Drive"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AHandshake_put_Drive(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AHandshake"), _T("put_Drive"));
	NTL_METHOD_START(IAgilent34950AHandshake, put_Drive);
	CMethodTrace mt(pT, _T("IAgilent34950AHandshake"), _T("put_Drive"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AInput_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AChannelWidthEnum Width, double Threshold)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInput"), _T("Configure"));
	NTL_METHOD_START(IAgilent34950AInput, Configure);
	CMethodTrace mt(pT, _T("IAgilent34950AInput"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Width), IN_PARAM(Threshold), NULL);

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

	strCmd.Format(_T(":CONF:DIG %s,%.15g,(@%s)"), pT->EnumToString<Agilent34950AChannelWidthEnum>(Width), Threshold, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInput_Configure(ChannelList, Width, Threshold);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AInput_put_Threshold(Agilent34950A* pT, BSTR ChannelList, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInput"), _T("put_Threshold"));
	NTL_METHOD_START(IAgilent34950AInput, put_Threshold);
	CMethodTrace mt(pT, _T("IAgilent34950AInput"), _T("put_Threshold"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AInput_get_Memory(Agilent34950A* pT, IAgilent34950AInputMemory** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInput"), _T("get_Memory"));
	NTL_METHOD_START(IAgilent34950AInput, get_Memory);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Memory"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950AInput"), _T("get_Memory"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AInputMemory_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AActionEnum Action, long Count)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("Configure"));
	NTL_METHOD_START(IAgilent34950AInputMemory, Configure);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Action), IN_PARAM(Count), NULL);

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

	strCmd.Format(_T(":DIG:MEM:COMP:ACT %s, (@%s); :DIG:MEM:SAMP:COUN %d, (@%s); :DIG:MEM:ENAB ON, (@%s)"), pT->EnumToString<Agilent34950AActionEnum>(Action), LPCTSTR(COLE2T(ChannelList)), Count, LPCTSTR(COLE2T(ChannelList)), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_Configure(ChannelList, Action, Count);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_Clear(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("Clear"));
	NTL_METHOD_START(IAgilent34950AInputMemory, Clear);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("Clear"), IN_PARAM(ChannelList), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AInputMemory_InterruptSettings(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL State, Agilent34950AReportConditionEnum Mode, Agilent34950AHandshakeLineTypeEnum Drive)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("InterruptSettings"));
	NTL_METHOD_START(IAgilent34950AInputMemory, InterruptSettings);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("InterruptSettings"), IN_PARAM(ChannelList), IN_PARAM(State), IN_PARAM(Mode), IN_PARAM(Drive), NULL);

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

	strCmd.Format(_T(":DIG:INT:ENAB %s, (@%s);DRIV %s, (@%s);MODE %s, (@%s)"), State == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)), pT->EnumToString<Agilent34950AHandshakeLineTypeEnum>(Drive), LPCTSTR(COLE2T(ChannelList)), pT->EnumToString<Agilent34950AReportConditionEnum>(Mode), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_InterruptSettings(ChannelList, State, Mode, Drive);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_ReadAllData(Agilent34950A* pT, BSTR Channel, SAFEARRAY** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("ReadAllData"));
	NTL_METHOD_START(IAgilent34950AInputMemory, ReadAllData);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadAllData"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("ReadAllData"), IN_PARAM(Channel), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIG:MEM:FORM LIST; DATA:ALL? (@%s)"), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_ReadAllData(Channel, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_ReadSelectedData(Agilent34950A* pT, BSTR Channel, long Index, long Count, SAFEARRAY** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("ReadSelectedData"));
	NTL_METHOD_START(IAgilent34950AInputMemory, ReadSelectedData);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadSelectedData"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("ReadSelectedData"), IN_PARAM(Channel), IN_PARAM(Index), IN_PARAM(Count), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIG:MEM:FORM LIST; DATA? %d, %d, (@%s)"), Index, Count, LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_ReadSelectedData(Channel, Index, Count, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_Start(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("Start"));
	NTL_METHOD_START(IAgilent34950AInputMemory, Start);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("Start"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":DIG:MEM:STAR (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_Start(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_Step(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("Step"));
	NTL_METHOD_START(IAgilent34950AInputMemory, Step);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("Step"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":DIG:MEM:STEP (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_Step(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_Stop(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("Stop"));
	NTL_METHOD_START(IAgilent34950AInputMemory, Stop);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("Stop"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":DIG:MEM:STOP (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_Stop(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_get_CompareAction(Agilent34950A* pT, BSTR ChannelList, Agilent34950AActionEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("get_CompareAction"));
	NTL_METHOD_START(IAgilent34950AInputMemory, get_CompareAction);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_CompareAction"), _T("val"));
		*val = Agilent34950AActionContinue;
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("get_CompareAction"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AInputMemory_put_CompareAction(Agilent34950A* pT, BSTR ChannelList, Agilent34950AActionEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("put_CompareAction"));
	NTL_METHOD_START(IAgilent34950AInputMemory, put_CompareAction);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("put_CompareAction"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIG:MEM:COMP:ACT %s, (@%s)"), pT->EnumToString<Agilent34950AActionEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_put_CompareAction(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_get_DataFormat(Agilent34950A* pT, BSTR Channel, Agilent34950ADataFormatEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("get_DataFormat"));
	NTL_METHOD_START(IAgilent34950AInputMemory, get_DataFormat);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DataFormat"), _T("val"));
		*val = Agilent34950ADataFormatList;
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("get_DataFormat"), IN_PARAM(Channel), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIG:MEM:FORM?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_get_DataFormat(Channel, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_put_DataFormat(Agilent34950A* pT, BSTR Channel, Agilent34950ADataFormatEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("put_DataFormat"));
	NTL_METHOD_START(IAgilent34950AInputMemory, put_DataFormat);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("put_DataFormat"), IN_PARAM(Channel), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIG:MEM:FORM %s"), pT->EnumToString<Agilent34950ADataFormatEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_put_DataFormat(Channel, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_get_DataPoints(Agilent34950A* pT, BSTR Channel, long* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("get_DataPoints"));
	NTL_METHOD_START(IAgilent34950AInputMemory, get_DataPoints);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DataPoints"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("get_DataPoints"), IN_PARAM(Channel), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIG:MEM:POIN? (@%s)"), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_get_DataPoints(Channel, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AInputMemory_put_Enable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("put_Enable"));
	NTL_METHOD_START(IAgilent34950AInputMemory, put_Enable);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("put_Enable"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIG:MEM:ENAB %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_put_Enable(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_get_InterruptMode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AReportConditionEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("get_InterruptMode"));
	NTL_METHOD_START(IAgilent34950AInputMemory, get_InterruptMode);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_InterruptMode"), _T("val"));
		*val = Agilent34950AReportConditionFull;
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("get_InterruptMode"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AInputMemory_put_InterruptMode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AReportConditionEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("put_InterruptMode"));
	NTL_METHOD_START(IAgilent34950AInputMemory, put_InterruptMode);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("put_InterruptMode"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIG:INT:MODE %s, (@%s)"), pT->EnumToString<Agilent34950AReportConditionEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_put_InterruptMode(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AInputMemory_put_InterruptEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("put_InterruptEnable"));
	NTL_METHOD_START(IAgilent34950AInputMemory, put_InterruptEnable);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("put_InterruptEnable"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AInputMemory_get_InterruptPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("get_InterruptPolarity"));
	NTL_METHOD_START(IAgilent34950AInputMemory, get_InterruptPolarity);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_InterruptPolarity"), _T("val"));
		*val = Agilent34950APolarityNormal;
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("get_InterruptPolarity"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AInputMemory_put_InterruptPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("put_InterruptPolarity"));
	NTL_METHOD_START(IAgilent34950AInputMemory, put_InterruptPolarity);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("put_InterruptPolarity"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34950AInputMemory_put_SampleCount(Agilent34950A* pT, BSTR ChannelList, long val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("put_SampleCount"));
	NTL_METHOD_START(IAgilent34950AInputMemory, put_SampleCount);
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("put_SampleCount"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIG:MEM:SAMP:COUN %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AInputMemory_put_SampleCount(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AInputMemory_get_Status(Agilent34950A* pT, BSTR Channel, VARIANT_BOOL* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AInputMemory"), _T("get_Status"));
	NTL_METHOD_START(IAgilent34950AInputMemory, get_Status);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Status"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34950AInputMemory"), _T("get_Status"), IN_PARAM(Channel), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AOutput_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AChannelWidthEnum Width, double VoltageLevel)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutput"), _T("Configure"));
	NTL_METHOD_START(IAgilent34950AOutput, Configure);
	CMethodTrace mt(pT, _T("IAgilent34950AOutput"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Width), IN_PARAM(VoltageLevel), NULL);

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

	strCmd.Format(_T(":CONF:DIG:WIDT %s, (@%s); DIR OUTP,(@%s); :SOUR:DIG:LEV %.15g, (@%s);"), pT->EnumToString<Agilent34950AChannelWidthEnum>(Width), LPCTSTR(COLE2T(ChannelList)), LPCTSTR(COLE2T(ChannelList)), VoltageLevel, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutput_Configure(ChannelList, Width, VoltageLevel);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutput_get_Drive(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutput"), _T("get_Drive"));
	NTL_METHOD_START(IAgilent34950AOutput, get_Drive);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Drive"), _T("val"));
		*val = Agilent34950AHandshakeLineTypeActive;
	CMethodTrace mt(pT, _T("IAgilent34950AOutput"), _T("get_Drive"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AOutput_put_Drive(Agilent34950A* pT, BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutput"), _T("put_Drive"));
	NTL_METHOD_START(IAgilent34950AOutput, put_Drive);
	CMethodTrace mt(pT, _T("IAgilent34950AOutput"), _T("put_Drive"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:DRIV %s, (@%s)"), pT->EnumToString<Agilent34950AHandshakeLineTypeEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutput_put_Drive(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AOutput_put_VoltLevel(Agilent34950A* pT, BSTR ChannelList, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutput"), _T("put_VoltLevel"));
	NTL_METHOD_START(IAgilent34950AOutput, put_VoltLevel);
	CMethodTrace mt(pT, _T("IAgilent34950AOutput"), _T("put_VoltLevel"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AOutput_get_Memory(Agilent34950A* pT, IAgilent34950AOutputMemory** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutput"), _T("get_Memory"));
	NTL_METHOD_START(IAgilent34950AOutput, get_Memory);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Memory"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950AOutput"), _T("get_Memory"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AOutputMemory_Configure(Agilent34950A* pT, BSTR Channel, BSTR TraceName, long Cycles)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("Configure"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, Configure);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("Configure"), IN_PARAM(Channel), IN_PARAM(TraceName), IN_PARAM(Cycles), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:MEM:TRAC %s, (@%s); NCYC %d, (@%s); :SOUR:DIG:MEM:ENAB ON, (@%s)"), LPCTSTR(COLE2T(TraceName)), LPCTSTR(COLE2T(Channel)), Cycles, LPCTSTR(COLE2T(Channel)), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputMemory_Configure(Channel, TraceName, Cycles);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputMemory_Abort(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("Abort"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, Abort);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("Abort"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:MEM:ABOR (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputMemory_Abort(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputMemory_InterruptSettings(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL State, Agilent34950AOutputModeEnum Mode)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("InterruptSettings"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, InterruptSettings);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("InterruptSettings"), IN_PARAM(ChannelList), IN_PARAM(State), IN_PARAM(Mode), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:INT:ENAB %s,(@%s); MODE %s, (@%s);"), State == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)), pT->EnumToString<Agilent34950AOutputModeEnum>(Mode), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputMemory_InterruptSettings(ChannelList, State, Mode);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputMemory_Start(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("Start"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, Start);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("Start"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:MEM:STAR (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputMemory_Start(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputMemory_Step(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("Step"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, Step);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("Step"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:MEM:STEP (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputMemory_Step(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputMemory_Stop(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("Stop"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, Stop);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("Stop"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:MEM:STOP (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputMemory_Stop(ChannelList);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AOutputMemory_put_CycleCount(Agilent34950A* pT, BSTR ChannelList, long val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("put_CycleCount"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, put_CycleCount);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("put_CycleCount"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34950AOutputMemory_put_Enable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("put_Enable"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, put_Enable);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("put_Enable"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:MEM:ENAB %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputMemory_put_Enable(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34950AOutputMemory_put_InterruptEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("put_InterruptEnable"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, put_InterruptEnable);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("put_InterruptEnable"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AOutputMemory_get_InterruptMode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AOutputModeEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("get_InterruptMode"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, get_InterruptMode);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_InterruptMode"), _T("val"));
		*val = Agilent34950AOutputModeGate;
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("get_InterruptMode"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AOutputMemory_put_InterruptMode(Agilent34950A* pT, BSTR ChannelList, Agilent34950AOutputModeEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("put_InterruptMode"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, put_InterruptMode);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("put_InterruptMode"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:INT:MODE %s, (@%s)"), pT->EnumToString<Agilent34950AOutputModeEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputMemory_put_InterruptMode(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputMemory_get_InterruptPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("get_InterruptPolarity"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, get_InterruptPolarity);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_InterruptPolarity"), _T("val"));
		*val = Agilent34950APolarityNormal;
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("get_InterruptPolarity"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AOutputMemory_put_InterruptPolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("put_InterruptPolarity"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, put_InterruptPolarity);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("put_InterruptPolarity"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AOutputMemory_get_TraceSelect(Agilent34950A* pT, BSTR Channel, BSTR* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("get_TraceSelect"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, get_TraceSelect);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_TraceSelect"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("get_TraceSelect"), IN_PARAM(Channel), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AOutputMemory_put_TraceSelect(Agilent34950A* pT, BSTR Channel, BSTR val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("put_TraceSelect"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, put_TraceSelect);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("put_TraceSelect"), IN_PARAM(Channel), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:DIG:MEM:TRAC %s, (@%s)"), LPCTSTR(COLE2T(val)), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputMemory_put_TraceSelect(Channel, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputMemory_get_Status(Agilent34950A* pT, BSTR Channel, VARIANT_BOOL* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputMemory"), _T("get_Status"));
	NTL_METHOD_START(IAgilent34950AOutputMemory, get_Status);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Status"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34950AOutputMemory"), _T("get_Status"), IN_PARAM(Channel), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ATrace_CreateCustom(Agilent34950A* pT, BSTR Channel, BSTR Name, SAFEARRAY** Data, Agilent34950AChannelWidthEnum Width, long Points)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATrace"), _T("CreateCustom"));
	NTL_METHOD_START(IAgilent34950ATrace, CreateCustom);
	CMethodTrace mt(pT, _T("IAgilent34950ATrace"), _T("CreateCustom"), IN_PARAM(Channel), IN_PARAM(Name), IN_PARAM(*Data), IN_PARAM(Width), IN_PARAM(Points), NULL);

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

	strCmd.Format(_T(":TRAC:DIG:%s (@%s), %s, %d"), pT->EnumToString<Agilent34950AChannelWidthEnum>(Width), LPCTSTR(COLE2T(Channel)), LPCTSTR(COLE2T(Name)), Data);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ATrace_CreateCustom(Channel, Name, Data, Width, Points);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ATrace_CreateStandard(Agilent34950A* pT, BSTR Channel, Agilent34950ATraceTypeEnum Type, BSTR Name, long Points)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATrace"), _T("CreateStandard"));
	NTL_METHOD_START(IAgilent34950ATrace, CreateStandard);
	CMethodTrace mt(pT, _T("IAgilent34950ATrace"), _T("CreateStandard"), IN_PARAM(Channel), IN_PARAM(Type), IN_PARAM(Name), IN_PARAM(Points), NULL);

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

	strCmd.Format(_T(":TRAC:DIG:FUNC (@%s), %s, %s, %d"), LPCTSTR(COLE2T(Channel)), pT->EnumToString<Agilent34950ATraceTypeEnum>(Type), LPCTSTR(COLE2T(Name)), Points);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ATrace_CreateStandard(Channel, Type, Name, Points);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ATrace_Delete(Agilent34950A* pT, BSTR Channel, BSTR Name)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATrace"), _T("Delete"));
	NTL_METHOD_START(IAgilent34950ATrace, Delete);
	CMethodTrace mt(pT, _T("IAgilent34950ATrace"), _T("Delete"), IN_PARAM(Channel), IN_PARAM(Name), NULL);

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

	strCmd.Format(_T(":TRAC:DEL:NAME (@%s), %s"), LPCTSTR(COLE2T(Channel)), LPCTSTR(COLE2T(Name)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ATrace_Delete(Channel, Name);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ATrace_DeleteAll(Agilent34950A* pT, BSTR Channel)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATrace"), _T("DeleteAll"));
	NTL_METHOD_START(IAgilent34950ATrace, DeleteAll);
	CMethodTrace mt(pT, _T("IAgilent34950ATrace"), _T("DeleteAll"), IN_PARAM(Channel), NULL);

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

	strCmd.Format(_T(":TRAC:DEL:ALL (@%s)"), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ATrace_DeleteAll(Channel);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ATrace_GetPoints(Agilent34950A* pT, BSTR Channel, BSTR TraceName, long* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATrace"), _T("GetPoints"));
	NTL_METHOD_START(IAgilent34950ATrace, GetPoints);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetPoints"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ATrace"), _T("GetPoints"), IN_PARAM(Channel), IN_PARAM(TraceName), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":TRAC:POIN? (@%s), %s"), LPCTSTR(COLE2T(Channel)), LPCTSTR(COLE2T(TraceName)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ATrace_GetPoints(Channel, TraceName, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ATrace_get_Catalog(Agilent34950A* pT, BSTR Channel, BSTR* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATrace"), _T("get_Catalog"));
	NTL_METHOD_START(IAgilent34950ATrace, get_Catalog);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Catalog"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950ATrace"), _T("get_Catalog"), IN_PARAM(Channel), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":TRAC:CAT? (@%s)"), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ATrace_get_Catalog(Channel, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ATrace_get_MemoryFree(Agilent34950A* pT, BSTR Channel, long* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATrace"), _T("get_MemoryFree"));
	NTL_METHOD_START(IAgilent34950ATrace, get_MemoryFree);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_MemoryFree"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ATrace"), _T("get_MemoryFree"), IN_PARAM(Channel), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":TRAC:FREE? (@%s)"), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ATrace_get_MemoryFree(Channel, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ACounter_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AFunctionEnum Function, double GateTime)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("Configure"));
	NTL_METHOD_START(IAgilent34950ACounter, Configure);
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Function), IN_PARAM(GateTime), NULL);

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

	strCmd.Format(_T(":COUN:FUNC %s, (@%s);  GATE:TIME %.15g, (@%s)"), pT->EnumToString<Agilent34950AFunctionEnum>(Function), LPCTSTR(COLE2T(ChannelList)), GateTime, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ACounter_Configure(ChannelList, Function, GateTime);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ACounter_get_Function(Agilent34950A* pT, BSTR ChannelList, Agilent34950AFunctionEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("get_Function"));
	NTL_METHOD_START(IAgilent34950ACounter, get_Function);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Function"), _T("val"));
		*val = Agilent34950AFunctionFrequency;
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("get_Function"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ACounter_put_Function(Agilent34950A* pT, BSTR ChannelList, Agilent34950AFunctionEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("put_Function"));
	NTL_METHOD_START(IAgilent34950ACounter, put_Function);
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("put_Function"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":COUN:FUNC %s, (@%s)"), pT->EnumToString<Agilent34950AFunctionEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ACounter_put_Function(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":COUN:GATE:TIME? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ACounter_get_GateTime(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ACounter_put_GateTime(Agilent34950A* pT, BSTR ChannelList, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("put_GateTime"));
	NTL_METHOD_START(IAgilent34950ACounter, put_GateTime);
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("put_GateTime"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ACounter_get_GateSource(Agilent34950A* pT, BSTR ChannelList, Agilent34950AGateSourceEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("get_GateSource"));
	NTL_METHOD_START(IAgilent34950ACounter, get_GateSource);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_GateSource"), _T("val"));
		*val = Agilent34950AGateSourceInternal;
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("get_GateSource"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ACounter_put_GateSource(Agilent34950A* pT, BSTR ChannelList, Agilent34950AGateSourceEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("put_GateSource"));
	NTL_METHOD_START(IAgilent34950ACounter, put_GateSource);
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("put_GateSource"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":COUN:GATE:SOUR %s, (@%s)"), pT->EnumToString<Agilent34950AGateSourceEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ACounter_put_GateSource(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ACounter_get_GatePolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("get_GatePolarity"));
	NTL_METHOD_START(IAgilent34950ACounter, get_GatePolarity);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_GatePolarity"), _T("val"));
		*val = Agilent34950APolarityNormal;
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("get_GatePolarity"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":COUN:GATE:POL? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ACounter_get_GatePolarity(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ACounter_put_GatePolarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("put_GatePolarity"));
	NTL_METHOD_START(IAgilent34950ACounter, put_GatePolarity);
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("put_GatePolarity"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":COUN:GATE:POL %s, (@%s)"), pT->EnumToString<Agilent34950APolarityEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ACounter_put_GatePolarity(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ACounter_get_GateThreshold(Agilent34950A* pT, long SlotNumber, double* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("get_GateThreshold"));
	NTL_METHOD_START(IAgilent34950ACounter, get_GateThreshold);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_GateThreshold"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("get_GateThreshold"), IN_PARAM(SlotNumber), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MOD:COUN:GATE:THR? %d"), SlotNumber);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ACounter_get_GateThreshold(SlotNumber, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ACounter_put_GateThreshold(Agilent34950A* pT, long SlotNumber, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("put_GateThreshold"));
	NTL_METHOD_START(IAgilent34950ACounter, put_GateThreshold);
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("put_GateThreshold"), IN_PARAM(SlotNumber), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":MOD:COUN:GATE:THR %.15g, %d"), val, SlotNumber);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ACounter_put_GateThreshold(SlotNumber, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ACounter_get_Slope(Agilent34950A* pT, BSTR ChannelList, Agilent34950ATotalizeSlopeEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("get_Slope"));
	NTL_METHOD_START(IAgilent34950ACounter, get_Slope);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Slope"), _T("val"));
		*val = Agilent34950ATotalizeSlopePositive;
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("get_Slope"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ACounter_put_Slope(Agilent34950A* pT, BSTR ChannelList, Agilent34950ATotalizeSlopeEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("put_Slope"));
	NTL_METHOD_START(IAgilent34950ACounter, put_Slope);
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("put_Slope"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ACounter_get_Totalizer(Agilent34950A* pT, IAgilent34950ATotalizer** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("get_Totalizer"));
	NTL_METHOD_START(IAgilent34950ACounter, get_Totalizer);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Totalizer"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("get_Totalizer"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ACounter_get_Measurement(Agilent34950A* pT, IAgilent34950AMeasurement** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("get_Measurement"));
	NTL_METHOD_START(IAgilent34950ACounter, get_Measurement);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Measurement"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("get_Measurement"), OUT_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34950ACounter_put_Threshold(Agilent34950A* pT, BSTR ChannelList, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ACounter"), _T("put_Threshold"));
	NTL_METHOD_START(IAgilent34950ACounter, put_Threshold);
	CMethodTrace mt(pT, _T("IAgilent34950ACounter"), _T("put_Threshold"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ATotalizer_Configure(Agilent34950A* pT, BSTR ChannelList, Agilent34950AGateSourceEnum GateSource, Agilent34950ATotalizeTypeEnum ReadType)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATotalizer"), _T("Configure"));
	NTL_METHOD_START(IAgilent34950ATotalizer, Configure);
	CMethodTrace mt(pT, _T("IAgilent34950ATotalizer"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(GateSource), IN_PARAM(ReadType), NULL);

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

	strCmd.Format(_T("COUN:FUNC TOT, (@%s); :TOT:TYPE %s, (@%s); :COUN:GATE:SOUR %s, (@%s)"), LPCTSTR(COLE2T(ChannelList)), pT->EnumToString<Agilent34950ATotalizeTypeEnum>(ReadType), LPCTSTR(COLE2T(ChannelList)), pT->EnumToString<Agilent34950AGateSourceEnum>(GateSource), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ATotalizer_Configure(ChannelList, GateSource, ReadType);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ATotalizer_Clear(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATotalizer"), _T("Clear"));
	NTL_METHOD_START(IAgilent34950ATotalizer, Clear);
	CMethodTrace mt(pT, _T("IAgilent34950ATotalizer"), _T("Clear"), IN_PARAM(ChannelList), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34950ATotalizer_get_ReadType(Agilent34950A* pT, BSTR ChannelList, Agilent34950ATotalizeTypeEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATotalizer"), _T("get_ReadType"));
	NTL_METHOD_START(IAgilent34950ATotalizer, get_ReadType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ReadType"), _T("val"));
		*val = Agilent34950ATotalizeTypeRead;
	CMethodTrace mt(pT, _T("IAgilent34950ATotalizer"), _T("get_ReadType"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ATotalizer_put_ReadType(Agilent34950A* pT, BSTR ChannelList, Agilent34950ATotalizeTypeEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ATotalizer"), _T("put_ReadType"));
	NTL_METHOD_START(IAgilent34950ATotalizer, put_ReadType);
	CMethodTrace mt(pT, _T("IAgilent34950ATotalizer"), _T("put_ReadType"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950AMeasurement_Abort(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AMeasurement"), _T("Abort"));
	NTL_METHOD_START(IAgilent34950AMeasurement, Abort);
	CMethodTrace mt(pT, _T("IAgilent34950AMeasurement"), _T("Abort"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":COUN:ABOR (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AMeasurement_Abort(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AMeasurement_Initiate(Agilent34950A* pT, BSTR ChannelList)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AMeasurement"), _T("Initiate"));
	NTL_METHOD_START(IAgilent34950AMeasurement, Initiate);
	CMethodTrace mt(pT, _T("IAgilent34950AMeasurement"), _T("Initiate"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":COUN:INIT (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AMeasurement_Initiate(ChannelList);
	pT->PopInstrCommand();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34950AOutputClock_Configure(Agilent34950A* pT, double Frequency, long Slot, double Voltage)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputClock"), _T("Configure"));
	NTL_METHOD_START(IAgilent34950AOutputClock, Configure);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputClock"), _T("Configure"), IN_PARAM(Frequency), IN_PARAM(Slot), IN_PARAM(Voltage), NULL);

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

	strCmd.Format(_T(":SOUR:MOD:CLOC:FREQ %.15g, %d; LEV %.15g, %d; STAT ON, %d"), Frequency, Slot, Voltage, Slot, Slot);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputClock_Configure(Frequency, Slot, Voltage);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputClock_get_Frequency(Agilent34950A* pT, long Slot, double* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputClock"), _T("get_Frequency"));
	NTL_METHOD_START(IAgilent34950AOutputClock, get_Frequency);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Frequency"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34950AOutputClock"), _T("get_Frequency"), IN_PARAM(Slot), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:MOD:CLOC:FREQ? %d"), Slot);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputClock_get_Frequency(Slot, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputClock_put_Frequency(Agilent34950A* pT, long Slot, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputClock"), _T("put_Frequency"));
	NTL_METHOD_START(IAgilent34950AOutputClock, put_Frequency);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputClock"), _T("put_Frequency"), IN_PARAM(Slot), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:MOD:CLOC:FREQ %.15g, %d"), val, Slot);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputClock_put_Frequency(Slot, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputClock_get_State(Agilent34950A* pT, long Slot, VARIANT_BOOL* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputClock"), _T("get_State"));
	NTL_METHOD_START(IAgilent34950AOutputClock, 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("IAgilent34950AOutputClock"), _T("get_State"), IN_PARAM(Slot), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:MOD:CLOC:STAT? %d"), Slot);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputClock_get_State(Slot, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputClock_put_State(Agilent34950A* pT, long Slot, VARIANT_BOOL val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputClock"), _T("put_State"));
	NTL_METHOD_START(IAgilent34950AOutputClock, put_State);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputClock"), _T("put_State"), IN_PARAM(Slot), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:MOD:CLOC:STAT %s, %d"), val == VARIANT_FALSE ? "0" : "1", Slot);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputClock_put_State(Slot, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputClock_get_Level(Agilent34950A* pT, long Slot, double* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputClock"), _T("get_Level"));
	NTL_METHOD_START(IAgilent34950AOutputClock, get_Level);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Level"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34950AOutputClock"), _T("get_Level"), IN_PARAM(Slot), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:MOD:CLOC:LEV? %d"), Slot);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputClock_get_Level(Slot, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950AOutputClock_put_Level(Agilent34950A* pT, long Slot, double val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950AOutputClock"), _T("put_Level"));
	NTL_METHOD_START(IAgilent34950AOutputClock, put_Level);
	CMethodTrace mt(pT, _T("IAgilent34950AOutputClock"), _T("put_Level"), IN_PARAM(Slot), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SOUR:MOD:CLOC:LEV %.15g, %d"), val, Slot);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950AOutputClock_put_Level(Slot, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_QueryLastByte(Agilent34950A* pT, BSTR ChannelList, BYTE* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("QueryLastByte"));
	NTL_METHOD_START(IAgilent34950ADigital, QueryLastByte);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("QueryLastByte"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_QueryLastByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_QueryLastWord(Agilent34950A* pT, BSTR ChannelList, short* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("QueryLastWord"));
	NTL_METHOD_START(IAgilent34950ADigital, QueryLastWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("QueryLastWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_QueryLastWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_ReadBit(Agilent34950A* pT, BSTR ChannelList, long BitNumber, VARIANT_BOOL* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("ReadBit"));
	NTL_METHOD_START(IAgilent34950ADigital, ReadBit);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadBit"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_ReadBit(ChannelList, BitNumber, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_ReadByte(Agilent34950A* pT, BSTR ChannelList, BYTE* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("ReadByte"));
	NTL_METHOD_START(IAgilent34950ADigital, ReadByte);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadByte"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_ReadByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_ReadWord(Agilent34950A* pT, BSTR ChannelList, short* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("ReadWord"));
	NTL_METHOD_START(IAgilent34950ADigital, ReadWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_ReadWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_ReadLongWord(Agilent34950A* pT, BSTR ChannelList, long* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("ReadLongWord"));
	NTL_METHOD_START(IAgilent34950ADigital, ReadLongWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadLongWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_ReadLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_WriteBit(Agilent34950A* pT, BSTR ChannelList, long Data, long BitNumber)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("WriteBit"));
	NTL_METHOD_START(IAgilent34950ADigital, WriteBit);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("WriteBit"), IN_PARAM(ChannelList), IN_PARAM(Data), IN_PARAM(BitNumber), 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->IAgilent34950ADigital_WriteBit(ChannelList, Data, BitNumber);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_WriteByte(Agilent34950A* pT, BSTR ChannelList, long Data)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("WriteByte"));
	NTL_METHOD_START(IAgilent34950ADigital, WriteByte);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_WriteByte(ChannelList, Data);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_WriteWord(Agilent34950A* pT, BSTR ChannelList, long Data)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("WriteWord"));
	NTL_METHOD_START(IAgilent34950ADigital, WriteWord);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_WriteWord(ChannelList, Data);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_WriteLongWord(Agilent34950A* pT, BSTR ChannelList, long Data)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("WriteLongWord"));
	NTL_METHOD_START(IAgilent34950ADigital, WriteLongWord);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_WriteLongWord(ChannelList, Data);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_QueryLastBit(Agilent34950A* pT, BSTR ChannelList, long BitNumber, BYTE* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("QueryLastBit"));
	NTL_METHOD_START(IAgilent34950ADigital, QueryLastBit);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("QueryLastBit"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("QueryLastBit"), IN_PARAM(ChannelList), IN_PARAM(BitNumber), OUT_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_get_ComparisonEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_ComparisonEnable"));
	NTL_METHOD_START(IAgilent34950ADigital, 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("IAgilent34950ADigital"), _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->IAgilent34950ADigital_get_ComparisonEnable(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_put_ComparisonEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_ComparisonEnable"));
	NTL_METHOD_START(IAgilent34950ADigital, put_ComparisonEnable);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_put_ComparisonEnable(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_get_ComparisonType(Agilent34950A* pT, BSTR ChannelList, Agilent34950AComparisonTypeEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_ComparisonType"));
	NTL_METHOD_START(IAgilent34950ADigital, get_ComparisonType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonType"), _T("val"));
		*val = Agilent34950AComparisonTypeEqual;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_get_ComparisonType(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_put_ComparisonType(Agilent34950A* pT, BSTR ChannelList, Agilent34950AComparisonTypeEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_ComparisonType"));
	NTL_METHOD_START(IAgilent34950ADigital, put_ComparisonType);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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<Agilent34950AComparisonTypeEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34950ADigital_put_ComparisonType(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_get_Direction(Agilent34950A* pT, BSTR ChannelList, Agilent34950ADirectionEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_Direction"));
	NTL_METHOD_START(IAgilent34950ADigital, get_Direction);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Direction"), _T("val"));
		*val = Agilent34950ADirectionInput;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("get_Direction"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_put_Direction(Agilent34950A* pT, BSTR ChannelList, Agilent34950ADirectionEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_Direction"));
	NTL_METHOD_START(IAgilent34950ADigital, put_Direction);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("put_Direction"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_get_ComparisonDataByte(Agilent34950A* pT, BSTR ChannelList, BYTE* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_ComparisonDataByte"));
	NTL_METHOD_START(IAgilent34950ADigital, get_ComparisonDataByte);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonDataByte"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_get_ComparisonDataByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_put_ComparisonDataByte(Agilent34950A* pT, BSTR ChannelList, BYTE val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_ComparisonDataByte"));
	NTL_METHOD_START(IAgilent34950ADigital, put_ComparisonDataByte);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_put_ComparisonDataByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_get_ComparisonDataWord(Agilent34950A* pT, BSTR ChannelList, short* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_ComparisonDataWord"));
	NTL_METHOD_START(IAgilent34950ADigital, get_ComparisonDataWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonDataWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_get_ComparisonDataWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_put_ComparisonDataWord(Agilent34950A* pT, BSTR ChannelList, short val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_ComparisonDataWord"));
	NTL_METHOD_START(IAgilent34950ADigital, put_ComparisonDataWord);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_put_ComparisonDataWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_get_ComparisonDataLongWord(Agilent34950A* pT, BSTR ChannelList, long* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_ComparisonDataLongWord"));
	NTL_METHOD_START(IAgilent34950ADigital, get_ComparisonDataLongWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonDataLongWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_get_ComparisonDataLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_put_ComparisonDataLongWord(Agilent34950A* pT, BSTR ChannelList, long val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_ComparisonDataLongWord"));
	NTL_METHOD_START(IAgilent34950ADigital, put_ComparisonDataLongWord);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_put_ComparisonDataLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_get_ComparisonAlarmEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_ComparisonAlarmEnable"));
	NTL_METHOD_START(IAgilent34950ADigital, get_ComparisonAlarmEnable);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonAlarmEnable"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("get_ComparisonAlarmEnable"), 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->IAgilent34950ADigital_get_ComparisonAlarmEnable(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_put_ComparisonAlarmEnable(Agilent34950A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_ComparisonAlarmEnable"));
	NTL_METHOD_START(IAgilent34950ADigital, put_ComparisonAlarmEnable);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("put_ComparisonAlarmEnable"), 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->IAgilent34950ADigital_put_ComparisonAlarmEnable(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_get_ComparisonMaskByte(Agilent34950A* pT, BSTR ChannelList, BYTE* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_ComparisonMaskByte"));
	NTL_METHOD_START(IAgilent34950ADigital, get_ComparisonMaskByte);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonMaskByte"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_get_ComparisonMaskByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_put_ComparisonMaskByte(Agilent34950A* pT, BSTR ChannelList, BYTE val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_ComparisonMaskByte"));
	NTL_METHOD_START(IAgilent34950ADigital, put_ComparisonMaskByte);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_put_ComparisonMaskByte(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_get_ComparisonMaskWord(Agilent34950A* pT, BSTR ChannelList, short* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_ComparisonMaskWord"));
	NTL_METHOD_START(IAgilent34950ADigital, get_ComparisonMaskWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonMaskWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_get_ComparisonMaskWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_put_ComparisonMaskWord(Agilent34950A* pT, BSTR ChannelList, short val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_ComparisonMaskWord"));
	NTL_METHOD_START(IAgilent34950ADigital, put_ComparisonMaskWord);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_put_ComparisonMaskWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_get_ComparisonMaskLongWord(Agilent34950A* pT, BSTR ChannelList, long* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_ComparisonMaskLongWord"));
	NTL_METHOD_START(IAgilent34950ADigital, get_ComparisonMaskLongWord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ComparisonMaskLongWord"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_get_ComparisonMaskLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_put_ComparisonMaskLongWord(Agilent34950A* pT, BSTR ChannelList, long val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_ComparisonMaskLongWord"));
	NTL_METHOD_START(IAgilent34950ADigital, put_ComparisonMaskLongWord);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _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->IAgilent34950ADigital_put_ComparisonMaskLongWord(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34950ADigital_get_Width(Agilent34950A* pT, BSTR ChannelList, Agilent34950AChannelWidthEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_Width"));
	NTL_METHOD_START(IAgilent34950ADigital, get_Width);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Width"), _T("val"));
		*val = Agilent34950AChannelWidthByte;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("get_Width"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_put_Width(Agilent34950A* pT, BSTR ChannelList, Agilent34950AChannelWidthEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_Width"));
	NTL_METHOD_START(IAgilent34950ADigital, put_Width);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("put_Width"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_get_Polarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum* val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_Polarity"));
	NTL_METHOD_START(IAgilent34950ADigital, get_Polarity);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Polarity"), _T("val"));
		*val = Agilent34950APolarityNormal;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("get_Polarity"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_put_Polarity(Agilent34950A* pT, BSTR ChannelList, Agilent34950APolarityEnum val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("put_Polarity"));
	NTL_METHOD_START(IAgilent34950ADigital, put_Polarity);
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("put_Polarity"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_get_Handshake(Agilent34950A* pT, IAgilent34950AHandshake** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_Handshake"));
	NTL_METHOD_START(IAgilent34950ADigital, get_Handshake);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Handshake"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("get_Handshake"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_get_Input(Agilent34950A* pT, IAgilent34950AInput** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_Input"));
	NTL_METHOD_START(IAgilent34950ADigital, get_Input);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Input"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("get_Input"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_get_Output(Agilent34950A* pT, IAgilent34950AOutput** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_Output"));
	NTL_METHOD_START(IAgilent34950ADigital, get_Output);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Output"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("get_Output"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950ADigital_get_Trace(Agilent34950A* pT, IAgilent34950ATrace** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950ADigital"), _T("get_Trace"));
	NTL_METHOD_START(IAgilent34950ADigital, get_Trace);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Trace"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950ADigital"), _T("get_Trace"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950A_get_Digital(Agilent34950A* pT, IAgilent34950ADigital** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950A"), _T("get_Digital"));
	NTL_METHOD_START(IAgilent34950A, get_Digital);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Digital"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950A"), _T("get_Digital"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950A_get_Counter(Agilent34950A* pT, IAgilent34950ACounter** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950A"), _T("get_Counter"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IAgilent34950A, get_Counter);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Counter"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950A"), _T("get_Counter"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34950A_get_OutputClock(Agilent34950A* pT, IAgilent34950AOutputClock** val)
{
	Agilent34950A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34950A"), _T("IAgilent34950A"), _T("get_OutputClock"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IAgilent34950A, get_OutputClock);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_OutputClock"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34950A"), _T("get_OutputClock"), OUT_PARAM(val), NULL);

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

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

	return hr;
}

